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

nodes add ret check

This commit is contained in:
wangjiaming0909 2024-07-21 18:20:30 +08:00 committed by wangjiaming0909
parent bf302a4abf
commit 1994c3339b
41 changed files with 4228 additions and 2347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/libs/nodes/nodes.h
View File

@ -112,11 +112,11 @@ int64_t nodesMakeAllocatorWeakRef(int64_t allocatorId);
int64_t nodesReleaseAllocatorWeakRef(int64_t allocatorId);
void nodesDestroyAllocator(int64_t allocatorId);
SNode* nodesMakeNode(ENodeType type);
int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut);
void nodesDestroyNode(SNode* pNode);
void nodesFree(void* p);
SNodeList* nodesMakeList();
int32_t nodesMakeList(SNodeList** ppListOut);
int32_t nodesListAppend(SNodeList* pList, SNode* pNode);
int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode);
int32_t nodesListMakeAppend(SNodeList** pList, SNode* pNode);
@ -156,8 +156,8 @@ bool nodeListNodeEqual(const SNodeList* a, const SNode* b);
bool nodesMatchNode(const SNode* pSub, const SNode* pNode);
SNode* nodesCloneNode(const SNode* pNode);
SNodeList* nodesCloneList(const SNodeList* pList);
int32_t nodesCloneNode(const SNode* pNode, SNode** ppNodeOut);
int32_t nodesCloneList(const SNodeList* pList, SNodeList** ppList);
const char* nodesNodeName(ENodeType type);
int32_t nodesNodeToString(const SNode* pNode, bool format, char** pStr, int32_t* pLen);

6
include/libs/nodes/querynodes.h
View File

@ -636,9 +636,9 @@ void* nodesGetValueFromNode(SValueNode* pNode);
int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value);
char* nodesGetStrValueFromNode(SValueNode* pNode);
void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
SValueNode* nodesMakeValueNodeFromString(char* literal);
SValueNode* nodesMakeValueNodeFromBool(bool b);
SNode* nodesMakeValueNodeFromInt32(int32_t value);
int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode);
int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode);
int32_t nodesMakeValueNodeFromInt32(int32_t value, SNode** ppNode);
char* nodesGetFillModeString(EFillMode mode);
int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc);

9
source/client/src/clientMain.c
View File

@ -999,10 +999,9 @@ void handleSubQueryFromAnalyse(SSqlCallbackWrapper *pWrapper, SMetaData *pResult
return;
}
pNewRequest->pQuery = (SQuery *)nodesMakeNode(QUERY_NODE_QUERY);
if (NULL == pNewRequest->pQuery) {
code = TSDB_CODE_OUT_OF_MEMORY;
} else {
pNewRequest->pQuery = NULL;
code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pNewRequest->pQuery);
if (pNewRequest->pQuery) {
pNewRequest->pQuery->pRoot = pRoot;
pRoot = NULL;
pNewRequest->pQuery->execStage = QUERY_EXEC_STAGE_ANALYSE;
@ -1901,4 +1900,4 @@ int taos_set_conn_mode(TAOS* taos, int mode, int value) {
char* getBuildInfo(){
return buildinfo;
}
}

27
source/client/src/clientRawBlockWrite.c
View File

@ -1214,12 +1214,14 @@ static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
}
SArray* pBufArray = NULL;
RAW_RETURN_CHECK(serializeVgroupsCreateTableBatch(pVgroupHashmap, &pBufArray));
pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
RAW_NULL_CHECK(pQuery);
pQuery = NULL;
code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
if (TSDB_CODE_SUCCESS != code) goto end;
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_CREATE_TABLE;
pQuery->stableQuery = false;
pQuery->pRoot = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT);
code = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT, &pQuery->pRoot);
if (TSDB_CODE_SUCCESS != code) goto end;
RAW_NULL_CHECK(pQuery->pRoot);
RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray));
@ -1343,13 +1345,14 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
}
SArray* pBufArray = NULL;
RAW_RETURN_CHECK(serializeVgroupsDropTableBatch(pVgroupHashmap, &pBufArray));
pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
RAW_NULL_CHECK(pQuery);
code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
if (TSDB_CODE_SUCCESS != code) goto end;
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_DROP_TABLE;
pQuery->stableQuery = false;
pQuery->pRoot = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT);
RAW_NULL_CHECK(pQuery->pRoot);
pQuery->pRoot = NULL;
code = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT, &pQuery->pRoot);
if (TSDB_CODE_SUCCESS != code) goto end;
RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray));
(void)launchQueryImpl(pRequest, pQuery, true, NULL);
@ -1486,13 +1489,15 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
pVgData->numOfTables = 1;
RAW_NULL_CHECK(taosArrayPush(pArray, &pVgData));
pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
RAW_NULL_CHECK(pQuery);
pQuery = NULL;
code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
if (NULL == pQuery) goto end;
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_ALTER_TABLE;
pQuery->stableQuery = false;
pQuery->pRoot = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
RAW_NULL_CHECK(pQuery->pRoot);
pQuery->pRoot = NULL;
code = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, &pQuery->pRoot);
if (TSDB_CODE_SUCCESS != code) goto end;
RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pArray));

4
source/libs/command/src/explain.c
View File

@ -163,10 +163,10 @@ int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNo
SNodeList *pPhysiChildren = pNode->pChildren;
if (pPhysiChildren) {
*pChildren = nodesMakeList();
int32_t code = nodesMakeList(pChildren);
if (NULL == *pChildren) {
qError("nodesMakeList failed");
QRY_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
QRY_ERR_RET(code);
}
}

1
source/libs/executor/inc/executorInt.h
View File

@ -364,6 +364,7 @@ typedef struct STagScanFilterContext {
SHashObj* colHash;
int32_t index;
SArray* cInfoList;
int32_t code;
} STagScanFilterContext;
typedef struct STagScanInfo {

76
source/libs/executor/src/executil.c
View File

@ -33,8 +33,14 @@ typedef struct tagFilterAssist {
SHashObj* colHash;
int32_t index;
SArray* cInfoList;
int32_t code;
} tagFilterAssist;
typedef struct STransTagExprCtx {
int32_t code;
SMetaReader* pReader;
} STransTagExprCtx;
typedef enum {
FILTER_NO_LOGIC = 1,
FILTER_AND,
@ -300,8 +306,9 @@ int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo)
}
EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
SMetaReader* mr = (SMetaReader*)pContext;
bool isTagCol = false, isTbname = false;
STransTagExprCtx* pCtx = pContext;
SMetaReader* mr = pCtx->pReader;
bool isTagCol = false, isTbname = false;
if (nodeType(*pNode) == QUERY_NODE_COLUMN) {
SColumnNode* pCol = (SColumnNode*)*pNode;
if (pCol->colType == COLUMN_TYPE_TBNAME)
@ -315,7 +322,8 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
if (isTagCol) {
SColumnNode* pSColumnNode = *(SColumnNode**)pNode;
SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* res = NULL;
pCtx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
return DEAL_RES_ERROR;
}
@ -345,7 +353,8 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
nodesDestroyNode(*pNode);
*pNode = (SNode*)res;
} else if (isTbname) {
SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* res = NULL;
pCtx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
return DEAL_RES_ERROR;
}
@ -377,10 +386,20 @@ int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle,
return TSDB_CODE_SUCCESS;
}
SNode* pTagCondTmp = nodesCloneNode(pTagCond);
nodesRewriteExprPostOrder(&pTagCondTmp, doTranslateTagExpr, &mr);
SNode* pTagCondTmp = NULL;
code = nodesCloneNode(pTagCond, &pTagCondTmp);
if (TSDB_CODE_SUCCESS != code) {
*pQualified = false;
return code;
}
STransTagExprCtx ctx = {.code = 0, .pReader = &mr};
nodesRewriteExprPostOrder(&pTagCondTmp, doTranslateTagExpr, &ctx);
pAPI->metaReaderFn.clearReader(&mr);
if (TSDB_CODE_SUCCESS != ctx.code) {
*pQualified = false;
terrno = code;
return code;
}
SNode* pNew = NULL;
code = scalarCalculateConstants(pTagCondTmp, &pNew);
@ -400,13 +419,14 @@ int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle,
}
static EDealRes getColumn(SNode** pNode, void* pContext) {
tagFilterAssist* pData = (tagFilterAssist*)pContext;
SColumnNode* pSColumnNode = NULL;
if (QUERY_NODE_COLUMN == nodeType((*pNode))) {
pSColumnNode = *(SColumnNode**)pNode;
} else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {
SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);
if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {
pSColumnNode = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
pData->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);
if (NULL == pSColumnNode) {
return DEAL_RES_ERROR;
}
@ -423,7 +443,6 @@ static EDealRes getColumn(SNode** pNode, void* pContext) {
return DEAL_RES_CONTINUE;
}
tagFilterAssist* pData = (tagFilterAssist*)pContext;
void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
if (!data) {
int32_t tempRes =
@ -571,12 +590,20 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
SNode* pNode = NULL;
FOREACH(pNode, group) {
nodesRewriteExprPostOrder(&pNode, getColumn, (void*)&ctx);
if (TSDB_CODE_SUCCESS != ctx.code) {
code = ctx.code;
goto end;
}
REPLACE_NODE(pNode);
}
T_MD5_CTX context = {0};
if (tsTagFilterCache) {
SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNodeListNode* listNode = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&listNode);
if (TSDB_CODE_SUCCESS != code) {
goto end;
}
listNode->pNodeList = group;
code = genTbGroupDigest((SNode*)listNode, digest, &context);
QUERY_CHECK_CODE(code, lino, end);
@ -1166,6 +1193,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
}
nodesRewriteExprPostOrder(&pTagCond, getColumn, (void*)&ctx);
if (TSDB_CODE_SUCCESS != ctx.code) {
terrno = code = ctx.code;
goto end;
}
SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};
@ -1414,9 +1445,20 @@ int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode,
return TSDB_CODE_PAR_TABLE_NOT_EXIST;
}
SNodeList* groupNew = nodesCloneList(pGroupNode);
SNodeList* groupNew = NULL;
int32_t code = nodesCloneList(pGroupNode, &groupNew);
if (TSDB_CODE_SUCCESS != code) {
pAPI->metaReaderFn.clearReader(&mr);
return code;
}
nodesRewriteExprsPostOrder(groupNew, doTranslateTagExpr, &mr);
STransTagExprCtx ctx = {.code = 0, .pReader = &mr};
nodesRewriteExprsPostOrder(groupNew, doTranslateTagExpr, &ctx);
if (TSDB_CODE_SUCCESS != ctx.code) {
nodesDestroyList(groupNew);
pAPI->metaReaderFn.clearReader(&mr);
return code;
}
char* isNull = (char*)keyBuf;
char* pStart = (char*)keyBuf + sizeof(int8_t) * LIST_LENGTH(pGroupNode);
@ -1667,9 +1709,13 @@ int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
if (!pFuncNode->pParameterList && (memcmp(pExprNode->_function.functionName, name, len) == 0) &&
pExprNode->_function.functionName[len] == 0) {
pFuncNode->pParameterList = nodesMakeList();
SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
if (NULL == res) { // todo handle error
pFuncNode->pParameterList = NULL;
int32_t code = nodesMakeList(&pFuncNode->pParameterList);
SValueNode* res = NULL;
if (TSDB_CODE_SUCCESS == code) {
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
}
if (TSDB_CODE_SUCCESS != code) { // todo handle error
} else {
res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT};
code = nodesListAppend(pFuncNode->pParameterList, (SNode*)res);

14
source/libs/executor/src/scanoperator.c
View File

@ -382,7 +382,7 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca
}
}
// free the sma info, since it should not be involved in later computing process.
// free the sma info, since it should not be involved in *later computing process.
taosMemoryFreeClear(pBlock->pBlockAgg);
// try to filter data block according to current results
@ -4073,15 +4073,17 @@ static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SSca
}
static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0;
STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;
SColumnNode* pSColumnNode = NULL;
if (QUERY_NODE_COLUMN == nodeType((*pNode))) {
pSColumnNode = *(SColumnNode**)pNode;
} else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {
SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);
if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {
pSColumnNode = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
pSColumnNode = NULL;
pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);
if (NULL == pSColumnNode) {
return DEAL_RES_ERROR;
}
@ -4098,8 +4100,7 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {
return DEAL_RES_CONTINUE;
}
STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;
void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
if (!data) {
code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));
if (code == TSDB_CODE_DUP_KEY) {
@ -4493,6 +4494,7 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi
nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);
}
}
//TODO wjm check pInfo->filterCtx.code
__optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry;
pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,
optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);

6
source/libs/executor/src/streamtimewindowoperator.c
View File

@ -1905,7 +1905,11 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream,
initResultRowInfo(&pInfo->binfo.resultRowInfo);
pInfo->numOfChild = numOfChild;
pInfo->pPhyNode = (SPhysiNode*)nodesCloneNode((SNode*)pPhyNode);
pInfo->pPhyNode = NULL;
code = nodesCloneNode((SNode*)pPhyNode, (SNode**)&pInfo->pPhyNode);
if (TSDB_CODE_SUCCESS != code) {
goto _error;
}
pInfo->pPullWins = taosArrayInit(8, sizeof(SPullWindowInfo));
pInfo->pullIndex = 0;

93
source/libs/executor/test/joinTests.cpp
View File

