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); int64_t nodesReleaseAllocatorWeakRef(int64_t allocatorId);
void nodesDestroyAllocator(int64_t allocatorId); void nodesDestroyAllocator(int64_t allocatorId);
SNode* nodesMakeNode(ENodeType type); int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut);
void nodesDestroyNode(SNode* pNode); void nodesDestroyNode(SNode* pNode);
void nodesFree(void* p); void nodesFree(void* p);
SNodeList* nodesMakeList(); int32_t nodesMakeList(SNodeList** ppListOut);
int32_t nodesListAppend(SNodeList* pList, SNode* pNode); int32_t nodesListAppend(SNodeList* pList, SNode* pNode);
int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode); int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode);
int32_t nodesListMakeAppend(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); bool nodesMatchNode(const SNode* pSub, const SNode* pNode);
SNode* nodesCloneNode(const SNode* pNode); int32_t nodesCloneNode(const SNode* pNode, SNode** ppNodeOut);
SNodeList* nodesCloneList(const SNodeList* pList); int32_t nodesCloneList(const SNodeList* pList, SNodeList** ppList);
const char* nodesNodeName(ENodeType type); const char* nodesNodeName(ENodeType type);
int32_t nodesNodeToString(const SNode* pNode, bool format, char** pStr, int32_t* pLen); 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); int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value);
char* nodesGetStrValueFromNode(SValueNode* pNode); char* nodesGetStrValueFromNode(SValueNode* pNode);
void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal); void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
SValueNode* nodesMakeValueNodeFromString(char* literal); int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode);
SValueNode* nodesMakeValueNodeFromBool(bool b); int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode);
SNode* nodesMakeValueNodeFromInt32(int32_t value); int32_t nodesMakeValueNodeFromInt32(int32_t value, SNode** ppNode);
char* nodesGetFillModeString(EFillMode mode); char* nodesGetFillModeString(EFillMode mode);
int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc); 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; return;
} }
pNewRequest->pQuery = (SQuery *)nodesMakeNode(QUERY_NODE_QUERY); pNewRequest->pQuery = NULL;
if (NULL == pNewRequest->pQuery) { code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pNewRequest->pQuery);
code = TSDB_CODE_OUT_OF_MEMORY; if (pNewRequest->pQuery) {
} else {
pNewRequest->pQuery->pRoot = pRoot; pNewRequest->pQuery->pRoot = pRoot;
pRoot = NULL; pRoot = NULL;
pNewRequest->pQuery->execStage = QUERY_EXEC_STAGE_ANALYSE; pNewRequest->pQuery->execStage = QUERY_EXEC_STAGE_ANALYSE;
@ -1901,4 +1900,4 @@ int taos_set_conn_mode(TAOS* taos, int mode, int value) {
char* getBuildInfo(){ char* getBuildInfo(){
return buildinfo; 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; SArray* pBufArray = NULL;
RAW_RETURN_CHECK(serializeVgroupsCreateTableBatch(pVgroupHashmap, &pBufArray)); RAW_RETURN_CHECK(serializeVgroupsCreateTableBatch(pVgroupHashmap, &pBufArray));
pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); pQuery = NULL;
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->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_CREATE_TABLE; pQuery->msgType = TDMT_VND_CREATE_TABLE;
pQuery->stableQuery = false; 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_NULL_CHECK(pQuery->pRoot);
RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray)); RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray));
@ -1343,13 +1345,14 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
} }
SArray* pBufArray = NULL; SArray* pBufArray = NULL;
RAW_RETURN_CHECK(serializeVgroupsDropTableBatch(pVgroupHashmap, &pBufArray)); RAW_RETURN_CHECK(serializeVgroupsDropTableBatch(pVgroupHashmap, &pBufArray));
pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
RAW_NULL_CHECK(pQuery); if (TSDB_CODE_SUCCESS != code) goto end;
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_DROP_TABLE; pQuery->msgType = TDMT_VND_DROP_TABLE;
pQuery->stableQuery = false; pQuery->stableQuery = false;
pQuery->pRoot = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT); pQuery->pRoot = NULL;
RAW_NULL_CHECK(pQuery->pRoot); code = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT, &pQuery->pRoot);
if (TSDB_CODE_SUCCESS != code) goto end;
RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray)); RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray));
(void)launchQueryImpl(pRequest, pQuery, true, NULL); (void)launchQueryImpl(pRequest, pQuery, true, NULL);
@ -1486,13 +1489,15 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
pVgData->numOfTables = 1; pVgData->numOfTables = 1;
RAW_NULL_CHECK(taosArrayPush(pArray, &pVgData)); RAW_NULL_CHECK(taosArrayPush(pArray, &pVgData));
pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); pQuery = NULL;
RAW_NULL_CHECK(pQuery); code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
if (NULL == pQuery) goto end;
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_ALTER_TABLE; pQuery->msgType = TDMT_VND_ALTER_TABLE;
pQuery->stableQuery = false; pQuery->stableQuery = false;
pQuery->pRoot = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); pQuery->pRoot = NULL;
RAW_NULL_CHECK(pQuery->pRoot); code = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, &pQuery->pRoot);
if (TSDB_CODE_SUCCESS != code) goto end;
RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pArray)); 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; SNodeList *pPhysiChildren = pNode->pChildren;
if (pPhysiChildren) { if (pPhysiChildren) {
*pChildren = nodesMakeList(); int32_t code = nodesMakeList(pChildren);
if (NULL == *pChildren) { if (NULL == *pChildren) {
qError("nodesMakeList failed"); 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; SHashObj* colHash;
int32_t index; int32_t index;
SArray* cInfoList; SArray* cInfoList;
int32_t code;
} STagScanFilterContext; } STagScanFilterContext;
typedef struct STagScanInfo { typedef struct STagScanInfo {

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

@ -33,8 +33,14 @@ typedef struct tagFilterAssist {
SHashObj* colHash; SHashObj* colHash;
int32_t index; int32_t index;
SArray* cInfoList; SArray* cInfoList;
int32_t code;
} tagFilterAssist; } tagFilterAssist;
typedef struct STransTagExprCtx {
int32_t code;
SMetaReader* pReader;
} STransTagExprCtx;
typedef enum { typedef enum {
FILTER_NO_LOGIC = 1, FILTER_NO_LOGIC = 1,
FILTER_AND, FILTER_AND,
@ -300,8 +306,9 @@ int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo)
} }
EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
SMetaReader* mr = (SMetaReader*)pContext; STransTagExprCtx* pCtx = pContext;
bool isTagCol = false, isTbname = false; SMetaReader* mr = pCtx->pReader;
bool isTagCol = false, isTbname = false;
if (nodeType(*pNode) == QUERY_NODE_COLUMN) { if (nodeType(*pNode) == QUERY_NODE_COLUMN) {
SColumnNode* pCol = (SColumnNode*)*pNode; SColumnNode* pCol = (SColumnNode*)*pNode;
if (pCol->colType == COLUMN_TYPE_TBNAME) if (pCol->colType == COLUMN_TYPE_TBNAME)
@ -315,7 +322,8 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
if (isTagCol) { if (isTagCol) {
SColumnNode* pSColumnNode = *(SColumnNode**)pNode; 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) { if (NULL == res) {
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -345,7 +353,8 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
nodesDestroyNode(*pNode); nodesDestroyNode(*pNode);
*pNode = (SNode*)res; *pNode = (SNode*)res;
} else if (isTbname) { } else if (isTbname) {
SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); SValueNode* res = NULL;
pCtx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) { if (NULL == res) {
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -377,10 +386,20 @@ int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle,
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
SNode* pTagCondTmp = nodesCloneNode(pTagCond); SNode* pTagCondTmp = NULL;
code = nodesCloneNode(pTagCond, &pTagCondTmp);
nodesRewriteExprPostOrder(&pTagCondTmp, doTranslateTagExpr, &mr); if (TSDB_CODE_SUCCESS != code) {
*pQualified = false;
return code;
}
STransTagExprCtx ctx = {.code = 0, .pReader = &mr};
nodesRewriteExprPostOrder(&pTagCondTmp, doTranslateTagExpr, &ctx);
pAPI->metaReaderFn.clearReader(&mr); pAPI->metaReaderFn.clearReader(&mr);
if (TSDB_CODE_SUCCESS != ctx.code) {
*pQualified = false;
terrno = code;
return code;
}
SNode* pNew = NULL; SNode* pNew = NULL;
code = scalarCalculateConstants(pTagCondTmp, &pNew); code = scalarCalculateConstants(pTagCondTmp, &pNew);
@ -400,13 +419,14 @@ int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle,
} }
static EDealRes getColumn(SNode** pNode, void* pContext) { static EDealRes getColumn(SNode** pNode, void* pContext) {
tagFilterAssist* pData = (tagFilterAssist*)pContext;
SColumnNode* pSColumnNode = NULL; SColumnNode* pSColumnNode = NULL;
if (QUERY_NODE_COLUMN == nodeType((*pNode))) { if (QUERY_NODE_COLUMN == nodeType((*pNode))) {
pSColumnNode = *(SColumnNode**)pNode; pSColumnNode = *(SColumnNode**)pNode;
} else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) { } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {
SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode); SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);
if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) { if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {
pSColumnNode = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); pData->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);
if (NULL == pSColumnNode) { if (NULL == pSColumnNode) {
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -423,7 +443,6 @@ static EDealRes getColumn(SNode** pNode, void* pContext) {
return DEAL_RES_CONTINUE; return DEAL_RES_CONTINUE;
} }
tagFilterAssist* pData = (tagFilterAssist*)pContext;
void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
if (!data) { if (!data) {
int32_t tempRes = int32_t tempRes =
@ -571,12 +590,20 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
SNode* pNode = NULL; SNode* pNode = NULL;
FOREACH(pNode, group) { FOREACH(pNode, group) {
nodesRewriteExprPostOrder(&pNode, getColumn, (void*)&ctx); nodesRewriteExprPostOrder(&pNode, getColumn, (void*)&ctx);
if (TSDB_CODE_SUCCESS != ctx.code) {
code = ctx.code;
goto end;
}
REPLACE_NODE(pNode); REPLACE_NODE(pNode);
} }
T_MD5_CTX context = {0}; T_MD5_CTX context = {0};
if (tsTagFilterCache) { 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; listNode->pNodeList = group;
code = genTbGroupDigest((SNode*)listNode, digest, &context); code = genTbGroupDigest((SNode*)listNode, digest, &context);
QUERY_CHECK_CODE(code, lino, end); QUERY_CHECK_CODE(code, lino, end);
@ -1166,6 +1193,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
} }
nodesRewriteExprPostOrder(&pTagCond, getColumn, (void*)&ctx); 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)}; 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; 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* isNull = (char*)keyBuf;
char* pStart = (char*)keyBuf + sizeof(int8_t) * LIST_LENGTH(pGroupNode); 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) && if (!pFuncNode->pParameterList && (memcmp(pExprNode->_function.functionName, name, len) == 0) &&
pExprNode->_function.functionName[len] == 0) { pExprNode->_function.functionName[len] == 0) {
pFuncNode->pParameterList = nodesMakeList(); pFuncNode->pParameterList = NULL;
SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); int32_t code = nodesMakeList(&pFuncNode->pParameterList);
if (NULL == res) { // todo handle error SValueNode* res = NULL;
if (TSDB_CODE_SUCCESS == code) {
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
}
if (TSDB_CODE_SUCCESS != code) { // todo handle error
} else { } else {
res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT}; res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT};
code = nodesListAppend(pFuncNode->pParameterList, (SNode*)res); 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); taosMemoryFreeClear(pBlock->pBlockAgg);
// try to filter data block according to current results // 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) { static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
int32_t lino = 0; int32_t lino = 0;
STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;
SColumnNode* pSColumnNode = NULL; SColumnNode* pSColumnNode = NULL;
if (QUERY_NODE_COLUMN == nodeType((*pNode))) { if (QUERY_NODE_COLUMN == nodeType((*pNode))) {
pSColumnNode = *(SColumnNode**)pNode; pSColumnNode = *(SColumnNode**)pNode;
} else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) { } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {
SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode); SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);
if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) { 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) { if (NULL == pSColumnNode) {
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -4098,8 +4100,7 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {
return DEAL_RES_CONTINUE; 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) { if (!data) {
code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));
if (code == TSDB_CODE_DUP_KEY) { if (code == TSDB_CODE_DUP_KEY) {
@ -4493,6 +4494,7 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi
nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx); nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);
} }
} }
//TODO wjm check pInfo->filterCtx.code
__optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry; __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry;
pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo, pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,
optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); 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); initResultRowInfo(&pInfo->binfo.resultRowInfo);
pInfo->numOfChild = numOfChild; 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->pPullWins = taosArrayInit(8, sizeof(SPullWindowInfo));
pInfo->pullIndex = 0; 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; 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) { if (NULL == pLogicCond) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
pLogicCond->condType = LOGIC_COND_TYPE_AND; 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, *ppSrc));
assert(0 == nodesListStrictAppend(pLogicCond->pParameterList, *ppDst)); assert(0 == nodesListStrictAppend(pLogicCond->pParameterList, *ppDst));
@ -387,8 +389,10 @@ void createTargetSlotList(SSortMergeJoinPhysiNode* p) {
jtCtx.keyColOffset = dstOffset; jtCtx.keyColOffset = dstOffset;
} }
STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET); STargetNode* pTarget = NULL;
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); int32_t code = nodesMakeNode(QUERY_NODE_TARGET, (SNode**)&pTarget);
SColumnNode* pCol = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
assert(NULL != pTarget && NULL != pCol); assert(NULL != pTarget && NULL != pCol);
pCol->dataBlockId = LEFT_BLK_ID; pCol->dataBlockId = LEFT_BLK_ID;
pCol->slotId = i; pCol->slotId = i;
@ -412,8 +416,10 @@ void createTargetSlotList(SSortMergeJoinPhysiNode* p) {
jtCtx.keyColOffset = dstOffset; jtCtx.keyColOffset = dstOffset;
} }
STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET); STargetNode* pTarget = NULL;
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); int32_t code = nodesMakeNode(QUERY_NODE_TARGET, (SNode**)&pTarget);
SColumnNode* pCol = NULL;
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
assert(NULL != pTarget && NULL != pCol); assert(NULL != pTarget && NULL != pCol);
pCol->dataBlockId = RIGHT_BLK_ID; pCol->dataBlockId = RIGHT_BLK_ID;
pCol->slotId = i; pCol->slotId = i;
@ -454,9 +460,9 @@ void createColEqCondStart(SSortMergeJoinPhysiNode* p) {
for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.colEqList[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); assert(pCol1);
pCol1->dataBlockId = LEFT_BLK_ID; pCol1->dataBlockId = LEFT_BLK_ID;
pCol1->slotId = i; pCol1->slotId = i;
pCol1->node.resType.type = jtInputColType[i]; pCol1->node.resType.type = jtInputColType[i];
@ -464,7 +470,8 @@ void createColEqCondStart(SSortMergeJoinPhysiNode* p) {
assert(0 == nodesListMakeStrictAppend(&p->pEqLeft, (SNode*)pCol1)); 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->dataBlockId = RIGHT_BLK_ID;
pCol2->slotId = i; pCol2->slotId = i;
pCol2->node.resType.type = jtInputColType[i]; pCol2->node.resType.type = jtInputColType[i];
@ -511,7 +518,7 @@ void createColEqCondEnd(SSortMergeJoinPhysiNode* p) {
SLogicConditionNode* pLogic = NULL; SLogicConditionNode* pLogic = NULL;
if (jtCtx.colEqNum > 1) { if (jtCtx.colEqNum > 1) {
pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic);
assert(pLogic); assert(pLogic);
pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; 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) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.colEqList[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); assert(pCol1);
pCol1->dataBlockId = RES_BLK_ID; pCol1->dataBlockId = RES_BLK_ID;
pCol1->slotId = getDstSlotId(i); pCol1->slotId = getDstSlotId(i);
pCol1->node.resType.type = jtInputColType[i]; pCol1->node.resType.type = jtInputColType[i];
pCol1->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; 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); assert(pCol2);
pCol2->dataBlockId = RES_BLK_ID; pCol2->dataBlockId = RES_BLK_ID;
pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i); pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i);
pCol2->node.resType.type = jtInputColType[i]; pCol2->node.resType.type = jtInputColType[i];
pCol2->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; 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); assert(pOp);
pOp->opType = OP_TYPE_EQUAL; pOp->opType = OP_TYPE_EQUAL;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@ -563,7 +573,7 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) {
SLogicConditionNode* pLogic = NULL; SLogicConditionNode* pLogic = NULL;
if (jtCtx.colOnNum > 1) { if (jtCtx.colOnNum > 1) {
pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic);
assert(pLogic); assert(pLogic);
pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; 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) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.colOnList[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); assert(pCol1);
pCol1->dataBlockId = RES_BLK_ID; pCol1->dataBlockId = RES_BLK_ID;
pCol1->slotId = getDstSlotId(i); pCol1->slotId = getDstSlotId(i);
pCol1->node.resType.type = jtInputColType[i]; pCol1->node.resType.type = jtInputColType[i];
pCol1->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; 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); assert(pCol2);
pCol2->dataBlockId = RES_BLK_ID; pCol2->dataBlockId = RES_BLK_ID;
pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i); pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i);
pCol2->node.resType.type = jtInputColType[i]; pCol2->node.resType.type = jtInputColType[i];
pCol2->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; 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); assert(pOp);
pOp->opType = OP_TYPE_GREATER_THAN; pOp->opType = OP_TYPE_GREATER_THAN;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@ -607,7 +620,8 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) {
p->pColOnCond = (SNode*)pLogic; p->pColOnCond = (SNode*)pLogic;
} }
SNode* pTmp = nodesCloneNode(p->pColOnCond); SNode* pTmp = NULL;
int32_t code = nodesCloneNode(p->pColOnCond, &pTmp);
assert(pTmp); assert(pTmp);
assert(0 == jtMergeEqCond(&p->pFullOnCond, &pTmp)); assert(0 == jtMergeEqCond(&p->pFullOnCond, &pTmp));
} }
@ -721,7 +735,7 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) {
SLogicConditionNode* pLogic = NULL; SLogicConditionNode* pLogic = NULL;
if ((jtCtx.leftFilterNum + jtCtx.rightFilterNum) > 1) { 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); assert(pLogic);
pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; 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) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.leftFilterColList[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); assert(pCol);
pCol->dataBlockId = RES_BLK_ID; pCol->dataBlockId = RES_BLK_ID;
pCol->slotId = getDstSlotId(i); pCol->slotId = getDstSlotId(i);
@ -738,13 +753,15 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) {
pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
(void)sprintf(pCol->colName, "l%d", i); (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); assert(pVal);
pVal->node.resType.type = jtInputColType[i]; pVal->node.resType.type = jtInputColType[i];
pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
assert(0 == nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i]))); 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); assert(pOp);
pOp->opType = OP_TYPE_GREATER_THAN; pOp->opType = OP_TYPE_GREATER_THAN;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; 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) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) {
if (jtCtx.rightFilterColList[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); assert(pCol);
pCol->dataBlockId = RES_BLK_ID; pCol->dataBlockId = RES_BLK_ID;
pCol->slotId = getDstSlotId(MAX_SLOT_NUM + i); 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; pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
(void)sprintf(pCol->colName, "r%d", i); (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); assert(pVal);
pVal->node.resType.type = jtInputColType[i]; pVal->node.resType.type = jtInputColType[i];
pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes;
assert(0 == nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i]))); 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); assert(pOp);
pOp->opType = OP_TYPE_GREATER_THAN; pOp->opType = OP_TYPE_GREATER_THAN;
pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@ -810,13 +830,15 @@ void updateColRowInfo() {
} }
void createBlockDescNode(SDataBlockDescNode** ppNode) { 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); assert(pDesc);
pDesc->dataBlockId = RES_BLK_ID; pDesc->dataBlockId = RES_BLK_ID;
pDesc->totalRowSize = jtCtx.resColSize - MAX_SLOT_NUM * 2 * sizeof(bool); pDesc->totalRowSize = jtCtx.resColSize - MAX_SLOT_NUM * 2 * sizeof(bool);
pDesc->outputRowSize = pDesc->totalRowSize; pDesc->outputRowSize = pDesc->totalRowSize;
for (int32_t i = 0; i < jtCtx.resColNum; ++i) { 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); assert(pSlot);
pSlot->slotId = i; pSlot->slotId = i;
int32_t slotIdx = jtCtx.resColInSlot[i] >= MAX_SLOT_NUM ? jtCtx.resColInSlot[i] - MAX_SLOT_NUM : jtCtx.resColInSlot[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* 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); assert(p);
p->joinType = param->joinType; p->joinType = param->joinType;
p->subType = param->subType; p->subType = param->subType;
p->asofOpType = param->asofOp; p->asofOpType = param->asofOp;
p->grpJoin = param->grpJoin; p->grpJoin = param->grpJoin;
if (p->subType == JOIN_STYPE_WIN || param->jLimit > 1 || taosRand() % 2) { 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); assert(limitNode);
limitNode->limit = param->jLimit; limitNode->limit = param->jLimit;
p->pJLimit = (SNode*)limitNode; p->pJLimit = (SNode*)limitNode;
@ -847,11 +871,14 @@ SSortMergeJoinPhysiNode* createDummySortMergeJoinPhysiNode(SJoinTestParam* param
p->rightPrimSlotId = JT_PRIM_TS_SLOT_ID; p->rightPrimSlotId = JT_PRIM_TS_SLOT_ID;
p->node.inputTsOrder = param->asc ? ORDER_ASC : ORDER_DESC; p->node.inputTsOrder = param->asc ? ORDER_ASC : ORDER_DESC;
if (JOIN_STYPE_WIN == p->subType) { 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); assert(pOffset);
SValueNode* pStart = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); SValueNode* pStart = NULL;
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pStart);
assert(pStart); assert(pStart);
SValueNode* pEnd = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); SValueNode* pEnd = NULL;
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pEnd);
assert(pEnd); assert(pEnd);
pStart->node.resType.type = TSDB_DATA_TYPE_BIGINT; pStart->node.resType.type = TSDB_DATA_TYPE_BIGINT;
pStart->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes; 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); 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) { if (pVal == NULL) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pVal->literal = strndup(buf, len); pVal->literal = strndup(buf, len);
@ -247,9 +248,10 @@ static int32_t addTimezoneParam(SNodeList* pList) {
} }
static int32_t addDbPrecisonParam(SNodeList** pList, uint8_t precision) { 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) { if (pVal == NULL) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pVal->literal = NULL; 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) { static int32_t reserveFirstMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) {
int32_t code = nodesListMakeAppend(pParameters, pPartialRes); int32_t code = nodesListMakeAppend(pParameters, pPartialRes);
if (TSDB_CODE_SUCCESS == code) { 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) { 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 apercentileCreateMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) {
int32_t code = reserveFirstMergeParam(pRawParameters, pPartialRes, pParameters); int32_t code = reserveFirstMergeParam(pRawParameters, pPartialRes, pParameters);
if (TSDB_CODE_SUCCESS == code && pRawParameters->length >= 3) { 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; 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)); return fmGetFuncInfo(pFunc, msg, sizeof(msg));
} }
int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** pFunc) { int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** ppFunc) {
*pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)ppFunc);
if (NULL == *pFunc) { if (NULL == *ppFunc) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
(void)snprintf((*pFunc)->functionName, sizeof((*pFunc)->functionName), "%s", pName); (void)snprintf((*ppFunc)->functionName, sizeof((*ppFunc)->functionName), "%s", pName);
(*pFunc)->pParameterList = pParameterList; (*ppFunc)->pParameterList = pParameterList;
int32_t code = getFuncInfo((*pFunc)); code = getFuncInfo((*ppFunc));
if (TSDB_CODE_SUCCESS != code) { if (TSDB_CODE_SUCCESS != code) {
(*pFunc)->pParameterList = NULL; (*ppFunc)->pParameterList = NULL;
nodesDestroyNode((SNode*)*pFunc); nodesDestroyNode((SNode*)*ppFunc);
*ppFunc = NULL;
return code; return code;
} }
return code; return code;
} }
static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** pCol) { static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** ppCol) {
*pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&ppCol);
if (NULL == *pCol) { if (NULL == *ppCol) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
(void)strcpy((*pCol)->colName, pFunc->node.aliasName); (void)strcpy((*ppCol)->colName, pFunc->node.aliasName);
(*pCol)->node.resType = pFunc->node.resType; (*ppCol)->node.resType = pFunc->node.resType;
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -419,11 +420,12 @@ bool fmIsDistExecFunc(int32_t funcId) {
} }
static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNode** pPartialFunc) { 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) { 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) { if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParameterList); nodesDestroyList(pParameterList);
return code; return code;
@ -542,12 +544,13 @@ char* fmGetFuncName(int32_t funcId) {
/// @retval 0 for succ, otherwise err occured /// @retval 0 for succ, otherwise err occured
static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pStateFunc) { static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pStateFunc) {
if (funcMgtBuiltins[pFunc->funcId].pStateFunc) { if (funcMgtBuiltins[pFunc->funcId].pStateFunc) {
SNodeList* pParams = nodesCloneList(pFunc->pParameterList); SNodeList* pParams = NULL;
if (!pParams) return TSDB_CODE_OUT_OF_MEMORY; int32_t code = nodesCloneList(pFunc->pParameterList, &pParams);
int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc); if (!pParams) return code;
code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc);
if (TSDB_CODE_SUCCESS != code) { if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParams); nodesDestroyList(pParams);
return TSDB_CODE_FUNC_FUNTION_ERROR; return terrno;
} }
(void)strcpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName); (void)strcpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName);
(void)strcpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias); (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) { static int32_t fmCreateStateMergeFunc(SFunctionNode* pFunc, SFunctionNode** pStateMergeFunc) {
if (funcMgtBuiltins[pFunc->funcId].pMergeFunc) { if (funcMgtBuiltins[pFunc->funcId].pMergeFunc) {
SNodeList* pParams = nodesCloneList(pFunc->pParameterList); SNodeList* pParams = NULL;
if (!pParams) return TSDB_CODE_OUT_OF_MEMORY; int32_t code = nodesCloneList(pFunc->pParameterList, &pParams);
int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams, pStateMergeFunc); if (!pParams) return code;
code = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams, pStateMergeFunc);
if (TSDB_CODE_SUCCESS != code) { if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParams); nodesDestroyList(pParams);
return code; return code;

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

@ -47,37 +47,37 @@
} \ } \
} while (0) } while (0)
#define CLONE_NODE_FIELD(fldname) \ #define CLONE_NODE_FIELD(fldname) \
do { \ do { \
if (NULL == (pSrc)->fldname) { \ if (NULL == (pSrc)->fldname) { \
break; \ break; \
} \ } \
(pDst)->fldname = nodesCloneNode((pSrc)->fldname); \ int32_t code = nodesCloneNode((pSrc)->fldname, &((pDst)->fldname)); \
if (NULL == (pDst)->fldname) { \ if (NULL == (pDst)->fldname) { \
return TSDB_CODE_OUT_OF_MEMORY; \ return code; \
} \ } \
} while (0) } while (0)
#define CLONE_NODE_FIELD_EX(fldname, nodePtrType) \ #define CLONE_NODE_FIELD_EX(fldname, nodePtrType) \
do { \ do { \
if (NULL == (pSrc)->fldname) { \ if (NULL == (pSrc)->fldname) { \
break; \ break; \
} \ } \
(pDst)->fldname = (nodePtrType)nodesCloneNode((SNode*)(pSrc)->fldname); \ int32_t code = nodesCloneNode((SNode*)(pSrc)->fldname, (SNode**)&((pDst)->fldname)); \
if (NULL == (pDst)->fldname) { \ if (NULL == (pDst)->fldname) { \
return TSDB_CODE_OUT_OF_MEMORY; \ return code; \
} \ } \
} while (0) } while (0)
#define CLONE_NODE_LIST_FIELD(fldname) \ #define CLONE_NODE_LIST_FIELD(fldname) \
do { \ do { \
if (NULL == (pSrc)->fldname) { \ if (NULL == (pSrc)->fldname) { \
break; \ break; \
} \ } \
(pDst)->fldname = nodesCloneList((pSrc)->fldname); \ int32_t code = nodesCloneList((pSrc)->fldname, &((pDst)->fldname)); \
if (NULL == (pDst)->fldname) { \ if (NULL == (pDst)->fldname) { \
return TSDB_CODE_OUT_OF_MEMORY; \ return code; \
} \ } \
} while (0) } while (0)
#define CLONE_OBJECT_FIELD(fldname, cloneFunc) \ #define CLONE_OBJECT_FIELD(fldname, cloneFunc) \
@ -869,18 +869,17 @@ static int32_t setOperatorCopy(const SSetOperator* pSrc, SSetOperator* pDst) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
SNode* nodesCloneNode(const SNode* pNode) { int32_t nodesCloneNode(const SNode* pNode, SNode** ppNode) {
if (NULL == pNode) { if (NULL == pNode) {
return NULL; return TSDB_CODE_SUCCESS;
} }
SNode* pDst = nodesMakeNode(nodeType(pNode)); SNode* pDst = NULL;
if (NULL == pDst) { int32_t code = nodesMakeNode(nodeType(pNode), &pDst);
terrno = TSDB_CODE_OUT_OF_MEMORY; if (TSDB_CODE_SUCCESS != code) {
return NULL; return code;
} }
int32_t code = TSDB_CODE_SUCCESS;
switch (nodeType(pNode)) { switch (nodeType(pNode)) {
case QUERY_NODE_COLUMN: case QUERY_NODE_COLUMN:
code = columnNodeCopy((const SColumnNode*)pNode, (SColumnNode*)pDst); code = columnNodeCopy((const SColumnNode*)pNode, (SColumnNode*)pDst);
@ -1058,25 +1057,31 @@ SNode* nodesCloneNode(const SNode* pNode) {
terrno = TSDB_CODE_OUT_OF_MEMORY; terrno = TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyNode(pDst); nodesDestroyNode(pDst);
nodesError("nodesCloneNode failed node = %s", nodesNodeName(nodeType(pNode))); 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) { if (NULL == pList) {
return NULL; return TSDB_CODE_SUCCESS;
} }
SNodeList* pDst = NULL; SNodeList* pDst = NULL;
SNode* pNode; SNode* pNode;
FOREACH(pNode, pList) { FOREACH(pNode, pList) {
int32_t code = nodesListMakeStrictAppend(&pDst, nodesCloneNode(pNode)); SNode* pNew = NULL;
int32_t code = nodesCloneNode(pNode, &pNew);
if (TSDB_CODE_SUCCESS != code) { if (TSDB_CODE_SUCCESS != code) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
nodesDestroyList(pDst); 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) { static int32_t jsonToNodeListImpl(const SJson* pJsonArray, SNodeList** pList) {
int32_t size = (NULL == pJsonArray ? 0 : tjsonGetArraySize(pJsonArray)); int32_t size = (NULL == pJsonArray ? 0 : tjsonGetArraySize(pJsonArray));
if (size > 0) { if (size > 0) {
*pList = nodesMakeList(); int32_t code = nodesMakeList(pList);
if (NULL == *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 val = 0;
int32_t code = tjsonGetIntValue(pJson, jkNodeType, &val); int32_t code = tjsonGetIntValue(pJson, jkNodeType, &val);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
*pNode = nodesMakeNode(val); code = nodesMakeNode(val, pNode);
if (NULL == *pNode) { if (NULL == *pNode) {
return TSDB_CODE_FAILED; return code;
} }
code = jsonToNode(pJson, *pNode); 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 (*FToMsg)(const void* pObj, STlvEncoder* pEncoder);
typedef int32_t (*FToObject)(STlvDecoder* pDecoder, void* pObj); 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); typedef int32_t (*FSetObject)(STlv* pTlv, void* pObj);
static int32_t nodeToMsg(const void* pObj, STlvEncoder* pEncoder); 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) { 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) { if (NULL == *pObj) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
return tlvDecodeObjFromTlv(pTlv, toFunc, *pObj); 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) { static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) {
SNodeList* pList = nodesMakeList(); SNodeList* pList = NULL;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
code = nodesMakeList(&pList);
while (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) { while (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) {
SNode* pNode = NULL; SNode* pNode = NULL;
code = msgToNode(pDecoder, (void**)&pNode); 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 registerCheckFunc(const std::function<void(const SNode*, const SNode*)>& func) { checkFunc_ = func; }
void run(const SNode* pSrc) { 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()); checkFunc_(pSrc, pDst.get());
} }
@ -43,9 +45,13 @@ TEST_F(NodesCloneTest, tempTable) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); 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(); return srcNode.get();
}()); }());
} }
@ -66,12 +72,14 @@ TEST_F(NodesCloneTest, joinTable) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SJoinTableNode* pNode = (SJoinTableNode*)srcNode.get();
pNode->joinType = JOIN_TYPE_INNER; pNode->joinType = JOIN_TYPE_INNER;
pNode->pLeft = nodesMakeNode(QUERY_NODE_REAL_TABLE); code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pLeft);
pNode->pRight = nodesMakeNode(QUERY_NODE_REAL_TABLE); code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pRight);
pNode->pOnCond = nodesMakeNode(QUERY_NODE_OPERATOR); code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pOnCond);
return srcNode.get(); return srcNode.get();
}()); }());
} }
@ -88,10 +96,12 @@ TEST_F(NodesCloneTest, stateWindow) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SStateWindowNode* pNode = (SStateWindowNode*)srcNode.get();
pNode->pCol = nodesMakeNode(QUERY_NODE_COLUMN); code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pCol);
pNode->pExpr = nodesMakeNode(QUERY_NODE_OPERATOR); code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pExpr);
return srcNode.get(); return srcNode.get();
}()); }());
} }
@ -108,10 +118,12 @@ TEST_F(NodesCloneTest, sessionWindow) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SSessionWindowNode* pNode = (SSessionWindowNode*)srcNode.get();
pNode->pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pNode->pCol);
pNode->pGap = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pNode->pGap);
return srcNode.get(); return srcNode.get();
}()); }());
} }
@ -136,12 +148,14 @@ TEST_F(NodesCloneTest, intervalWindow) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SIntervalWindowNode* pNode = (SIntervalWindowNode*)srcNode.get();
pNode->pInterval = nodesMakeNode(QUERY_NODE_VALUE); code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pInterval);
pNode->pOffset = nodesMakeNode(QUERY_NODE_VALUE); code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pOffset);
pNode->pSliding = nodesMakeNode(QUERY_NODE_VALUE); code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pSliding);
pNode->pFill = nodesMakeNode(QUERY_NODE_FILL); code = nodesMakeNode(QUERY_NODE_FILL, &pNode->pFill);
return srcNode.get(); return srcNode.get();
}()); }());
} }
@ -163,11 +177,13 @@ TEST_F(NodesCloneTest, fill) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SFillNode* pNode = (SFillNode*)srcNode.get();
pNode->mode = FILL_MODE_VALUE; pNode->mode = FILL_MODE_VALUE;
pNode->pValues = nodesMakeNode(QUERY_NODE_NODE_LIST); code = nodesMakeNode(QUERY_NODE_NODE_LIST, &pNode->pValues);
pNode->pWStartTs = nodesMakeNode(QUERY_NODE_COLUMN); code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pWStartTs);
pNode->timeRange.skey = 1666756692907; pNode->timeRange.skey = 1666756692907;
pNode->timeRange.ekey = 1666756699907; pNode->timeRange.ekey = 1666756699907;
return srcNode.get(); return srcNode.get();
@ -188,7 +204,9 @@ TEST_F(NodesCloneTest, logicSubplan) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SLogicSubplan* pNode = (SLogicSubplan*)srcNode.get();
return srcNode.get(); return srcNode.get();
}()); }());
@ -208,7 +226,9 @@ TEST_F(NodesCloneTest, physiScan) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); STagScanPhysiNode* pNode = (STagScanPhysiNode*)srcNode.get();
return srcNode.get(); return srcNode.get();
}()); }());
@ -227,7 +247,9 @@ TEST_F(NodesCloneTest, physiSystemTableScan) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SSystemTableScanPhysiNode* pNode = (SSystemTableScanPhysiNode*)srcNode.get();
return srcNode.get(); return srcNode.get();
}()); }());
@ -244,7 +266,9 @@ TEST_F(NodesCloneTest, physiStreamSemiSessionWinodw) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SStreamSemiSessionWinodwPhysiNode* pNode = (SStreamSemiSessionWinodwPhysiNode*)srcNode.get();
return srcNode.get(); return srcNode.get();
}()); }());
@ -261,7 +285,9 @@ TEST_F(NodesCloneTest, physiStreamFinalSessionWinodw) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SStreamFinalSessionWinodwPhysiNode* pNode = (SStreamFinalSessionWinodwPhysiNode*)srcNode.get();
return srcNode.get(); return srcNode.get();
}()); }());
@ -277,7 +303,9 @@ TEST_F(NodesCloneTest, physiStreamPartition) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SStreamPartitionPhysiNode* pNode = (SStreamPartitionPhysiNode*)srcNode.get();
return srcNode.get(); return srcNode.get();
}()); }());
@ -293,7 +321,9 @@ TEST_F(NodesCloneTest, physiPartition) {
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode); std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
run([&]() { 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(); SPartitionPhysiNode* pNode = (SPartitionPhysiNode*)srcNode.get();
return 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)) { if (QUERY_NODE_VALUE != nodeType(pOp->pLeft) || QUERY_NODE_VALUE != nodeType(pOp->pRight)) {
*pRes = DEAL_RES_ERROR; *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)); string tmp = to_string(stoi(((SValueNode*)(pOp->pLeft))->literal) + stoi(((SValueNode*)(pOp->pRight))->literal));
pVal->literal = taosStrdup(tmp.c_str()); pVal->literal = taosStrdup(tmp.c_str());
nodesDestroyNode(*pNode); nodesDestroyNode(*pNode);
@ -36,15 +37,18 @@ static EDealRes rewriterTest(SNode** pNode, void* pContext) {
} }
TEST(NodesTest, traverseTest) { 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* pOp = (SOperatorNode*)pRoot;
SOperatorNode* pLeft = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); SOperatorNode* pLeft = NULL;
pLeft->pLeft = (SNode*)nodesMakeNode(QUERY_NODE_VALUE); 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"); ((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"); ((SValueNode*)(pLeft->pRight))->literal = taosStrdup("5");
pOp->pLeft = (SNode*)pLeft; 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"); ((SValueNode*)(pOp->pRight))->literal = taosStrdup("3");
EXPECT_EQ(nodeType(pRoot), QUERY_NODE_OPERATOR); EXPECT_EQ(nodeType(pRoot), QUERY_NODE_OPERATOR);
@ -90,19 +94,24 @@ void assert_sort_result(SNodeList* pList) {
} }
TEST(NodesTest, sort) { 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; 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; 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; 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; 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; vn5->datum.i = 0;
SNodeList* l = NULL; 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 getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput);
int32_t getDnodeListFromCache(SParseMetaCache* pMetaCache, SArray** pDnodes); int32_t getDnodeListFromCache(SParseMetaCache* pMetaCache, SArray** pDnodes);
void destoryParseMetaCache(SParseMetaCache* pMetaCache, bool request); 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 getTableTsmasFromCache(SParseMetaCache* pMetaCache, const SName* pTbName, SArray** pTsmas);
int32_t getTsmaFromCache(SParseMetaCache* pMetaCache, const SName* pTsmaName, STableTSMAInfo** pTsma); 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*); extern void ParseTrace(FILE*, char*);
int32_t buildQueryAfterParse(SQuery** pQuery, SNode* pRootNode, int16_t placeholderNo, SArray** pPlaceholderValues) { 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) { if (NULL == *pQuery) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
(*pQuery)->pRoot = pRootNode; (*pQuery)->pRoot = pRootNode;
(*pQuery)->placeholderNum = placeholderNo; (*pQuery)->placeholderNum = placeholderNo;
@ -424,7 +425,7 @@ static int32_t collectMetaKeyFromDescribe(SCollectMetaKeyCxt* pCxt, SDescribeStm
#ifdef TD_ENTERPRISE #ifdef TD_ENTERPRISE
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
char dbFName[TSDB_DB_FNAME_LEN]; char dbFName[TSDB_DB_FNAME_LEN];
tNameGetFullDbName(&name, dbFName); (void)tNameGetFullDbName(&name, dbFName);
code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->tableName, 0); code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->tableName, 0);
} }
#endif #endif
@ -439,9 +440,9 @@ static int32_t collectMetaKeyFromCreateStream(SCollectMetaKeyCxt* pCxt, SCreateS
reserveTableMetaInCache(pCxt->pParseCxt->acctId, pStmt->targetDbName, pStmt->targetTabName, pCxt->pMetaCache); reserveTableMetaInCache(pCxt->pParseCxt->acctId, pStmt->targetDbName, pStmt->targetTabName, pCxt->pMetaCache);
if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pSubtable && NULL != pStmt->pQuery) { if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pSubtable && NULL != pStmt->pQuery) {
SSelectStmt* pSelect = (SSelectStmt*)pStmt->pQuery; SSelectStmt* pSelect = (SSelectStmt*)pStmt->pQuery;
pSelect->pSubtable = nodesCloneNode(pStmt->pSubtable); int32_t code = nodesCloneNode(pStmt->pSubtable, &pSelect->pSubtable);
if (NULL == pSelect->pSubtable) { if (NULL == pSelect->pSubtable) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
@ -724,7 +725,7 @@ static int32_t collectMetaKeyFromShowCreateView(SCollectMetaKeyCxt* pCxt, SShowC
strcpy(name.dbname, pStmt->dbName); strcpy(name.dbname, pStmt->dbName);
strcpy(name.tname, pStmt->viewName); strcpy(name.tname, pStmt->viewName);
char dbFName[TSDB_DB_FNAME_LEN]; 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); int32_t code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->viewName, 0);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = reserveViewUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pStmt->dbName, pStmt->viewName, 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 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) { bool isView, bool effective, SUserAuthInfo* pAuth) {
if (effective) { if (effective) {
snprintf(pAuth->user, sizeof(pAuth->user), "%s", pCxt->pEffectiveUser ? pCxt->pEffectiveUser : ""); 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) { 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 { } else {
toName(pCxt->acctId, pDbName, pTabName, &pAuth->tbName); (void)toName(pCxt->acctId, pDbName, pTabName, &pAuth->tbName);
} }
pAuth->type = type; pAuth->type = type;
pAuth->isView = isView; 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) { 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; AUTH_RES_TYPE auth_res_type = isView ? AUTH_RES_VIEW : AUTH_RES_BASIC;
SUserAuthInfo authInfo = {0}; SUserAuthInfo authInfo = {0};
setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo); int32_t code = setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo);
int32_t code = TSDB_CODE_SUCCESS; if (TSDB_CODE_SUCCESS != code) return code;
SUserAuthRes authRes = {0}; SUserAuthRes authRes = {0};
if (NULL != pCxt->pMetaCache) { if (NULL != pCxt->pMetaCache) {
code = getUserAuthFromCache(pCxt->pMetaCache, &authInfo, &authRes); 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) { 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) { if (NULL == pLogicCond) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
pLogicCond->condType = LOGIC_COND_TYPE_AND; pLogicCond->condType = LOGIC_COND_TYPE_AND;
int32_t code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, pTagCond); code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, pTagCond);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeAppend(&pLogicCond->pParameterList, *pWhere); 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) { 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) { if (NULL == pTagCondCopy) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
SAuthRewriteCxt cxt = {.pTarget = pTable}; 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) { 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) { if (NULL == pOp) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pOp->opType = OP_TYPE_IS_TRUE; pOp->opType = OP_TYPE_IS_TRUE;
pOp->pLeft = pSrc; pOp->pLeft = pSrc;
@ -179,9 +180,9 @@ static EDealRes doFindAndReplaceNode(SNode** pNode, void* pContext) {
char aliasName[TSDB_COL_NAME_LEN] = {0}; char aliasName[TSDB_COL_NAME_LEN] = {0};
strcpy(aliasName, ((SExprNode*)*pNode)->aliasName); strcpy(aliasName, ((SExprNode*)*pNode)->aliasName);
nodesDestroyNode(*pNode); nodesDestroyNode(*pNode);
*pNode = nodesCloneNode(pCxt->replaceCxt.pNew); *pNode = NULL;
pCxt->code = nodesCloneNode(pCxt->replaceCxt.pNew, pNode);
if (NULL == *pNode) { if (NULL == *pNode) {
pCxt->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
strcpy(((SExprNode*)*pNode)->aliasName, aliasName); strcpy(((SExprNode*)*pNode)->aliasName, aliasName);
@ -231,12 +232,14 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d
SArray* pOrigAss = NULL; SArray* pOrigAss = NULL;
TSWAP(((SExprNode*)*pCol)->pAssociation, pOrigAss); TSWAP(((SExprNode*)*pCol)->pAssociation, pOrigAss);
nodesDestroyNode(*pCol); nodesDestroyNode(*pCol);
*pCol = nodesCloneNode(*pNew); *pCol = NULL;
TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation); code = nodesCloneNode(*pNew, pCol);
if (TSDB_CODE_SUCCESS == code) {
strcpy(((SExprNode*)*pCol)->aliasName, aliasName);
TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation);
}
taosArrayDestroy(pOrigAss); taosArrayDestroy(pOrigAss);
strcpy(((SExprNode*)*pCol)->aliasName, aliasName); if (TSDB_CODE_SUCCESS != code) {
if (NULL == *pCol) {
code = TSDB_CODE_OUT_OF_MEMORY;
break; break;
} }
} else { } else {
@ -276,17 +279,23 @@ static bool isUselessCol(SExprNode* pProj) {
return NULL == ((SExprNode*)pProj)->pAssociation; return NULL == ((SExprNode*)pProj)->pAssociation;
} }
static SNode* createConstantValue() { static int32_t createConstantValue(SValueNode** ppNode) {
SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); SValueNode* pVal = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
if (NULL == pVal) { if (NULL == pVal) {
return NULL; return code;
} }
pVal->node.resType.type = TSDB_DATA_TYPE_INT; pVal->node.resType.type = TSDB_DATA_TYPE_INT;
pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes; pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes;
const int32_t val = 1; const int32_t val = 1;
nodesSetValueNodeValue(pVal, (void*)&val); code = nodesSetValueNodeValue(pVal, (void*)&val);
pVal->translate = true; if (TSDB_CODE_SUCCESS == code) {
return (SNode*)pVal; pVal->translate = true;
*ppNode = pVal;
} else {
nodesDestroyNode((SNode*)pVal);
}
return code;
} }
static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) { static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) {
@ -306,7 +315,11 @@ static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelec
WHERE_NEXT; WHERE_NEXT;
} }
if (0 == LIST_LENGTH(pSelect->pProjectionList)) { 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; return TSDB_CODE_SUCCESS;
} }
@ -417,7 +430,7 @@ static void eraseSetOpChildProjection(SSetOperator* pSetOp, int32_t index) {
eraseSetOpChildProjection((SSetOperator*)pSetOp->pLeft, index); eraseSetOpChildProjection((SSetOperator*)pSetOp->pLeft, index);
} }
SNodeList* pRightProjs = getChildProjection(pSetOp->pRight); SNodeList* pRightProjs = getChildProjection(pSetOp->pRight);
nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index)); (void)nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index));
if (QUERY_NODE_SET_OPERATOR == nodeType(pSetOp->pRight)) { if (QUERY_NODE_SET_OPERATOR == nodeType(pSetOp->pRight)) {
eraseSetOpChildProjection((SSetOperator*)pSetOp->pRight, index); eraseSetOpChildProjection((SSetOperator*)pSetOp->pRight, index);
} }
@ -495,7 +508,11 @@ static int32_t calcConstSetOpProjections(SCalcConstContext* pCxt, SSetOperator*
WHERE_NEXT; WHERE_NEXT;
} }
if (0 == LIST_LENGTH(pSetOp->pProjectionList)) { 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; return TSDB_CODE_SUCCESS;
} }

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

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

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

@ -796,9 +796,10 @@ typedef struct SRewriteTagCondCxt {
} SRewriteTagCondCxt; } SRewriteTagCondCxt;
static int32_t rewriteTagCondColumnImpl(STagVal* pVal, SNode** pNode) { 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) { if (NULL == pValue) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pValue->node.resType = ((SColumnNode*)*pNode)->node.resType; pValue->node.resType = ((SColumnNode*)*pNode)->node.resType;
@ -1240,7 +1241,8 @@ static int32_t getTargetTableSchema(SInsertParseContext* pCxt, SVnodeModifyOpStm
pCxt->needTableTagVal = (NULL != pTagCond); pCxt->needTableTagVal = (NULL != pTagCond);
pCxt->missCache = (NULL != pTagCond); pCxt->missCache = (NULL != pTagCond);
} else { } else {
pStmt->pTagCond = nodesCloneNode(pTagCond); pStmt->pTagCond = NULL;
code = nodesCloneNode(pTagCond, &pStmt->pTagCond);
} }
} }
nodesDestroyNode(pTagCond); nodesDestroyNode(pTagCond);
@ -2535,9 +2537,10 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS
static void destroySubTableHashElem(void* p) { taosMemoryFree(*(STableMeta**)p); } static void destroySubTableHashElem(void* p) { taosMemoryFree(*(STableMeta**)p); }
static int32_t createVnodeModifOpStmt(SInsertParseContext* pCxt, bool reentry, SNode** pOutput) { 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) { if (NULL == pStmt) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
if (pCxt->pComCxt->pStmtCb) { 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) { 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) { if (NULL == pQuery) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->haveResultSet = false; pQuery->haveResultSet = false;
pQuery->msgType = TDMT_VND_SUBMIT; pQuery->msgType = TDMT_VND_SUBMIT;
int32_t code = createVnodeModifOpStmt(pCxt, false, &pQuery->pRoot); code = createVnodeModifOpStmt(pCxt, false, &pQuery->pRoot);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
*pOutput = pQuery; *pOutput = pQuery;
} else { } else {
@ -2601,10 +2605,10 @@ static int32_t checkAuthFromMetaData(const SArray* pUsers, SNode** pTagCond) {
SMetaRes* pRes = taosArrayGet(pUsers, 0); SMetaRes* pRes = taosArrayGet(pUsers, 0);
if (TSDB_CODE_SUCCESS == pRes->code) { if (TSDB_CODE_SUCCESS == pRes->code) {
SUserAuthRes* pAuth = pRes->pRes; SUserAuthRes* pAuth = pRes->pRes;
if (NULL != pAuth->pCond) { pRes->code = nodesCloneNode(pAuth->pCond[AUTH_RES_BASIC], pTagCond);
*pTagCond = nodesCloneNode(pAuth->pCond[AUTH_RES_BASIC]); 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; 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; return code;
} }
SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint) { int32_t createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint, SNode** ppSelect) {
SSelectStmt* select = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT); SSelectStmt* select = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_SELECT_STMT, (SNode**)&select);
if (NULL == select) { if (NULL == select) {
return NULL; return code;
} }
select->isDistinct = isDistinct; select->isDistinct = isDistinct;
select->pProjectionList = pProjectionList; select->pProjectionList = pProjectionList;
@ -777,7 +778,8 @@ SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode*
select->timeRange = TSWINDOW_INITIALIZER; select->timeRange = TSWINDOW_INITIALIZER;
select->pHint = pHint; select->pHint = pHint;
select->lastProcessByRowFuncId = -1; 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) { 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)) { if (TSDB_CODE_SUCCESS == code && (colIdx < 0 || colIdx + 1 == pQuery->placeholderNum)) {
nodesDestroyNode(pQuery->pRoot); nodesDestroyNode(pQuery->pRoot);
pQuery->pRoot = nodesCloneNode(pQuery->pPrepareRoot); pQuery->pRoot = NULL;
code = nodesCloneNode(pQuery->pPrepareRoot, &pQuery->pRoot);
if (NULL == pQuery->pRoot) { if (NULL == pQuery->pRoot) {
code = TSDB_CODE_OUT_OF_MEMORY; code = code;
} }
} }
if (TSDB_CODE_SUCCESS == 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_LIMIT 1
#define CLONE_SLIMIT 1 << 1 #define CLONE_SLIMIT 1 << 1
#define CLONE_LIMIT_SLIMIT (CLONE_LIMIT | CLONE_SLIMIT) #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, int32_t sortPriKeyOptGetSequencingNodesImpl(SLogicNode* pNode, bool groupSort, SSortLogicNode* pSort,
bool* pNotOptimize, SNodeList** pSequencingNodes, bool* keepSort); 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); pExpr = nodesListGetNode(((SGroupingSetNode*)pExpr)->pParameterList, 0);
} }
if (nodesEqualNode(pExpr, *pNode)) { 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) { if (NULL == pCol) {
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -177,7 +178,11 @@ static int32_t cloneRewriteExprs(SNodeList* pExprs, bool* pOutputs, SNodeList**
SNode* pExpr = NULL; SNode* pExpr = NULL;
FOREACH(pExpr, pExprs) { FOREACH(pExpr, pExprs) {
if (pOutputs[index]) { 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) { if (TSDB_CODE_SUCCESS != code) {
NODES_DESTORY_LIST(*pRewriteExpr); NODES_DESTORY_LIST(*pRewriteExpr);
break; break;
@ -223,9 +228,9 @@ static int32_t rewriteExprs(SNodeList* pExprs, SNodeList* pTarget) {
static int32_t pushLogicNode(SLogicPlanContext* pCxt, SLogicNode** pOldRoot, SLogicNode* pNewRoot) { static int32_t pushLogicNode(SLogicPlanContext* pCxt, SLogicNode** pOldRoot, SLogicNode* pNewRoot) {
if (NULL == pNewRoot->pChildren) { if (NULL == pNewRoot->pChildren) {
pNewRoot->pChildren = nodesMakeList(); int32_t code = nodesMakeList(&pNewRoot->pChildren);
if (NULL == pNewRoot->pChildren) { if (NULL == pNewRoot->pChildren) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
} }
if (TSDB_CODE_SUCCESS != nodesListAppend(pNewRoot->pChildren, (SNode*)*pOldRoot)) { 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) { 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) { if (NULL == pCol) {
return NULL; return NULL;
} }
@ -360,9 +366,10 @@ static int32_t addDefaultScanCol(SRealTableNode* pTable, SNodeList** pCols) {
static int32_t makeScanLogicNode(SLogicPlanContext* pCxt, SRealTableNode* pRealTable, bool hasRepeatScanFuncs, static int32_t makeScanLogicNode(SLogicPlanContext* pCxt, SRealTableNode* pRealTable, bool hasRepeatScanFuncs,
SLogicNode** pLogicNode) { 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) { if (NULL == pScan) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
TSWAP(pScan->pVgroupList, pRealTable->pVgroupList); 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) { if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pTags && NULL == pSelect->pPartitionByList) {
pScan->pTags = nodesCloneList(pSelect->pTags); code = nodesCloneList(pSelect->pTags, &pScan->pTags);
if (NULL == pScan->pTags) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable && NULL == pSelect->pPartitionByList) { if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable && NULL == pSelect->pPartitionByList) {
pScan->pSubtable = nodesCloneNode(pSelect->pSubtable); code = nodesCloneNode(pSelect->pSubtable, &pScan->pSubtable);
if (NULL == pScan->pSubtable) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
// set output // set output
@ -518,9 +519,10 @@ int32_t collectJoinResColumns(SSelectStmt* pSelect, SJoinLogicNode* pJoin, SNode
static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SJoinTableNode* pJoinTable, static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SJoinTableNode* pJoinTable,
SLogicNode** pLogicNode) { SLogicNode** pLogicNode) {
int32_t code = TSDB_CODE_SUCCESS; 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) { if (NULL == pJoin) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pJoin->joinType = pJoinTable->joinType; 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.requireDataOrder = pJoin->hashJoinHint ? DATA_ORDER_LEVEL_NONE : DATA_ORDER_LEVEL_GLOBAL;
pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
pJoin->isLowLevelJoin = pJoinTable->isLowLevelJoin; pJoin->isLowLevelJoin = pJoinTable->isLowLevelJoin;
pJoin->pWindowOffset = nodesCloneNode(pJoinTable->pWindowOffset); code = nodesCloneNode(pJoinTable->pWindowOffset, &pJoin->pWindowOffset);
pJoin->pJLimit = nodesCloneNode(pJoinTable->pJLimit); if (TSDB_CODE_SUCCESS == code) {
pJoin->addPrimEqCond = nodesCloneNode(pJoinTable->addPrimCond); code = nodesCloneNode(pJoinTable->pJLimit, &pJoin->pJLimit);
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;
} }
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; SLogicNode* pLeft = NULL;
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
@ -566,10 +570,7 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
// set on conditions // set on conditions
if (TSDB_CODE_SUCCESS == code && NULL != pJoinTable->pOnCond) { if (TSDB_CODE_SUCCESS == code && NULL != pJoinTable->pOnCond) {
pJoin->pFullOnCond = nodesCloneNode(pJoinTable->pOnCond); code = nodesCloneNode(pJoinTable->pOnCond, &pJoin->pFullOnCond);
if (NULL == pJoin->pFullOnCond) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
#if 0 #if 0
@ -631,10 +632,7 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
} }
if (NULL == pJoin->node.pTargets && NULL != pLeft) { if (NULL == pJoin->node.pTargets && NULL != pLeft) {
pJoin->node.pTargets = nodesCloneList(pLeft->pTargets); code = nodesCloneList(pLeft->pTargets, &pJoin->node.pTargets);
if (NULL == pJoin->node.pTargets) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
#endif #endif
@ -669,10 +667,11 @@ static int32_t createLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSel
SLogicNode* pNode = NULL; SLogicNode* pNode = NULL;
int32_t code = doCreateLogicNodeByTable(pCxt, pSelect, pTable, &pNode); int32_t code = doCreateLogicNodeByTable(pCxt, pSelect, pTable, &pNode);
if (TSDB_CODE_SUCCESS == code) { 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) { if (NULL != pSelect->pWhere && NULL == pNode->pConditions) {
nodesDestroyNode((SNode*)pNode); nodesDestroyNode((SNode*)pNode);
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pNode->precision = pSelect->precision; pNode->precision = pSelect->precision;
*pLogicNode = pNode; *pLogicNode = pNode;
@ -682,7 +681,8 @@ static int32_t createLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSel
} }
static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr) { 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) { if (NULL == pCol) {
return NULL; return NULL;
} }
@ -694,17 +694,24 @@ static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr)
return pCol; return pCol;
} }
static SNode* createGroupingSetNode(SNode* pExpr) { static int32_t createGroupingSetNode(SNode* pExpr, SNode** ppNode) {
SGroupingSetNode* pGroupingSet = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET); SGroupingSetNode* pGroupingSet = NULL;
int32_t code = 0;
*ppNode = NULL;
code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pGroupingSet);
if (NULL == pGroupingSet) { if (NULL == pGroupingSet) {
return NULL; return code;
} }
pGroupingSet->groupingSetType = GP_TYPE_NORMAL; pGroupingSet->groupingSetType = GP_TYPE_NORMAL;
if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pGroupingSet->pParameterList, nodesCloneNode(pExpr))) { SNode* pNew = NULL;
nodesDestroyNode((SNode*)pGroupingSet); code = nodesCloneNode(pExpr, &pNew);
return NULL; 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) { 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) { 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; SJoinTableNode* pJoinTable = (SJoinTableNode*)pSelect->pFromTable;
SRealTableNode* pProbeTable = NULL; SRealTableNode* pProbeTable = NULL;
switch (pJoinTable->joinType) { switch (pJoinTable->joinType) {
@ -742,10 +756,11 @@ static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pLi
return TSDB_CODE_PLAN_INTERNAL_ERROR; 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 (NULL == pCol) {
if (!*pList) nodesDestroyList(pTargets); if (!*pList) nodesDestroyList(pTargets);
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
SSchema* pColSchema = &pProbeTable->pMeta->schema[0]; 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; pCol->node.resType.precision = pProbeTable->pMeta->tableInfo.precision;
SNode* pFunc = (SNode*)createGroupKeyAggFunc(pCol); 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) { 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; 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) { if (NULL == pAgg) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
bool winJoin = isWindowJoinStmt(pSelect); 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.resultDataOrder = pAgg->onlyHasKeepOrderFunc ? pAgg->node.requireDataOrder : DATA_ORDER_LEVEL_NONE;
pAgg->node.forceCreateNonBlockingOptr = winJoin ? true : false; pAgg->node.forceCreateNonBlockingOptr = winJoin ? true : false;
int32_t code = TSDB_CODE_SUCCESS;
// set grouyp keys, agg funcs and having conditions // set grouyp keys, agg funcs and having conditions
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = nodesCollectFuncs(pSelect, SQL_CLAUSE_GROUP_BY, NULL, fmIsAggFunc, &pAgg->pAggFuncs); 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) { if (NULL != pSelect->pGroupByList) {
pAgg->pGroupKeys = nodesCloneList(pSelect->pGroupByList); pAgg->pGroupKeys = NULL;
if (NULL == pAgg->pGroupKeys) { code = nodesCloneList(pSelect->pGroupByList, &pAgg->pGroupKeys);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
// rewrite the expression in subsequent clauses // 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) { if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving) {
pAgg->node.pConditions = nodesCloneNode(pSelect->pHaving); pAgg->node.pConditions = NULL;
if (NULL == pAgg->node.pConditions) { code = nodesCloneNode(pSelect->pHaving, &pAgg->node.pConditions);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
// set the output // set the output
@ -857,10 +874,10 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
SIndefRowsFuncLogicNode* pIdfRowsFunc = SIndefRowsFuncLogicNode* pIdfRowsFunc = NULL;
(SIndefRowsFuncLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC); int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, (SNode**)&pIdfRowsFunc);
if (NULL == pIdfRowsFunc) { if (NULL == pIdfRowsFunc) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pIdfRowsFunc->isTailFunc = pSelect->hasTailFunc; pIdfRowsFunc->isTailFunc = pSelect->hasTailFunc;
@ -871,7 +888,7 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt
pIdfRowsFunc->node.resultDataOrder = pIdfRowsFunc->node.requireDataOrder; pIdfRowsFunc->node.resultDataOrder = pIdfRowsFunc->node.requireDataOrder;
// indefinite rows functions and _select_values functions // 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) { if (TSDB_CODE_SUCCESS == code) {
code = rewriteExprsForSelect(pIdfRowsFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL); 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; 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) { if (NULL == pInterpFunc) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pInterpFunc->node.groupAction = getGroupAction(pCxt, pSelect); pInterpFunc->node.groupAction = getGroupAction(pCxt, pSelect);
@ -909,7 +927,7 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p
pInterpFunc->node.resultDataOrder = pInterpFunc->node.requireDataOrder; pInterpFunc->node.resultDataOrder = pInterpFunc->node.requireDataOrder;
// interp functions and _group_key functions // 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) { if (TSDB_CODE_SUCCESS == code) {
code = rewriteExprsForSelect(pInterpFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL); 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; SFillNode* pFill = (SFillNode*)pSelect->pFill;
pInterpFunc->timeRange = pFill->timeRange; pInterpFunc->timeRange = pFill->timeRange;
pInterpFunc->fillMode = pFill->mode; pInterpFunc->fillMode = pFill->mode;
pInterpFunc->pTimeSeries = nodesCloneNode(pFill->pWStartTs); pInterpFunc->pTimeSeries = NULL;
pInterpFunc->pFillValues = nodesCloneNode(pFill->pValues); code = nodesCloneNode(pFill->pWStartTs, &pInterpFunc->pTimeSeries);
if (NULL == pInterpFunc->pTimeSeries || (NULL != pFill->pValues && NULL == pInterpFunc->pFillValues)) { if (TSDB_CODE_SUCCESS == code) {
code = TSDB_CODE_OUT_OF_MEMORY; 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) { if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving) {
pWindow->node.pConditions = nodesCloneNode(pSelect->pHaving); code = nodesCloneNode(pSelect->pHaving, &pWindow->node.pConditions);
if (NULL == pWindow->node.pConditions) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
pSelect->hasAggFuncs = false; pSelect->hasAggFuncs = false;
@ -984,9 +999,10 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm
static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindowNode* pState, SSelectStmt* pSelect, static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindowNode* pState, SSelectStmt* pSelect,
SLogicNode** pLogicNode) { 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) { if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pWindow->winType = WINDOW_TYPE_STATE; 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); pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_IN_BLOCK : getRequireDataOrder(true, pSelect);
pWindow->node.resultDataOrder = pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder; pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder;
pWindow->pStateExpr = nodesCloneNode(pState->pExpr); pWindow->pStateExpr = NULL;
pWindow->pTspk = nodesCloneNode(pState->pCol); code = nodesCloneNode(pState->pExpr, &pWindow->pStateExpr);
if (NULL == pWindow->pStateExpr || NULL == pWindow->pTspk) { if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode((SNode*)pWindow); 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 // 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) { if (TSDB_CODE_SUCCESS == code) {
code = createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode); code = createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode);
} else {
nodesDestroyNode((SNode*)pWindow);
} }
return code; return code;
@ -1012,9 +1035,10 @@ static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindo
static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionWindowNode* pSession, static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionWindowNode* pSession,
SSelectStmt* pSelect, SLogicNode** pLogicNode) { 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) { if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pWindow->winType = WINDOW_TYPE_SESSION; pWindow->winType = WINDOW_TYPE_SESSION;
@ -1026,21 +1050,28 @@ static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionW
pWindow->node.resultDataOrder = pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder; 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) { if (NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow); 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); return createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode);
} }
static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SIntervalWindowNode* pInterval, static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SIntervalWindowNode* pInterval,
SSelectStmt* pSelect, SLogicNode** pLogicNode) { 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) { if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pWindow->winType = WINDOW_TYPE_INTERVAL; 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); : (pSelect->hasTimeLineFunc ? getRequireDataOrder(true, pSelect) : DATA_ORDER_LEVEL_IN_BLOCK);
pWindow->node.resultDataOrder = pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : getRequireDataOrder(true, pSelect); 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) { if (NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow); nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pWindow->isPartTb = pSelect->pPartitionByList ? keysHasTbname(pSelect->pPartitionByList) : 0; 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, static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindowNode* pEvent, SSelectStmt* pSelect,
SLogicNode** pLogicNode) { 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) { if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pWindow->winType = WINDOW_TYPE_EVENT; 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); pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_IN_BLOCK : getRequireDataOrder(true, pSelect);
pWindow->node.resultDataOrder = pWindow->node.resultDataOrder =
pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder; pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder;
pWindow->pStartCond = nodesCloneNode(pEvent->pStartCond); pWindow->pStartCond = NULL;
pWindow->pEndCond = nodesCloneNode(pEvent->pEndCond); code = nodesCloneNode(pEvent->pStartCond, &pWindow->pStartCond);
pWindow->pTspk = nodesCloneNode(pEvent->pCol); 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) { if (NULL == pWindow->pStartCond || NULL == pWindow->pEndCond || NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow); nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY; 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, static int32_t createWindowLogicNodeByCount(SLogicPlanContext* pCxt, SCountWindowNode* pCount, SSelectStmt* pSelect,
SLogicNode** pLogicNode) { 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) { if (NULL == pWindow) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pWindow->winType = WINDOW_TYPE_COUNT; 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; pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder;
pWindow->windowCount = pCount->windowCount; pWindow->windowCount = pCount->windowCount;
pWindow->windowSliding = pCount->windowSliding; pWindow->windowSliding = pCount->windowSliding;
pWindow->pTspk = nodesCloneNode(pCount->pCol); pWindow->pTspk = NULL;
code = nodesCloneNode(pCount->pCol, &pWindow->pTspk);
if (NULL == pWindow->pTspk) { if (NULL == pWindow->pTspk) {
nodesDestroyNode((SNode*)pWindow); nodesDestroyNode((SNode*)pWindow);
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
return createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode); return createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode);
} }
@ -1159,9 +1207,17 @@ static int32_t partFillExprs(SSelectStmt* pSelect, SNodeList** pFillExprs, SNode
SNode* pProject = NULL; SNode* pProject = NULL;
FOREACH(pProject, pSelect->pProjectionList) { FOREACH(pProject, pSelect->pProjectionList) {
if (needFillValue(pProject)) { 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)) { } 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) { if (TSDB_CODE_SUCCESS != code) {
NODES_DESTORY_LIST(*pFillExprs); NODES_DESTORY_LIST(*pFillExprs);
@ -1174,9 +1230,17 @@ static int32_t partFillExprs(SSelectStmt* pSelect, SNodeList** pFillExprs, SNode
FOREACH(pOrderExpr, pSelect->pOrderByList) { FOREACH(pOrderExpr, pSelect->pOrderByList) {
SNode* pExpr = ((SOrderByExprNode*)pOrderExpr)->pExpr; SNode* pExpr = ((SOrderByExprNode*)pOrderExpr)->pExpr;
if (needFillValue(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)) { } 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) { if (TSDB_CODE_SUCCESS != code) {
NODES_DESTORY_LIST(*pFillExprs); NODES_DESTORY_LIST(*pFillExprs);
@ -1199,9 +1263,10 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
return TSDB_CODE_SUCCESS; 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) { if (NULL == pFill) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pFill->node.groupAction = getGroupAction(pCxt, pSelect); 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.resultDataOrder = pFill->node.requireDataOrder;
pFill->node.inputTsOrder = TSDB_ORDER_ASC; 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) { if (TSDB_CODE_SUCCESS == code) {
code = rewriteExprsForSelect(pFill->pFillExprs, pSelect, SQL_CLAUSE_FILL, NULL); 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->mode = pFillNode->mode;
pFill->timeRange = pFillNode->timeRange; pFill->timeRange = pFillNode->timeRange;
pFill->pValues = nodesCloneNode(pFillNode->pValues); pFill->pValues = NULL;
pFill->pWStartTs = nodesCloneNode(pFillNode->pWStartTs); code = nodesCloneNode(pFillNode->pValues, &pFill->pValues);
if ((NULL != pFillNode->pValues && NULL == pFill->pValues) || NULL == pFill->pWStartTs) { if (TSDB_CODE_SUCCESS == code) {
code = TSDB_CODE_OUT_OF_MEMORY; code = nodesCloneNode(pFillNode->pWStartTs, &pFillNode->pWStartTs);
} }
if (TSDB_CODE_SUCCESS == code && 0 == LIST_LENGTH(pFill->node.pTargets)) { 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; 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) { if (NULL == pSort) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pSort->groupSort = pSelect->groupSort; pSort->groupSort = pSelect->groupSort;
@ -1268,16 +1334,20 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
pSort->node.resultDataOrder = isPrimaryKeySort(pSelect->pOrderByList) pSort->node.resultDataOrder = isPrimaryKeySort(pSelect->pOrderByList)
? (pSort->groupSort ? DATA_ORDER_LEVEL_IN_GROUP : DATA_ORDER_LEVEL_GLOBAL) ? (pSort->groupSort ? DATA_ORDER_LEVEL_IN_GROUP : DATA_ORDER_LEVEL_GLOBAL)
: DATA_ORDER_LEVEL_NONE; : 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) { if (TSDB_CODE_SUCCESS == code && NULL == pSort->node.pTargets) {
code = nodesListMakeStrictAppend(&pSort->node.pTargets, SNode* pNew = NULL;
nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0))); code = nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0), &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pSort->node.pTargets, pNew);
}
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pSort->pSortKeys = nodesCloneList(pSelect->pOrderByList); pSort->pSortKeys = NULL;
code = nodesCloneList(pSelect->pOrderByList, &pSort->pSortKeys);
if (NULL == pSort->pSortKeys) { if (NULL == pSort->pSortKeys) {
code = TSDB_CODE_OUT_OF_MEMORY; code = code;
} }
SNode* pNode = NULL; SNode* pNode = NULL;
SOrderByExprNode* firstSortKey = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0); 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, static int32_t createColumnByProjections(SLogicPlanContext* pCxt, const char* pStmtName, SNodeList* pExprs,
SNodeList** pCols) { SNodeList** pCols) {
SNodeList* pList = nodesMakeList(); SNodeList* pList = NULL;
int32_t code = nodesMakeList(&pList);
if (NULL == pList) { if (NULL == pList) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
SNode* pNode; SNode* pNode;
FOREACH(pNode, pExprs) { 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); 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) { 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) { if (NULL == pProject) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
TSWAP(pProject->node.pLimit, pSelect->pLimit); 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.requireDataOrder = DATA_ORDER_LEVEL_NONE;
pProject->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; pProject->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
int32_t code = TSDB_CODE_SUCCESS; pProject->pProjections = NULL;
code = nodesCloneList(pSelect->pProjectionList, &pProject->pProjections);
pProject->pProjections = nodesCloneList(pSelect->pProjectionList);
if (NULL == pProject->pProjections) { if (NULL == pProject->pProjections) {
code = TSDB_CODE_OUT_OF_MEMORY; code = code;
} }
strcpy(pProject->stmtName, pSelect->stmtName); strcpy(pProject->stmtName, pSelect->stmtName);
@ -1363,20 +1434,23 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
return TSDB_CODE_SUCCESS; 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) { if (NULL == pPartition) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pPartition->node.groupAction = GROUP_ACTION_SET; pPartition->node.groupAction = GROUP_ACTION_SET;
pPartition->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pPartition->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
pPartition->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; pPartition->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
int32_t code = code = nodesCollectColumns(pSelect, SQL_CLAUSE_PARTITION_BY, NULL, COLLECT_COL_TYPE_ALL, &pPartition->node.pTargets);
nodesCollectColumns(pSelect, SQL_CLAUSE_PARTITION_BY, NULL, COLLECT_COL_TYPE_ALL, &pPartition->node.pTargets);
if (TSDB_CODE_SUCCESS == code && NULL == pPartition->node.pTargets) { if (TSDB_CODE_SUCCESS == code && NULL == pPartition->node.pTargets) {
code = nodesListMakeStrictAppend(&pPartition->node.pTargets, SNode* pNew = NULL;
nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0))); code = nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0), &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pPartition->node.pTargets, pNew);
}
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
@ -1385,10 +1459,8 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pPartition->pPartitionKeys = nodesCloneList(pSelect->pPartitionByList); pPartition->pPartitionKeys = NULL;
if (NULL == pPartition->pPartitionKeys) { code = nodesCloneList(pSelect->pPartitionByList, &pPartition->pPartitionKeys);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (keysHasCol(pPartition->pPartitionKeys) && pSelect->pWindow && 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) { if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pTags) {
pPartition->pTags = nodesCloneList(pSelect->pTags); pPartition->pTags = NULL;
if (NULL == pPartition->pTags) { code = nodesCloneList(pSelect->pTags, &pPartition->pTags);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable) { if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable) {
pPartition->pSubtable = nodesCloneNode(pSelect->pSubtable); pPartition->pSubtable = NULL;
if (NULL == pPartition->pSubtable) { code = nodesCloneNode(pSelect->pSubtable, &pPartition->pSubtable);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving && !pSelect->hasAggFuncs && NULL == pSelect->pGroupByList && if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving && !pSelect->hasAggFuncs && NULL == pSelect->pGroupByList &&
NULL == pSelect->pWindow) { NULL == pSelect->pWindow) {
pPartition->node.pConditions = nodesCloneNode(pSelect->pHaving); pPartition->node.pConditions = NULL;
if (NULL == pPartition->node.pConditions) { code = nodesCloneNode(pSelect->pHaving, &pPartition->node.pConditions);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
@ -1436,21 +1502,25 @@ static int32_t createDistinctLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe
return TSDB_CODE_SUCCESS; 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) { if (NULL == pAgg) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pAgg->node.groupAction = GROUP_ACTION_CLEAR;//getDistinctGroupAction(pCxt, pSelect); pAgg->node.groupAction = GROUP_ACTION_CLEAR;//getDistinctGroupAction(pCxt, pSelect);
pAgg->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pAgg->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
pAgg->node.resultDataOrder = 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 // set grouyp keys, agg funcs and having conditions
SNodeList* pGroupKeys = NULL; SNodeList* pGroupKeys = NULL;
SNode* pProjection = NULL; SNode* pProjection = NULL;
FOREACH(pProjection, pSelect->pProjectionList) { 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) { if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pGroupKeys); nodesDestroyList(pGroupKeys);
break; break;
@ -1548,25 +1618,20 @@ static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* p
return TSDB_CODE_SUCCESS; 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) { if (NULL == pSort) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
TSWAP(pSort->node.pLimit, pSetOperator->pLimit); TSWAP(pSort->node.pLimit, pSetOperator->pLimit);
int32_t code = TSDB_CODE_SUCCESS; pSort->node.pTargets = NULL;
code = nodesCloneList(pSetOperator->pProjectionList, &pSort->node.pTargets);
pSort->node.pTargets = nodesCloneList(pSetOperator->pProjectionList);
if (NULL == pSort->node.pTargets) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pSort->pSortKeys = nodesCloneList(pSetOperator->pOrderByList); pSort->pSortKeys = NULL;
if (NULL == pSort->pSortKeys) { code = nodesCloneList(pSetOperator->pOrderByList, &pSort->pSortKeys);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code) { 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, static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator,
SLogicNode** pLogicNode) { 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) { if (NULL == pProject) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
if (NULL == pSetOperator->pOrderByList) { if (NULL == pSetOperator->pOrderByList) {
@ -1591,12 +1657,8 @@ static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator
pProject->ignoreGroupId = true; pProject->ignoreGroupId = true;
pProject->isSetOpProj = true; pProject->isSetOpProj = true;
int32_t code = TSDB_CODE_SUCCESS; pProject->pProjections = NULL;
code = nodesCloneList(pSetOperator->pProjectionList, &pProject->pProjections);
pProject->pProjections = nodesCloneList(pSetOperator->pProjectionList);
if (NULL == pProject->pProjections) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = createColumnByProjections(pCxt, pSetOperator->stmtName, pSetOperator->pProjectionList, 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) { 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) { if (NULL == pAgg) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
if (NULL == pSetOperator->pOrderByList) { if (NULL == pSetOperator->pOrderByList) {
TSWAP(pAgg->node.pSlimit, pSetOperator->pLimit); TSWAP(pAgg->node.pSlimit, pSetOperator->pLimit);
} }
int32_t code = TSDB_CODE_SUCCESS; pAgg->pGroupKeys = NULL;
pAgg->pGroupKeys = nodesCloneList(pSetOperator->pProjectionList); code = nodesCloneList(pSetOperator->pProjectionList, &pAgg->pGroupKeys);
if (NULL == pAgg->pGroupKeys) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
// rewrite the expression in subsequent clauses // rewrite the expression in subsequent clauses
if (TSDB_CODE_SUCCESS == code) { 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) { 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) { if (NULL == pModif) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pModif->modifyType = MODIFY_TABLE_TYPE_INSERT; pModif->modifyType = MODIFY_TABLE_TYPE_INSERT;
TSWAP(pModif->pDataBlocks, pStmt->pDataBlocks); TSWAP(pModif->pDataBlocks, pStmt->pDataBlocks);
@ -1747,10 +1808,8 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pScan->scanType = SCAN_TYPE_TABLE; pScan->scanType = SCAN_TYPE_TABLE;
pScan->scanRange = pDelete->timeRange; pScan->scanRange = pDelete->timeRange;
pScan->pScanCols = nodesCloneList(((SFunctionNode*)pDelete->pCountFunc)->pParameterList); pScan->pScanCols = NULL;
if (NULL == pScan->pScanCols) { code = nodesCloneList(((SFunctionNode*)pDelete->pCountFunc)->pParameterList, &pScan->pScanCols);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
STableMeta* pMeta = ((SRealTableNode*)pDelete->pFromTable)->pMeta; 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) { if (TSDB_CODE_SUCCESS == code && NULL != pDelete->pTagCond) {
pScan->pTagCond = nodesCloneNode(pDelete->pTagCond); code = nodesCloneNode(pDelete->pTagCond, &pScan->pTagCond);
if (NULL == pScan->pTagCond) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
// set output // set output
@ -1780,17 +1836,30 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
} }
static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) { 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) { 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) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pAgg->pAggFuncs, nodesCloneNode(pDelete->pFirstFunc)); code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, pNew);
} }
if (TSDB_CODE_SUCCESS == code) { 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) { if (TSDB_CODE_SUCCESS == code) {
code = rewriteExpr(pAgg->pAggFuncs, &pDelete->pCountFunc); 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, static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDeleteStmt* pDelete,
SLogicNode** pLogicNode) { 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) { if (NULL == pModify) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
SRealTableNode* pRealTable = (SRealTableNode*)pDelete->pFromTable; 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); snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName);
strcpy(pModify->tsColName, pRealTable->pMeta->schema->name); strcpy(pModify->tsColName, pRealTable->pMeta->schema->name);
pModify->deleteTimeRange = pDelete->timeRange; pModify->deleteTimeRange = pDelete->timeRange;
pModify->pAffectedRows = nodesCloneNode(pDelete->pCountFunc); pModify->pAffectedRows = NULL;
pModify->pStartTs = nodesCloneNode(pDelete->pFirstFunc); code = nodesCloneNode(pDelete->pCountFunc, &pModify->pAffectedRows);
pModify->pEndTs = nodesCloneNode(pDelete->pLastFunc); if (TSDB_CODE_SUCCESS != code) {
if (NULL == pModify->pAffectedRows || NULL == pModify->pStartTs || NULL == pModify->pEndTs) {
nodesDestroyNode((SNode*)pModify); 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; *pLogicNode = (SLogicNode*)pModify;
@ -1868,9 +1947,10 @@ static int32_t creatInsertRootLogicNode(SLogicPlanContext* pCxt, SInsertStmt* pI
static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInsertStmt* pInsert, static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInsertStmt* pInsert,
SLogicNode** pLogicNode) { 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) { if (NULL == pModify) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
SRealTableNode* pRealTable = (SRealTableNode*)pInsert->pTable; SRealTableNode* pRealTable = (SRealTableNode*)pInsert->pTable;
@ -1881,10 +1961,11 @@ static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInser
pModify->tableType = pRealTable->pMeta->tableType; pModify->tableType = pRealTable->pMeta->tableType;
snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName); snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName);
TSWAP(pModify->pVgroupList, pRealTable->pVgroupList); TSWAP(pModify->pVgroupList, pRealTable->pVgroupList);
pModify->pInsertCols = nodesCloneList(pInsert->pCols); pModify->pInsertCols = NULL;
code = nodesCloneList(pInsert->pCols, &pModify->pInsertCols);
if (NULL == pModify->pInsertCols) { if (NULL == pModify->pInsertCols) {
nodesDestroyNode((SNode*)pModify); nodesDestroyNode((SNode*)pModify);
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
*pLogicNode = (SLogicNode*)pModify; *pLogicNode = (SLogicNode*)pModify;
@ -1949,15 +2030,16 @@ static void setLogicSubplanType(bool hasScan, SLogicSubplan* pSubplan) {
int32_t createLogicPlan(SPlanContext* pCxt, SLogicSubplan** pLogicSubplan) { int32_t createLogicPlan(SPlanContext* pCxt, SLogicSubplan** pLogicSubplan) {
SLogicPlanContext cxt = {.pPlanCxt = pCxt, .pCurrRoot = NULL, .hasScan = false}; 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) { if (NULL == pSubplan) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pSubplan->id.queryId = pCxt->queryId; pSubplan->id.queryId = pCxt->queryId;
pSubplan->id.groupId = 1; pSubplan->id.groupId = 1;
pSubplan->id.subplanId = 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) { if (TSDB_CODE_SUCCESS == code) {
setLogicNodeParent(pSubplan->pNode); setLogicNodeParent(pSubplan->pNode);
setLogicSubplanType(cxt.hasScan, pSubplan); 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; } SScaleOutContext;
static SLogicSubplan* singleCloneSubLogicPlan(SScaleOutContext* pCxt, SLogicSubplan* pSrc, int32_t level) { 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) { if (NULL == pDst) {
terrno = code;
return NULL; return NULL;
} }
pDst->pNode = (SLogicNode*)nodesCloneNode((SNode*)pSrc->pNode); pDst->pNode = NULL;
code = nodesCloneNode((SNode*)pSrc->pNode, (SNode**)&pDst->pNode);
if (NULL == pDst->pNode) { if (NULL == pDst->pNode) {
terrno = code;
nodesDestroyNode((SNode*)pDst); nodesDestroyNode((SNode*)pDst);
return NULL; return NULL;
} }
@ -69,7 +73,7 @@ static int32_t scaleOutByVgroups(SScaleOutContext* pCxt, SLogicSubplan* pSubplan
for (int32_t i = 0; i < pSubplan->pVgroupList->numOfVgroups; ++i) { for (int32_t i = 0; i < pSubplan->pVgroupList->numOfVgroups; ++i) {
SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level); SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
if (NULL == pNewSubplan) { if (NULL == pNewSubplan) {
return TSDB_CODE_OUT_OF_MEMORY; return terrno;
} }
code = setScanVgroup(pNewSubplan->pNode, pSubplan->pVgroupList->vgroups + i); code = setScanVgroup(pNewSubplan->pNode, pSubplan->pVgroupList->vgroups + i);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
@ -90,14 +94,15 @@ static int32_t scaleOutForInsertValues(SScaleOutContext* pCxt, SLogicSubplan* pS
SNodeList* pGroup) { SNodeList* pGroup) {
SVnodeModifyLogicNode* pNode = (SVnodeModifyLogicNode*)pSubplan->pNode; SVnodeModifyLogicNode* pNode = (SVnodeModifyLogicNode*)pSubplan->pNode;
size_t numOfVgroups = taosArrayGetSize(pNode->pDataBlocks); size_t numOfVgroups = taosArrayGetSize(pNode->pDataBlocks);
int32_t code = 0;
for (int32_t i = 0; i < numOfVgroups; ++i) { for (int32_t i = 0; i < numOfVgroups; ++i) {
SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level); SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
if (NULL == pNewSubplan) { if (NULL == pNewSubplan) {
return TSDB_CODE_OUT_OF_MEMORY; return terrno;
} }
((SVnodeModifyLogicNode*)pNewSubplan->pNode)->pVgDataBlocks = (SVgDataBlocks*)taosArrayGetP(pNode->pDataBlocks, i); ((SVnodeModifyLogicNode*)pNewSubplan->pNode)->pVgDataBlocks = (SVgDataBlocks*)taosArrayGetP(pNode->pDataBlocks, i);
if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pGroup, (SNode*)pNewSubplan)) { if (TSDB_CODE_SUCCESS != (code = nodesListStrictAppend(pGroup, (SNode*)pNewSubplan))) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
} }
return TSDB_CODE_SUCCESS; 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) { for (int32_t i = 0; i < pSubplan->numOfComputeNodes; ++i) {
SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level); SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level);
if (NULL == pNewSubplan) { if (NULL == pNewSubplan) {
return TSDB_CODE_OUT_OF_MEMORY; return terrno;
} }
code = nodesListStrictAppend(pGroup, (SNode*)pNewSubplan); code = nodesListStrictAppend(pGroup, (SNode*)pNewSubplan);
if (TSDB_CODE_SUCCESS != code) { 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) { 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) { if (NULL == pCurrentGroup) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
int32_t code = TSDB_CODE_SUCCESS;
switch (pSubplan->subplanType) { switch (pSubplan->subplanType) {
case SUBPLAN_TYPE_MERGE: case SUBPLAN_TYPE_MERGE:
code = scaleOutForMerge(pCxt, pSubplan, level, pCurrentGroup); code = scaleOutForMerge(pCxt, pSubplan, level, pCurrentGroup);
@ -243,13 +248,17 @@ static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32
} }
static SQueryLogicPlan* makeQueryLogicPlan() { 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) { if (NULL == pLogicPlan) {
terrno = code;
return NULL; return NULL;
} }
pLogicPlan->pTopSubplans = nodesMakeList(); pLogicPlan->pTopSubplans = NULL;
code = nodesMakeList(&pLogicPlan->pTopSubplans);
if (NULL == pLogicPlan->pTopSubplans) { if (NULL == pLogicPlan->pTopSubplans) {
nodesDestroyNode((SNode*)pLogicPlan); nodesDestroyNode((SNode*)pLogicPlan);
terrno = code;
return NULL; return NULL;
} }
return pLogicPlan; return pLogicPlan;
@ -258,7 +267,7 @@ static SQueryLogicPlan* makeQueryLogicPlan() {
int32_t scaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQueryLogicPlan** pLogicPlan) { int32_t scaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQueryLogicPlan** pLogicPlan) {
SQueryLogicPlan* pPlan = makeQueryLogicPlan(); SQueryLogicPlan* pPlan = makeQueryLogicPlan();
if (NULL == pPlan) { if (NULL == pPlan) {
return TSDB_CODE_OUT_OF_MEMORY; return terrno;
} }
SScaleOutContext cxt = {.pPlanCxt = pCxt, .subplanId = 1}; 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) { 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) { if (NULL == pSubplan) {
return NULL; return NULL;
} }
@ -93,37 +94,44 @@ static void splSetSubplanType(SLogicSubplan* pSubplan) {
pSubplan->subplanType = splHasScan(pSubplan->pNode) ? SUBPLAN_TYPE_SCAN : SUBPLAN_TYPE_MERGE; pSubplan->subplanType = splHasScan(pSubplan->pNode) ? SUBPLAN_TYPE_SCAN : SUBPLAN_TYPE_MERGE;
} }
static SLogicSubplan* splCreateSubplan(SSplitContext* pCxt, SLogicNode* pNode) { static int32_t splCreateSubplan(SSplitContext* pCxt, SLogicNode* pNode, SLogicSubplan** ppSubplan) {
SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN); SLogicSubplan* pSubplan = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan);
if (NULL == pSubplan) { if (NULL == pSubplan) {
return NULL; return code;
} }
pSubplan->id.queryId = pCxt->queryId; pSubplan->id.queryId = pCxt->queryId;
pSubplan->id.groupId = pCxt->groupId; pSubplan->id.groupId = pCxt->groupId;
pSubplan->pNode = pNode; pSubplan->pNode = pNode;
pNode->pParent = NULL; pNode->pParent = NULL;
splSetSubplanType(pSubplan); splSetSubplanType(pSubplan);
return pSubplan; *ppSubplan = pSubplan;
return code;
} }
static int32_t splCreateExchangeNode(SSplitContext* pCxt, SLogicNode* pChild, SExchangeLogicNode** pOutput) { 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) { if (NULL == pExchange) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pExchange->srcStartGroupId = pCxt->groupId; pExchange->srcStartGroupId = pCxt->groupId;
pExchange->srcEndGroupId = pCxt->groupId; pExchange->srcEndGroupId = pCxt->groupId;
pExchange->node.precision = pChild->precision; pExchange->node.precision = pChild->precision;
pExchange->node.dynamicOp = pChild->dynamicOp; 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) { if (NULL == pExchange->node.pTargets) {
return TSDB_CODE_OUT_OF_MEMORY; nodesDestroyNode((SNode*)pExchange);
return code;
} }
if (NULL != pChild->pLimit) { 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) { 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)->limit += ((SLimitNode*)pChild->pLimit)->offset;
((SLimitNode*)pChild->pLimit)->offset = 0; ((SLimitNode*)pChild->pLimit)->offset = 0;
@ -368,18 +376,14 @@ static int32_t stbSplRewriteFuns(const SNodeList* pFuncs, SNodeList** pPartialFu
SFunctionNode* pMergeFunc = NULL; SFunctionNode* pMergeFunc = NULL;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
if (fmIsWindowPseudoColumnFunc(pFunc->funcId)) { if (fmIsWindowPseudoColumnFunc(pFunc->funcId)) {
pPartFunc = (SFunctionNode*)nodesCloneNode(pNode); code = nodesCloneNode(pNode, (SNode**)&pPartFunc);
pMergeFunc = (SFunctionNode*)nodesCloneNode(pNode); if (TSDB_CODE_SUCCESS == code) {
if (NULL == pPartFunc || NULL == pMergeFunc) { code = nodesCloneNode(pNode, (SNode**)&pMergeFunc);
nodesDestroyNode((SNode*)pPartFunc);
nodesDestroyNode((SNode*)pMergeFunc);
code = TSDB_CODE_OUT_OF_MEMORY;
} }
if(pMidFuncs != NULL){ if(TSDB_CODE_SUCCESS == code && pMidFuncs != NULL){
pMidFunc = (SFunctionNode*)nodesCloneNode(pNode); code = nodesCloneNode(pNode, (SNode**)&pMidFunc);
if (NULL == pMidFunc) { if (NULL == pMidFunc) {
nodesDestroyNode((SNode*)pMidFunc); nodesDestroyNode((SNode*)pMidFunc);
code = TSDB_CODE_OUT_OF_MEMORY;
} }
} }
} else { } else {
@ -419,9 +423,10 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr
++index; ++index;
} }
SFunctionNode* pWStart = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); SFunctionNode* pWStart = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWStart);
if (NULL == pWStart) { if (NULL == pWStart) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
strcpy(pWStart->functionName, "_wstart"); strcpy(pWStart->functionName, "_wstart");
int64_t pointer = (int64_t)pWStart; 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); strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
pWStart->node.resType.precision = precision; pWStart->node.resType.precision = precision;
int32_t code = fmGetFuncInfo(pWStart, NULL, 0); code = fmGetFuncInfo(pWStart, NULL, 0);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pFuncs, (SNode*)pWStart); code = nodesListStrictAppend(pFuncs, (SNode*)pWStart);
} }
@ -450,9 +455,10 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) {
++index; ++index;
} }
SFunctionNode* pWEnd = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); SFunctionNode* pWEnd = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWEnd);
if (NULL == pWEnd) { if (NULL == pWEnd) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
strcpy(pWEnd->functionName, "_wend"); strcpy(pWEnd->functionName, "_wend");
int64_t pointer = (int64_t)pWEnd; int64_t pointer = (int64_t)pWEnd;
@ -461,7 +467,7 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) {
taosCreateMD5Hash(name, len); taosCreateMD5Hash(name, len);
strncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN - 1); 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) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pWin->pFuncs, (SNode*)pWEnd); code = nodesListStrictAppend(pWin->pFuncs, (SNode*)pWEnd);
} }
@ -482,9 +488,10 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
SNode* pConditions = pMergeWindow->node.pConditions; SNode* pConditions = pMergeWindow->node.pConditions;
pMergeWindow->node.pConditions = NULL; pMergeWindow->node.pConditions = NULL;
SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow); SWindowLogicNode* pPartWin = NULL;
int32_t code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pPartWin);
if (NULL == pPartWin) { if (NULL == pPartWin) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pPartWin->node.groupAction = GROUP_ACTION_KEEP; pPartWin->node.groupAction = GROUP_ACTION_KEEP;
@ -494,7 +501,7 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
splSetParent((SLogicNode*)pPartWin); splSetParent((SLogicNode*)pPartWin);
int32_t index = 0; 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) { if (TSDB_CODE_SUCCESS == code) {
code = stbSplAppendWStart(pPartWin->pFuncs, &index, ((SColumnNode*)pMergeWindow->pTspk)->node.resType.precision); 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) { if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMergeWindow->pTspk); nodesDestroyNode(pMergeWindow->pTspk);
pMergeWindow->pTspk = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index)); pMergeWindow->pTspk = NULL;
if (NULL == pMergeWindow->pTspk) { code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMergeWindow->pTspk);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
nodesDestroyList(pFunc); nodesDestroyList(pFunc);
@ -529,14 +534,17 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
SNode* pConditions = pMergeWindow->node.pConditions; SNode* pConditions = pMergeWindow->node.pConditions;
pMergeWindow->node.pConditions = NULL; pMergeWindow->node.pConditions = NULL;
SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow); SWindowLogicNode* pPartWin = NULL;
int32_t code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pPartWin);
if (NULL == 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) { if (NULL == pMidWin) {
return TSDB_CODE_OUT_OF_MEMORY; nodesDestroyNode((SNode*)pPartWin);
return code;
} }
pPartWin->node.groupAction = GROUP_ACTION_KEEP; pPartWin->node.groupAction = GROUP_ACTION_KEEP;
@ -550,7 +558,7 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
SNodeList* pFuncPart = NULL; SNodeList* pFuncPart = NULL;
SNodeList* pFuncMid = NULL; SNodeList* pFuncMid = NULL;
SNodeList* pFuncMerge = NULL; SNodeList* pFuncMerge = NULL;
int32_t code = stbSplRewriteFuns(pFunc, &pFuncPart, &pFuncMid, &pFuncMerge); code = stbSplRewriteFuns(pFunc, &pFuncPart, &pFuncMid, &pFuncMerge);
pPartWin->pFuncs = pFuncPart; pPartWin->pFuncs = pFuncPart;
pMidWin->pFuncs = pFuncMid; pMidWin->pFuncs = pFuncMid;
pMergeWindow->pFuncs = pFuncMerge; pMergeWindow->pFuncs = pFuncMerge;
@ -565,10 +573,8 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMidWin->pTspk); nodesDestroyNode(pMidWin->pTspk);
pMidWin->pTspk = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index)); pMidWin->pTspk = NULL;
if (NULL == pMidWin->pTspk) { code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMidWin->pTspk);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
@ -580,10 +586,7 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMergeWindow->pTspk); nodesDestroyNode(pMergeWindow->pTspk);
pMergeWindow->pTspk = nodesCloneNode(nodesListGetNode(pMidWin->node.pTargets, index)); code = nodesCloneNode(nodesListGetNode(pMidWin->node.pTargets, index), &pMergeWindow->pTspk);
if (NULL == pMergeWindow->pTspk) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
nodesDestroyList(pFunc); nodesDestroyList(pFunc);
@ -649,9 +652,10 @@ static int32_t stbSplRewriteFromMergeNode(SMergeLogicNode* pMerge, SLogicNode* p
static int32_t stbSplCreateMergeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SLogicNode* pSplitNode, static int32_t stbSplCreateMergeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SLogicNode* pSplitNode,
SNodeList* pMergeKeys, SLogicNode* pPartChild, bool groupSort, bool needSort) { 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) { if (NULL == pMerge) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pMerge->needSort = needSort; pMerge->needSort = needSort;
pMerge->numOfChannels = stbSplGetNumOfVgroups(pPartChild); pMerge->numOfChannels = stbSplGetNumOfVgroups(pPartChild);
@ -662,22 +666,19 @@ static int32_t stbSplCreateMergeNode(SSplitContext* pCxt, SLogicSubplan* pSubpla
pMerge->groupSort = groupSort; pMerge->groupSort = groupSort;
pMerge->numOfSubplans = 1; pMerge->numOfSubplans = 1;
int32_t code = TSDB_CODE_SUCCESS; pMerge->pInputs = NULL;
pMerge->pInputs = nodesCloneList(pPartChild->pTargets); code = nodesCloneList(pPartChild->pTargets, &pMerge->pInputs);
// NULL != pSubplan means 'merge node' replaces 'split node'. if (TSDB_CODE_SUCCESS == code) {
if (NULL == pSubplan) { // NULL != pSubplan means 'merge node' replaces 'split node'.
pMerge->node.pTargets = nodesCloneList(pPartChild->pTargets); if (NULL == pSubplan) {
} else { code = nodesCloneList(pPartChild->pTargets, &pMerge->node.pTargets);
pMerge->node.pTargets = nodesCloneList(pSplitNode->pTargets); } else {
} code = nodesCloneList(pSplitNode->pTargets, &pMerge->node.pTargets);
if (NULL == pMerge->node.pTargets || NULL == pMerge->pInputs) { }
code = TSDB_CODE_OUT_OF_MEMORY;
} }
if (TSDB_CODE_SUCCESS == code && NULL != pSplitNode->pLimit) { if (TSDB_CODE_SUCCESS == code && NULL != pSplitNode->pLimit) {
pMerge->node.pLimit = nodesCloneNode(pSplitNode->pLimit); pMerge->node.pLimit = NULL;
if (NULL == pMerge->node.pLimit) { code = nodesCloneNode(pSplitNode->pLimit, &pMerge->node.pLimit);
code = TSDB_CODE_OUT_OF_MEMORY;
}
((SLimitNode*)pSplitNode->pLimit)->limit += ((SLimitNode*)pSplitNode->pLimit)->offset; ((SLimitNode*)pSplitNode->pLimit)->limit += ((SLimitNode*)pSplitNode->pLimit)->offset;
((SLimitNode*)pSplitNode->pLimit)->offset = 0; ((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) { 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) { 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) { if (NULL == pOrderByExpr->pExpr) {
nodesDestroyNode((SNode*)pOrderByExpr); nodesDestroyNode((SNode*)pOrderByExpr);
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pOrderByExpr->order = order; pOrderByExpr->order = order;
pOrderByExpr->nullOrder = (order == ORDER_ASC) ? NULL_ORDER_FIRST : NULL_ORDER_LAST; 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; SLogicSubplan* pSplitSubPlan = NULL;
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pSplitSubPlan = splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT); 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) { if (code == TSDB_CODE_SUCCESS) {
SNode* pNode; SNode* pNode;
@ -793,11 +796,14 @@ static int32_t stbSplSplitIntervalForStreamMultiAgg(SSplitContext* pCxt, SStable
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
SNode* subPlan = (SNode*)splCreateSubplan(pCxt, pMidWindow); SNode* subPlan = NULL;
((SLogicSubplan*)subPlan)->subplanType = SUBPLAN_TYPE_MERGE; code = splCreateSubplan(pCxt, pMidWindow, (SLogicSubplan**)&subPlan);
if (TSDB_CODE_SUCCESS == code) {
((SLogicSubplan*)subPlan)->subplanType = SUBPLAN_TYPE_MERGE;
code = nodesListMakeStrictAppend(&((SLogicSubplan*)subPlan)->pChildren, code = nodesListMakeStrictAppend(&((SLogicSubplan*)subPlan)->pChildren,
(SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT)); (SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT));
}
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren, subPlan); code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren, subPlan);
} }
@ -828,9 +834,10 @@ static int32_t stbSplSplitSessionForStream(SSplitContext* pCxt, SStableSplitInfo
int32_t code = stbSplAppendWEnd(pPartWin, &index); int32_t code = stbSplAppendWEnd(pPartWin, &index);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
nodesDestroyNode(pMergeWin->pTsEnd); 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) { if (NULL == pMergeWin->pTsEnd) {
code = TSDB_CODE_OUT_OF_MEMORY; code = code;
} }
} }
code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartWindow); code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartWindow);
@ -1006,24 +1013,21 @@ static int32_t stbSplCreatePartAggNode(SAggLogicNode* pMergeAgg, SLogicNode** pO
SNode* pConditions = pMergeAgg->node.pConditions; SNode* pConditions = pMergeAgg->node.pConditions;
pMergeAgg->node.pConditions = NULL; pMergeAgg->node.pConditions = NULL;
SAggLogicNode* pPartAgg = (SAggLogicNode*)nodesCloneNode((SNode*)pMergeAgg); SAggLogicNode* pPartAgg = NULL;
int32_t code = nodesCloneNode((SNode*)pMergeAgg, (SNode**)&pPartAgg);
if (NULL == pPartAgg) { if (NULL == pPartAgg) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pPartAgg->node.groupAction = GROUP_ACTION_KEEP; pPartAgg->node.groupAction = GROUP_ACTION_KEEP;
int32_t code = TSDB_CODE_SUCCESS;
if (NULL != pGroupKeys) { if (NULL != pGroupKeys) {
pPartAgg->pGroupKeys = pGroupKeys; pPartAgg->pGroupKeys = pGroupKeys;
code = createColumnByRewriteExprs(pPartAgg->pGroupKeys, &pPartAgg->node.pTargets); code = createColumnByRewriteExprs(pPartAgg->pGroupKeys, &pPartAgg->node.pTargets);
} }
if (TSDB_CODE_SUCCESS == code && NULL != pGroupKeys) { if (TSDB_CODE_SUCCESS == code && NULL != pGroupKeys) {
pMergeAgg->pGroupKeys = nodesCloneList(pPartAgg->node.pTargets); pMergeAgg->pGroupKeys = NULL;
if (NULL == pMergeAgg->pGroupKeys) { code = nodesCloneList(pPartAgg->node.pTargets, &pMergeAgg->pGroupKeys);
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pMergeAgg->node.pConditions = pConditions; pMergeAgg->node.pConditions = pConditions;
@ -1090,7 +1094,7 @@ static int32_t stbSplAggNodeCreateMerge(SSplitContext* pCtx, SStableSplitInfo* p
if (idx++ < originalLen) continue; if (idx++ < originalLen) continue;
SFunctionNode* pGroupKeyFunc = createGroupKeyAggFunc((SColumnNode*)node); SFunctionNode* pGroupKeyFunc = createGroupKeyAggFunc((SColumnNode*)node);
if (!pGroupKeyFunc) { if (!pGroupKeyFunc) {
code = TSDB_CODE_OUT_OF_MEMORY; code = terrno;
break; break;
} }
code = nodesListMakeStrictAppend(&extraAggFuncs, (SNode*)pGroupKeyFunc); code = nodesListMakeStrictAppend(&extraAggFuncs, (SNode*)pGroupKeyFunc);
@ -1165,7 +1169,7 @@ static int32_t stbSplSplitAggNodeForCrossTableMulSubplan(SSplitContext* pCxt, SS
if (code == TSDB_CODE_SUCCESS) { if (code == TSDB_CODE_SUCCESS) {
pFirstScanSubplan = splCreateScanSubplan(pCxt, pPartAgg, SPLIT_FLAG_STABLE_SPLIT); 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) { if (code == TSDB_CODE_SUCCESS) {
@ -1220,7 +1224,7 @@ static int32_t stbSplSplitAggNodeForCrossTable(SSplitContext* pCxt, SStableSplit
SLogicSubplan* pScanSubplan = NULL; SLogicSubplan* pScanSubplan = NULL;
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pScanSubplan = splCreateScanSubplan(pCxt, pPartAgg, SPLIT_FLAG_STABLE_SPLIT); 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) { if (code == TSDB_CODE_SUCCESS) {
@ -1242,10 +1246,11 @@ static int32_t stbSplSplitAggNode(SSplitContext* pCxt, SStableSplitInfo* pInfo)
return stbSplSplitAggNodeForCrossTable(pCxt, pInfo); return stbSplSplitAggNodeForCrossTable(pCxt, pInfo);
} }
static SNode* stbSplCreateColumnNode(SExprNode* pExpr) { static int32_t stbSplCreateColumnNode(SExprNode* pExpr, SNode** ppNode) {
SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); SColumnNode* pCol = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
if (NULL == pCol) { if (NULL == pCol) {
return NULL; return code;
} }
if (QUERY_NODE_COLUMN == nodeType(pExpr)) { if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
strcpy(pCol->dbName, ((SColumnNode*)pExpr)->dbName); strcpy(pCol->dbName, ((SColumnNode*)pExpr)->dbName);
@ -1258,22 +1263,26 @@ static SNode* stbSplCreateColumnNode(SExprNode* pExpr) {
strcpy(pCol->node.aliasName, pExpr->aliasName); strcpy(pCol->node.aliasName, pExpr->aliasName);
strcpy(pCol->node.userAlias, pExpr->userAlias); strcpy(pCol->node.userAlias, pExpr->userAlias);
pCol->node.resType = pExpr->resType; pCol->node.resType = pExpr->resType;
return (SNode*)pCol; *ppNode = (SNode*)pCol;
return code;
} }
static SNode* stbSplCreateOrderByExpr(SOrderByExprNode* pSortKey, SNode* pCol) { static int32_t stbSplCreateOrderByExpr(SOrderByExprNode* pSortKey, SNode* pCol, SNode** ppNode) {
SOrderByExprNode* pOutput = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); SOrderByExprNode* pOutput = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOutput);
if (NULL == pOutput) { if (NULL == pOutput) {
return NULL; return code;
} }
pOutput->pExpr = nodesCloneNode(pCol); pOutput->pExpr = NULL;
code = nodesCloneNode(pCol, &pOutput->pExpr);
if (NULL == pOutput->pExpr) { if (NULL == pOutput->pExpr) {
nodesDestroyNode((SNode*)pOutput); nodesDestroyNode((SNode*)pOutput);
return NULL; return code;
} }
pOutput->order = pSortKey->order; pOutput->order = pSortKey->order;
pOutput->nullOrder = pSortKey->nullOrder; pOutput->nullOrder = pSortKey->nullOrder;
return (SNode*)pOutput; *ppNode = (SNode*)pOutput;
return code;
} }
static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets, SNodeList** pOutput) { 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) { FOREACH(pTarget, pTargets) {
if ((QUERY_NODE_COLUMN == nodeType(pSortExpr) && nodesEqualNode((SNode*)pSortExpr, pTarget)) || if ((QUERY_NODE_COLUMN == nodeType(pSortExpr) && nodesEqualNode((SNode*)pSortExpr, pTarget)) ||
(0 == strcmp(pSortExpr->aliasName, ((SColumnNode*)pTarget)->colName))) { (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) { if (TSDB_CODE_SUCCESS != code) {
break; break;
} }
@ -1296,8 +1309,15 @@ static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets,
} }
} }
if (TSDB_CODE_SUCCESS == code && !found) { if (TSDB_CODE_SUCCESS == code && !found) {
SNode* pCol = stbSplCreateColumnNode(pSortExpr); SNode* pCol = NULL;
code = nodesListMakeStrictAppend(&pMergeKeys, stbSplCreateOrderByExpr(pSortKey, pCol)); 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) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pTargets, pCol); code = nodesListStrictAppend(pTargets, pCol);
} else { } else {
@ -1324,9 +1344,10 @@ static int32_t stbSplCreatePartSortNode(SSortLogicNode* pSort, SLogicNode** pOut
pSort->node.pChildren = NULL; pSort->node.pChildren = NULL;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
SSortLogicNode* pPartSort = (SSortLogicNode*)nodesCloneNode((SNode*)pSort); SSortLogicNode* pPartSort = NULL;
code = nodesCloneNode((SNode*)pSort, (SNode**)&pPartSort);
if (NULL == pPartSort) { if (NULL == pPartSort) {
code = TSDB_CODE_OUT_OF_MEMORY; code = code;
} }
SNodeList* pMergeKeys = NULL; SNodeList* pMergeKeys = NULL;
@ -1392,9 +1413,10 @@ static int32_t stbSplGetSplitNodeForScan(SStableSplitInfo* pInfo, SLogicNode** p
!((SProjectLogicNode*)pInfo->pSplitNode->pParent)->inputIgnoreGroup) { !((SProjectLogicNode*)pInfo->pSplitNode->pParent)->inputIgnoreGroup) {
*pSplitNode = pInfo->pSplitNode->pParent; *pSplitNode = pInfo->pSplitNode->pParent;
if (NULL != pInfo->pSplitNode->pLimit) { 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) { 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)->limit += ((SLimitNode*)pInfo->pSplitNode->pLimit)->offset;
((SLimitNode*)pInfo->pSplitNode->pLimit)->offset = 0; ((SLimitNode*)pInfo->pSplitNode->pLimit)->offset = 0;
@ -1436,7 +1458,7 @@ static int32_t stbSplSplitScanNodeWithPartTags(SSplitContext* pCxt, SStableSplit
return code; return code;
} }
static SNode* stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan) { static int32_t stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan, SNode** ppNode) {
bool find = false; bool find = false;
SNode* pCol = NULL; SNode* pCol = NULL;
FOREACH(pCol, pScan->pScanCols) { FOREACH(pCol, pScan->pScanCols) {
@ -1446,19 +1468,29 @@ static SNode* stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan) {
} }
} }
if (!find) { if (!find) {
return NULL; *ppNode = NULL;
return TSDB_CODE_SUCCESS;
} }
SNode* pTarget = NULL; SNode* pTarget = NULL;
FOREACH(pTarget, pScan->node.pTargets) { FOREACH(pTarget, pScan->node.pTargets) {
if (nodesEqualNode(pTarget, pCol)) { if (nodesEqualNode(pTarget, pCol)) {
return pCol; *ppNode = pCol;
return TSDB_CODE_SUCCESS;
} }
} }
nodesListStrictAppend(pScan->node.pTargets, nodesCloneNode(pCol)); SNode* pNew = NULL;
return pCol; 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; bool find = false;
SNode* pCol = NULL; SNode* pCol = NULL;
FOREACH(pCol, pScan->pScanCols) { FOREACH(pCol, pScan->pScanCols) {
@ -1468,16 +1500,25 @@ static SNode* stbSplFindPkFromScan(SScanLogicNode* pScan) {
} }
} }
if (!find) { if (!find) {
return NULL; *ppNode = NULL;
return code;
} }
SNode* pTarget = NULL; SNode* pTarget = NULL;
FOREACH(pTarget, pScan->node.pTargets) { FOREACH(pTarget, pScan->node.pTargets) {
if (nodesEqualNode(pTarget, pCol)) { if (nodesEqualNode(pTarget, pCol)) {
return pCol; *ppNode = pCol;
return code;
} }
} }
nodesListStrictAppend(pScan->node.pTargets, nodesCloneNode(pCol)); SNode* pNew = NULL;
return pCol; 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, static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOutputMergeScan,
@ -1486,9 +1527,10 @@ static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOu
pScan->node.pChildren = NULL; pScan->node.pChildren = NULL;
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
SScanLogicNode* pMergeScan = (SScanLogicNode*)nodesCloneNode((SNode*)pScan); SScanLogicNode* pMergeScan = NULL;
code = nodesCloneNode((SNode*)pScan, (SNode**)&pMergeScan);
if (NULL == pMergeScan) { if (NULL == pMergeScan) {
code = TSDB_CODE_OUT_OF_MEMORY; code = code;
} }
SNodeList* pMergeKeys = NULL; SNodeList* pMergeKeys = NULL;
@ -1498,9 +1540,15 @@ static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOu
pMergeScan->node.pChildren = pChildren; pMergeScan->node.pChildren = pChildren;
splSetParent((SLogicNode*)pMergeScan); splSetParent((SLogicNode*)pMergeScan);
SNode* pTs = stbSplFindPrimaryKeyFromScan(pMergeScan); SNode* pTs = NULL;
code = stbSplCreateMergeKeysByPrimaryKey(pTs, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys); code = stbSplFindPrimaryKeyFromScan(pMergeScan, &pTs);
SNode* pPk = stbSplFindPkFromScan(pMergeScan); 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) { if (TSDB_CODE_SUCCESS == code && NULL != pPk) {
code = stbSplCreateMergeKeysByExpr(pPk, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys); 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) { static int32_t stbSplCreateMergeKeysForPartitionNode(SLogicNode* pPart, SNodeList** pMergeKeys) {
SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pPart->pChildren, 0); SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pPart->pChildren, 0);
SNode* pPrimaryKey = nodesCloneNode(stbSplFindPrimaryKeyFromScan(pScan)); SNode* pPK = NULL;
if (NULL == pPrimaryKey) { SNode* pPrimaryKey = NULL;
return TSDB_CODE_OUT_OF_MEMORY; 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) { if (TSDB_CODE_SUCCESS == code) {
code = stbSplCreateMergeKeysByPrimaryKey(pPrimaryKey, pScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, pMergeKeys); 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; SNode* pChild = NULL;
FOREACH(pChild, pSplitNode->pChildren) { FOREACH(pChild, pSplitNode->pChildren) {
SLogicSubplan* pNewSubplan = splCreateSubplan(pCxt, (SLogicNode*)pChild); SLogicSubplan* pNewSubplan = NULL;
code = nodesListMakeStrictAppend(&pUnionSubplan->pChildren, (SNode*)pNewSubplan); code = splCreateSubplan(pCxt, (SLogicNode*)pChild, &pNewSubplan);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pUnionSubplan->pChildren, (SNode*)pNewSubplan);
}
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
REPLACE_NODE(NULL); REPLACE_NODE(NULL);
code = splMountSubplan(pNewSubplan, pSubplanChildren); 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, static int32_t unAllSplCreateExchangeNode(SSplitContext* pCxt, int32_t startGroupId, SLogicSubplan* pSubplan,
SProjectLogicNode* pProject) { 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) { if (NULL == pExchange) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pExchange->srcStartGroupId = startGroupId; pExchange->srcStartGroupId = startGroupId;
pExchange->srcEndGroupId = pCxt->groupId - 1; pExchange->srcEndGroupId = pCxt->groupId - 1;
pExchange->node.precision = pProject->node.precision; pExchange->node.precision = pProject->node.precision;
pExchange->node.pTargets = nodesCloneList(pProject->node.pTargets); pExchange->node.pTargets = NULL;
pExchange->node.pConditions = nodesCloneNode(pProject->node.pConditions); code = nodesCloneList(pProject->node.pTargets, &pExchange->node.pTargets);
if (NULL == pExchange->node.pTargets || (NULL != pProject->node.pConditions && NULL == pExchange->node.pConditions)) { if (TSDB_CODE_SUCCESS != code) {
return TSDB_CODE_OUT_OF_MEMORY; 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); 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, static int32_t unDistSplCreateExchangeNode(SSplitContext* pCxt, int32_t startGroupId, SLogicSubplan* pSubplan,
SAggLogicNode* pAgg) { 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) { if (NULL == pExchange) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
pExchange->srcStartGroupId = startGroupId; pExchange->srcStartGroupId = startGroupId;
pExchange->srcEndGroupId = pCxt->groupId - 1; pExchange->srcEndGroupId = pCxt->groupId - 1;
pExchange->node.precision = pAgg->node.precision; 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) { if (NULL == pExchange->node.pTargets) {
return TSDB_CODE_OUT_OF_MEMORY; nodesDestroyNode((SNode*)pExchange);
return code;
} }
pSubplan->subplanType = SUBPLAN_TYPE_MERGE; 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, 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; SNodeList* pSubplanChildren = info.pSubplan->pChildren;
int32_t code = splCreateExchangeNodeForSubplan(pCxt, info.pSubplan, info.pQueryRoot, SUBPLAN_TYPE_MODIFY); int32_t code = splCreateExchangeNodeForSubplan(pCxt, info.pSubplan, info.pQueryRoot, SUBPLAN_TYPE_MODIFY);
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
pNewSubplan = splCreateSubplan(pCxt, info.pQueryRoot); code = splCreateSubplan(pCxt, info.pQueryRoot, &pNewSubplan);
if (NULL == pNewSubplan) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
} }
if (TSDB_CODE_SUCCESS == code) { if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, (SNode*)pNewSubplan); 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); code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, (SNode*)pScanSubplan);
} else { } else {
code = TSDB_CODE_OUT_OF_MEMORY; code = terrno;
} }
} }
info.pSubplan->subplanType = SUBPLAN_TYPE_COMPUTE; 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; SCreateColumnCxt* pCxt = (SCreateColumnCxt*)pContext;
switch (nodeType(pNode)) { switch (nodeType(pNode)) {
case QUERY_NODE_COLUMN: { case QUERY_NODE_COLUMN: {
SNode* pCol = nodesCloneNode(pNode); SNode* pCol = NULL;
pCxt->errCode = nodesCloneNode(pNode, &pCol);
if (NULL == pCol) { if (NULL == pCol) {
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -61,7 +62,8 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
case QUERY_NODE_FUNCTION: case QUERY_NODE_FUNCTION:
case QUERY_NODE_CASE_WHEN: { case QUERY_NODE_CASE_WHEN: {
SExprNode* pExpr = (SExprNode*)pNode; 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) { if (NULL == pCol) {
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -88,9 +90,12 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) {
} }
int32_t createColumnByRewriteExprs(SNodeList* pExprs, SNodeList** pList) { int32_t createColumnByRewriteExprs(SNodeList* pExprs, SNodeList** pList) {
SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = (NULL == *pList ? nodesMakeList() : *pList)}; SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = *pList};
if (NULL == cxt.pList) { if (!cxt.pList) {
return TSDB_CODE_OUT_OF_MEMORY; int32_t code = nodesMakeList(&cxt.pList);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
} }
nodesWalkExprs(pExprs, doCreateColumn, &cxt); nodesWalkExprs(pExprs, doCreateColumn, &cxt);
@ -105,9 +110,12 @@ int32_t createColumnByRewriteExprs(SNodeList* pExprs, SNodeList** pList) {
} }
int32_t createColumnByRewriteExpr(SNode* pExpr, SNodeList** pList) { int32_t createColumnByRewriteExpr(SNode* pExpr, SNodeList** pList) {
SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = (NULL == *pList ? nodesMakeList() : *pList)}; SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = *pList};
if (NULL == cxt.pList) { if (!cxt.pList) {
return TSDB_CODE_OUT_OF_MEMORY; int32_t code = nodesMakeList(&cxt.pList);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
} }
nodesWalkExpr(pExpr, doCreateColumn, &cxt); nodesWalkExpr(pExpr, doCreateColumn, &cxt);
@ -545,25 +553,35 @@ bool isPartTableWinodw(SWindowLogicNode* pWindow) {
return pWindow->isPartTb || keysHasTbname(stbGetPartKeys((SLogicNode*)nodesListGetNode(pWindow->node.pChildren, 0))); return pWindow->isPartTb || keysHasTbname(stbGetPartKeys((SLogicNode*)nodesListGetNode(pWindow->node.pChildren, 0)));
} }
bool cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat) { int32_t cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat, bool* pCloned) {
SLimitNode* pLimit; SLimitNode* pLimit = NULL, *pSlimit = NULL;
bool cloned = false; int32_t code = 0;
bool cloned = false;
if (pParent->pLimit && (cloneWhat & CLONE_LIMIT)) { if (pParent->pLimit && (cloneWhat & CLONE_LIMIT)) {
pChild->pLimit = nodesCloneNode(pParent->pLimit); code = nodesCloneNode(pParent->pLimit, (SNode**)&pLimit);
pLimit = (SLimitNode*)pChild->pLimit; if (TSDB_CODE_SUCCESS == code) {
pLimit->limit += pLimit->offset; pLimit->limit += pLimit->offset;
pLimit->offset = 0; pLimit->offset = 0;
cloned = true; cloned = true;
}
} }
if (pParent->pSlimit && (cloneWhat & CLONE_SLIMIT)) { if (pParent->pSlimit && (cloneWhat & CLONE_SLIMIT)) {
pChild->pSlimit = nodesCloneNode(pParent->pSlimit); code = nodesCloneNode(pParent->pSlimit, (SNode**)&pSlimit);
pLimit = (SLimitNode*)pChild->pSlimit; if (TSDB_CODE_SUCCESS == code) {
pLimit->limit += pLimit->offset; pSlimit->limit += pSlimit->offset;
pLimit->offset = 0; pSlimit->offset = 0;
cloned = true; 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) { static EDealRes partTagsOptHasColImpl(SNode* pNode, void* pContext) {
@ -583,12 +601,17 @@ bool keysHasCol(SNodeList* pKeys) {
} }
SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) { 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) { if (pFunc) {
strcpy(pFunc->functionName, "_group_key"); strcpy(pFunc->functionName, "_group_key");
strcpy(pFunc->node.aliasName, pGroupCol->node.aliasName); strcpy(pFunc->node.aliasName, pGroupCol->node.aliasName);
strcpy(pFunc->node.userAlias, pGroupCol->node.userAlias); 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) { if (code == TSDB_CODE_SUCCESS) {
code = fmGetFuncInfo(pFunc, NULL, 0); code = fmGetFuncInfo(pFunc, NULL, 0);
} }
@ -596,10 +619,17 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) {
nodesDestroyNode((SNode*)pFunc); nodesDestroyNode((SNode*)pFunc);
pFunc = NULL; pFunc = NULL;
} }
char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0}; if (TSDB_CODE_SUCCESS == code) {
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc); char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
taosCreateMD5Hash(name, len); int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc);
strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1); 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; return pFunc;
} }
@ -656,14 +686,20 @@ int32_t tagScanSetExecutionMode(SScanLogicNode* pScan) {
return TSDB_CODE_SUCCESS; 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* pTagCond = NULL;
SNode* pTagIndexCond = NULL; SNode* pTagIndexCond = NULL;
filterPartitionCond(&pCond, NULL, &pTagIndexCond, &pTagCond, NULL); code = filterPartitionCond(&pCond, NULL, &pTagIndexCond, &pTagCond, NULL);
if (pTagIndexCond || tagScanNodeHasTbname(pTagCond)) { if (TSDB_CODE_SUCCESS == code) {
pScan->onlyMetaCtbIdx = false; if (pTagIndexCond || tagScanNodeHasTbname(pTagCond)) {
} else { pScan->onlyMetaCtbIdx = false;
pScan->onlyMetaCtbIdx = true; } else {
pScan->onlyMetaCtbIdx = true;
}
} }
nodesDestroyNode(pCond); nodesDestroyNode(pCond);
nodesDestroyNode(pTagIndexCond); 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) { static int32_t setSubplanExecutionNode(SPhysiNode* pNode, int32_t groupId, SDownstreamSourceNode* pSource) {
int32_t code = 0;
if (QUERY_NODE_PHYSICAL_PLAN_EXCHANGE == nodeType(pNode)) { if (QUERY_NODE_PHYSICAL_PLAN_EXCHANGE == nodeType(pNode)) {
SExchangePhysiNode* pExchange = (SExchangePhysiNode*)pNode; SExchangePhysiNode* pExchange = (SExchangePhysiNode*)pNode;
if (groupId >= pExchange->srcStartGroupId && groupId <= pExchange->srcEndGroupId) { 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)) { } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE == nodeType(pNode)) {
SMergePhysiNode* pMerge = (SMergePhysiNode*)pNode; SMergePhysiNode* pMerge = (SMergePhysiNode*)pNode;
@ -87,17 +92,23 @@ static int32_t setSubplanExecutionNode(SPhysiNode* pNode, int32_t groupId, SDown
} else { } else {
--(pMerge->numOfChannels); --(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; SNode* pChild = NULL;
FOREACH(pChild, pNode->pChildren) { if (TSDB_CODE_SUCCESS == code) {
if (TSDB_CODE_SUCCESS != setSubplanExecutionNode((SPhysiNode*)pChild, groupId, pSource)) { FOREACH(pChild, pNode->pChildren) {
return TSDB_CODE_OUT_OF_MEMORY; if (TSDB_CODE_SUCCESS != (code = setSubplanExecutionNode((SPhysiNode*)pChild, groupId, pSource))) {
return code;
}
} }
} }
return TSDB_CODE_SUCCESS; return code;
} }
int32_t qContinuePlanPostQuery(void *pPostPlan) { 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. // TODO(smj):wait for nodesCloneNode change it's return value, use terrno for now.
terrno = TSDB_CODE_SUCCESS; terrno = TSDB_CODE_SUCCESS;
SColumnNode *pColumnNode = (SColumnNode *)nodesCloneNode((SNode *)colNode); SColumnNode *pColumnNode = NULL;
FLT_ERR_RET(terrno); int32_t code = nodesCloneNode((SNode *)colNode, (SNode**)&pColumnNode);
FLT_ERR_RET(code);
SFltSclColumnRange newColRange = {.colNode = pColumnNode, .points = taosArrayInit(4, sizeof(SFltSclPoint))}; SFltSclColumnRange newColRange = {.colNode = pColumnNode, .points = taosArrayInit(4, sizeof(SFltSclPoint))};
if (NULL == newColRange.points) { if (NULL == newColRange.points) {
FLT_ERR_RET(terrno); FLT_ERR_RET(terrno);
@ -4915,16 +4916,22 @@ static int32_t fltSclCollectOperatorFromNode(SNode *pNode, SArray *sclOpList) {
SValueNode *valNode = (SValueNode *)pOper->pRight; SValueNode *valNode = (SValueNode *)pOper->pRight;
if (IS_NUMERIC_TYPE(valNode->node.resType.type) || valNode->node.resType.type == TSDB_DATA_TYPE_TIMESTAMP) { if (IS_NUMERIC_TYPE(valNode->node.resType.type) || valNode->node.resType.type == TSDB_DATA_TYPE_TIMESTAMP) {
SFltSclOperator sclOp = {.colNode = (SColumnNode *)nodesCloneNode(pOper->pLeft), SNode* pLeft = NULL, *pRight = NULL;
.valNode = (SValueNode *)nodesCloneNode(pOper->pRight), 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}; .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)) { if (NULL == taosArrayPush(sclOpList, &sclOp)) {
nodesDestroyNode(pLeft);
nodesDestroyNode(pRight);
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
} }
} }
@ -5209,8 +5216,12 @@ EConditionType filterClassifyCondition(SNode *pNode) {
} }
int32_t filterIsMultiTableColsCond(SNode *pCond, bool *res) { int32_t filterIsMultiTableColsCond(SNode *pCond, bool *res) {
SNodeList *pCondCols = nodesMakeList(); SNodeList *pCondCols = NULL;
int32_t code = nodesCollectColumnsFromNode(pCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols); 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 (code == TSDB_CODE_SUCCESS) {
if (LIST_LENGTH(pCondCols) >= 2) { if (LIST_LENGTH(pCondCols) >= 2) {
SColumnNode *pFirstCol = (SColumnNode *)nodesListGetNode(pCondCols, 0); SColumnNode *pFirstCol = (SColumnNode *)nodesListGetNode(pCondCols, 0);
@ -5249,32 +5260,56 @@ static int32_t partitionLogicCond(SNode **pCondition, SNode **pPrimaryKeyCond, S
} }
if (result) { if (result) {
if (NULL != pOtherCond) { 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 { } else {
switch (filterClassifyCondition(pCond)) { switch (filterClassifyCondition(pCond)) {
case COND_TYPE_PRIMARY_KEY: case COND_TYPE_PRIMARY_KEY:
if (NULL != pPrimaryKeyCond) { 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; break;
case COND_TYPE_TAG_INDEX: case COND_TYPE_TAG_INDEX:
if (NULL != pTagIndexCond) { 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) { 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; break;
case COND_TYPE_TAG: case COND_TYPE_TAG:
if (NULL != pTagCond) { 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; break;
case COND_TYPE_NORMAL: case COND_TYPE_NORMAL:
default: default:
if (NULL != pOtherCond) { 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; break;
} }
@ -5361,9 +5396,10 @@ int32_t filterPartitionCond(SNode **pCondition, SNode **pPrimaryKeyCond, SNode *
if (NULL != pTagCond) { if (NULL != pTagCond) {
SNode *pTempCond = *pCondition; SNode *pTempCond = *pCondition;
if (NULL != pTagIndexCond) { if (NULL != pTagIndexCond) {
pTempCond = nodesCloneNode(*pCondition); pTempCond = NULL;
int32_t code = nodesCloneNode(*pCondition, &pTempCond);
if (NULL == pTempCond) { if (NULL == pTempCond) {
return TSDB_CODE_OUT_OF_MEMORY; return code;
} }
} }
*pTagCond = pTempCond; *pTagCond = pTempCond;

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

@ -1028,10 +1028,10 @@ _return:
EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opType) { EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opType) {
if (opType <= OP_TYPE_CALC_MAX) { 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) { if (NULL == res) {
sclError("make value node failed"); sclError("make value node failed");
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -1040,10 +1040,10 @@ EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opTy
nodesDestroyNode(*pNode); nodesDestroyNode(*pNode);
*pNode = (SNode *)res; *pNode = (SNode *)res;
} else { } else {
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE); SValueNode *res = NULL;
ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res);
if (NULL == res) { if (NULL == res) {
sclError("make value node failed"); sclError("make value node failed");
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -1221,11 +1221,11 @@ EDealRes sclRewriteFunction(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR; 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) { if (NULL == res) {
sclError("make value node failed"); sclError("make value node failed");
sclFreeParam(&output); sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -1295,11 +1295,11 @@ EDealRes sclRewriteLogic(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_CONTINUE; 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) { if (NULL == res) {
sclError("make value node failed"); sclError("make value node failed");
sclFreeParam(&output); sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -1345,11 +1345,11 @@ EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR; 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) { if (NULL == res) {
sclError("make value node failed"); sclError("make value node failed");
sclFreeParam(&output); sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR; return DEAL_RES_ERROR;
} }
@ -1408,11 +1408,11 @@ EDealRes sclRewriteCaseWhen(SNode **pNode, SScalarCtx *ctx) {
return DEAL_RES_ERROR; 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) { if (NULL == res) {
sclError("make value node failed"); sclError("make value node failed");
sclFreeParam(&output); sclFreeParam(&output);
ctx->code = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR; 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) { 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) { if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); FLT_ERR_RET(code);
} }
SValueNode *vnode = (SValueNode *)node; SValueNode *vnode = (SValueNode *)node;
vnode->node.resType.type = dataType; vnode->node.resType.type = dataType;
@ -90,9 +91,10 @@ int32_t flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType,
void *value) { void *value) {
static uint64_t dbidx = 0; 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) { if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); FLT_ERR_RET(code);
} }
SColumnNode *rnode = (SColumnNode *)node; SColumnNode *rnode = (SColumnNode *)node;
rnode->node.resType.type = dataType; 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) { 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) { if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); FLT_ERR_RET(code);
} }
SOperatorNode *onode = (SOperatorNode *)node; SOperatorNode *onode = (SOperatorNode *)node;
onode->node.resType.type = resType; 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) { 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) { if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); FLT_ERR_RET(code);
} }
SLogicConditionNode *onode = (SLogicConditionNode *)node; SLogicConditionNode *onode = (SLogicConditionNode *)node;
onode->condType = opType; onode->condType = opType;
onode->node.resType.type = TSDB_DATA_TYPE_BOOL; onode->node.resType.type = TSDB_DATA_TYPE_BOOL;
onode->node.resType.bytes = sizeof(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) { for (int32_t i = 0; i < nodeNum; ++i) {
FLT_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[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) { 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) { if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); FLT_ERR_RET(code);
} }
SLogicConditionNode *onode = (SLogicConditionNode *)node; SLogicConditionNode *onode = (SLogicConditionNode *)node;
onode->condType = opType; 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) { 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) { if (NULL == node) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); FLT_ERR_RET(code);
} }
SNodeListNode *lnode = (SNodeListNode *)node; SNodeListNode *lnode = (SNodeListNode *)node;
lnode->node.resType.type = resType; 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) { 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) { if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); SCL_ERR_RET(code);
} }
SValueNode *vnode = (SValueNode *)node; SValueNode *vnode = (SValueNode *)node;
vnode->node.resType.type = dataType; 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, int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, int32_t dataBytes, int32_t rowNum,
void *value) { void *value) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_COLUMN); SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, &node);
if (NULL == node) { if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); SCL_ERR_RET(code);
} }
SColumnNode *rnode = (SColumnNode *)node; SColumnNode *rnode = (SColumnNode *)node;
rnode->node.resType.type = dataType; rnode->node.resType.type = dataType;
@ -182,7 +184,6 @@ int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType,
SCL_RET(TSDB_CODE_SUCCESS); SCL_RET(TSDB_CODE_SUCCESS);
} }
int32_t code = TSDB_CODE_SUCCESS;
if (NULL == *block) { if (NULL == *block) {
SSDataBlock *res = createDataBlock(); SSDataBlock *res = createDataBlock();
for (int32_t i = 0; i < 2; ++i) { 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, int32_t scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight,
bool isReverse) { bool isReverse) {
SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR); SNode *node = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, &node);
if (NULL == node) { if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); SCL_ERR_RET(code);
} }
SOperatorNode *onode = (SOperatorNode *)node; SOperatorNode *onode = (SOperatorNode *)node;
onode->node.resType.type = resType; 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) { 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) { if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); SCL_ERR_RET(code);
} }
SOperatorNode *onode = (SOperatorNode *)node; SOperatorNode *onode = (SOperatorNode *)node;
onode->node.resType.type = resType; 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) { 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) { if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); SCL_ERR_RET(code);
} }
SNodeListNode *lnode = (SNodeListNode *)node; SNodeListNode *lnode = (SNodeListNode *)node;
lnode->node.resType.type = resType; 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) { 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) { if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); SCL_ERR_RET(code);
} }
SLogicConditionNode *onode = (SLogicConditionNode *)node; SLogicConditionNode *onode = (SLogicConditionNode *)node;
onode->condType = opType; onode->condType = opType;
onode->node.resType.type = TSDB_DATA_TYPE_BOOL; onode->node.resType.type = TSDB_DATA_TYPE_BOOL;
onode->node.resType.bytes = sizeof(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) { for (int32_t i = 0; i < nodeNum; ++i) {
SCL_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[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) { 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) { if (NULL == node) {
SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); SCL_ERR_RET(code);
} }
STargetNode *onode = (STargetNode *)node; STargetNode *onode = (STargetNode *)node;
onode->pExpr = snode; onode->pExpr = snode;
@ -632,7 +642,8 @@ TEST(constantTest, int_in_smallint1) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList(); SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr); ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -669,7 +680,8 @@ TEST(constantTest, int_in_smallint2) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList(); SNodeList* list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr); ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -704,7 +716,8 @@ TEST(constantTest, int_not_in_smallint1) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList(); SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr); ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -741,7 +754,8 @@ TEST(constantTest, int_not_in_smallint2) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList(); SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr); ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -2084,7 +2098,8 @@ TEST(columnTest, int_column_in_double_list) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, leftv); code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList(); SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr); ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv1); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv1);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
@ -2157,7 +2172,8 @@ TEST(columnTest, binary_column_in_binary_list) {
int32_t code = TSDB_CODE_SUCCESS; int32_t code = TSDB_CODE_SUCCESS;
code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_EQ(code, TSDB_CODE_SUCCESS);
SNodeList *list = nodesMakeList(); SNodeList *list = NULL;
code = nodesMakeList(&list);
ASSERT_NE(list, nullptr); ASSERT_NE(list, nullptr);
code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[0]); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[0]);
ASSERT_EQ(code, TSDB_CODE_SUCCESS); 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->queryId = qId;
dag->numOfSubplans = 2; dag->numOfSubplans = 2;
dag->pSubplans = nodesMakeList(); dag->pSubplans = NULL;
int32_t code = nodesMakeList(&dag->pSubplans);
if (NULL == dag->pSubplans) { if (NULL == dag->pSubplans) {
return; return;
} }
SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); SNodeListNode *scan = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&scan);
if (NULL == scan) { if (NULL == scan) {
return; return;
} }
SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); SNodeListNode *merge = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&merge);
if (NULL == merge) { if (NULL == merge) {
return; return;
} }
SSubplan *scanPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); SSubplan *scanPlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&scanPlan);
if (NULL == scanPlan) { if (NULL == scanPlan) {
return; return;
} }
SSubplan *mergePlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); SSubplan *mergePlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&mergePlan);
if (NULL == mergePlan) { if (NULL == mergePlan) {
return; return;
} }
@ -187,11 +192,13 @@ void schtBuildQueryDag(SQueryPlan *dag) {
scanPlan->pChildren = NULL; scanPlan->pChildren = NULL;
scanPlan->level = 1; scanPlan->level = 1;
scanPlan->pParents = nodesMakeList(); scanPlan->pParents = NULL;
code = nodesMakeList(&scanPlan->pParents);
if (NULL == scanPlan->pParents) { if (NULL == scanPlan->pParents) {
return; 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) { if (NULL == scanPlan->pNode) {
return; return;
} }
@ -204,22 +211,26 @@ void schtBuildQueryDag(SQueryPlan *dag) {
mergePlan->level = 0; mergePlan->level = 0;
mergePlan->execNode.epSet.numOfEps = 0; mergePlan->execNode.epSet.numOfEps = 0;
mergePlan->pChildren = nodesMakeList(); mergePlan->pChildren = NULL;
code = nodesMakeList(&mergePlan->pChildren);
if (NULL == mergePlan->pChildren) { if (NULL == mergePlan->pChildren) {
return; return;
} }
mergePlan->pParents = NULL; 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) { if (NULL == mergePlan->pNode) {
return; return;
} }
mergePlan->msgType = TDMT_SCH_QUERY; mergePlan->msgType = TDMT_SCH_QUERY;
merge->pNodeList = nodesMakeList(); merge->pNodeList = NULL;
code = nodesMakeList(&merge->pNodeList);
if (NULL == merge->pNodeList) { if (NULL == merge->pNodeList) {
return; return;
} }
scan->pNodeList = nodesMakeList(); scan->pNodeList = NULL;
code = nodesMakeList(&scan->pNodeList);
if (NULL == scan->pNodeList) { if (NULL == scan->pNodeList) {
return; return;
} }
@ -240,40 +251,48 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
dag->queryId = qId; dag->queryId = qId;
dag->numOfSubplans = 2; dag->numOfSubplans = 2;
dag->pSubplans = nodesMakeList(); dag->pSubplans = NULL;
int32_t code = nodesMakeList(&dag->pSubplans);
if (NULL == dag->pSubplans) { if (NULL == dag->pSubplans) {
return; return;
} }
SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); SNodeListNode *scan = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&scan);
if (NULL == scan) { if (NULL == scan) {
return; return;
} }
SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); SNodeListNode *merge = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&merge);
if (NULL == merge) { if (NULL == merge) {
return; return;
} }
SSubplan *mergePlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); SSubplan *mergePlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&mergePlan);
if (NULL == mergePlan) { if (NULL == mergePlan) {
return; return;
} }
merge->pNodeList = nodesMakeList(); merge->pNodeList = NULL;
code = nodesMakeList(&merge->pNodeList);
if (NULL == merge->pNodeList) { if (NULL == merge->pNodeList) {
return; return;
} }
scan->pNodeList = nodesMakeList(); scan->pNodeList = NULL;
code = nodesMakeList(&scan->pNodeList);
if (NULL == scan->pNodeList) { if (NULL == scan->pNodeList) {
return; return;
} }
mergePlan->pChildren = nodesMakeList(); mergePlan->pChildren = NULL;
code = nodesMakeList(&mergePlan->pChildren);
if (NULL == mergePlan->pChildren) { if (NULL == mergePlan->pChildren) {
return; return;
} }
for (int32_t i = 0; i < scanPlanNum; ++i) { 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) { if (NULL == scanPlan) {
return; return;
} }
@ -292,11 +311,13 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
scanPlan->pChildren = NULL; scanPlan->pChildren = NULL;
scanPlan->level = 1; scanPlan->level = 1;
scanPlan->pParents = nodesMakeList(); scanPlan->pParents = NULL;
code = nodesMakeList(&scanPlan->pParents);
if (NULL == scanPlan->pParents) { if (NULL == scanPlan->pParents) {
return; 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) { if (NULL == scanPlan->pNode) {
return; return;
} }
@ -316,7 +337,8 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) {
mergePlan->execNode.epSet.numOfEps = 0; mergePlan->execNode.epSet.numOfEps = 0;
mergePlan->pParents = NULL; 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) { if (NULL == mergePlan->pNode) {
return; return;
} }
@ -335,20 +357,24 @@ void schtBuildInsertDag(SQueryPlan *dag) {
dag->queryId = qId; dag->queryId = qId;
dag->numOfSubplans = 2; dag->numOfSubplans = 2;
dag->pSubplans = nodesMakeList(); dag->pSubplans = NULL;
int32_t code = nodesMakeList(&dag->pSubplans);
if (NULL == dag->pSubplans) { if (NULL == dag->pSubplans) {
return; return;
} }
SNodeListNode *inserta = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); SNodeListNode *inserta = NULL;
code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&inserta);
if (NULL == inserta) { if (NULL == inserta) {
return; return;
} }
inserta->pNodeList = nodesMakeList(); inserta->pNodeList = NULL;
code = nodesMakeList(&inserta->pNodeList);
if (NULL == inserta->pNodeList) { if (NULL == inserta->pNodeList) {
return; return;
} }
SSubplan *insertPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); SSubplan *insertPlan = NULL;
code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&insertPlan);
if (NULL == insertPlan) { if (NULL == insertPlan) {
return; return;
} }
@ -366,7 +392,8 @@ void schtBuildInsertDag(SQueryPlan *dag) {
insertPlan->pChildren = NULL; insertPlan->pChildren = NULL;
insertPlan->pParents = NULL; insertPlan->pParents = NULL;
insertPlan->pNode = 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) { if (NULL == insertPlan->pDataSink) {
return; return;
} }
@ -379,7 +406,8 @@ void schtBuildInsertDag(SQueryPlan *dag) {
(void)nodesListAppend(inserta->pNodeList, (SNode *)insertPlan); (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) { if (NULL == insertPlan) {
return; return;
} }
@ -397,7 +425,8 @@ void schtBuildInsertDag(SQueryPlan *dag) {
insertPlan->pChildren = NULL; insertPlan->pChildren = NULL;
insertPlan->pParents = NULL; insertPlan->pParents = NULL;
insertPlan->pNode = 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) { if (NULL == insertPlan->pDataSink) {
return; return;
} }
@ -640,11 +669,12 @@ void *schtRunJobThread(void *aa) {
char *dbname = "1.db1"; char *dbname = "1.db1";
char *tablename = "table1"; char *tablename = "table1";
SVgroupInfo vgInfo = {0}; 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(); schtInitLogFile();
int32_t code = schedulerInit(); code = schedulerInit();
assert(code == 0); assert(code == 0);
schtSetPlanToString(); schtSetPlanToString();
@ -828,7 +858,9 @@ TEST(queryTest, normalCase) {
char *tablename = "table1"; char *tablename = "table1";
SVgroupInfo vgInfo = {0}; SVgroupInfo vgInfo = {0};
int64_t job = 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)); SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
@ -838,7 +870,7 @@ TEST(queryTest, normalCase) {
load.addr.epSet.eps[0].port = 6031; load.addr.epSet.eps[0].port = 6031;
assert(taosArrayPush(qnodeList, &load) != NULL); assert(taosArrayPush(qnodeList, &load) != NULL);
int32_t code = schedulerInit(); code = schedulerInit();
ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
schtBuildQueryDag(dag); schtBuildQueryDag(dag);
@ -942,7 +974,9 @@ TEST(queryTest, readyFirstCase) {
char *tablename = "table1"; char *tablename = "table1";
SVgroupInfo vgInfo = {0}; SVgroupInfo vgInfo = {0};
int64_t job = 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)); SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
@ -952,7 +986,7 @@ TEST(queryTest, readyFirstCase) {
load.addr.epSet.eps[0].port = 6031; load.addr.epSet.eps[0].port = 6031;
assert(NULL != taosArrayPush(qnodeList, &load)); assert(NULL != taosArrayPush(qnodeList, &load));
int32_t code = schedulerInit(); code = schedulerInit();
ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
schtBuildQueryDag(dag); schtBuildQueryDag(dag);
@ -1055,7 +1089,9 @@ TEST(queryTest, flowCtrlCase) {
char *tablename = "table1"; char *tablename = "table1";
SVgroupInfo vgInfo = {0}; SVgroupInfo vgInfo = {0};
int64_t job = 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(); schtInitLogFile();
@ -1069,7 +1105,7 @@ TEST(queryTest, flowCtrlCase) {
load.addr.epSet.eps[0].port = 6031; load.addr.epSet.eps[0].port = 6031;
assert(NULL != taosArrayPush(qnodeList, &load)); assert(NULL != taosArrayPush(qnodeList, &load));
int32_t code = schedulerInit(); code = schedulerInit();
ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
schtBuildQueryFlowCtrlDag(dag); schtBuildQueryFlowCtrlDag(dag);
@ -1151,7 +1187,9 @@ TEST(insertTest, normalCase) {
char *dbname = "1.db1"; char *dbname = "1.db1";
char *tablename = "table1"; char *tablename = "table1";
SVgroupInfo vgInfo = {0}; 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; uint64_t numOfRows = 0;
SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad));
@ -1162,7 +1200,7 @@ TEST(insertTest, normalCase) {
load.addr.epSet.eps[0].port = 6031; load.addr.epSet.eps[0].port = 6031;
assert(NULL != taosArrayPush(qnodeList, &load)); assert(NULL != taosArrayPush(qnodeList, &load));
int32_t code = schedulerInit(); code = schedulerInit();
ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
schtBuildInsertDag(dag); schtBuildInsertDag(dag);