@ -305,14 +305,16 @@ static int32_t jtMergeEqCond(SNode** ppDst, SNode** ppSrc) {
return TSDB_CODE_SUCCESS;
}
SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
SLogicConditionNode* pLogicCond = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);
if (NULL == pLogicCond) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
pLogicCond->condType = LOGIC_COND_TYPE_AND;
pLogicCond->pParameterList = nodesMakeList();
pLogicCond->pParameterList = NULL;
code = nodesMakeList(&pLogicCond->pParameterList);
assert(0 == nodesListStrictAppend(pLogicCond->pParameterList, *ppSrc));
assert(0 == nodesListStrictAppend(pLogicCond->pParameterList, *ppDst));
@ -387,8 +389,10 @@ void createTargetSlotList(SSortMergeJoinPhysiNode* p) {
jtCtx.keyColOffset = dstOffset;
}
STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET);
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
STargetNode* pTarget = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_TARGET, (SNode**)&pTarget);
SColumnNode* pCol = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
assert(NULL != pTarget && NULL != pCol);
pCol->dataBlockId = LEFT_BLK_ID;
pCol->slotId = i;
@ -412,8 +416,10 @@ void createTargetSlotList(SSortMergeJoinPhysiNode* p) {
jtCtx.keyColOffset = dstOffset;
}
STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET);
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
STargetNode* pTarget = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_TARGET, (SNode**)&pTarget);
SColumnNode* pCol = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
assert(NULL != pTarget && NULL != pCol);
pCol->dataBlockId = RIGHT_BLK_ID;
pCol->slotId = i;
@ -454,9 +460,9 @@ void createColEqCondStart(SSortMergeJoinPhysiNode* p) {
for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.colEqList[i]) {
SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol1 = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol1);
assert(pCol1);
pCol1->dataBlockId = LEFT_BLK_ID;
pCol1->slotId = i;
pCol1->node.resType.type = jtInputColType[i];
@ -464,7 +470,8 @@ void createColEqCondStart(SSortMergeJoinPhysiNode* p) {
assert(0 == nodesListMakeStrictAppend(&p->pEqLeft, (SNode*)pCol1));
SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol2 = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol2);
pCol2->dataBlockId = RIGHT_BLK_ID;
pCol2->slotId = i;
pCol2->node.resType.type = jtInputColType[i];
@ -511,7 +518,7 @@ void createColEqCondEnd(SSortMergeJoinPhysiNode* p) {
SLogicConditionNode* pLogic = NULL;
if (jtCtx.colEqNum > 1) {
pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic);
assert(pLogic);
pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
@ -520,21 +527,24 @@ void createColEqCondEnd(SSortMergeJoinPhysiNode* p) {
for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.colEqList[i]) {
SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol1 = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol1);
assert(pCol1);
pCol1->dataBlockId = RES_BLK_ID;
pCol1->slotId = getDstSlotId(i);
pCol1->node.resType.type = jtInputColType[i];
pCol1->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol2 = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol2);
assert(pCol2);
pCol2->dataBlockId = RES_BLK_ID;
pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i);
pCol2->node.resType.type = jtInputColType[i];
pCol2->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
SOperatorNode* pOp = NULL;
code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);
assert(pOp);
pOp->opType = OP_TYPE_EQUAL;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@ -563,7 +573,7 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) {
SLogicConditionNode* pLogic = NULL;
if (jtCtx.colOnNum > 1) {
pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic);
assert(pLogic);
pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
@ -572,21 +582,24 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) {
for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.colOnList[i]) {
SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol1 = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol1);
assert(pCol1);
pCol1->dataBlockId = RES_BLK_ID;
pCol1->slotId = getDstSlotId(i);
pCol1->node.resType.type = jtInputColType[i];
pCol1->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol2 = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol2);
assert(pCol2);
pCol2->dataBlockId = RES_BLK_ID;
pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i);
pCol2->node.resType.type = jtInputColType[i];
pCol2->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
SOperatorNode* pOp = NULL;
code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);
assert(pOp);
pOp->opType = OP_TYPE_GREATER_THAN;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@ -607,7 +620,8 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) {
p->pColOnCond = (SNode*)pLogic;
}
SNode* pTmp = nodesCloneNode(p->pColOnCond);
SNode* pTmp = NULL;
int32_t code = nodesCloneNode(p->pColOnCond, &pTmp);
assert(pTmp);
assert(0 == jtMergeEqCond(&p->pFullOnCond, &pTmp));
}
@ -721,7 +735,7 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) {
SLogicConditionNode* pLogic = NULL;
if ((jtCtx.leftFilterNum + jtCtx.rightFilterNum) > 1) {
pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic);
assert(pLogic);
pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
@ -730,7 +744,8 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) {
for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.leftFilterColList[i]) {
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN,(SNode**)&pCol);
assert(pCol);
pCol->dataBlockId = RES_BLK_ID;
pCol->slotId = getDstSlotId(i);
@ -738,13 +753,15 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) {
pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
(void)sprintf(pCol->colName, "l%d", i);
SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pVal = NULL;
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
assert(pVal);
pVal->node.resType.type = jtInputColType[i];
pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
assert(0 == nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i])));
SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
SOperatorNode* pOp = NULL;
code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);
assert(pOp);
pOp->opType = OP_TYPE_GREATER_THAN;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@ -763,7 +780,8 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) {
for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.rightFilterColList[i]) {
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
assert(pCol);
pCol->dataBlockId = RES_BLK_ID;
pCol->slotId = getDstSlotId(MAX_SLOT_NUM + i);
@ -771,13 +789,15 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) {
pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
(void)sprintf(pCol->colName, "r%d", i);
SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pVal = NULL;
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
assert(pVal);
pVal->node.resType.type = jtInputColType[i];
pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
assert(0 == nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i])));
SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
SOperatorNode* pOp = NULL;
code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);
assert(pOp);
pOp->opType = OP_TYPE_GREATER_THAN;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@ -810,13 +830,15 @@ void updateColRowInfo() {
}
void createBlockDescNode(SDataBlockDescNode** ppNode) {
SDataBlockDescNode* pDesc = (SDataBlockDescNode*)nodesMakeNode(QUERY_NODE_DATABLOCK_DESC);
SDataBlockDescNode* pDesc = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_DATABLOCK_DESC, (SNode**)&pDesc);
assert(pDesc);
pDesc->dataBlockId = RES_BLK_ID;
pDesc->totalRowSize = jtCtx.resColSize - MAX_SLOT_NUM * 2 * sizeof(bool);
pDesc->outputRowSize = pDesc->totalRowSize;
for (int32_t i = 0; i < jtCtx.resColNum; ++i) {
SSlotDescNode* pSlot = (SSlotDescNode*)nodesMakeNode(QUERY_NODE_SLOT_DESC);
SSlotDescNode* pSlot = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_SLOT_DESC, (SNode**)&pSlot);
assert(pSlot);
pSlot->slotId = i;
int32_t slotIdx = jtCtx.resColInSlot[i] >= MAX_SLOT_NUM ? jtCtx.resColInSlot[i] - MAX_SLOT_NUM : jtCtx.resColInSlot[i];
@ -830,14 +852,16 @@ void createBlockDescNode(SDataBlockDescNode** ppNode) {
}
SSortMergeJoinPhysiNode* createDummySortMergeJoinPhysiNode(SJoinTestParam* param) {
SSortMergeJoinPhysiNode* p = (SSortMergeJoinPhysiNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN);
SSortMergeJoinPhysiNode* p = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN, (SNode**)&p);
assert(p);
p->joinType = param->joinType;
p->subType = param->subType;
p->asofOpType = param->asofOp;
p->grpJoin = param->grpJoin;
if (p->subType == JOIN_STYPE_WIN || param->jLimit > 1 || taosRand() % 2) {
SLimitNode* limitNode = (SLimitNode*)nodesMakeNode(QUERY_NODE_LIMIT);
SLimitNode* limitNode = NULL;
code = nodesMakeNode(QUERY_NODE_LIMIT, (SNode**)&limitNode);
assert(limitNode);
limitNode->limit = param->jLimit;
p->pJLimit = (SNode*)limitNode;
@ -847,11 +871,14 @@ SSortMergeJoinPhysiNode* createDummySortMergeJoinPhysiNode(SJoinTestParam* param
p->rightPrimSlotId = JT_PRIM_TS_SLOT_ID;
p->node.inputTsOrder = param->asc ? ORDER_ASC : ORDER_DESC;
if (JOIN_STYPE_WIN == p->subType) {
SWindowOffsetNode* pOffset = (SWindowOffsetNode*)nodesMakeNode(QUERY_NODE_WINDOW_OFFSET);
SWindowOffsetNode* pOffset = NULL;
code = nodesMakeNode(QUERY_NODE_WINDOW_OFFSET, (SNode**)&pOffset);
assert(pOffset);
SValueNode* pStart = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pStart = NULL;
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pStart);
assert(pStart);
SValueNode* pEnd = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pEnd = NULL;
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pEnd);
assert(pEnd);
pStart->node.resType.type = TSDB_DATA_TYPE_BIGINT;
pStart->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;

24
source/libs/function/src/builtins.c
View File

@ -216,9 +216,10 @@ static int32_t addTimezoneParam(SNodeList* pList) {
}
int32_t len = (int32_t)strlen(buf);
SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pVal = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
if (pVal == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pVal->literal = strndup(buf, len);
@ -247,9 +248,10 @@ static int32_t addTimezoneParam(SNodeList* pList) {
}
static int32_t addDbPrecisonParam(SNodeList** pList, uint8_t precision) {
SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pVal = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
if (pVal == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pVal->literal = NULL;
@ -835,9 +837,13 @@ static int32_t translateTopBot(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
static int32_t reserveFirstMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) {
int32_t code = nodesListMakeAppend(pParameters, pPartialRes);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(*pParameters, nodesCloneNode(nodesListGetNode(pRawParameters, 1)));
SNode* pNew = NULL;
code = nodesCloneNode(nodesListGetNode(pRawParameters, 1), &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(*pParameters, pNew);
}
}
return TSDB_CODE_SUCCESS;
return code;
}
int32_t topBotCreateMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) {
@ -847,7 +853,11 @@ int32_t topBotCreateMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SN
int32_t apercentileCreateMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) {
int32_t code = reserveFirstMergeParam(pRawParameters, pPartialRes, pParameters);
if (TSDB_CODE_SUCCESS == code && pRawParameters->length >= 3) {
code = nodesListStrictAppend(*pParameters, nodesCloneNode(nodesListGetNode(pRawParameters, 2)));
SNode* pNew = NULL;
code = nodesCloneNode(nodesListGetNode(pRawParameters, 2), &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(*pParameters, pNew);
}
}
return code;
}

54
source/libs/function/src/functionMgt.c
View File

@ -382,29 +382,30 @@ static int32_t getFuncInfo(SFunctionNode* pFunc) {
return fmGetFuncInfo(pFunc, msg, sizeof(msg));
}
int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** pFunc) {
*pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
if (NULL == *pFunc) {
return TSDB_CODE_OUT_OF_MEMORY;
int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** ppFunc) {
int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)ppFunc);
if (NULL == *ppFunc) {
return code;
}
(void)snprintf((*pFunc)->functionName, sizeof((*pFunc)->functionName), "%s", pName);
(*pFunc)->pParameterList = pParameterList;
int32_t code = getFuncInfo((*pFunc));
(void)snprintf((*ppFunc)->functionName, sizeof((*ppFunc)->functionName), "%s", pName);
(*ppFunc)->pParameterList = pParameterList;
code = getFuncInfo((*ppFunc));
if (TSDB_CODE_SUCCESS != code) {
(*pFunc)->pParameterList = NULL;
nodesDestroyNode((SNode*)*pFunc);
(*ppFunc)->pParameterList = NULL;
nodesDestroyNode((SNode*)*ppFunc);
*ppFunc = NULL;
return code;
}
return code;
}
static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** pCol) {
*pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
if (NULL == *pCol) {
return TSDB_CODE_OUT_OF_MEMORY;
static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** ppCol) {
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&ppCol);
if (NULL == *ppCol) {
return code;
}
(void)strcpy((*pCol)->colName, pFunc->node.aliasName);
(*pCol)->node.resType = pFunc->node.resType;
(void)strcpy((*ppCol)->colName, pFunc->node.aliasName);
(*ppCol)->node.resType = pFunc->node.resType;
return TSDB_CODE_SUCCESS;
}
@ -419,11 +420,12 @@ bool fmIsDistExecFunc(int32_t funcId) {
}
static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNode** pPartialFunc) {
SNodeList* pParameterList = nodesCloneList(pSrcFunc->pParameterList);
SNodeList* pParameterList = NULL;
int32_t code = nodesCloneList(pSrcFunc->pParameterList, &pParameterList);
if (NULL == pParameterList) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
int32_t code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pParameterList,pPartialFunc );
code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pParameterList,pPartialFunc );
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParameterList);
return code;
@ -542,12 +544,13 @@ char* fmGetFuncName(int32_t funcId) {
/// @retval 0 for succ, otherwise err occured
static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pStateFunc) {
if (funcMgtBuiltins[pFunc->funcId].pStateFunc) {
SNodeList* pParams = nodesCloneList(pFunc->pParameterList);
if (!pParams) return TSDB_CODE_OUT_OF_MEMORY;
int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc);
SNodeList* pParams = NULL;
int32_t code = nodesCloneList(pFunc->pParameterList, &pParams);
if (!pParams) return code;
code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParams);
return TSDB_CODE_FUNC_FUNTION_ERROR;
return terrno;
}
(void)strcpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName);
(void)strcpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias);
@ -588,9 +591,10 @@ int32_t fmCreateStateFuncs(SNodeList* pFuncs) {
static int32_t fmCreateStateMergeFunc(SFunctionNode* pFunc, SFunctionNode** pStateMergeFunc) {
if (funcMgtBuiltins[pFunc->funcId].pMergeFunc) {
SNodeList* pParams = nodesCloneList(pFunc->pParameterList);
if (!pParams) return TSDB_CODE_OUT_OF_MEMORY;
int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams, pStateMergeFunc);
SNodeList* pParams = NULL;
int32_t code = nodesCloneList(pFunc->pParameterList, &pParams);
if (!pParams) return code;
code = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams, pStateMergeFunc);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParams);
return code;

89
source/libs/nodes/src/nodesCloneFuncs.c
View File

@ -47,37 +47,37 @@
} \
} while (0)
#define CLONE_NODE_FIELD(fldname) \
do { \
if (NULL == (pSrc)->fldname) { \
break; \
} \
(pDst)->fldname = nodesCloneNode((pSrc)->fldname); \
if (NULL == (pDst)->fldname) { \
return TSDB_CODE_OUT_OF_MEMORY; \
} \
#define CLONE_NODE_FIELD(fldname) \
do { \
if (NULL == (pSrc)->fldname) { \
break; \
} \
int32_t code = nodesCloneNode((pSrc)->fldname, &((pDst)->fldname)); \
if (NULL == (pDst)->fldname) { \
return code; \
} \
} while (0)
#define CLONE_NODE_FIELD_EX(fldname, nodePtrType) \
do { \
if (NULL == (pSrc)->fldname) { \
break; \
} \
(pDst)->fldname = (nodePtrType)nodesCloneNode((SNode*)(pSrc)->fldname); \
if (NULL == (pDst)->fldname) { \
return TSDB_CODE_OUT_OF_MEMORY; \
} \
#define CLONE_NODE_FIELD_EX(fldname, nodePtrType) \
do { \
if (NULL == (pSrc)->fldname) { \
break; \
} \
int32_t code = nodesCloneNode((SNode*)(pSrc)->fldname, (SNode**)&((pDst)->fldname)); \
if (NULL == (pDst)->fldname) { \
return code; \
} \
} while (0)
#define CLONE_NODE_LIST_FIELD(fldname) \
do { \
if (NULL == (pSrc)->fldname) { \
break; \
} \
(pDst)->fldname = nodesCloneList((pSrc)->fldname); \
if (NULL == (pDst)->fldname) { \
return TSDB_CODE_OUT_OF_MEMORY; \
} \
#define CLONE_NODE_LIST_FIELD(fldname) \
do { \
if (NULL == (pSrc)->fldname) { \
break; \
} \
int32_t code = nodesCloneList((pSrc)->fldname, &((pDst)->fldname)); \
if (NULL == (pDst)->fldname) { \
return code; \
} \
} while (0)
#define CLONE_OBJECT_FIELD(fldname, cloneFunc) \
@ -869,18 +869,17 @@ static int32_t setOperatorCopy(const SSetOperator* pSrc, SSetOperator* pDst) {
return TSDB_CODE_SUCCESS;
}
SNode* nodesCloneNode(const SNode* pNode) {
int32_t nodesCloneNode(const SNode* pNode, SNode** ppNode) {
if (NULL == pNode) {
return NULL;
return TSDB_CODE_SUCCESS;
}
SNode* pDst = nodesMakeNode(nodeType(pNode));
if (NULL == pDst) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
SNode* pDst = NULL;
int32_t code = nodesMakeNode(nodeType(pNode), &pDst);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
int32_t code = TSDB_CODE_SUCCESS;
switch (nodeType(pNode)) {
case QUERY_NODE_COLUMN:
code = columnNodeCopy((const SColumnNode*)pNode, (SColumnNode*)pDst);
@ -1058,25 +1057,31 @@ SNode* nodesCloneNode(const SNode* pNode) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyNode(pDst);
nodesError("nodesCloneNode failed node = %s", nodesNodeName(nodeType(pNode)));
return NULL;
return code;
}
return pDst;
*ppNode = pDst;
return code;
}
SNodeList* nodesCloneList(const SNodeList* pList) {
int32_t nodesCloneList(const SNodeList* pList, SNodeList** ppList) {
if (NULL == pList) {
return NULL;
return TSDB_CODE_SUCCESS;
}
SNodeList* pDst = NULL;
SNode* pNode;
FOREACH(pNode, pList) {
int32_t code = nodesListMakeStrictAppend(&pDst, nodesCloneNode(pNode));
SNode* pNew = NULL;
int32_t code = nodesCloneNode(pNode, &pNew);
if (TSDB_CODE_SUCCESS != code) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyList(pDst);
return NULL;
return code;
}
code = nodesListMakeStrictAppend(&pDst, pNew);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pDst);
return code;
}
}
return pDst;
return TSDB_CODE_SUCCESS;
}

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

@ -456,9 +456,9 @@ static int32_t nodeListToJson(SJson* pJson, const char* pName, const SNodeList*
static int32_t jsonToNodeListImpl(const SJson* pJsonArray, SNodeList** pList) {
int32_t size = (NULL == pJsonArray ? 0 : tjsonGetArraySize(pJsonArray));
if (size > 0) {
*pList = nodesMakeList();
int32_t code = nodesMakeList(pList);
if (NULL == *pList) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
}
@ -8212,9 +8212,9 @@ static int32_t makeNodeByJson(const SJson* pJson, SNode** pNode) {
int32_t val = 0;
int32_t code = tjsonGetIntValue(pJson, jkNodeType, &val);
if (TSDB_CODE_SUCCESS == code) {
*pNode = nodesMakeNode(val);
code = nodesMakeNode(val, pNode);
if (NULL == *pNode) {
return TSDB_CODE_FAILED;
return code;
}
code = jsonToNode(pJson, *pNode);
}

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

@ -60,7 +60,7 @@ typedef struct STlvDecoder {
typedef int32_t (*FToMsg)(const void* pObj, STlvEncoder* pEncoder);
typedef int32_t (*FToObject)(STlvDecoder* pDecoder, void* pObj);
typedef void* (*FMakeObject)(int16_t type);
typedef int32_t (*FMakeObject)(int16_t type, SNode** ppNode);
typedef int32_t (*FSetObject)(STlv* pTlv, void* pObj);
static int32_t nodeToMsg(const void* pObj, STlvEncoder* pEncoder);
@ -568,9 +568,9 @@ static int32_t tlvDecodeObjArrayFromTlv(STlv* pTlv, FToObject func, void* pArray
}
static int32_t tlvDecodeDynObjFromTlv(STlv* pTlv, FMakeObject makeFunc, FToObject toFunc, void** pObj) {
*pObj = makeFunc(pTlv->type);
int32_t code = makeFunc(pTlv->type, (SNode**)pObj);
if (NULL == *pObj) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
return tlvDecodeObjFromTlv(pTlv, toFunc, *pObj);
}
@ -4786,9 +4786,10 @@ static int32_t SArrayToMsg(const void* pObj, STlvEncoder* pEncoder) {
static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) {
SNodeList* pList = nodesMakeList();
SNodeList* pList = NULL;
int32_t code = TSDB_CODE_SUCCESS;
code = nodesMakeList(&pList);
while (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) {
SNode* pNode = NULL;
code = msgToNode(pDecoder, (void**)&pNode);

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

File diff suppressed because it is too large Load Diff

86
source/libs/nodes/test/nodesCloneTest.cpp
View File

@ -24,7 +24,9 @@ class NodesCloneTest : public testing::Test {
void registerCheckFunc(const std::function<void(const SNode*, const SNode*)>& func) { checkFunc_ = func; }
void run(const SNode* pSrc) {
std::unique_ptr<SNode, void (*)(SNode*)> pDst(nodesCloneNode(pSrc), nodesDestroyNode);
SNode* pNew = NULL;
int32_t code = nodesCloneNode(pSrc, &pNew);
std::unique_ptr<SNode, void (*)(SNode*)> pDst(pNew, nodesDestroyNode);
checkFunc_(pSrc, pDst.get());
}
@ -43,9 +45,13 @@ TEST_F(NodesCloneTest, tempTable) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_TEMP_TABLE));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_TEMP_TABLE, &pNew);
srcNode.reset(pNew);
STempTableNode* pNode = (STempTableNode*)srcNode.get();
pNode->pSubquery = nodesMakeNode(QUERY_NODE_SELECT_STMT);
pNew = NULL;
code = nodesMakeNode(QUERY_NODE_SELECT_STMT, &pNew);
pNode->pSubquery = pNew;
return srcNode.get();
}());
}
@ -66,12 +72,14 @@ TEST_F(NodesCloneTest, joinTable) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_JOIN_TABLE));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_JOIN_TABLE, &pNew);
srcNode.reset(pNew);
SJoinTableNode* pNode = (SJoinTableNode*)srcNode.get();
pNode->joinType = JOIN_TYPE_INNER;
pNode->pLeft = nodesMakeNode(QUERY_NODE_REAL_TABLE);
pNode->pRight = nodesMakeNode(QUERY_NODE_REAL_TABLE);
pNode->pOnCond = nodesMakeNode(QUERY_NODE_OPERATOR);
code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pLeft);
code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pRight);
code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pOnCond);
return srcNode.get();
}());
}
@ -88,10 +96,12 @@ TEST_F(NodesCloneTest, stateWindow) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_STATE_WINDOW));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_STATE_WINDOW, &pNew);
srcNode.reset(pNew);
SStateWindowNode* pNode = (SStateWindowNode*)srcNode.get();
pNode->pCol = nodesMakeNode(QUERY_NODE_COLUMN);
pNode->pExpr = nodesMakeNode(QUERY_NODE_OPERATOR);
code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pCol);
code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pExpr);
return srcNode.get();
}());
}
@ -108,10 +118,12 @@ TEST_F(NodesCloneTest, sessionWindow) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_SESSION_WINDOW));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_SESSION_WINDOW, &pNew);
srcNode.reset(pNew);
SSessionWindowNode* pNode = (SSessionWindowNode*)srcNode.get();
pNode->pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
pNode->pGap = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pNode->pCol);
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pNode->pGap);
return srcNode.get();
}());
}
@ -136,12 +148,14 @@ TEST_F(NodesCloneTest, intervalWindow) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW, &pNew);
srcNode.reset(pNew);
SIntervalWindowNode* pNode = (SIntervalWindowNode*)srcNode.get();
pNode->pInterval = nodesMakeNode(QUERY_NODE_VALUE);
pNode->pOffset = nodesMakeNode(QUERY_NODE_VALUE);
pNode->pSliding = nodesMakeNode(QUERY_NODE_VALUE);
pNode->pFill = nodesMakeNode(QUERY_NODE_FILL);
code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pInterval);
code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pOffset);
code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pSliding);
code = nodesMakeNode(QUERY_NODE_FILL, &pNode->pFill);
return srcNode.get();
}());
}
@ -163,11 +177,13 @@ TEST_F(NodesCloneTest, fill) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_FILL));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_FILL, &pNew);
srcNode.reset(pNew);
SFillNode* pNode = (SFillNode*)srcNode.get();
pNode->mode = FILL_MODE_VALUE;
pNode->pValues = nodesMakeNode(QUERY_NODE_NODE_LIST);
pNode->pWStartTs = nodesMakeNode(QUERY_NODE_COLUMN);
code = nodesMakeNode(QUERY_NODE_NODE_LIST, &pNode->pValues);
code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pWStartTs);
pNode->timeRange.skey = 1666756692907;
pNode->timeRange.ekey = 1666756699907;
return srcNode.get();
@ -188,7 +204,9 @@ TEST_F(NodesCloneTest, logicSubplan) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, &pNew);
srcNode.reset(pNew);
SLogicSubplan* pNode = (SLogicSubplan*)srcNode.get();
return srcNode.get();
}());
@ -208,7 +226,9 @@ TEST_F(NodesCloneTest, physiScan) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN));
SNode* pNew = nullptr;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, &pNew);
srcNode.reset(pNew);
STagScanPhysiNode* pNode = (STagScanPhysiNode*)srcNode.get();
return srcNode.get();
}());
@ -227,7 +247,9 @@ TEST_F(NodesCloneTest, physiSystemTableScan) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN, &pNew);
srcNode.reset(pNew);
SSystemTableScanPhysiNode* pNode = (SSystemTableScanPhysiNode*)srcNode.get();
return srcNode.get();
}());
@ -244,7 +266,9 @@ TEST_F(NodesCloneTest, physiStreamSemiSessionWinodw) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION, &pNew);
srcNode.reset(pNew);
SStreamSemiSessionWinodwPhysiNode* pNode = (SStreamSemiSessionWinodwPhysiNode*)srcNode.get();
return srcNode.get();
}());
@ -261,7 +285,9 @@ TEST_F(NodesCloneTest, physiStreamFinalSessionWinodw) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION, &pNew);
srcNode.reset(pNew);
SStreamFinalSessionWinodwPhysiNode* pNode = (SStreamFinalSessionWinodwPhysiNode*)srcNode.get();
return srcNode.get();
}());
@ -277,7 +303,9 @@ TEST_F(NodesCloneTest, physiStreamPartition) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION, &pNew);
srcNode.reset(pNew);
SStreamPartitionPhysiNode* pNode = (SStreamPartitionPhysiNode*)srcNode.get();
return srcNode.get();
}());
@ -293,7 +321,9 @@ TEST_F(NodesCloneTest, physiPartition) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() {
srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_PARTITION));
SNode* pNew = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_PARTITION, &pNew);
srcNode.reset(pNew);
SPartitionPhysiNode* pNode = (SPartitionPhysiNode*)srcNode.get();
return srcNode.get();
}());

31
source/libs/nodes/test/nodesTestMain.cpp
View File

@ -26,7 +26,8 @@ static EDealRes rewriterTest(SNode** pNode, void* pContext) {
if (QUERY_NODE_VALUE != nodeType(pOp->pLeft) || QUERY_NODE_VALUE != nodeType(pOp->pRight)) {
*pRes = DEAL_RES_ERROR;
}
SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pVal = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
string tmp = to_string(stoi(((SValueNode*)(pOp->pLeft))->literal) + stoi(((SValueNode*)(pOp->pRight))->literal));
pVal->literal = taosStrdup(tmp.c_str());
nodesDestroyNode(*pNode);
@ -36,15 +37,18 @@ static EDealRes rewriterTest(SNode** pNode, void* pContext) {
}
TEST(NodesTest, traverseTest) {
SNode* pRoot = (SNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
SNode* pRoot = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR,(SNode**)&pRoot);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SOperatorNode* pOp = (SOperatorNode*)pRoot;
SOperatorNode* pLeft = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
pLeft->pLeft = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
SOperatorNode* pLeft = NULL;
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pLeft));
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pLeft->pLeft));
((SValueNode*)(pLeft->pLeft))->literal = taosStrdup("10");
pLeft->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pLeft->pRight));
((SValueNode*)(pLeft->pRight))->literal = taosStrdup("5");
pOp->pLeft = (SNode*)pLeft;
pOp->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE);
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pOp->pRight));
((SValueNode*)(pOp->pRight))->literal = taosStrdup("3");
EXPECT_EQ(nodeType(pRoot), QUERY_NODE_OPERATOR);
@ -90,19 +94,24 @@ void assert_sort_result(SNodeList* pList) {
}
TEST(NodesTest, sort) {
SValueNode *vn1 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *vn1 = NULL;
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn1));
vn1->datum.i = 4;
SValueNode *vn2 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *vn2 = NULL;
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn2));
vn2->datum.i = 3;
SValueNode *vn3 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *vn3 = NULL;
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn3));
vn3->datum.i = 2;
SValueNode *vn4 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *vn4 = NULL;
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn4));
vn4->datum.i = 1;
SValueNode *vn5 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *vn5 = NULL;
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn5));
vn5->datum.i = 0;
SNodeList* l = NULL;

2
source/libs/parser/inc/parUtil.h
View File

@ -172,7 +172,7 @@ int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName,
int32_t getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput);
int32_t getDnodeListFromCache(SParseMetaCache* pMetaCache, SArray** pDnodes);
void destoryParseMetaCache(SParseMetaCache* pMetaCache, bool request);
SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint);
int32_t createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint, SNode** ppSelect);
int32_t getTableTsmasFromCache(SParseMetaCache* pMetaCache, const SName* pTbName, SArray** pTsmas);
int32_t getTsmaFromCache(SParseMetaCache* pMetaCache, const SName* pTsmaName, STableTSMAInfo** pTsma);

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

File diff suppressed because it is too large Load Diff

13
source/libs/parser/src/parAstParser.c
View File

@ -30,9 +30,10 @@ extern void ParseFree(void*, FFree);
extern void ParseTrace(FILE*, char*);
int32_t buildQueryAfterParse(SQuery** pQuery, SNode* pRootNode, int16_t placeholderNo, SArray** pPlaceholderValues) {
*pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
*pQuery = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)pQuery);
if (NULL == *pQuery) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
(*pQuery)->pRoot = pRootNode;
(*pQuery)->placeholderNum = placeholderNo;
@ -424,7 +425,7 @@ static int32_t collectMetaKeyFromDescribe(SCollectMetaKeyCxt* pCxt, SDescribeStm
#ifdef TD_ENTERPRISE
if (TSDB_CODE_SUCCESS == code) {
char dbFName[TSDB_DB_FNAME_LEN];
tNameGetFullDbName(&name, dbFName);
(void)tNameGetFullDbName(&name, dbFName);
code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->tableName, 0);
}
#endif
@ -439,9 +440,9 @@ static int32_t collectMetaKeyFromCreateStream(SCollectMetaKeyCxt* pCxt, SCreateS
reserveTableMetaInCache(pCxt->pParseCxt->acctId, pStmt->targetDbName, pStmt->targetTabName, pCxt->pMetaCache);
if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pSubtable && NULL != pStmt->pQuery) {
SSelectStmt* pSelect = (SSelectStmt*)pStmt->pQuery;
pSelect->pSubtable = nodesCloneNode(pStmt->pSubtable);
int32_t code = nodesCloneNode(pStmt->pSubtable, &pSelect->pSubtable);
if (NULL == pSelect->pSubtable) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
}
if (TSDB_CODE_SUCCESS == code) {
@ -724,7 +725,7 @@ static int32_t collectMetaKeyFromShowCreateView(SCollectMetaKeyCxt* pCxt, SShowC
strcpy(name.dbname, pStmt->dbName);
strcpy(name.tname, pStmt->viewName);
char dbFName[TSDB_DB_FNAME_LEN];
tNameGetFullDbName(&name, dbFName);
(void)tNameGetFullDbName(&name, dbFName);
int32_t code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->viewName, 0);
if (TSDB_CODE_SUCCESS == code) {
code = reserveViewUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pStmt->dbName, pStmt->viewName,

24
source/libs/parser/src/parAuthenticator.c
View File

@ -34,7 +34,7 @@ typedef struct SAuthRewriteCxt {
static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt);
static void setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type,
static int32_t setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type,
bool isView, bool effective, SUserAuthInfo* pAuth) {
if (effective) {
snprintf(pAuth->user, sizeof(pAuth->user), "%s", pCxt->pEffectiveUser ? pCxt->pEffectiveUser : "");
@ -43,12 +43,14 @@ static void setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const char
}
if (NULL == pTabName) {
tNameSetDbName(&pAuth->tbName, pCxt->acctId, pDbName, strlen(pDbName));
int32_t code = tNameSetDbName(&pAuth->tbName, pCxt->acctId, pDbName, strlen(pDbName));
if (TSDB_CODE_SUCCESS != code) return code;
} else {
toName(pCxt->acctId, pDbName, pTabName, &pAuth->tbName);
(void)toName(pCxt->acctId, pDbName, pTabName, &pAuth->tbName);
}
pAuth->type = type;
pAuth->isView = isView;
return TSDB_CODE_SUCCESS;
}
static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, SNode** pCond, bool isView, bool effective) {
@ -59,8 +61,8 @@ static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pT
AUTH_RES_TYPE auth_res_type = isView ? AUTH_RES_VIEW : AUTH_RES_BASIC;
SUserAuthInfo authInfo = {0};
setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo);
int32_t code = TSDB_CODE_SUCCESS;
int32_t code = setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo);
if (TSDB_CODE_SUCCESS != code) return code;
SUserAuthRes authRes = {0};
if (NULL != pCxt->pMetaCache) {
code = getUserAuthFromCache(pCxt->pMetaCache, &authInfo, &authRes);
@ -105,14 +107,15 @@ static EDealRes authSubquery(SAuthCxt* pCxt, SNode* pStmt) {
}
static int32_t mergeStableTagCond(SNode** pWhere, SNode* pTagCond) {
SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
SLogicConditionNode* pLogicCond = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);
if (NULL == pLogicCond) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
pLogicCond->condType = LOGIC_COND_TYPE_AND;
int32_t code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, pTagCond);
code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, pTagCond);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pLogicCond->pParameterList, *pWhere);
}
@ -136,9 +139,10 @@ EDealRes rewriteAuthTable(SNode* pNode, void* pContext) {
}
static int32_t rewriteAppendStableTagCond(SNode** pWhere, SNode* pTagCond, STableNode* pTable) {
SNode* pTagCondCopy = nodesCloneNode(pTagCond);
SNode* pTagCondCopy = NULL;
int32_t code = nodesCloneNode(pTagCond, &pTagCondCopy);
if (NULL == pTagCondCopy) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
SAuthRewriteCxt cxt = {.pTarget = pTable};

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

@ -72,9 +72,10 @@ static bool isCondition(const SNode* pNode) {
}
static int32_t rewriteIsTrue(SNode* pSrc, SNode** pIsTrue) {
SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
SOperatorNode* pOp = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);
if (NULL == pOp) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pOp->opType = OP_TYPE_IS_TRUE;
pOp->pLeft = pSrc;
@ -179,9 +180,9 @@ static EDealRes doFindAndReplaceNode(SNode** pNode, void* pContext) {
char aliasName[TSDB_COL_NAME_LEN] = {0};
strcpy(aliasName, ((SExprNode*)*pNode)->aliasName);
nodesDestroyNode(*pNode);
*pNode = nodesCloneNode(pCxt->replaceCxt.pNew);
*pNode = NULL;
pCxt->code = nodesCloneNode(pCxt->replaceCxt.pNew, pNode);
if (NULL == *pNode) {
pCxt->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}
strcpy(((SExprNode*)*pNode)->aliasName, aliasName);
@ -231,12 +232,14 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d
SArray* pOrigAss = NULL;
TSWAP(((SExprNode*)*pCol)->pAssociation, pOrigAss);
nodesDestroyNode(*pCol);
*pCol = nodesCloneNode(*pNew);
TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation);
*pCol = NULL;
code = nodesCloneNode(*pNew, pCol);
if (TSDB_CODE_SUCCESS == code) {
strcpy(((SExprNode*)*pCol)->aliasName, aliasName);
TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation);
}
taosArrayDestroy(pOrigAss);
strcpy(((SExprNode*)*pCol)->aliasName, aliasName);
if (NULL == *pCol) {
code = TSDB_CODE_OUT_OF_MEMORY;
if (TSDB_CODE_SUCCESS != code) {
break;
}
} else {
@ -276,17 +279,23 @@ static bool isUselessCol(SExprNode* pProj) {
return NULL == ((SExprNode*)pProj)->pAssociation;
}
static SNode* createConstantValue() {
SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
static int32_t createConstantValue(SValueNode** ppNode) {
SValueNode* pVal = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
if (NULL == pVal) {
return NULL;
return code;
}
pVal->node.resType.type = TSDB_DATA_TYPE_INT;
pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes;
const int32_t val = 1;
nodesSetValueNodeValue(pVal, (void*)&val);
pVal->translate = true;
return (SNode*)pVal;
code = nodesSetValueNodeValue(pVal, (void*)&val);
if (TSDB_CODE_SUCCESS == code) {
pVal->translate = true;
*ppNode = pVal;
} else {
nodesDestroyNode((SNode*)pVal);
}
return code;
}
static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) {
@ -306,7 +315,11 @@ static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelec
WHERE_NEXT;
}
if (0 == LIST_LENGTH(pSelect->pProjectionList)) {
return nodesListStrictAppend(pSelect->pProjectionList, createConstantValue());
SValueNode* pVal = NULL;
int32_t code = createConstantValue(&pVal);
if (TSDB_CODE_SUCCESS == code) {
return nodesListStrictAppend(pSelect->pProjectionList, (SNode*)pVal);
}
}
return TSDB_CODE_SUCCESS;
}
@ -417,7 +430,7 @@ static void eraseSetOpChildProjection(SSetOperator* pSetOp, int32_t index) {
eraseSetOpChildProjection((SSetOperator*)pSetOp->pLeft, index);
}
SNodeList* pRightProjs = getChildProjection(pSetOp->pRight);
nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index));
(void)nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index));
if (QUERY_NODE_SET_OPERATOR == nodeType(pSetOp->pRight)) {
eraseSetOpChildProjection((SSetOperator*)pSetOp->pRight, index);
}
@ -495,7 +508,11 @@ static int32_t calcConstSetOpProjections(SCalcConstContext* pCxt, SSetOperator*
WHERE_NEXT;
}
if (0 == LIST_LENGTH(pSetOp->pProjectionList)) {
return nodesListStrictAppend(pSetOp->pProjectionList, createConstantValue());
SValueNode* pVal = NULL;
int32_t code = createConstantValue(&pVal);
if (TSDB_CODE_SUCCESS == code) {
return nodesListStrictAppend(pSetOp->pProjectionList, (SNode*)pVal);
}
}
return TSDB_CODE_SUCCESS;
}

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

@ -459,19 +459,21 @@ end:
int32_t smlInitHandle(SQuery** query) {
*query = NULL;
SQuery* pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
SQuery* pQuery = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
if (NULL == pQuery) {
uError("create pQuery error");
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->haveResultSet = false;
pQuery->msgType = TDMT_VND_SUBMIT;
SVnodeModifyOpStmt* stmt = (SVnodeModifyOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT);
SVnodeModifyOpStmt* stmt = NULL;
code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&stmt);
if (NULL == stmt) {
uError("create SVnodeModifyOpStmt error");
qDestroyQuery(pQuery);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
stmt->pTableBlockHashObj = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
if (stmt->pTableBlockHashObj == NULL){

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

@ -796,9 +796,10 @@ typedef struct SRewriteTagCondCxt {
} SRewriteTagCondCxt;
static int32_t rewriteTagCondColumnImpl(STagVal* pVal, SNode** pNode) {
SValueNode* pValue = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode* pValue = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValue);
if (NULL == pValue) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pValue->node.resType = ((SColumnNode*)*pNode)->node.resType;
@ -1240,7 +1241,8 @@ static int32_t getTargetTableSchema(SInsertParseContext* pCxt, SVnodeModifyOpStm
pCxt->needTableTagVal = (NULL != pTagCond);
pCxt->missCache = (NULL != pTagCond);
} else {
pStmt->pTagCond = nodesCloneNode(pTagCond);
pStmt->pTagCond = NULL;
code = nodesCloneNode(pTagCond, &pStmt->pTagCond);
}
}
nodesDestroyNode(pTagCond);
@ -2535,9 +2537,10 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS
static void destroySubTableHashElem(void* p) { taosMemoryFree(*(STableMeta**)p); }
static int32_t createVnodeModifOpStmt(SInsertParseContext* pCxt, bool reentry, SNode** pOutput) {
SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT);
SVnodeModifyOpStmt* pStmt = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&pStmt);
if (NULL == pStmt) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
if (pCxt->pComCxt->pStmtCb) {
@ -2575,16 +2578,17 @@ static int32_t createVnodeModifOpStmt(SInsertParseContext* pCxt, bool reentry, S
}
static int32_t createInsertQuery(SInsertParseContext* pCxt, SQuery** pOutput) {
SQuery* pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
SQuery* pQuery = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
if (NULL == pQuery) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->haveResultSet = false;
pQuery->msgType = TDMT_VND_SUBMIT;
int32_t code = createVnodeModifOpStmt(pCxt, false, &pQuery->pRoot);
code = createVnodeModifOpStmt(pCxt, false, &pQuery->pRoot);
if (TSDB_CODE_SUCCESS == code) {
*pOutput = pQuery;
} else {
@ -2601,10 +2605,10 @@ static int32_t checkAuthFromMetaData(const SArray* pUsers, SNode** pTagCond) {
SMetaRes* pRes = taosArrayGet(pUsers, 0);
if (TSDB_CODE_SUCCESS == pRes->code) {
SUserAuthRes* pAuth = pRes->pRes;
if (NULL != pAuth->pCond) {
*pTagCond = nodesCloneNode(pAuth->pCond[AUTH_RES_BASIC]);
pRes->code = nodesCloneNode(pAuth->pCond[AUTH_RES_BASIC], pTagCond);
if (TSDB_CODE_SUCCESS == pRes->code) {
return pAuth->pass[AUTH_RES_BASIC] ? TSDB_CODE_SUCCESS : TSDB_CODE_PAR_PERMISSION_DENIED;
}
return pAuth->pass[AUTH_RES_BASIC] ? TSDB_CODE_SUCCESS : TSDB_CODE_PAR_PERMISSION_DENIED;
}
return pRes->code;
}

1402
source/libs/parser/src/parTranslater.c
View File

File diff suppressed because it is too large Load Diff

10
source/libs/parser/src/parUtil.c
View File

@ -762,10 +762,11 @@ int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalog
return code;
}
SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint) {
SSelectStmt* select = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT);
int32_t createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint, SNode** ppSelect) {
SSelectStmt* select = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_SELECT_STMT, (SNode**)&select);
if (NULL == select) {
return NULL;
return code;
}
select->isDistinct = isDistinct;
select->pProjectionList = pProjectionList;
@ -777,7 +778,8 @@ SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode*
select->timeRange = TSWINDOW_INITIALIZER;
select->pHint = pHint;
select->lastProcessByRowFuncId = -1;
return (SNode*)select;
*ppSelect = (SNode*)select;
return code;
}
static int32_t putMetaDataToHash(const char* pKey, int32_t len, const SArray* pData, int32_t index, SHashObj** pHash) {

5
source/libs/parser/src/parser.c
View File

@ -429,9 +429,10 @@ int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx
if (TSDB_CODE_SUCCESS == code && (colIdx < 0 || colIdx + 1 == pQuery->placeholderNum)) {
nodesDestroyNode(pQuery->pRoot);
pQuery->pRoot = nodesCloneNode(pQuery->pPrepareRoot);
pQuery->pRoot = NULL;
code = nodesCloneNode(pQuery->pPrepareRoot, &pQuery->pRoot);
if (NULL == pQuery->pRoot) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = code;
}
}
if (TSDB_CODE_SUCCESS == code) {

2
source/libs/planner/inc/planInt.h
View File

@ -65,7 +65,7 @@ int32_t tagScanSetExecutionMode(SScanLogicNode* pScan);
#define CLONE_LIMIT 1
#define CLONE_SLIMIT 1 << 1
#define CLONE_LIMIT_SLIMIT (CLONE_LIMIT | CLONE_SLIMIT)
bool cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat);
int32_t cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat, bool* pCloned);
int32_t sortPriKeyOptGetSequencingNodesImpl(SLogicNode* pNode, bool groupSort, SSortLogicNode* pSort,
bool* pNotOptimize, SNodeList** pSequencingNodes, bool* keepSort);

502
source/libs/planner/src/planLogicCreater.c
View File

@ -112,7 +112,8 @@ static EDealRes doRewriteExpr(SNode** pNode, void* pContext) {
pExpr = nodesListGetNode(((SGroupingSetNode*)pExpr)->pParameterList, 0);
}
if (nodesEqualNode(pExpr, *pNode)) {
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol = NULL;
pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
if (NULL == pCol) {
return DEAL_RES_ERROR;
}
@ -177,7 +178,11 @@ static int32_t cloneRewriteExprs(SNodeList* pExprs, bool* pOutputs, SNodeList**
SNode* pExpr = NULL;
FOREACH(pExpr, pExprs) {
if (pOutputs[index]) {
code = nodesListMakeStrictAppend(pRewriteExpr, nodesCloneNode(pExpr));
SNode* pNew = NULL;
code = nodesCloneNode(pExpr, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(pRewriteExpr, pNew);
}
if (TSDB_CODE_SUCCESS != code) {
NODES_DESTORY_LIST(*pRewriteExpr);
break;
@ -223,9 +228,9 @@ static int32_t rewriteExprs(SNodeList* pExprs, SNodeList* pTarget) {
static int32_t pushLogicNode(SLogicPlanContext* pCxt, SLogicNode** pOldRoot, SLogicNode* pNewRoot) {
if (NULL == pNewRoot->pChildren) {
pNewRoot->pChildren = nodesMakeList();
int32_t code = nodesMakeList(&pNewRoot->pChildren);
if (NULL == pNewRoot->pChildren) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
}
if (TSDB_CODE_SUCCESS != nodesListAppend(pNewRoot->pChildren, (SNode*)*pOldRoot)) {
@ -289,7 +294,8 @@ static bool hasPkInTable(const STableMeta* pTableMeta) {
}
static SNode* createFirstCol(SRealTableNode* pTable, const SSchema* pSchema) {
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol = NULL;
terrno = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
if (NULL == pCol) {
return NULL;
}
@ -360,9 +366,10 @@ static int32_t addDefaultScanCol(SRealTableNode* pTable, SNodeList** pCols) {
static int32_t makeScanLogicNode(SLogicPlanContext* pCxt, SRealTableNode* pRealTable, bool hasRepeatScanFuncs,
SLogicNode** pLogicNode) {
SScanLogicNode* pScan = (SScanLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN);
SScanLogicNode* pScan = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN, (SNode**)&pScan);
if (NULL == pScan) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
TSWAP(pScan->pVgroupList, pRealTable->pVgroupList);
@ -448,17 +455,11 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
}
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pTags && NULL == pSelect->pPartitionByList) {
pScan->pTags = nodesCloneList(pSelect->pTags);
if (NULL == pScan->pTags) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = nodesCloneList(pSelect->pTags, &pScan->pTags);
}
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable && NULL == pSelect->pPartitionByList) {
pScan->pSubtable = nodesCloneNode(pSelect->pSubtable);
if (NULL == pScan->pSubtable) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = nodesCloneNode(pSelect->pSubtable, &pScan->pSubtable);
}
// set output
@ -518,9 +519,10 @@ int32_t collectJoinResColumns(SSelectStmt* pSelect, SJoinLogicNode* pJoin, SNode
static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SJoinTableNode* pJoinTable,
SLogicNode** pLogicNode) {
int32_t code = TSDB_CODE_SUCCESS;
SJoinLogicNode* pJoin = (SJoinLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN);
SJoinLogicNode* pJoin = NULL;
code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN, (SNode**)&pJoin);
if (NULL == pJoin) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pJoin->joinType = pJoinTable->joinType;
@ -535,15 +537,17 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
pJoin->node.requireDataOrder = pJoin->hashJoinHint ? DATA_ORDER_LEVEL_NONE : DATA_ORDER_LEVEL_GLOBAL;
pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
pJoin->isLowLevelJoin = pJoinTable->isLowLevelJoin;
pJoin->pWindowOffset = nodesCloneNode(pJoinTable->pWindowOffset);
pJoin->pJLimit = nodesCloneNode(pJoinTable->pJLimit);
pJoin->addPrimEqCond = nodesCloneNode(pJoinTable->addPrimCond);
pJoin->node.pChildren = nodesMakeList();
pJoin->seqWinGroup = (JOIN_STYPE_WIN == pJoinTable->subType) && (pSelect->hasAggFuncs || pSelect->hasIndefiniteRowsFunc);
if (NULL == pJoin->node.pChildren) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = nodesCloneNode(pJoinTable->pWindowOffset, &pJoin->pWindowOffset);
if (TSDB_CODE_SUCCESS == code) {
code = nodesCloneNode(pJoinTable->pJLimit, &pJoin->pJLimit);
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesCloneNode(pJoinTable->addPrimCond, &pJoin->addPrimEqCond);
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesMakeList(&pJoin->node.pChildren);
}
pJoin->seqWinGroup = (JOIN_STYPE_WIN == pJoinTable->subType) && (pSelect->hasAggFuncs || pSelect->hasIndefiniteRowsFunc);
SLogicNode* pLeft = NULL;
if (TSDB_CODE_SUCCESS == code) {
@ -566,10 +570,7 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
// set on conditions
if (TSDB_CODE_SUCCESS == code && NULL != pJoinTable->pOnCond) {
pJoin->pFullOnCond = nodesCloneNode(pJoinTable->pOnCond);
if (NULL == pJoin->pFullOnCond) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = nodesCloneNode(pJoinTable->pOnCond, &pJoin->pFullOnCond);
}
#if 0
@ -631,10 +632,7 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
}
if (NULL == pJoin->node.pTargets && NULL != pLeft) {
pJoin->node.pTargets = nodesCloneList(pLeft->pTargets);
if (NULL == pJoin->node.pTargets) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = nodesCloneList(pLeft->pTargets, &pJoin->node.pTargets);
}
#endif
@ -669,10 +667,11 @@ static int32_t createLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSel
SLogicNode* pNode = NULL;
int32_t code = doCreateLogicNodeByTable(pCxt, pSelect, pTable, &pNode);
if (TSDB_CODE_SUCCESS == code) {
pNode->pConditions = nodesCloneNode(pSelect->pWhere);
pNode->pConditions = NULL;
code = nodesCloneNode(pSelect->pWhere, &pNode->pConditions);
if (NULL != pSelect->pWhere && NULL == pNode->pConditions) {
nodesDestroyNode((SNode*)pNode);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pNode->precision = pSelect->precision;
*pLogicNode = pNode;
@ -682,7 +681,8 @@ static int32_t createLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSel
}
static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr) {
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol = NULL;
terrno = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
if (NULL == pCol) {
return NULL;
}
@ -694,17 +694,24 @@ static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr)
return pCol;
}
static SNode* createGroupingSetNode(SNode* pExpr) {
SGroupingSetNode* pGroupingSet = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET);
static int32_t createGroupingSetNode(SNode* pExpr, SNode** ppNode) {
SGroupingSetNode* pGroupingSet = NULL;
int32_t code = 0;
*ppNode = NULL;
code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pGroupingSet);
if (NULL == pGroupingSet) {
return NULL;
return code;
}
pGroupingSet->groupingSetType = GP_TYPE_NORMAL;
if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pGroupingSet->pParameterList, nodesCloneNode(pExpr))) {
nodesDestroyNode((SNode*)pGroupingSet);
return NULL;
SNode* pNew = NULL;
code = nodesCloneNode(pExpr, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pGroupingSet->pParameterList, pNew);
}
return (SNode*)pGroupingSet;
if (TSDB_CODE_SUCCESS == code) {
*ppNode = (SNode*)pGroupingSet;
}
return code;
}
static EGroupAction getDistinctGroupAction(SLogicPlanContext* pCxt, SSelectStmt* pSelect) {
@ -727,7 +734,14 @@ static EDataOrderLevel getRequireDataOrder(bool needTimeline, SSelectStmt* pSele
}
static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pList) {
SNodeList* pTargets = (NULL == *pList) ? nodesMakeList() : *pList;
SNodeList* pTargets = *pList;
int32_t code = 0;
if (pTargets) {
code = nodesMakeList(&pTargets);
}
if (TSDB_CODE_SUCCESS != code) {
return code;
}
SJoinTableNode* pJoinTable = (SJoinTableNode*)pSelect->pFromTable;
SRealTableNode* pProbeTable = NULL;
switch (pJoinTable->joinType) {
@ -742,10 +756,11 @@ static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pLi
return TSDB_CODE_PLAN_INTERNAL_ERROR;
}
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
if (NULL == pCol) {
if (!*pList) nodesDestroyList(pTargets);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
SSchema* pColSchema = &pProbeTable->pMeta->schema[0];
@ -765,10 +780,17 @@ static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pLi
pCol->node.resType.precision = pProbeTable->pMeta->tableInfo.precision;
SNode* pFunc = (SNode*)createGroupKeyAggFunc(pCol);
if (!pFunc) {
nodesDestroyList(pTargets);
return terrno;
}
nodesListAppend(pTargets, pFunc);
code = nodesListStrictAppend(pTargets, pFunc);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pTargets);
}
return TSDB_CODE_SUCCESS;
return code;
}
static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) {
@ -776,9 +798,10 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect,
return TSDB_CODE_SUCCESS;
}
SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG);
SAggLogicNode* pAgg = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
if (NULL == pAgg) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
bool winJoin = isWindowJoinStmt(pSelect);
@ -792,8 +815,6 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect,
pAgg->node.resultDataOrder = pAgg->onlyHasKeepOrderFunc ? pAgg->node.requireDataOrder : DATA_ORDER_LEVEL_NONE;
pAgg->node.forceCreateNonBlockingOptr = winJoin ? true : false;
int32_t code = TSDB_CODE_SUCCESS;
// set grouyp keys, agg funcs and having conditions
if (TSDB_CODE_SUCCESS == code) {
code = nodesCollectFuncs(pSelect, SQL_CLAUSE_GROUP_BY, NULL, fmIsAggFunc, &pAgg->pAggFuncs);
@ -805,10 +826,8 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect,
}
if (NULL != pSelect->pGroupByList) {
pAgg->pGroupKeys = nodesCloneList(pSelect->pGroupByList);
if (NULL == pAgg->pGroupKeys) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pAgg->pGroupKeys = NULL;
code = nodesCloneList(pSelect->pGroupByList, &pAgg->pGroupKeys);
}
// rewrite the expression in subsequent clauses
@ -818,10 +837,8 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect,
}
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving) {
pAgg->node.pConditions = nodesCloneNode(pSelect->pHaving);
if (NULL == pAgg->node.pConditions) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pAgg->node.pConditions = NULL;
code = nodesCloneNode(pSelect->pHaving, &pAgg->node.pConditions);
}
// set the output
@ -857,10 +874,10 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt
return TSDB_CODE_SUCCESS;
}
SIndefRowsFuncLogicNode* pIdfRowsFunc =
(SIndefRowsFuncLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC);
SIndefRowsFuncLogicNode* pIdfRowsFunc = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, (SNode**)&pIdfRowsFunc);
if (NULL == pIdfRowsFunc) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pIdfRowsFunc->isTailFunc = pSelect->hasTailFunc;
@ -871,7 +888,7 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt
pIdfRowsFunc->node.resultDataOrder = pIdfRowsFunc->node.requireDataOrder;
// indefinite rows functions and _select_values functions
int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, fmIsVectorFunc, &pIdfRowsFunc->pFuncs);
code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, fmIsVectorFunc, &pIdfRowsFunc->pFuncs);
if (TSDB_CODE_SUCCESS == code) {
code = rewriteExprsForSelect(pIdfRowsFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL);
}
@ -899,9 +916,10 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p
return TSDB_CODE_SUCCESS;
}
SInterpFuncLogicNode* pInterpFunc = (SInterpFuncLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INTERP_FUNC);
SInterpFuncLogicNode* pInterpFunc = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INTERP_FUNC, (SNode**)&pInterpFunc);
if (NULL == pInterpFunc) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pInterpFunc->node.groupAction = getGroupAction(pCxt, pSelect);
@ -909,7 +927,7 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p
pInterpFunc->node.resultDataOrder = pInterpFunc->node.requireDataOrder;
// interp functions and _group_key functions
int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, isInterpFunc, &pInterpFunc->pFuncs);
code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, isInterpFunc, &pInterpFunc->pFuncs);
if (TSDB_CODE_SUCCESS == code) {
code = rewriteExprsForSelect(pInterpFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL);
}
@ -918,10 +936,10 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p
SFillNode* pFill = (SFillNode*)pSelect->pFill;
pInterpFunc->timeRange = pFill->timeRange;
pInterpFunc->fillMode = pFill->mode;
pInterpFunc->pTimeSeries = nodesCloneNode(pFill->pWStartTs);
pInterpFunc->pFillValues = nodesCloneNode(pFill->pValues);
if (NULL == pInterpFunc->pTimeSeries || (NULL != pFill->pValues && NULL == pInterpFunc->pFillValues)) {
code = TSDB_CODE_OUT_OF_MEMORY;
pInterpFunc->pTimeSeries = NULL;
code = nodesCloneNode(pFill->pWStartTs, &pInterpFunc->pTimeSeries);
if (TSDB_CODE_SUCCESS == code) {
code = nodesCloneNode(pFill->pValues, &pInterpFunc->pFillValues);
}
}
@ -965,10 +983,7 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm
}
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving) {
pWindow->node.pConditions = nodesCloneNode(pSelect->pHaving);
if (NULL == pWindow->node.pConditions) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = nodesCloneNode(pSelect->pHaving, &pWindow->node.pConditions);
}
pSelect->hasAggFuncs = false;
@ -984,9 +999,10 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm
static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindowNode* pState, SSelectStmt* pSelect,
SLogicNode** pLogicNode) {
SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
SWindowLogicNode* pWindow = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pWindow->winType = WINDOW_TYPE_STATE;
@ -995,16 +1011,23 @@ static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindo
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_IN_BLOCK : getRequireDataOrder(true, pSelect);
pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder;
pWindow->pStateExpr = nodesCloneNode(pState->pExpr);
pWindow->pTspk = nodesCloneNode(pState->pCol);
if (NULL == pWindow->pStateExpr || NULL == pWindow->pTspk) {
pWindow->pStateExpr = NULL;
code = nodesCloneNode(pState->pExpr, &pWindow->pStateExpr);
if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
code = nodesCloneNode(pState->pCol, &pWindow->pTspk);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pWindow);
return code;
}
// rewrite the expression in subsequent clauses
int32_t code = rewriteExprForSelect(pWindow->pStateExpr, pSelect, SQL_CLAUSE_WINDOW);
code = rewriteExprForSelect(pWindow->pStateExpr, pSelect, SQL_CLAUSE_WINDOW);
if (TSDB_CODE_SUCCESS == code) {
code = createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode);
} else {
nodesDestroyNode((SNode*)pWindow);
}
return code;
@ -1012,9 +1035,10 @@ static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindo
static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionWindowNode* pSession,
SSelectStmt* pSelect, SLogicNode** pLogicNode) {
SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
SWindowLogicNode* pWindow = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pWindow->winType = WINDOW_TYPE_SESSION;
@ -1026,21 +1050,28 @@ static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionW
pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder;
pWindow->pTspk = nodesCloneNode((SNode*)pSession->pCol);
pWindow->pTspk = NULL;
code = nodesCloneNode((SNode*)pSession->pCol, &pWindow->pTspk);
if (NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pWindow->pTsEnd = NULL;
code = nodesCloneNode((SNode*)pSession->pCol, &pWindow->pTsEnd);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pWindow);
return code;
}
pWindow->pTsEnd = nodesCloneNode((SNode*)pSession->pCol);
return createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode);
}
static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SIntervalWindowNode* pInterval,
SSelectStmt* pSelect, SLogicNode** pLogicNode) {
SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
SWindowLogicNode* pWindow = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pWindow->winType = WINDOW_TYPE_INTERVAL;
@ -1058,10 +1089,11 @@ static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SInterva
: (pSelect->hasTimeLineFunc ? getRequireDataOrder(true, pSelect) : DATA_ORDER_LEVEL_IN_BLOCK);
pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : getRequireDataOrder(true, pSelect);
pWindow->pTspk = nodesCloneNode(pInterval->pCol);
pWindow->pTspk = NULL;
code = nodesCloneNode(pInterval->pCol, &pWindow->pTspk);
if (NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pWindow->isPartTb = pSelect->pPartitionByList ? keysHasTbname(pSelect->pPartitionByList) : 0;
@ -1070,9 +1102,10 @@ static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SInterva
static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindowNode* pEvent, SSelectStmt* pSelect,
SLogicNode** pLogicNode) {
SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
SWindowLogicNode* pWindow = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pWindow->winType = WINDOW_TYPE_EVENT;
@ -1081,9 +1114,22 @@ static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindo
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_IN_BLOCK : getRequireDataOrder(true, pSelect);
pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder;
pWindow->pStartCond = nodesCloneNode(pEvent->pStartCond);
pWindow->pEndCond = nodesCloneNode(pEvent->pEndCond);
pWindow->pTspk = nodesCloneNode(pEvent->pCol);
pWindow->pStartCond = NULL;
code = nodesCloneNode(pEvent->pStartCond, &pWindow->pStartCond);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pWindow);
return code;
}
code = nodesCloneNode(pEvent->pEndCond, &pWindow->pEndCond);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pWindow);
return code;
}
code = nodesCloneNode(pEvent->pCol, &pWindow->pTspk);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pWindow);
return code;
}
if (NULL == pWindow->pStartCond || NULL == pWindow->pEndCond || NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY;
@ -1093,9 +1139,10 @@ static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindo
static int32_t createWindowLogicNodeByCount(SLogicPlanContext* pCxt, SCountWindowNode* pCount, SSelectStmt* pSelect,
SLogicNode** pLogicNode) {
SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW);
SWindowLogicNode* pWindow = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pWindow->winType = WINDOW_TYPE_COUNT;
@ -1106,10 +1153,11 @@ static int32_t createWindowLogicNodeByCount(SLogicPlanContext* pCxt, SCountWindo
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder;
pWindow->windowCount = pCount->windowCount;
pWindow->windowSliding = pCount->windowSliding;
pWindow->pTspk = nodesCloneNode(pCount->pCol);
pWindow->pTspk = NULL;
code = nodesCloneNode(pCount->pCol, &pWindow->pTspk);
if (NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
return createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode);
}
@ -1159,9 +1207,17 @@ static int32_t partFillExprs(SSelectStmt* pSelect, SNodeList** pFillExprs, SNode
SNode* pProject = NULL;
FOREACH(pProject, pSelect->pProjectionList) {
if (needFillValue(pProject)) {
code = nodesListMakeStrictAppend(pFillExprs, nodesCloneNode(pProject));
SNode* pNew = NULL;
code = nodesCloneNode(pProject, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(pFillExprs, pNew);
}
} else if (QUERY_NODE_VALUE != nodeType(pProject)) {
code = nodesListMakeStrictAppend(pNotFillExprs, nodesCloneNode(pProject));
SNode* pNew = NULL;
code = nodesCloneNode(pProject, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(pNotFillExprs, pNew);
}
}
if (TSDB_CODE_SUCCESS != code) {
NODES_DESTORY_LIST(*pFillExprs);
@ -1174,9 +1230,17 @@ static int32_t partFillExprs(SSelectStmt* pSelect, SNodeList** pFillExprs, SNode
FOREACH(pOrderExpr, pSelect->pOrderByList) {
SNode* pExpr = ((SOrderByExprNode*)pOrderExpr)->pExpr;
if (needFillValue(pExpr)) {
code = nodesListMakeStrictAppend(pFillExprs, nodesCloneNode(pExpr));
SNode* pNew = NULL;
code = nodesCloneNode(pProject, &pExpr);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(pFillExprs, pNew);
}
} else if (QUERY_NODE_VALUE != nodeType(pExpr)) {
code = nodesListMakeStrictAppend(pNotFillExprs, nodesCloneNode(pExpr));
SNode* pNew = NULL;
code = nodesCloneNode(pProject, &pExpr);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(pNotFillExprs, pNew);
}
}
if (TSDB_CODE_SUCCESS != code) {
NODES_DESTORY_LIST(*pFillExprs);
@ -1199,9 +1263,10 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
return TSDB_CODE_SUCCESS;
}
SFillLogicNode* pFill = (SFillLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FILL);
SFillLogicNode* pFill = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FILL, (SNode**)&pFill);
if (NULL == pFill) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pFill->node.groupAction = getGroupAction(pCxt, pSelect);
@ -1209,7 +1274,7 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
pFill->node.resultDataOrder = pFill->node.requireDataOrder;
pFill->node.inputTsOrder = TSDB_ORDER_ASC;
int32_t code = partFillExprs(pSelect, &pFill->pFillExprs, &pFill->pNotFillExprs);
code = partFillExprs(pSelect, &pFill->pFillExprs, &pFill->pNotFillExprs);
if (TSDB_CODE_SUCCESS == code) {
code = rewriteExprsForSelect(pFill->pFillExprs, pSelect, SQL_CLAUSE_FILL, NULL);
}
@ -1225,10 +1290,10 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
pFill->mode = pFillNode->mode;
pFill->timeRange = pFillNode->timeRange;
pFill->pValues = nodesCloneNode(pFillNode->pValues);
pFill->pWStartTs = nodesCloneNode(pFillNode->pWStartTs);
if ((NULL != pFillNode->pValues && NULL == pFill->pValues) || NULL == pFill->pWStartTs) {
code = TSDB_CODE_OUT_OF_MEMORY;
pFill->pValues = NULL;
code = nodesCloneNode(pFillNode->pValues, &pFill->pValues);
if (TSDB_CODE_SUCCESS == code) {
code = nodesCloneNode(pFillNode->pWStartTs, &pFillNode->pWStartTs);
}
if (TSDB_CODE_SUCCESS == code && 0 == LIST_LENGTH(pFill->node.pTargets)) {
@ -1257,9 +1322,10 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
return TSDB_CODE_SUCCESS;
}
SSortLogicNode* pSort = (SSortLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT);
SSortLogicNode* pSort = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
if (NULL == pSort) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pSort->groupSort = pSelect->groupSort;
@ -1268,16 +1334,20 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
pSort->node.resultDataOrder = isPrimaryKeySort(pSelect->pOrderByList)
? (pSort->groupSort ? DATA_ORDER_LEVEL_IN_GROUP : DATA_ORDER_LEVEL_GLOBAL)
: DATA_ORDER_LEVEL_NONE;
int32_t code = nodesCollectColumns(pSelect, SQL_CLAUSE_ORDER_BY, NULL, COLLECT_COL_TYPE_ALL, &pSort->node.pTargets);
code = nodesCollectColumns(pSelect, SQL_CLAUSE_ORDER_BY, NULL, COLLECT_COL_TYPE_ALL, &pSort->node.pTargets);
if (TSDB_CODE_SUCCESS == code && NULL == pSort->node.pTargets) {
code = nodesListMakeStrictAppend(&pSort->node.pTargets,
nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0)));
SNode* pNew = NULL;
code = nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0), &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pSort->node.pTargets, pNew);
}
}
if (TSDB_CODE_SUCCESS == code) {
pSort->pSortKeys = nodesCloneList(pSelect->pOrderByList);
pSort->pSortKeys = NULL;
code = nodesCloneList(pSelect->pOrderByList, &pSort->pSortKeys);
if (NULL == pSort->pSortKeys) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = code;
}
SNode* pNode = NULL;
SOrderByExprNode* firstSortKey = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0);
@ -1306,16 +1376,17 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
static int32_t createColumnByProjections(SLogicPlanContext* pCxt, const char* pStmtName, SNodeList* pExprs,
SNodeList** pCols) {
SNodeList* pList = nodesMakeList();
SNodeList* pList = NULL;
int32_t code = nodesMakeList(&pList);
if (NULL == pList) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
SNode* pNode;
FOREACH(pNode, pExprs) {
if (TSDB_CODE_SUCCESS != nodesListAppend(pList, (SNode*)createColumnByExpr(pStmtName, (SExprNode*)pNode))) {
if (TSDB_CODE_SUCCESS != (code = nodesListStrictAppend(pList, (SNode*)createColumnByExpr(pStmtName, (SExprNode*)pNode)))) {
nodesDestroyList(pList);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
}
@ -1324,9 +1395,10 @@ static int32_t createColumnByProjections(SLogicPlanContext* pCxt, const char* pS
}
static int32_t createProjectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) {
SProjectLogicNode* pProject = (SProjectLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT);
SProjectLogicNode* pProject = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
if (NULL == pProject) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
TSWAP(pProject->node.pLimit, pSelect->pLimit);
@ -1337,11 +1409,10 @@ static int32_t createProjectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSel
pProject->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
pProject->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
int32_t code = TSDB_CODE_SUCCESS;
pProject->pProjections = nodesCloneList(pSelect->pProjectionList);
pProject->pProjections = NULL;
code = nodesCloneList(pSelect->pProjectionList, &pProject->pProjections);
if (NULL == pProject->pProjections) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = code;
}
strcpy(pProject->stmtName, pSelect->stmtName);
@ -1363,20 +1434,23 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
return TSDB_CODE_SUCCESS;
}
SPartitionLogicNode* pPartition = (SPartitionLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION);
SPartitionLogicNode* pPartition = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION, (SNode**)&pPartition);
if (NULL == pPartition) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pPartition->node.groupAction = GROUP_ACTION_SET;
pPartition->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
pPartition->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
int32_t code =
nodesCollectColumns(pSelect, SQL_CLAUSE_PARTITION_BY, NULL, COLLECT_COL_TYPE_ALL, &pPartition->node.pTargets);
code = nodesCollectColumns(pSelect, SQL_CLAUSE_PARTITION_BY, NULL, COLLECT_COL_TYPE_ALL, &pPartition->node.pTargets);
if (TSDB_CODE_SUCCESS == code && NULL == pPartition->node.pTargets) {
code = nodesListMakeStrictAppend(&pPartition->node.pTargets,
nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0)));
SNode* pNew = NULL;
code = nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0), &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pPartition->node.pTargets, pNew);
}
}
if (TSDB_CODE_SUCCESS == code) {
@ -1385,10 +1459,8 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
}
if (TSDB_CODE_SUCCESS == code) {
pPartition->pPartitionKeys = nodesCloneList(pSelect->pPartitionByList);
if (NULL == pPartition->pPartitionKeys) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pPartition->pPartitionKeys = NULL;
code = nodesCloneList(pSelect->pPartitionByList, &pPartition->pPartitionKeys);
}
if (keysHasCol(pPartition->pPartitionKeys) && pSelect->pWindow &&
@ -1401,25 +1473,19 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
}
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pTags) {
pPartition->pTags = nodesCloneList(pSelect->pTags);
if (NULL == pPartition->pTags) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pPartition->pTags = NULL;
code = nodesCloneList(pSelect->pTags, &pPartition->pTags);
}
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable) {
pPartition->pSubtable = nodesCloneNode(pSelect->pSubtable);
if (NULL == pPartition->pSubtable) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pPartition->pSubtable = NULL;
code = nodesCloneNode(pSelect->pSubtable, &pPartition->pSubtable);
}
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving && !pSelect->hasAggFuncs && NULL == pSelect->pGroupByList &&
NULL == pSelect->pWindow) {
pPartition->node.pConditions = nodesCloneNode(pSelect->pHaving);
if (NULL == pPartition->node.pConditions) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pPartition->node.pConditions = NULL;
code = nodesCloneNode(pSelect->pHaving, &pPartition->node.pConditions);
}
if (TSDB_CODE_SUCCESS == code) {
@ -1436,21 +1502,25 @@ static int32_t createDistinctLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe
return TSDB_CODE_SUCCESS;
}
SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG);
SAggLogicNode* pAgg = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
if (NULL == pAgg) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pAgg->node.groupAction = GROUP_ACTION_CLEAR;//getDistinctGroupAction(pCxt, pSelect);
pAgg->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
pAgg->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
int32_t code = TSDB_CODE_SUCCESS;
// set grouyp keys, agg funcs and having conditions
SNodeList* pGroupKeys = NULL;
SNode* pProjection = NULL;
FOREACH(pProjection, pSelect->pProjectionList) {
code = nodesListMakeStrictAppend(&pGroupKeys, createGroupingSetNode(pProjection));
SNode* pNew = NULL;
code = createGroupingSetNode(pProjection, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pGroupKeys, pNew);
}
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pGroupKeys);
break;
@ -1548,25 +1618,20 @@ static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* p
return TSDB_CODE_SUCCESS;
}
SSortLogicNode* pSort = (SSortLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT);
SSortLogicNode* pSort = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
if (NULL == pSort) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
TSWAP(pSort->node.pLimit, pSetOperator->pLimit);
int32_t code = TSDB_CODE_SUCCESS;
pSort->node.pTargets = nodesCloneList(pSetOperator->pProjectionList);
if (NULL == pSort->node.pTargets) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pSort->node.pTargets = NULL;
code = nodesCloneList(pSetOperator->pProjectionList, &pSort->node.pTargets);
if (TSDB_CODE_SUCCESS == code) {
pSort->pSortKeys = nodesCloneList(pSetOperator->pOrderByList);
if (NULL == pSort->pSortKeys) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pSort->pSortKeys = NULL;
code = nodesCloneList(pSetOperator->pOrderByList, &pSort->pSortKeys);
}
if (TSDB_CODE_SUCCESS == code) {
@ -1580,9 +1645,10 @@ static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* p
static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator,
SLogicNode** pLogicNode) {
SProjectLogicNode* pProject = (SProjectLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT);
SProjectLogicNode* pProject = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
if (NULL == pProject) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
if (NULL == pSetOperator->pOrderByList) {
@ -1591,12 +1657,8 @@ static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator
pProject->ignoreGroupId = true;
pProject->isSetOpProj = true;
int32_t code = TSDB_CODE_SUCCESS;
pProject->pProjections = nodesCloneList(pSetOperator->pProjectionList);
if (NULL == pProject->pProjections) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pProject->pProjections = NULL;
code = nodesCloneList(pSetOperator->pProjectionList, &pProject->pProjections);
if (TSDB_CODE_SUCCESS == code) {
code = createColumnByProjections(pCxt, pSetOperator->stmtName, pSetOperator->pProjectionList,
@ -1613,20 +1675,18 @@ static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator
}
static int32_t createSetOpAggLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG);
SAggLogicNode* pAgg = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
if (NULL == pAgg) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
if (NULL == pSetOperator->pOrderByList) {
TSWAP(pAgg->node.pSlimit, pSetOperator->pLimit);
}
int32_t code = TSDB_CODE_SUCCESS;
pAgg->pGroupKeys = nodesCloneList(pSetOperator->pProjectionList);
if (NULL == pAgg->pGroupKeys) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pAgg->pGroupKeys = NULL;
code = nodesCloneList(pSetOperator->pProjectionList, &pAgg->pGroupKeys);
// rewrite the expression in subsequent clauses
if (TSDB_CODE_SUCCESS == code) {
@ -1723,9 +1783,10 @@ static int32_t getMsgType(ENodeType sqlType) {
}
static int32_t createVnodeModifLogicNode(SLogicPlanContext* pCxt, SVnodeModifyOpStmt* pStmt, SLogicNode** pLogicNode) {
SVnodeModifyLogicNode* pModif = (SVnodeModifyLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY);
SVnodeModifyLogicNode* pModif = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModif);
if (NULL == pModif) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pModif->modifyType = MODIFY_TABLE_TYPE_INSERT;
TSWAP(pModif->pDataBlocks, pStmt->pDataBlocks);
@ -1747,10 +1808,8 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
if (TSDB_CODE_SUCCESS == code) {
pScan->scanType = SCAN_TYPE_TABLE;
pScan->scanRange = pDelete->timeRange;
pScan->pScanCols = nodesCloneList(((SFunctionNode*)pDelete->pCountFunc)->pParameterList);
if (NULL == pScan->pScanCols) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pScan->pScanCols = NULL;
code = nodesCloneList(((SFunctionNode*)pDelete->pCountFunc)->pParameterList, &pScan->pScanCols);
}
STableMeta* pMeta = ((SRealTableNode*)pDelete->pFromTable)->pMeta;
@ -1759,10 +1818,7 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
}
if (TSDB_CODE_SUCCESS == code && NULL != pDelete->pTagCond) {
pScan->pTagCond = nodesCloneNode(pDelete->pTagCond);
if (NULL == pScan->pTagCond) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = nodesCloneNode(pDelete->pTagCond, &pScan->pTagCond);
}
// set output
@ -1780,17 +1836,30 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
}
static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) {
SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG);
SAggLogicNode* pAgg = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
if (NULL == pAgg) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
int32_t code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, nodesCloneNode(pDelete->pCountFunc));
SNode* pNew = NULL;
code = nodesCloneNode(pDelete->pCountFunc, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pAgg->pAggFuncs, nodesCloneNode(pDelete->pFirstFunc));
code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, pNew);
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pAgg->pAggFuncs, nodesCloneNode(pDelete->pLastFunc));
SNode* pNew = NULL;
code = nodesCloneNode(pDelete->pFirstFunc, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pAgg->pAggFuncs, pNew);
}
}
if (TSDB_CODE_SUCCESS == code) {
SNode* pNew = NULL;
code = nodesCloneNode(pDelete->pLastFunc, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pAgg->pAggFuncs, pNew);
}
}
if (TSDB_CODE_SUCCESS == code) {
code = rewriteExpr(pAgg->pAggFuncs, &pDelete->pCountFunc);
@ -1817,9 +1886,10 @@ static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pD
static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDeleteStmt* pDelete,
SLogicNode** pLogicNode) {
SVnodeModifyLogicNode* pModify = (SVnodeModifyLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY);
SVnodeModifyLogicNode* pModify = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify);
if (NULL == pModify) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
SRealTableNode* pRealTable = (SRealTableNode*)pDelete->pFromTable;
@ -1830,12 +1900,21 @@ static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDelet
snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName);
strcpy(pModify->tsColName, pRealTable->pMeta->schema->name);
pModify->deleteTimeRange = pDelete->timeRange;
pModify->pAffectedRows = nodesCloneNode(pDelete->pCountFunc);
pModify->pStartTs = nodesCloneNode(pDelete->pFirstFunc);
pModify->pEndTs = nodesCloneNode(pDelete->pLastFunc);
if (NULL == pModify->pAffectedRows || NULL == pModify->pStartTs || NULL == pModify->pEndTs) {
pModify->pAffectedRows = NULL;
code = nodesCloneNode(pDelete->pCountFunc, &pModify->pAffectedRows);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pModify);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
code = nodesCloneNode(pDelete->pFirstFunc, &pModify->pStartTs);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pModify);
return code;
}
code = nodesCloneNode(pDelete->pLastFunc, &pModify->pEndTs);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pModify);
return code;
}
*pLogicNode = (SLogicNode*)pModify;
@ -1868,9 +1947,10 @@ static int32_t creatInsertRootLogicNode(SLogicPlanContext* pCxt, SInsertStmt* pI
static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInsertStmt* pInsert,
SLogicNode** pLogicNode) {
SVnodeModifyLogicNode* pModify = (SVnodeModifyLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY);
SVnodeModifyLogicNode* pModify = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify);
if (NULL == pModify) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
SRealTableNode* pRealTable = (SRealTableNode*)pInsert->pTable;
@ -1881,10 +1961,11 @@ static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInser
pModify->tableType = pRealTable->pMeta->tableType;
snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName);
TSWAP(pModify->pVgroupList, pRealTable->pVgroupList);
pModify->pInsertCols = nodesCloneList(pInsert->pCols);
pModify->pInsertCols = NULL;
code = nodesCloneList(pInsert->pCols, &pModify->pInsertCols);
if (NULL == pModify->pInsertCols) {
nodesDestroyNode((SNode*)pModify);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
*pLogicNode = (SLogicNode*)pModify;
@ -1949,15 +2030,16 @@ static void setLogicSubplanType(bool hasScan, SLogicSubplan* pSubplan) {
int32_t createLogicPlan(SPlanContext* pCxt, SLogicSubplan** pLogicSubplan) {
SLogicPlanContext cxt = {.pPlanCxt = pCxt, .pCurrRoot = NULL, .hasScan = false};
SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN);
SLogicSubplan* pSubplan = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan);
if (NULL == pSubplan) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pSubplan->id.queryId = pCxt->queryId;
pSubplan->id.groupId = 1;
pSubplan->id.subplanId = 1;
int32_t code = createQueryLogicNode(&cxt, pCxt->pAstRoot, &pSubplan->pNode);
code = createQueryLogicNode(&cxt, pCxt->pAstRoot, &pSubplan->pNode);
if (TSDB_CODE_SUCCESS == code) {
setLogicNodeParent(pSubplan->pNode);
setLogicSubplanType(cxt.hasScan, pSubplan);

1190
source/libs/planner/src/planOptimizer.c
View File

File diff suppressed because it is too large Load Diff

589
source/libs/planner/src/planPhysiCreater.c
View File

File diff suppressed because it is too large Load Diff

35
source/libs/planner/src/planScaleOut.c
View File

@ -21,12 +21,16 @@ typedef struct SScaleOutContext {
} SScaleOutContext;
static SLogicSubplan* singleCloneSubLogicPlan(SScaleOutContext* pCxt, SLogicSubplan* pSrc, int32_t level) {
SLogicSubplan* pDst = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN);
SLogicSubplan* pDst = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pDst);
if (NULL == pDst) {
terrno = code;
return NULL;
}
pDst->pNode = (SLogicNode*)nodesCloneNode((SNode*)pSrc->pNode);
pDst->pNode = NULL;
code = nodesCloneNode((SNode*)pSrc->pNode, (SNode**)&pDst->pNode);
if (NULL == pDst->pNode) {
terrno = code;
nodesDestroyNode((SNode*)pDst);
return NULL;
}
@ -69,7 +73,7 @@ static int32_t scaleOutByVgroups(SScaleOutContext* pCxt, SLogicSubplan* pSubplan
for (int32_t i = 0; i < pSubplan->pVgroupList->numOfVgroups; ++i) {
SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
if (NULL == pNewSubplan) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
code = setScanVgroup(pNewSubplan->pNode, pSubplan->pVgroupList->vgroups + i);
if (TSDB_CODE_SUCCESS == code) {
@ -90,14 +94,15 @@ static int32_t scaleOutForInsertValues(SScaleOutContext* pCxt, SLogicSubplan* pS
SNodeList* pGroup) {
SVnodeModifyLogicNode* pNode = (SVnodeModifyLogicNode*)pSubplan->pNode;
size_t numOfVgroups = taosArrayGetSize(pNode->pDataBlocks);
int32_t code = 0;
for (int32_t i = 0; i < numOfVgroups; ++i) {
SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
if (NULL == pNewSubplan) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
((SVnodeModifyLogicNode*)pNewSubplan->pNode)->pVgDataBlocks = (SVgDataBlocks*)taosArrayGetP(pNode->pDataBlocks, i);
if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pGroup, (SNode*)pNewSubplan)) {
return TSDB_CODE_OUT_OF_MEMORY;
if (TSDB_CODE_SUCCESS != (code = nodesListStrictAppend(pGroup, (SNode*)pNewSubplan))) {
return code;
}
}
return TSDB_CODE_SUCCESS;
@ -132,7 +137,7 @@ static int32_t scaleOutForCompute(SScaleOutContext* pCxt, SLogicSubplan* pSubpla
for (int32_t i = 0; i < pSubplan->numOfComputeNodes; ++i) {
SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
if (NULL == pNewSubplan) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
code = nodesListStrictAppend(pGroup, (SNode*)pNewSubplan);
if (TSDB_CODE_SUCCESS != code) {
@ -196,12 +201,12 @@ static int32_t pushHierarchicalPlan(SNodeList* pParentsGroup, SNodeList* pCurren
}
static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pParentsGroup) {
SNodeList* pCurrentGroup = nodesMakeList();
SNodeList* pCurrentGroup = NULL;
int32_t code = nodesMakeList(&pCurrentGroup);
if (NULL == pCurrentGroup) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
int32_t code = TSDB_CODE_SUCCESS;
switch (pSubplan->subplanType) {
case SUBPLAN_TYPE_MERGE:
code = scaleOutForMerge(pCxt, pSubplan, level, pCurrentGroup);
@ -243,13 +248,17 @@ static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32
}
static SQueryLogicPlan* makeQueryLogicPlan() {
SQueryLogicPlan* pLogicPlan = (SQueryLogicPlan*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN);
SQueryLogicPlan* pLogicPlan = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN, (SNode**)&pLogicPlan);
if (NULL == pLogicPlan) {
terrno = code;
return NULL;
}
pLogicPlan->pTopSubplans = nodesMakeList();
pLogicPlan->pTopSubplans = NULL;
code = nodesMakeList(&pLogicPlan->pTopSubplans);
if (NULL == pLogicPlan->pTopSubplans) {
nodesDestroyNode((SNode*)pLogicPlan);
terrno = code;
return NULL;
}
return pLogicPlan;
@ -258,7 +267,7 @@ static SQueryLogicPlan* makeQueryLogicPlan() {
int32_t scaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQueryLogicPlan** pLogicPlan) {
SQueryLogicPlan* pPlan = makeQueryLogicPlan();
if (NULL == pPlan) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
SScaleOutContext cxt = {.pPlanCxt = pCxt, .subplanId = 1};

340
source/libs/planner/src/planSpliter.c
View File

@ -59,7 +59,8 @@ static void splSetSubplanVgroups(SLogicSubplan* pSubplan, SLogicNode* pNode) {
}
static SLogicSubplan* splCreateScanSubplan(SSplitContext* pCxt, SLogicNode* pNode, int32_t flag) {
SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN);
SLogicSubplan* pSubplan = NULL;
terrno = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan);
if (NULL == pSubplan) {
return NULL;
}
@ -93,37 +94,44 @@ static void splSetSubplanType(SLogicSubplan* pSubplan) {
pSubplan->subplanType = splHasScan(pSubplan->pNode) ? SUBPLAN_TYPE_SCAN : SUBPLAN_TYPE_MERGE;
}
static SLogicSubplan* splCreateSubplan(SSplitContext* pCxt, SLogicNode* pNode) {
SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN);
static int32_t splCreateSubplan(SSplitContext* pCxt, SLogicNode* pNode, SLogicSubplan** ppSubplan) {
SLogicSubplan* pSubplan = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan);
if (NULL == pSubplan) {
return NULL;
return code;
}
pSubplan->id.queryId = pCxt->queryId;
pSubplan->id.groupId = pCxt->groupId;
pSubplan->pNode = pNode;
pNode->pParent = NULL;
splSetSubplanType(pSubplan);
return pSubplan;
*ppSubplan = pSubplan;
return code;
}
static int32_t splCreateExchangeNode(SSplitContext* pCxt, SLogicNode* pChild, SExchangeLogicNode** pOutput) {
SExchangeLogicNode* pExchange = (SExchangeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE);
SExchangeLogicNode* pExchange = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE, (SNode**)&pExchange);
if (NULL == pExchange) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pExchange->srcStartGroupId = pCxt->groupId;
pExchange->srcEndGroupId = pCxt->groupId;
pExchange->node.precision = pChild->precision;
pExchange->node.dynamicOp = pChild->dynamicOp;
pExchange->node.pTargets = nodesCloneList(pChild->pTargets);
pExchange->node.pTargets = NULL;
code = nodesCloneList(pChild->pTargets, &pExchange->node.pTargets);
if (NULL == pExchange->node.pTargets) {
return TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyNode((SNode*)pExchange);
return code;
}
if (NULL != pChild->pLimit) {
pExchange->node.pLimit = nodesCloneNode(pChild->pLimit);
pExchange->node.pLimit = NULL;
code = nodesCloneNode(pChild->pLimit, &pExchange->node.pLimit);
if (NULL == pExchange->node.pLimit) {
return TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyNode((SNode*)pExchange);
return code;
}
((SLimitNode*)pChild->pLimit)->limit += ((SLimitNode*)pChild->pLimit)->offset;
((SLimitNode*)pChild->pLimit)->offset = 0;
@ -368,18 +376,14 @@ static int32_t stbSplRewriteFuns(const SNodeList* pFuncs, SNodeList** pPartialFu
SFunctionNode* pMergeFunc = NULL;
int32_t code = TSDB_CODE_SUCCESS;
if (fmIsWindowPseudoColumnFunc(pFunc->funcId)) {
pPartFunc = (SFunctionNode*)nodesCloneNode(pNode);
pMergeFunc = (SFunctionNode*)nodesCloneNode(pNode);
if (NULL == pPartFunc || NULL == pMergeFunc) {
nodesDestroyNode((SNode*)pPartFunc);
nodesDestroyNode((SNode*)pMergeFunc);
code = TSDB_CODE_OUT_OF_MEMORY;
code = nodesCloneNode(pNode, (SNode**)&pPartFunc);
if (TSDB_CODE_SUCCESS == code) {
code = nodesCloneNode(pNode, (SNode**)&pMergeFunc);
}
if(pMidFuncs != NULL){
pMidFunc = (SFunctionNode*)nodesCloneNode(pNode);
if(TSDB_CODE_SUCCESS == code && pMidFuncs != NULL){
code = nodesCloneNode(pNode, (SNode**)&pMidFunc);
if (NULL == pMidFunc) {
nodesDestroyNode((SNode*)pMidFunc);
code = TSDB_CODE_OUT_OF_MEMORY;
}
}
} else {
@ -419,9 +423,10 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr
++index;
}
SFunctionNode* pWStart = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
SFunctionNode* pWStart = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWStart);
if (NULL == pWStart) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
strcpy(pWStart->functionName, "_wstart");
int64_t pointer = (int64_t)pWStart;
@ -431,7 +436,7 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr
strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
pWStart->node.resType.precision = precision;
int32_t code = fmGetFuncInfo(pWStart, NULL, 0);
code = fmGetFuncInfo(pWStart, NULL, 0);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pFuncs, (SNode*)pWStart);
}
@ -450,9 +455,10 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) {
++index;
}
SFunctionNode* pWEnd = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
SFunctionNode* pWEnd = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWEnd);
if (NULL == pWEnd) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
strcpy(pWEnd->functionName, "_wend");
int64_t pointer = (int64_t)pWEnd;
@ -461,7 +467,7 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) {
taosCreateMD5Hash(name, len);
strncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
int32_t code = fmGetFuncInfo(pWEnd, NULL, 0);
code = fmGetFuncInfo(pWEnd, NULL, 0);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pWin->pFuncs, (SNode*)pWEnd);
}
@ -482,9 +488,10 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
SNode* pConditions = pMergeWindow->node.pConditions;
pMergeWindow->node.pConditions = NULL;
SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow);
SWindowLogicNode* pPartWin = NULL;
int32_t code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pPartWin);
if (NULL == pPartWin) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pPartWin->node.groupAction = GROUP_ACTION_KEEP;
@ -494,7 +501,7 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
splSetParent((SLogicNode*)pPartWin);
int32_t index = 0;
int32_t code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, NULL, &pMergeWindow->pFuncs);
code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, NULL, &pMergeWindow->pFuncs);
if (TSDB_CODE_SUCCESS == code) {
code = stbSplAppendWStart(pPartWin->pFuncs, &index, ((SColumnNode*)pMergeWindow->pTspk)->node.resType.precision);
}
@ -503,10 +510,8 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
}
if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMergeWindow->pTspk);
pMergeWindow->pTspk = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index));
if (NULL == pMergeWindow->pTspk) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pMergeWindow->pTspk = NULL;
code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMergeWindow->pTspk);
}
nodesDestroyList(pFunc);
@ -529,14 +534,17 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
SNode* pConditions = pMergeWindow->node.pConditions;
pMergeWindow->node.pConditions = NULL;
SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow);
SWindowLogicNode* pPartWin = NULL;
int32_t code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pPartWin);
if (NULL == pPartWin) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
SWindowLogicNode* pMidWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow);
SWindowLogicNode* pMidWin = NULL;
code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pMidWin);
if (NULL == pMidWin) {
return TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyNode((SNode*)pPartWin);
return code;
}
pPartWin->node.groupAction = GROUP_ACTION_KEEP;
@ -550,7 +558,7 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
SNodeList* pFuncPart = NULL;
SNodeList* pFuncMid = NULL;
SNodeList* pFuncMerge = NULL;
int32_t code = stbSplRewriteFuns(pFunc, &pFuncPart, &pFuncMid, &pFuncMerge);
code = stbSplRewriteFuns(pFunc, &pFuncPart, &pFuncMid, &pFuncMerge);
pPartWin->pFuncs = pFuncPart;
pMidWin->pFuncs = pFuncMid;
pMergeWindow->pFuncs = pFuncMerge;
@ -565,10 +573,8 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMidWin->pTspk);
pMidWin->pTspk = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index));
if (NULL == pMidWin->pTspk) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pMidWin->pTspk = NULL;
code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMidWin->pTspk);
}
if (TSDB_CODE_SUCCESS == code) {
@ -580,10 +586,7 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMergeWindow->pTspk);
pMergeWindow->pTspk = nodesCloneNode(nodesListGetNode(pMidWin->node.pTargets, index));
if (NULL == pMergeWindow->pTspk) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = nodesCloneNode(nodesListGetNode(pMidWin->node.pTargets, index), &pMergeWindow->pTspk);
}
nodesDestroyList(pFunc);
@ -649,9 +652,10 @@ static int32_t stbSplRewriteFromMergeNode(SMergeLogicNode* pMerge, SLogicNode* p
static int32_t stbSplCreateMergeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SLogicNode* pSplitNode,
SNodeList* pMergeKeys, SLogicNode* pPartChild, bool groupSort, bool needSort) {
SMergeLogicNode* pMerge = (SMergeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE);
SMergeLogicNode* pMerge = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE, (SNode**)&pMerge);
if (NULL == pMerge) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pMerge->needSort = needSort;
pMerge->numOfChannels = stbSplGetNumOfVgroups(pPartChild);
@ -662,22 +666,19 @@ static int32_t stbSplCreateMergeNode(SSplitContext* pCxt, SLogicSubplan* pSubpla
pMerge->groupSort = groupSort;
pMerge->numOfSubplans = 1;
int32_t code = TSDB_CODE_SUCCESS;
pMerge->pInputs = nodesCloneList(pPartChild->pTargets);
// NULL != pSubplan means 'merge node' replaces 'split node'.
if (NULL == pSubplan) {
pMerge->node.pTargets = nodesCloneList(pPartChild->pTargets);
} else {
pMerge->node.pTargets = nodesCloneList(pSplitNode->pTargets);
}
if (NULL == pMerge->node.pTargets || NULL == pMerge->pInputs) {
code = TSDB_CODE_OUT_OF_MEMORY;
pMerge->pInputs = NULL;
code = nodesCloneList(pPartChild->pTargets, &pMerge->pInputs);
if (TSDB_CODE_SUCCESS == code) {
// NULL != pSubplan means 'merge node' replaces 'split node'.
if (NULL == pSubplan) {
code = nodesCloneList(pPartChild->pTargets, &pMerge->node.pTargets);
} else {
code = nodesCloneList(pSplitNode->pTargets, &pMerge->node.pTargets);
}
}
if (TSDB_CODE_SUCCESS == code && NULL != pSplitNode->pLimit) {
pMerge->node.pLimit = nodesCloneNode(pSplitNode->pLimit);
if (NULL == pMerge->node.pLimit) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pMerge->node.pLimit = NULL;
code = nodesCloneNode(pSplitNode->pLimit, &pMerge->node.pLimit);
((SLimitNode*)pSplitNode->pLimit)->limit += ((SLimitNode*)pSplitNode->pLimit)->offset;
((SLimitNode*)pSplitNode->pLimit)->offset = 0;
}
@ -708,14 +709,16 @@ static int32_t stbSplCreateExchangeNode(SSplitContext* pCxt, SLogicNode* pParent
}
static int32_t stbSplCreateMergeKeysByExpr(SNode* pExpr, EOrder order, SNodeList** pMergeKeys) {
SOrderByExprNode* pOrderByExpr = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR);
SOrderByExprNode* pOrderByExpr = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrderByExpr);
if (NULL == pOrderByExpr) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pOrderByExpr->pExpr = nodesCloneNode(pExpr);
pOrderByExpr->pExpr = NULL;
code = nodesCloneNode(pExpr, &pOrderByExpr->pExpr);
if (NULL == pOrderByExpr->pExpr) {
nodesDestroyNode((SNode*)pOrderByExpr);
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pOrderByExpr->order = order;
pOrderByExpr->nullOrder = (order == ORDER_ASC) ? NULL_ORDER_FIRST : NULL_ORDER_LAST;
@ -745,7 +748,7 @@ static int32_t stbSplSplitIntervalForBatch(SSplitContext* pCxt, SStableSplitInfo
SLogicSubplan* pSplitSubPlan = NULL;
if (TSDB_CODE_SUCCESS == code) {
pSplitSubPlan = splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT);
if (!pSplitSubPlan) code = TSDB_CODE_OUT_OF_MEMORY;
if (!pSplitSubPlan) code = terrno;
}
if (code == TSDB_CODE_SUCCESS) {
SNode* pNode;
@ -793,11 +796,14 @@ static int32_t stbSplSplitIntervalForStreamMultiAgg(SSplitContext* pCxt, SStable
}
if (TSDB_CODE_SUCCESS == code) {
SNode* subPlan = (SNode*)splCreateSubplan(pCxt, pMidWindow);
((SLogicSubplan*)subPlan)->subplanType = SUBPLAN_TYPE_MERGE;
SNode* subPlan = NULL;
code = splCreateSubplan(pCxt, pMidWindow, (SLogicSubplan**)&subPlan);
if (TSDB_CODE_SUCCESS == code) {
((SLogicSubplan*)subPlan)->subplanType = SUBPLAN_TYPE_MERGE;
code = nodesListMakeStrictAppend(&((SLogicSubplan*)subPlan)->pChildren,
(SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT));
code = nodesListMakeStrictAppend(&((SLogicSubplan*)subPlan)->pChildren,
(SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT));
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren, subPlan);
}
@ -828,9 +834,10 @@ static int32_t stbSplSplitSessionForStream(SSplitContext* pCxt, SStableSplitInfo
int32_t code = stbSplAppendWEnd(pPartWin, &index);
if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMergeWin->pTsEnd);
pMergeWin->pTsEnd = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index));
pMergeWin->pTsEnd = NULL;
code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMergeWin->pTsEnd);
if (NULL == pMergeWin->pTsEnd) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = code;
}
}
code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartWindow);
@ -1006,24 +1013,21 @@ static int32_t stbSplCreatePartAggNode(SAggLogicNode* pMergeAgg, SLogicNode** pO
SNode* pConditions = pMergeAgg->node.pConditions;
pMergeAgg->node.pConditions = NULL;
SAggLogicNode* pPartAgg = (SAggLogicNode*)nodesCloneNode((SNode*)pMergeAgg);
SAggLogicNode* pPartAgg = NULL;
int32_t code = nodesCloneNode((SNode*)pMergeAgg, (SNode**)&pPartAgg);
if (NULL == pPartAgg) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pPartAgg->node.groupAction = GROUP_ACTION_KEEP;
int32_t code = TSDB_CODE_SUCCESS;
if (NULL != pGroupKeys) {
pPartAgg->pGroupKeys = pGroupKeys;
code = createColumnByRewriteExprs(pPartAgg->pGroupKeys, &pPartAgg->node.pTargets);
}
if (TSDB_CODE_SUCCESS == code && NULL != pGroupKeys) {
pMergeAgg->pGroupKeys = nodesCloneList(pPartAgg->node.pTargets);
if (NULL == pMergeAgg->pGroupKeys) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
pMergeAgg->pGroupKeys = NULL;
code = nodesCloneList(pPartAgg->node.pTargets, &pMergeAgg->pGroupKeys);
}
if (TSDB_CODE_SUCCESS == code) {
pMergeAgg->node.pConditions = pConditions;
@ -1090,7 +1094,7 @@ static int32_t stbSplAggNodeCreateMerge(SSplitContext* pCtx, SStableSplitInfo* p
if (idx++ < originalLen) continue;
SFunctionNode* pGroupKeyFunc = createGroupKeyAggFunc((SColumnNode*)node);
if (!pGroupKeyFunc) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
break;
}
code = nodesListMakeStrictAppend(&extraAggFuncs, (SNode*)pGroupKeyFunc);
@ -1165,7 +1169,7 @@ static int32_t stbSplSplitAggNodeForCrossTableMulSubplan(SSplitContext* pCxt, SS
if (code == TSDB_CODE_SUCCESS) {
pFirstScanSubplan = splCreateScanSubplan(pCxt, pPartAgg, SPLIT_FLAG_STABLE_SPLIT);
if (!pFirstScanSubplan) code = TSDB_CODE_OUT_OF_MEMORY;
if (!pFirstScanSubplan) code = terrno;
}
if (code == TSDB_CODE_SUCCESS) {
@ -1220,7 +1224,7 @@ static int32_t stbSplSplitAggNodeForCrossTable(SSplitContext* pCxt, SStableSplit
SLogicSubplan* pScanSubplan = NULL;
if (TSDB_CODE_SUCCESS == code) {
pScanSubplan = splCreateScanSubplan(pCxt, pPartAgg, SPLIT_FLAG_STABLE_SPLIT);
if (!pScanSubplan) code = TSDB_CODE_OUT_OF_MEMORY;
if (!pScanSubplan) code = terrno;
}
if (code == TSDB_CODE_SUCCESS) {
@ -1242,10 +1246,11 @@ static int32_t stbSplSplitAggNode(SSplitContext* pCxt, SStableSplitInfo* pInfo)
return stbSplSplitAggNodeForCrossTable(pCxt, pInfo);
}
static SNode* stbSplCreateColumnNode(SExprNode* pExpr) {
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
static int32_t stbSplCreateColumnNode(SExprNode* pExpr, SNode** ppNode) {
SColumnNode* pCol = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
if (NULL == pCol) {
return NULL;
return code;
}
if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
strcpy(pCol->dbName, ((SColumnNode*)pExpr)->dbName);
@ -1258,22 +1263,26 @@ static SNode* stbSplCreateColumnNode(SExprNode* pExpr) {
strcpy(pCol->node.aliasName, pExpr->aliasName);
strcpy(pCol->node.userAlias, pExpr->userAlias);
pCol->node.resType = pExpr->resType;
return (SNode*)pCol;
*ppNode = (SNode*)pCol;
return code;
}
static SNode* stbSplCreateOrderByExpr(SOrderByExprNode* pSortKey, SNode* pCol) {
SOrderByExprNode* pOutput = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR);
static int32_t stbSplCreateOrderByExpr(SOrderByExprNode* pSortKey, SNode* pCol, SNode** ppNode) {
SOrderByExprNode* pOutput = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOutput);
if (NULL == pOutput) {
return NULL;
return code;
}
pOutput->pExpr = nodesCloneNode(pCol);
pOutput->pExpr = NULL;
code = nodesCloneNode(pCol, &pOutput->pExpr);
if (NULL == pOutput->pExpr) {
nodesDestroyNode((SNode*)pOutput);
return NULL;
return code;
}
pOutput->order = pSortKey->order;
pOutput->nullOrder = pSortKey->nullOrder;
return (SNode*)pOutput;
*ppNode = (SNode*)pOutput;
return code;
}
static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets, SNodeList** pOutput) {
@ -1288,7 +1297,11 @@ static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets,
FOREACH(pTarget, pTargets) {
if ((QUERY_NODE_COLUMN == nodeType(pSortExpr) && nodesEqualNode((SNode*)pSortExpr, pTarget)) ||
(0 == strcmp(pSortExpr->aliasName, ((SColumnNode*)pTarget)->colName))) {
code = nodesListMakeStrictAppend(&pMergeKeys, stbSplCreateOrderByExpr(pSortKey, pTarget));
SNode* pNew = NULL;
code = stbSplCreateOrderByExpr(pSortKey, pTarget, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pMergeKeys, pNew);
}
if (TSDB_CODE_SUCCESS != code) {
break;
}
@ -1296,8 +1309,15 @@ static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets,
}
}
if (TSDB_CODE_SUCCESS == code && !found) {
SNode* pCol = stbSplCreateColumnNode(pSortExpr);
code = nodesListMakeStrictAppend(&pMergeKeys, stbSplCreateOrderByExpr(pSortKey, pCol));
SNode* pCol = NULL;
code = stbSplCreateColumnNode(pSortExpr, &pCol);
if (TSDB_CODE_SUCCESS == code) {
SNode* pNew = NULL;
code = stbSplCreateOrderByExpr(pSortKey, pCol, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pMergeKeys, pNew);
}
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pTargets, pCol);
} else {
@ -1324,9 +1344,10 @@ static int32_t stbSplCreatePartSortNode(SSortLogicNode* pSort, SLogicNode** pOut
pSort->node.pChildren = NULL;
int32_t code = TSDB_CODE_SUCCESS;
SSortLogicNode* pPartSort = (SSortLogicNode*)nodesCloneNode((SNode*)pSort);
SSortLogicNode* pPartSort = NULL;
code = nodesCloneNode((SNode*)pSort, (SNode**)&pPartSort);
if (NULL == pPartSort) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = code;
}
SNodeList* pMergeKeys = NULL;
@ -1392,9 +1413,10 @@ static int32_t stbSplGetSplitNodeForScan(SStableSplitInfo* pInfo, SLogicNode** p
!((SProjectLogicNode*)pInfo->pSplitNode->pParent)->inputIgnoreGroup) {
*pSplitNode = pInfo->pSplitNode->pParent;
if (NULL != pInfo->pSplitNode->pLimit) {
(*pSplitNode)->pLimit = nodesCloneNode(pInfo->pSplitNode->pLimit);
(*pSplitNode)->pLimit = NULL;
int32_t code = nodesCloneNode(pInfo->pSplitNode->pLimit, &(*pSplitNode)->pLimit);
if (NULL == (*pSplitNode)->pLimit) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
((SLimitNode*)pInfo->pSplitNode->pLimit)->limit += ((SLimitNode*)pInfo->pSplitNode->pLimit)->offset;
((SLimitNode*)pInfo->pSplitNode->pLimit)->offset = 0;
@ -1436,7 +1458,7 @@ static int32_t stbSplSplitScanNodeWithPartTags(SSplitContext* pCxt, SStableSplit
return code;
}
static SNode* stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan) {
static int32_t stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan, SNode** ppNode) {
bool find = false;
SNode* pCol = NULL;
FOREACH(pCol, pScan->pScanCols) {
@ -1446,19 +1468,29 @@ static SNode* stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan) {
}
}
if (!find) {
return NULL;
*ppNode = NULL;
return TSDB_CODE_SUCCESS;
}
SNode* pTarget = NULL;
FOREACH(pTarget, pScan->node.pTargets) {
if (nodesEqualNode(pTarget, pCol)) {
return pCol;
*ppNode = pCol;
return TSDB_CODE_SUCCESS;
}
}
nodesListStrictAppend(pScan->node.pTargets, nodesCloneNode(pCol));
return pCol;
SNode* pNew = NULL;
int32_t code = nodesCloneNode(pCol, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pScan->node.pTargets, pNew);
}
if (TSDB_CODE_SUCCESS == code) {
*ppNode = pCol;
}
return code;
}
static SNode* stbSplFindPkFromScan(SScanLogicNode* pScan) {
static int32_t stbSplFindPkFromScan(SScanLogicNode* pScan, SNode** ppNode) {
int32_t code = 0;
bool find = false;
SNode* pCol = NULL;
FOREACH(pCol, pScan->pScanCols) {
@ -1468,16 +1500,25 @@ static SNode* stbSplFindPkFromScan(SScanLogicNode* pScan) {
}
}
if (!find) {
return NULL;
*ppNode = NULL;
return code;
}
SNode* pTarget = NULL;
FOREACH(pTarget, pScan->node.pTargets) {
if (nodesEqualNode(pTarget, pCol)) {
return pCol;
*ppNode = pCol;
return code;
}
}
nodesListStrictAppend(pScan->node.pTargets, nodesCloneNode(pCol));
return pCol;
SNode* pNew = NULL;
code = nodesCloneNode(pCol, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pScan->node.pTargets, pNew);
}
if (TSDB_CODE_SUCCESS == code) {
*ppNode = pCol;
}
return code;
}
static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOutputMergeScan,
@ -1486,9 +1527,10 @@ static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOu
pScan->node.pChildren = NULL;
int32_t code = TSDB_CODE_SUCCESS;
SScanLogicNode* pMergeScan = (SScanLogicNode*)nodesCloneNode((SNode*)pScan);
SScanLogicNode* pMergeScan = NULL;
code = nodesCloneNode((SNode*)pScan, (SNode**)&pMergeScan);
if (NULL == pMergeScan) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = code;
}
SNodeList* pMergeKeys = NULL;
@ -1498,9 +1540,15 @@ static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOu
pMergeScan->node.pChildren = pChildren;
splSetParent((SLogicNode*)pMergeScan);
SNode* pTs = stbSplFindPrimaryKeyFromScan(pMergeScan);
code = stbSplCreateMergeKeysByPrimaryKey(pTs, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys);
SNode* pPk = stbSplFindPkFromScan(pMergeScan);
SNode* pTs = NULL;
code = stbSplFindPrimaryKeyFromScan(pMergeScan, &pTs);
if (TSDB_CODE_SUCCESS == code) {
code = stbSplCreateMergeKeysByPrimaryKey(pTs, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys);
}
SNode* pPk = NULL;
if (TSDB_CODE_SUCCESS == code) {
code = stbSplFindPkFromScan(pMergeScan, &pPk);
}
if (TSDB_CODE_SUCCESS == code && NULL != pPk) {
code = stbSplCreateMergeKeysByExpr(pPk, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys);
}
@ -1589,11 +1637,16 @@ static int32_t stbSplSplitJoinNode(SSplitContext* pCxt, SStableSplitInfo* pInfo)
static int32_t stbSplCreateMergeKeysForPartitionNode(SLogicNode* pPart, SNodeList** pMergeKeys) {
SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pPart->pChildren, 0);
SNode* pPrimaryKey = nodesCloneNode(stbSplFindPrimaryKeyFromScan(pScan));
if (NULL == pPrimaryKey) {
return TSDB_CODE_OUT_OF_MEMORY;
SNode* pPK = NULL;
SNode* pPrimaryKey = NULL;
int32_t code = stbSplFindPrimaryKeyFromScan(pScan, &pPK);
if (TSDB_CODE_SUCCESS == code) {
code = nodesCloneNode(pPK, &pPrimaryKey);
}
int32_t code = nodesListAppend(pPart->pTargets, pPrimaryKey);
if (NULL == pPrimaryKey) {
return code;
}
code = nodesListStrictAppend(pPart->pTargets, pPrimaryKey);
if (TSDB_CODE_SUCCESS == code) {
code = stbSplCreateMergeKeysByPrimaryKey(pPrimaryKey, pScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, pMergeKeys);
}
@ -1711,8 +1764,11 @@ static int32_t unionSplitSubplan(SSplitContext* pCxt, SLogicSubplan* pUnionSubpl
SNode* pChild = NULL;
FOREACH(pChild, pSplitNode->pChildren) {
SLogicSubplan* pNewSubplan = splCreateSubplan(pCxt, (SLogicNode*)pChild);
code = nodesListMakeStrictAppend(&pUnionSubplan->pChildren, (SNode*)pNewSubplan);
SLogicSubplan* pNewSubplan = NULL;
code = splCreateSubplan(pCxt, (SLogicNode*)pChild, &pNewSubplan);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pUnionSubplan->pChildren, (SNode*)pNewSubplan);
}
if (TSDB_CODE_SUCCESS == code) {
REPLACE_NODE(NULL);
code = splMountSubplan(pNewSubplan, pSubplanChildren);
@ -1752,17 +1808,25 @@ static bool unAllSplFindSplitNode(SSplitContext* pCxt, SLogicSubplan* pSubplan,
static int32_t unAllSplCreateExchangeNode(SSplitContext* pCxt, int32_t startGroupId, SLogicSubplan* pSubplan,
SProjectLogicNode* pProject) {
SExchangeLogicNode* pExchange = (SExchangeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE);
SExchangeLogicNode* pExchange = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE, (SNode**)&pExchange);
if (NULL == pExchange) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pExchange->srcStartGroupId = startGroupId;
pExchange->srcEndGroupId = pCxt->groupId - 1;
pExchange->node.precision = pProject->node.precision;
pExchange->node.pTargets = nodesCloneList(pProject->node.pTargets);
pExchange->node.pConditions = nodesCloneNode(pProject->node.pConditions);
if (NULL == pExchange->node.pTargets || (NULL != pProject->node.pConditions && NULL == pExchange->node.pConditions)) {
return TSDB_CODE_OUT_OF_MEMORY;
pExchange->node.pTargets = NULL;
code = nodesCloneList(pProject->node.pTargets, &pExchange->node.pTargets);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pExchange);
return code;
}
pExchange->node.pConditions = NULL;
code = nodesCloneNode(pProject->node.pConditions, &pExchange->node.pConditions);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode((SNode*)pExchange);
return code;
}
TSWAP(pExchange->node.pLimit, pProject->node.pLimit);
@ -1808,21 +1872,24 @@ typedef struct SUnionDistinctSplitInfo {
static int32_t unDistSplCreateExchangeNode(SSplitContext* pCxt, int32_t startGroupId, SLogicSubplan* pSubplan,
SAggLogicNode* pAgg) {
SExchangeLogicNode* pExchange = (SExchangeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE);
SExchangeLogicNode* pExchange = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE, (SNode**)&pExchange);
if (NULL == pExchange) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
pExchange->srcStartGroupId = startGroupId;
pExchange->srcEndGroupId = pCxt->groupId - 1;
pExchange->node.precision = pAgg->node.precision;
pExchange->node.pTargets = nodesCloneList(pAgg->pGroupKeys);
pExchange->node.pTargets = NULL;
code = nodesCloneList(pAgg->pGroupKeys, &pExchange->node.pTargets);
if (NULL == pExchange->node.pTargets) {
return TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyNode((SNode*)pExchange);
return code;
}
pSubplan->subplanType = SUBPLAN_TYPE_MERGE;
return nodesListMakeAppend(&pAgg->node.pChildren, (SNode*)pExchange);
return nodesListMakeStrictAppend(&pAgg->node.pChildren, (SNode*)pExchange);
}
static bool unDistSplFindSplitNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SLogicNode* pNode,
@ -1910,10 +1977,7 @@ static int32_t insertSelectSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
SNodeList* pSubplanChildren = info.pSubplan->pChildren;
int32_t code = splCreateExchangeNodeForSubplan(pCxt, info.pSubplan, info.pQueryRoot, SUBPLAN_TYPE_MODIFY);
if (TSDB_CODE_SUCCESS == code) {
pNewSubplan = splCreateSubplan(pCxt, info.pQueryRoot);
if (NULL == pNewSubplan) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
code = splCreateSubplan(pCxt, info.pQueryRoot, &pNewSubplan);
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, (SNode*)pNewSubplan);
@ -1967,7 +2031,7 @@ static int32_t qnodeSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) {
}
code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, (SNode*)pScanSubplan);
} else {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
}
}
info.pSubplan->subplanType = SUBPLAN_TYPE_COMPUTE;

104
source/libs/planner/src/planUtil.c
View File

@ -49,7 +49,8 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
SCreateColumnCxt* pCxt = (SCreateColumnCxt*)pContext;
switch (nodeType(pNode)) {
case QUERY_NODE_COLUMN: {
SNode* pCol = nodesCloneNode(pNode);
SNode* pCol = NULL;
pCxt->errCode = nodesCloneNode(pNode, &pCol);
if (NULL == pCol) {
return DEAL_RES_ERROR;
}
@ -61,7 +62,8 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
case QUERY_NODE_FUNCTION:
case QUERY_NODE_CASE_WHEN: {
SExprNode* pExpr = (SExprNode*)pNode;
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
SColumnNode* pCol = NULL;
pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
if (NULL == pCol) {
return DEAL_RES_ERROR;
}
@ -88,9 +90,12 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
}
int32_t createColumnByRewriteExprs(SNodeList* pExprs, SNodeList** pList) {
SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = (NULL == *pList ? nodesMakeList() : *pList)};
if (NULL == cxt.pList) {
return TSDB_CODE_OUT_OF_MEMORY;
SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = *pList};
if (!cxt.pList) {
int32_t code = nodesMakeList(&cxt.pList);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
}
nodesWalkExprs(pExprs, doCreateColumn, &cxt);
@ -105,9 +110,12 @@ int32_t createColumnByRewriteExprs(SNodeList* pExprs, SNodeList** pList) {
}
int32_t createColumnByRewriteExpr(SNode* pExpr, SNodeList** pList) {
SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = (NULL == *pList ? nodesMakeList() : *pList)};
if (NULL == cxt.pList) {
return TSDB_CODE_OUT_OF_MEMORY;
SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = *pList};
if (!cxt.pList) {
int32_t code = nodesMakeList(&cxt.pList);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
}
nodesWalkExpr(pExpr, doCreateColumn, &cxt);
@ -545,25 +553,35 @@ bool isPartTableWinodw(SWindowLogicNode* pWindow) {
return pWindow->isPartTb || keysHasTbname(stbGetPartKeys((SLogicNode*)nodesListGetNode(pWindow->node.pChildren, 0)));
}
bool cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat) {
SLimitNode* pLimit;
bool cloned = false;
int32_t cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat, bool* pCloned) {
SLimitNode* pLimit = NULL, *pSlimit = NULL;
int32_t code = 0;
bool cloned = false;
if (pParent->pLimit && (cloneWhat & CLONE_LIMIT)) {
pChild->pLimit = nodesCloneNode(pParent->pLimit);
pLimit = (SLimitNode*)pChild->pLimit;
pLimit->limit += pLimit->offset;
pLimit->offset = 0;
cloned = true;
code = nodesCloneNode(pParent->pLimit, (SNode**)&pLimit);
if (TSDB_CODE_SUCCESS == code) {
pLimit->limit += pLimit->offset;
pLimit->offset = 0;
cloned = true;
}
}
if (pParent->pSlimit && (cloneWhat & CLONE_SLIMIT)) {
pChild->pSlimit = nodesCloneNode(pParent->pSlimit);
pLimit = (SLimitNode*)pChild->pSlimit;
pLimit->limit += pLimit->offset;
pLimit->offset = 0;
cloned = true;
code = nodesCloneNode(pParent->pSlimit, (SNode**)&pSlimit);
if (TSDB_CODE_SUCCESS == code) {
pSlimit->limit += pSlimit->offset;
pSlimit->offset = 0;
cloned = true;
}
}
return cloned;
if (TSDB_CODE_SUCCESS == code) {
pChild->pLimit = (SNode*)pLimit;
pChild->pSlimit = (SNode*)pSlimit;
*pCloned = cloned;
} else {
nodesDestroyNode((SNode*)pLimit);
}
return code;
}
static EDealRes partTagsOptHasColImpl(SNode* pNode, void* pContext) {
@ -583,12 +601,17 @@ bool keysHasCol(SNodeList* pKeys) {
}
SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) {
SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
SFunctionNode* pFunc = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
if (pFunc) {
strcpy(pFunc->functionName, "_group_key");
strcpy(pFunc->node.aliasName, pGroupCol->node.aliasName);
strcpy(pFunc->node.userAlias, pGroupCol->node.userAlias);
int32_t code = nodesListMakeStrictAppend(&pFunc->pParameterList, nodesCloneNode((SNode*)pGroupCol));
SNode* pNew = NULL;
code = nodesCloneNode((SNode*)pGroupCol, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pFunc->pParameterList, pNew);
}
if (code == TSDB_CODE_SUCCESS) {
code = fmGetFuncInfo(pFunc, NULL, 0);
}
@ -596,10 +619,17 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) {
nodesDestroyNode((SNode*)pFunc);
pFunc = NULL;
}
char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc);
taosCreateMD5Hash(name, len);
strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
if (TSDB_CODE_SUCCESS == code) {
char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc);
taosCreateMD5Hash(name, len);
strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
}
}
if (TSDB_CODE_SUCCESS != code) {
terrno = code;
nodesDestroyNode((SNode*)pFunc);
pFunc = NULL;
}
return pFunc;
}
@ -656,14 +686,20 @@ int32_t tagScanSetExecutionMode(SScanLogicNode* pScan) {
return TSDB_CODE_SUCCESS;
}
SNode* pCond = nodesCloneNode(pScan->node.pConditions);
SNode* pCond = NULL;
int32_t code = nodesCloneNode(pScan->node.pConditions, &pCond);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
SNode* pTagCond = NULL;
SNode* pTagIndexCond = NULL;
filterPartitionCond(&pCond, NULL, &pTagIndexCond, &pTagCond, NULL);
if (pTagIndexCond || tagScanNodeHasTbname(pTagCond)) {
pScan->onlyMetaCtbIdx = false;
} else {
pScan->onlyMetaCtbIdx = true;
code = filterPartitionCond(&pCond, NULL, &pTagIndexCond, &pTagCond, NULL);
if (TSDB_CODE_SUCCESS == code) {
if (pTagIndexCond || tagScanNodeHasTbname(pTagCond)) {
pScan->onlyMetaCtbIdx = false;
} else {
pScan->onlyMetaCtbIdx = true;
}
}
nodesDestroyNode(pCond);
nodesDestroyNode(pTagIndexCond);

23
source/libs/planner/src/planner.c
View File

@ -72,10 +72,15 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
}
static int32_t setSubplanExecutionNode(SPhysiNode* pNode, int32_t groupId, SDownstreamSourceNode* pSource) {
int32_t code = 0;
if (QUERY_NODE_PHYSICAL_PLAN_EXCHANGE == nodeType(pNode)) {
SExchangePhysiNode* pExchange = (SExchangePhysiNode*)pNode;
if (groupId >= pExchange->srcStartGroupId && groupId <= pExchange->srcEndGroupId) {
return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, nodesCloneNode((SNode*)pSource));
SNode* pNew = NULL;
code = nodesCloneNode((SNode*)pSource, &pNew);
if (TSDB_CODE_SUCCESS == code) {
return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, pNew);
}
}
} else if (QUERY_NODE_PHYSICAL_PLAN_MERGE == nodeType(pNode)) {
SMergePhysiNode* pMerge = (SMergePhysiNode*)pNode;
@ -87,17 +92,23 @@ static int32_t setSubplanExecutionNode(SPhysiNode* pNode, int32_t groupId, SDown
} else {
--(pMerge->numOfChannels);
}
return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, nodesCloneNode((SNode*)pSource));
SNode* pNew = NULL;
code = nodesCloneNode((SNode*)pSource, &pNew);
if (TSDB_CODE_SUCCESS == code) {
return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, pNew);
}
}
}
SNode* pChild = NULL;
FOREACH(pChild, pNode->pChildren) {
if (TSDB_CODE_SUCCESS != setSubplanExecutionNode((SPhysiNode*)pChild, groupId, pSource)) {
return TSDB_CODE_OUT_OF_MEMORY;
if (TSDB_CODE_SUCCESS == code) {
FOREACH(pChild, pNode->pChildren) {
if (TSDB_CODE_SUCCESS != (code = setSubplanExecutionNode((SPhysiNode*)pChild, groupId, pSource))) {
return code;
}
}
}
return TSDB_CODE_SUCCESS;
return code;
}
int32_t qContinuePlanPostQuery(void *pPostPlan) {

76
source/libs/scalar/src/filter.c
View File

@ -3931,8 +3931,9 @@ int32_t fltSclGetOrCreateColumnRange(SColumnNode *colNode, SArray *colRangeList,
}
// 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);
SColumnNode *pColumnNode = NULL;
int32_t code = nodesCloneNode((SNode *)colNode, (SNode**)&pColumnNode);
FLT_ERR_RET(code);
SFltSclColumnRange newColRange = {.colNode = pColumnNode, .points = taosArrayInit(4, sizeof(SFltSclPoint))};
if (NULL == newColRange.points) {
FLT_ERR_RET(terrno);
@ -4915,16 +4916,22 @@ static int32_t fltSclCollectOperatorFromNode(SNode *pNode, SArray *sclOpList) {
SValueNode *valNode = (SValueNode *)pOper->pRight;
if (IS_NUMERIC_TYPE(valNode->node.resType.type) || valNode->node.resType.type == TSDB_DATA_TYPE_TIMESTAMP) {
SFltSclOperator sclOp = {.colNode = (SColumnNode *)nodesCloneNode(pOper->pLeft),
.valNode = (SValueNode *)nodesCloneNode(pOper->pRight),
SNode* pLeft = NULL, *pRight = NULL;
int32_t code = nodesCloneNode(pOper->pLeft, &pLeft);
if (TSDB_CODE_SUCCESS != code) {
FLT_ERR_RET(code);
}
code = nodesCloneNode(pOper->pRight, &pRight);
if (TSDB_CODE_SUCCESS != code) {
nodesDestroyNode(pLeft);
FLT_ERR_RET(code);
}
SFltSclOperator sclOp = {.colNode = (SColumnNode *)pLeft,
.valNode = (SValueNode *)pRight,
.type = pOper->opType};
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)) {
nodesDestroyNode(pLeft);
nodesDestroyNode(pRight);
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
}
@ -5209,8 +5216,12 @@ EConditionType filterClassifyCondition(SNode *pNode) {
}
int32_t filterIsMultiTableColsCond(SNode *pCond, bool *res) {
SNodeList *pCondCols = nodesMakeList();
int32_t code = nodesCollectColumnsFromNode(pCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols);
SNodeList *pCondCols = NULL;
int32_t code = nodesMakeList(&pCondCols);
if (TSDB_CODE_SUCCESS!= code) {
return code;
}
code = nodesCollectColumnsFromNode(pCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols);
if (code == TSDB_CODE_SUCCESS) {
if (LIST_LENGTH(pCondCols) >= 2) {
SColumnNode *pFirstCol = (SColumnNode *)nodesListGetNode(pCondCols, 0);
@ -5249,32 +5260,56 @@ static int32_t partitionLogicCond(SNode **pCondition, SNode **pPrimaryKeyCond, S
}
if (result) {
if (NULL != pOtherCond) {
code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond));
SNode* pNew = NULL;
code = nodesCloneNode(pCond, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pOtherConds, pNew);
}
}
} else {
switch (filterClassifyCondition(pCond)) {
case COND_TYPE_PRIMARY_KEY:
if (NULL != pPrimaryKeyCond) {
code = nodesListMakeAppend(&pPrimaryKeyConds, nodesCloneNode(pCond));
SNode* pNew = NULL;
code = nodesCloneNode(pCond, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pPrimaryKeyConds, pNew);
}
}
break;
case COND_TYPE_TAG_INDEX:
if (NULL != pTagIndexCond) {
code = nodesListMakeAppend(&pTagIndexConds, nodesCloneNode(pCond));
SNode* pNew = NULL;
code = nodesCloneNode(pCond, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pTagIndexConds, pNew);
}
}
if (NULL != pTagCond) {
code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
SNode* pNew = NULL;
code = nodesCloneNode(pCond, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pTagConds, pNew);
}
}
break;
case COND_TYPE_TAG:
if (NULL != pTagCond) {
code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
SNode* pNew = NULL;
code = nodesCloneNode(pCond, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pTagConds, pNew);
}
}
break;
case COND_TYPE_NORMAL:
default:
if (NULL != pOtherCond) {
code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond));
SNode* pNew = NULL;
code = nodesCloneNode(pCond, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pOtherConds, pNew);
}
}
break;
}
@ -5361,9 +5396,10 @@ int32_t filterPartitionCond(SNode **pCondition, SNode **pPrimaryKeyCond, SNode *
if (NULL != pTagCond) {
SNode *pTempCond = *pCondition;
if (NULL != pTagIndexCond) {
pTempCond = nodesCloneNode(*pCondition);
pTempCond = NULL;
int32_t code = nodesCloneNode(*pCondition, &pTempCond);
if (NULL == pTempCond) {
return TSDB_CODE_OUT_OF_MEMORY;
return code;
}
}
*pTagCond = pTempCond;

24
source/libs/scalar/src/scalar.c
View File

@ -1028,10 +1028,10 @@ _return:
EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opType) {
if (opType <= OP_TYPE_CALC_MAX) {
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *res = NULL;
ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
sclError("make value node failed");
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}
@ -1040,10 +1040,10 @@ EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opTy
nodesDestroyNode(*pNode);
*pNode = (SNode *)res;
} else {
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *res = NULL;
ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
sclError("make value node failed");
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}
@ -1221,11 +1221,11 @@ EDealRes sclRewriteFunction(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR;
}
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *res = NULL;
ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
sclError("make value node failed");
sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}
@ -1295,11 +1295,11 @@ EDealRes sclRewriteLogic(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_CONTINUE;
}
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *res = NULL;
ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
sclError("make value node failed");
sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}
@ -1345,11 +1345,11 @@ EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR;
}
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *res = NULL;
ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
sclError("make value node failed");
sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}
@ -1408,11 +1408,11 @@ EDealRes sclRewriteCaseWhen(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR;
}
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
SValueNode *res = NULL;
ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) {
sclError("make value node failed");
sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}

33
source/libs/scalar/test/filter/filterTests.cpp
View File

@ -63,9 +63,10 @@ void flttInitLogFile() {
}
int32_t flttMakeValueNode(SNode **pNode, int32_t dataType, void *value) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_VALUE);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, &node);
if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
FLT_ERR_RET(code);
}
SValueNode *vnode = (SValueNode *)node;
vnode->node.resType.type = dataType;
@ -90,9 +91,10 @@ int32_t flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType,
void *value) {
static uint64_t dbidx = 0;
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_COLUMN);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, &node);
if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
FLT_ERR_RET(code);
}
SColumnNode *rnode = (SColumnNode *)node;
rnode->node.resType.type = dataType;
@ -170,9 +172,10 @@ int32_t flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType,
}
int32_t flttMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, &node);
if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
FLT_ERR_RET(code);
}
SOperatorNode *onode = (SOperatorNode *)node;
onode->node.resType.type = resType;
@ -187,16 +190,18 @@ int32_t flttMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNo
}
int32_t flttMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, &node);
if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
FLT_ERR_RET(code);
}
SLogicConditionNode *onode = (SLogicConditionNode *)node;
onode->condType = opType;
onode->node.resType.type = TSDB_DATA_TYPE_BOOL;
onode->node.resType.bytes = sizeof(bool);
onode->pParameterList = nodesMakeList();
onode->pParameterList = NULL;
code = nodesMakeList(&onode->pParameterList);
for (int32_t i = 0; i < nodeNum; ++i) {
FLT_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[i]));
}
@ -206,9 +211,10 @@ int32_t flttMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nod
}
int32_t flttMakeLogicNodeFromList(SNode **pNode, ELogicConditionType opType, SNodeList *nodeList) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, &node);
if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
FLT_ERR_RET(code);
}
SLogicConditionNode *onode = (SLogicConditionNode *)node;
onode->condType = opType;
@ -222,9 +228,10 @@ int32_t flttMakeLogicNodeFromList(SNode **pNode, ELogicConditionType opType, SNo
}
int32_t flttMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_NODE_LIST, &node);
if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
FLT_ERR_RET(code);
}
SNodeListNode *lnode = (SNodeListNode *)node;
lnode->node.resType.type = resType;

60
source/libs/scalar/test/scalar/scalarTests.cpp
View File

@ -143,9 +143,10 @@ int32_t scltAppendReservedSlot(SArray *pBlockList, int16_t *dataBlockId, int16_t
}
int32_t scltMakeValueNode(SNode **pNode, int32_t dataType, void *value) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_VALUE);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, &node);
if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
SCL_ERR_RET(code);
}
SValueNode *vnode = (SValueNode *)node;
vnode->node.resType.type = dataType;
@ -168,9 +169,10 @@ int32_t scltMakeValueNode(SNode **pNode, int32_t dataType, 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);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, &node);
if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
SCL_ERR_RET(code);
}
SColumnNode *rnode = (SColumnNode *)node;
rnode->node.resType.type = dataType;
@ -182,7 +184,6 @@ int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType,
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) {
@ -266,9 +267,10 @@ int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType,
int32_t scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight,
bool isReverse) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, &node);
if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
SCL_ERR_RET(code);
}
SOperatorNode *onode = (SOperatorNode *)node;
onode->node.resType.type = resType;
@ -288,9 +290,10 @@ int32_t scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SN
}
int32_t scltMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, &node);
if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
SCL_ERR_RET(code);
}
SOperatorNode *onode = (SOperatorNode *)node;
onode->node.resType.type = resType;
@ -305,9 +308,10 @@ int32_t scltMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNo
}
int32_t scltMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_NODE_LIST, &node);
if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
SCL_ERR_RET(code);
}
SNodeListNode *lnode = (SNodeListNode *)node;
lnode->node.resType.type = resType;
@ -318,16 +322,21 @@ int32_t scltMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) {
}
int32_t scltMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, &node);
if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
SCL_ERR_RET(code);
}
SLogicConditionNode *onode = (SLogicConditionNode *)node;
onode->condType = opType;
onode->node.resType.type = TSDB_DATA_TYPE_BOOL;
onode->node.resType.bytes = sizeof(bool);
onode->pParameterList = nodesMakeList();
onode->pParameterList = NULL;
code = nodesMakeList(&onode->pParameterList);
if (TSDB_CODE_SUCCESS != code) {
SCL_ERR_RET(code);
}
for (int32_t i = 0; i < nodeNum; ++i) {
SCL_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[i]));
}
@ -337,9 +346,10 @@ int32_t scltMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nod
}
int32_t scltMakeTargetNode(SNode **pNode, int16_t dataBlockId, int16_t slotId, SNode *snode) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_TARGET);
SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_TARGET, &node);
if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
SCL_ERR_RET(code);
}
STargetNode *onode = (STargetNode *)node;
onode->pExpr = snode;
@ -632,7 +642,8 @@ TEST(constantTest, int_in_smallint1) {
int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList();
SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -669,7 +680,8 @@ TEST(constantTest, int_in_smallint2) {
int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList();
SNodeList* list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -704,7 +716,8 @@ TEST(constantTest, int_not_in_smallint1) {
int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList();
SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -741,7 +754,8 @@ TEST(constantTest, int_not_in_smallint2) {
int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList();
SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -2084,7 +2098,8 @@ TEST(columnTest, int_column_in_double_list) {
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();
SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -2157,7 +2172,8 @@ TEST(columnTest, binary_column_in_binary_list) {
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();
SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[0]);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);

118
source/libs/scheduler/test/schedulerTests.cpp
View File

@ -154,24 +154,29 @@ void schtBuildQueryDag(SQueryPlan *dag) {
dag->queryId = qId;
dag->numOfSubplans = 2;
dag->pSubplans = nodesMakeList();
dag->pSubplans = NULL;
int32_t code = nodesMakeList(&dag->pSubplans);
if (NULL == dag->pSubplans) {
return;
}
SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNodeListNode *scan = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&scan);
if (NULL == scan) {
return;
}
SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNodeListNode *merge = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&merge);
if (NULL == merge) {
return;
}
SSubplan *scanPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
SSubplan *scanPlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&scanPlan);
if (NULL == scanPlan) {
return;
}
SSubplan *mergePlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
SSubplan *mergePlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&mergePlan);
if (NULL == mergePlan) {
return;
}
@ -187,11 +192,13 @@ void schtBuildQueryDag(SQueryPlan *dag) {
scanPlan->pChildren = NULL;
scanPlan->level = 1;
scanPlan->pParents = nodesMakeList();
scanPlan->pParents = NULL;
code = nodesMakeList(&scanPlan->pParents);
if (NULL == scanPlan->pParents) {
return;
}
scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN);
scanPlan->pNode = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, (SNode**)&scanPlan->pNode);
if (NULL == scanPlan->pNode) {
return;
}
@ -204,22 +211,26 @@ void schtBuildQueryDag(SQueryPlan *dag) {
mergePlan->level = 0;
mergePlan->execNode.epSet.numOfEps = 0;
mergePlan->pChildren = nodesMakeList();
mergePlan->pChildren = NULL;
code = nodesMakeList(&mergePlan->pChildren);
if (NULL == mergePlan->pChildren) {
return;
}
mergePlan->pParents = NULL;
mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE);
mergePlan->pNode = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE, (SNode**)&mergePlan->pNode);
if (NULL == mergePlan->pNode) {
return;
}
mergePlan->msgType = TDMT_SCH_QUERY;
merge->pNodeList = nodesMakeList();
merge->pNodeList = NULL;
code = nodesMakeList(&merge->pNodeList);
if (NULL == merge->pNodeList) {
return;
}
scan->pNodeList = nodesMakeList();
scan->pNodeList = NULL;
code = nodesMakeList(&scan->pNodeList);
if (NULL == scan->pNodeList) {
return;
}
@ -240,40 +251,48 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
dag->queryId = qId;
dag->numOfSubplans = 2;
dag->pSubplans = nodesMakeList();
dag->pSubplans = NULL;
int32_t code = nodesMakeList(&dag->pSubplans);
if (NULL == dag->pSubplans) {
return;
}
SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNodeListNode *scan = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&scan);
if (NULL == scan) {
return;
}
SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNodeListNode *merge = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&merge);
if (NULL == merge) {
return;
}
SSubplan *mergePlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
SSubplan *mergePlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&mergePlan);
if (NULL == mergePlan) {
return;
}
merge->pNodeList = nodesMakeList();
merge->pNodeList = NULL;
code = nodesMakeList(&merge->pNodeList);
if (NULL == merge->pNodeList) {
return;
}
scan->pNodeList = nodesMakeList();
scan->pNodeList = NULL;
code = nodesMakeList(&scan->pNodeList);
if (NULL == scan->pNodeList) {
return;
}
mergePlan->pChildren = nodesMakeList();
mergePlan->pChildren = NULL;
code = nodesMakeList(&mergePlan->pChildren);
if (NULL == mergePlan->pChildren) {
return;
}
for (int32_t i = 0; i < scanPlanNum; ++i) {
SSubplan *scanPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
SSubplan *scanPlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&scanPlan);
if (NULL == scanPlan) {
return;
}
@ -292,11 +311,13 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
scanPlan->pChildren = NULL;
scanPlan->level = 1;
scanPlan->pParents = nodesMakeList();
scanPlan->pParents = NULL;
code = nodesMakeList(&scanPlan->pParents);
if (NULL == scanPlan->pParents) {
return;
}
scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN);
scanPlan->pNode = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, (SNode**)&scanPlan->pNode);
if (NULL == scanPlan->pNode) {
return;
}
@ -316,7 +337,8 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
mergePlan->execNode.epSet.numOfEps = 0;
mergePlan->pParents = NULL;
mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE);
mergePlan->pNode = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE, (SNode**)&mergePlan->pNode);
if (NULL == mergePlan->pNode) {
return;
}
@ -335,20 +357,24 @@ void schtBuildInsertDag(SQueryPlan *dag) {
dag->queryId = qId;
dag->numOfSubplans = 2;
dag->pSubplans = nodesMakeList();
dag->pSubplans = NULL;
int32_t code = nodesMakeList(&dag->pSubplans);
if (NULL == dag->pSubplans) {
return;
}
SNodeListNode *inserta = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST);
SNodeListNode *inserta = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&inserta);
if (NULL == inserta) {
return;
}
inserta->pNodeList = nodesMakeList();
inserta->pNodeList = NULL;
code = nodesMakeList(&inserta->pNodeList);
if (NULL == inserta->pNodeList) {
return;
}
SSubplan *insertPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
SSubplan *insertPlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&insertPlan);
if (NULL == insertPlan) {
return;
}
@ -366,7 +392,8 @@ void schtBuildInsertDag(SQueryPlan *dag) {
insertPlan->pChildren = NULL;
insertPlan->pParents = NULL;
insertPlan->pNode = NULL;
insertPlan->pDataSink = (SDataSinkNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT);
insertPlan->pDataSink = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT, (SNode**)&insertPlan->pDataSink);
if (NULL == insertPlan->pDataSink) {
return;
}
@ -379,7 +406,8 @@ void schtBuildInsertDag(SQueryPlan *dag) {
(void)nodesListAppend(inserta->pNodeList, (SNode *)insertPlan);
insertPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN);
insertPlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&insertPlan);
if (NULL == insertPlan) {
return;
}
@ -397,7 +425,8 @@ void schtBuildInsertDag(SQueryPlan *dag) {
insertPlan->pChildren = NULL;
insertPlan->pParents = NULL;
insertPlan->pNode = NULL;
insertPlan->pDataSink = (SDataSinkNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT);
insertPlan->pDataSink = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT, (SNode**)&insertPlan->pDataSink);
if (NULL == insertPlan->pDataSink) {
return;
}
@ -640,11 +669,12 @@ void *schtRunJobThread(void *aa) {
char *dbname = "1.db1";
char *tablename = "table1";
SVgroupInfo vgInfo = {0};
SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
SQueryPlan *dag = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag);
assert(code == 0);
schtInitLogFile();
int32_t code = schedulerInit();
code = schedulerInit();
assert(code == 0);
schtSetPlanToString();
@ -828,7 +858,9 @@ TEST(queryTest, normalCase) {
char *tablename = "table1";
SVgroupInfo vgInfo = {0};
int64_t job = 0;
SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
SQueryPlan *dag = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag);
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
@ -838,7 +870,7 @@ TEST(queryTest, normalCase) {
load.addr.epSet.eps[0].port = 6031;
assert(taosArrayPush(qnodeList, &load) != NULL);
int32_t code = schedulerInit();
code = schedulerInit();
ASSERT_EQ(code, 0);
schtBuildQueryDag(dag);
@ -942,7 +974,9 @@ TEST(queryTest, readyFirstCase) {
char *tablename = "table1";
SVgroupInfo vgInfo = {0};
int64_t job = 0;
SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
SQueryPlan *dag = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag);
ASSERT_EQ(TSDB_CODE_SUCCESS, code);
SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
@ -952,7 +986,7 @@ TEST(queryTest, readyFirstCase) {
load.addr.epSet.eps[0].port = 6031;
assert(NULL != taosArrayPush(qnodeList, &load));
int32_t code = schedulerInit();
code = schedulerInit();
ASSERT_EQ(code, 0);
schtBuildQueryDag(dag);
@ -1055,7 +1089,9 @@ TEST(queryTest, flowCtrlCase) {
char *tablename = "table1";
SVgroupInfo vgInfo = {0};
int64_t job = 0;
SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
SQueryPlan *dag = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag);
ASSERT_EQ(TSDB_CODE_SUCCESS, code);
schtInitLogFile();
@ -1069,7 +1105,7 @@ TEST(queryTest, flowCtrlCase) {
load.addr.epSet.eps[0].port = 6031;
assert(NULL != taosArrayPush(qnodeList, &load));
int32_t code = schedulerInit();
code = schedulerInit();
ASSERT_EQ(code, 0);
schtBuildQueryFlowCtrlDag(dag);
@ -1151,7 +1187,9 @@ TEST(insertTest, normalCase) {
char *dbname = "1.db1";
char *tablename = "table1";
SVgroupInfo vgInfo = {0};
SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN);
SQueryPlan *dag = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag);
ASSERT_EQ(TSDB_CODE_SUCCESS, code);
uint64_t numOfRows = 0;
SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
@ -1162,7 +1200,7 @@ TEST(insertTest, normalCase) {
load.addr.epSet.eps[0].port = 6031;
assert(NULL != taosArrayPush(qnodeList, &load));
int32_t code = schedulerInit();
code = schedulerInit();
ASSERT_EQ(code, 0);
schtBuildInsertDag(dag);