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

planner/nodes/parser ret check

This commit is contained in:
wangjiaming0909 2024-07-23 15:59:10 +08:00
parent aa791c1bb0
commit 4d5cd9cd1a
30 changed files with 873 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/libs/parser/parser.h
View File

@ -118,6 +118,7 @@ void qDestroyQuery(SQuery* pQueryNode);
int32_t qExtractResultSchema(const SNode* pRoot, int32_t* numOfCols, SSchema** pSchema);
int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid);
int32_t qInitKeywordsTable();
void qCleanupKeywordsTable();
int32_t qAppendStmtTableOutput(SQuery* pQuery, SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, SStbInterlaceInfo* pBuildInfo);

1
source/client/src/clientEnv.c
View File

@ -988,6 +988,7 @@ void taos_init_imp(void) {
ENV_ERR_RET(taosGetAppName(appInfo.appName, NULL), "failed to get app name");
ENV_ERR_RET(taosThreadMutexInit(&appInfo.mutex, NULL), "failed to init thread mutex");
ENV_ERR_RET(tscCrashReportInit(), "failed to init crash report");
ENV_ERR_RET(qInitKeywordsTable(), "failed to init parser keywords table");
tscDebug("client is initialized successfully");
}

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

@ -1338,7 +1338,7 @@ static int32_t jsonToLogicDynQueryCtrlNode(const SJson* pJson, void* pObj) {
tjsonGetNumberValue(pJson, jkDynQueryCtrlLogicPlanQueryType, pNode->qType, code);
}
if (TSDB_CODE_SUCCESS == code) {
tjsonGetBoolValue(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, &pNode->stbJoin.batchFetch);
code = tjsonGetBoolValue(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, &pNode->stbJoin.batchFetch);
}
if (TSDB_CODE_SUCCESS == code) {
code = jsonToNodeList(pJson, jkDynQueryCtrlLogicPlanStbJoinVgList, &pNode->stbJoin.pVgList);
@ -3031,10 +3031,10 @@ static int32_t physiPartitionNodeToJson(const void* pObj, SJson* pJson) {
code = nodeListToJson(pJson, jkPartitionPhysiPlanTargets, pNode->pTargets);
}
if (TSDB_CODE_SUCCESS == code) {
tjsonAddBoolToObject(pJson, jkPartitionPhysiPlanNeedBlockOutputTsOrder, pNode->needBlockOutputTsOrder);
code = tjsonAddBoolToObject(pJson, jkPartitionPhysiPlanNeedBlockOutputTsOrder, pNode->needBlockOutputTsOrder);
}
if (TSDB_CODE_SUCCESS == code) {
tjsonAddIntegerToObject(pJson, jkPartitionPhysiPlanTsSlotId, pNode->tsSlotId);
code = tjsonAddIntegerToObject(pJson, jkPartitionPhysiPlanTsSlotId, pNode->tsSlotId);
}
return code;
@ -7390,7 +7390,7 @@ static int32_t jsonToTSMAOption(const SJson* pJson, void* pObj) {
code = jsonToNodeObject(pJson, jkTSMAOptionInterval, &pNode->pInterval);
}
if (TSDB_CODE_SUCCESS == code) {
tjsonGetUTinyIntValue(pJson, jkTSMAOptionTsPrecision, &pNode->tsPrecision);
code = tjsonGetUTinyIntValue(pJson, jkTSMAOptionTsPrecision, &pNode->tsPrecision);
}
return code;
}

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

@ -77,25 +77,26 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
TSWAP(*ppDst, *ppSrc);
}
int32_t code = 0;
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppDst)) {
SLogicConditionNode* pDst = (SLogicConditionNode*)*ppDst;
if (pDst->condType == LOGIC_COND_TYPE_AND) {
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList);
code = nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList);
((SLogicConditionNode*)(*ppSrc))->pParameterList = NULL;
} else {
nodesListStrictAppend(pDst->pParameterList, *ppSrc);
code = nodesListStrictAppend(pDst->pParameterList, *ppSrc);
*ppSrc = NULL;
}
nodesDestroyNode(*ppSrc);
*ppSrc = NULL;
return TSDB_CODE_SUCCESS;
return code;
}
}
SLogicConditionNode* pLogicCond = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);
code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
@ -187,7 +188,9 @@ static int32_t createNodeAllocator(int32_t chunkSize, SNodeAllocator** pAllocato
taosMemoryFreeClear(*pAllocator);
return code;
}
taosThreadMutexInit(&(*pAllocator)->mutex, NULL);
if (0 != taosThreadMutexInit(&(*pAllocator)->mutex, NULL)) {
return TAOS_SYSTEM_ERROR(errno);
}
return TSDB_CODE_SUCCESS;
}
@ -207,7 +210,7 @@ static void destroyNodeAllocator(void* p) {
taosMemoryFree(pChunk);
pChunk = pTemp;
}
taosThreadMutexDestroy(&pAllocator->mutex);
(void)taosThreadMutexDestroy(&pAllocator->mutex);
taosMemoryFree(pAllocator);
}
@ -232,10 +235,10 @@ void nodesDestroyAllocatorSet() {
int64_t refId = 0;
while (NULL != pAllocator) {
refId = pAllocator->self;
taosRemoveRef(g_allocatorReqRefPool, refId);
(void)taosRemoveRef(g_allocatorReqRefPool, refId);
pAllocator = taosIterateRef(g_allocatorReqRefPool, refId);
}
taosCloseRef(g_allocatorReqRefPool);
(void)taosCloseRef(g_allocatorReqRefPool);
}
}
@ -282,7 +285,7 @@ int32_t nodesAcquireAllocator(int64_t allocatorId) {
if (NULL == pAllocator) {
return terrno;
}
taosThreadMutexLock(&pAllocator->mutex);
(void)taosThreadMutexLock(&pAllocator->mutex);
g_pNodeAllocator = pAllocator;
return TSDB_CODE_SUCCESS;
}
@ -301,7 +304,7 @@ int32_t nodesReleaseAllocator(int64_t allocatorId) {
}
SNodeAllocator* pAllocator = g_pNodeAllocator;
g_pNodeAllocator = NULL;
taosThreadMutexUnlock(&pAllocator->mutex);
(void)taosThreadMutexUnlock(&pAllocator->mutex);
return taosReleaseRef(g_allocatorReqRefPool, allocatorId);
}
@ -325,7 +328,7 @@ void nodesDestroyAllocator(int64_t allocatorId) {
return;
}
taosRemoveRef(g_allocatorReqRefPool, allocatorId);
(void)taosRemoveRef(g_allocatorReqRefPool, allocatorId);
}
static int32_t makeNode(ENodeType type, int32_t size, SNode** ppNode) {
@ -1087,7 +1090,7 @@ void nodesDestroyNode(SNode* pNode) {
pStmt->destroyParseFileCxt(&pStmt->pParFileCxt);
}
taosCloseFile(&pStmt->fp);
assert(TSDB_CODE_SUCCESS == taosCloseFile(&pStmt->fp));
break;
}
case QUERY_NODE_CREATE_DATABASE_STMT:

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

@ -115,11 +115,11 @@ TEST(NodesTest, sort) {
vn5->datum.i = 0;
SNodeList* l = NULL;
nodesListMakeAppend(&l, (SNode*)vn1);
nodesListMakeAppend(&l, (SNode*)vn2);
nodesListMakeAppend(&l, (SNode*)vn3);
nodesListMakeAppend(&l, (SNode*)vn4);
nodesListMakeAppend(&l, (SNode*)vn5);
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn1));
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn2));
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn3));
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn4));
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn5));
nodesSortList(&l, compareValueNode);

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

@ -46,7 +46,7 @@ void insBuildCreateTbReq(SVCreateTbReq *pTbReq, const char *tname, STag *pTag
SArray *tagName, uint8_t tagNum, int32_t ttl);
int32_t insInitBoundColsInfo(int32_t numOfBound, SBoundColInfo *pInfo);
void insResetBoundColsInfo(SBoundColInfo *pInfo);
void insInitColValues(STableMeta *pTableMeta, SArray *aColValues);
int32_t insInitColValues(STableMeta *pTableMeta, SArray *aColValues);
void insCheckTableDataOrder(STableDataCxt *pTableCxt, SRowKey *rowKey);
int32_t insGetTableDataCxt(SHashObj *pHash, void *id, int32_t idLen, STableMeta *pTableMeta,
SVCreateTbReq **pCreateTbReq, STableDataCxt **pTableCxt, bool colMode, bool ignoreColVals);

3
source/libs/parser/inc/parToken.h
View File

@ -182,7 +182,8 @@ _end:
return (i < pToken->n) ? TK_NK_ILLEGAL : type;
}
void taosCleanupKeywordsTable();
int32_t taosInitKeywordsTable();
void taosCleanupKeywordsTable();
#ifdef __cplusplus
}

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

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

2
source/libs/parser/inc/sql.y
View File

@ -1107,7 +1107,7 @@ expr_or_subquery(A) ::= expression(B).
//expr_or_subquery(A) ::= subquery(B). { A = createTempTableNode(pCxt, releaseRawExprNode(pCxt, B), NULL); }
expression(A) ::= literal(B). { A = B; }
expression(A) ::= pseudo_column(B). { A = B; setRawExprNodeIsPseudoColumn(pCxt, A, true); }
expression(A) ::= pseudo_column(B). { A = B; (void)setRawExprNodeIsPseudoColumn(pCxt, A, true); }
expression(A) ::= column_reference(B). { A = B; }
expression(A) ::= function_expression(B). { A = B; }
expression(A) ::= case_when_expression(B). { A = B; }

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

@ -142,7 +142,10 @@ static int32_t parseDuplicateUsingClause(SInsertParseContext* pCxt, SVnodeModify
*pDuplicate = false;
char tbFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(&pStmt->targetTableName, tbFName);
code = tNameExtractFullName(&pStmt->targetTableName, tbFName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
STableMeta** pMeta = taosHashGet(pStmt->pSubTableHashObj, tbFName, strlen(tbFName));
if (NULL != pMeta) {
*pDuplicate = true;
@ -708,7 +711,10 @@ static int32_t parseTagToken(const char** end, SToken* pToken, SSchema* pSchema,
// input pStmt->pSql: [(tag1_name, ...)] TAGS (tag1_value, ...) ...
// output pStmt->pSql: TAGS (tag1_value, ...) ...
static int32_t parseBoundTagsClause(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) {
insInitBoundColsInfo(getNumOfTags(pStmt->pTableMeta), &pCxt->tags);
int32_t code = insInitBoundColsInfo(getNumOfTags(pStmt->pTableMeta), &pCxt->tags);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
SToken token;
int32_t index = 0;
@ -725,7 +731,9 @@ int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SS
SArray* pTagName, SArray* pTagVals, STag** pTag) {
bool isNull = isNullValue(pTagSchema->type, pToken);
if (!isNull && pTagName) {
taosArrayPush(pTagName, pTagSchema->name);
if (NULL == taosArrayPush(pTagName, pTagSchema->name)) {
return TSDB_CODE_OUT_OF_MEMORY;
}
}
if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
@ -745,7 +753,9 @@ int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SS
STagVal val = {0};
int32_t code = parseTagToken(pSql, pToken, pTagSchema, precision, &val, pMsgBuf);
if (TSDB_CODE_SUCCESS == code) {
taosArrayPush(pTagVals, &val);
if (NULL == taosArrayPush(pTagVals, &val)){
code = TSDB_CODE_OUT_OF_MEMORY;
}
}
return code;
@ -1029,8 +1039,16 @@ static int32_t storeChildTableMeta(SInsertParseContext* pCxt, SVnodeModifyOpStmt
}
char tbFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(&pStmt->targetTableName, tbFName);
return taosHashPut(pStmt->pSubTableHashObj, tbFName, strlen(tbFName), &pBackup, POINTER_BYTES);
int32_t code = tNameExtractFullName(&pStmt->targetTableName, tbFName);
if (TSDB_CODE_SUCCESS != code) {
taosMemoryFree(pBackup);
return code;
}
code = taosHashPut(pStmt->pSubTableHashObj, tbFName, strlen(tbFName), &pBackup, POINTER_BYTES);
if (TSDB_CODE_SUCCESS != code) {
taosMemoryFree(pBackup);
}
return code;
}
static int32_t parseTableOptions(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) {
@ -1216,13 +1234,19 @@ static int32_t getTargetTableMetaAndVgroup(SInsertParseContext* pCxt, SVnodeModi
static int32_t collectUseTable(const SName* pName, SHashObj* pTable) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pName, fullName);
int32_t code = tNameExtractFullName(pName, fullName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
return taosHashPut(pTable, fullName, strlen(fullName), pName, sizeof(SName));
}
static int32_t collectUseDatabase(const SName* pName, SHashObj* pDbs) {
char dbFName[TSDB_DB_FNAME_LEN] = {0};
tNameGetFullDbName(pName, dbFName);
int32_t code = tNameGetFullDbName(pName, dbFName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
return taosHashPut(pDbs, dbFName, strlen(dbFName), dbFName, sizeof(dbFName));
}
@ -1359,7 +1383,10 @@ static int32_t getTableDataCxt(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS
}
char tbFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(&pStmt->targetTableName, tbFName);
int32_t code = tNameExtractFullName(&pStmt->targetTableName, tbFName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
if (pStmt->usingTableProcessing) {
pStmt->pTableMeta->uid = 0;
}
@ -1862,9 +1889,11 @@ static int32_t getStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS
}
bool ctbFirst = true;
char ctbFName[TSDB_TABLE_FNAME_LEN];
if (code == TSDB_CODE_SUCCESS) {
char ctbFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName);
code = tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName);
}
if (TSDB_CODE_SUCCESS == code) {
STableMeta** pCtbMeta = taosHashGet(pStmt->pSubTableHashObj, ctbFName, strlen(ctbFName));
ctbFirst = (pCtbMeta == NULL);
if (!ctbFirst) {
@ -1901,23 +1930,31 @@ static int32_t processCtbAutoCreationAndCtbMeta(SInsertParseContext* pCxt, SVnod
if (code == TSDB_CODE_SUCCESS) {
char ctbFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName);
code = tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName);
SVgroupInfo vg;
SRequestConnInfo conn = {.pTrans = pCxt->pComCxt->pTransporter,
.requestId = pCxt->pComCxt->requestId,
.requestObjRefId = pCxt->pComCxt->requestRid,
.mgmtEps = pCxt->pComCxt->mgmtEpSet};
code = catalogGetTableHashVgroup(pCxt->pComCxt->pCatalog, &conn, &pStbRowsCxt->ctbName, &vg);
.requestId = pCxt->pComCxt->requestId,
.requestObjRefId = pCxt->pComCxt->requestRid,
.mgmtEps = pCxt->pComCxt->mgmtEpSet};
if (TSDB_CODE_SUCCESS == code) {
code = catalogGetTableHashVgroup(pCxt->pComCxt->pCatalog, &conn, &pStbRowsCxt->ctbName, &vg);
}
if (code == TSDB_CODE_SUCCESS) {
taosHashPut(pStmt->pVgroupsHashObj, (const char*)(&vg.vgId), sizeof(vg.vgId), &vg, sizeof(vg));
code = taosHashPut(pStmt->pVgroupsHashObj, (const char*)(&vg.vgId), sizeof(vg.vgId), &vg, sizeof(vg));
}
STableMeta* pBackup = NULL;
if (TSDB_CODE_SUCCESS == code) {
pStbRowsCxt->pCtbMeta->uid = taosHashGetSize(pStmt->pSubTableHashObj) + 1;
pStbRowsCxt->pCtbMeta->vgId = vg.vgId;
STableMeta* pBackup = NULL;
cloneTableMeta(pStbRowsCxt->pCtbMeta, &pBackup);
taosHashPut(pStmt->pSubTableHashObj, ctbFName, strlen(ctbFName), &pBackup, POINTER_BYTES);
code = cloneTableMeta(pStbRowsCxt->pCtbMeta, &pBackup);
}
if (TSDB_CODE_SUCCESS == code) {
code = taosHashPut(pStmt->pSubTableHashObj, ctbFName, strlen(ctbFName), &pBackup, POINTER_BYTES);
}
if (TSDB_CODE_SUCCESS == code) {
code = collectUseTable(&pStbRowsCxt->ctbName, pStmt->pTableNameHashObj);
}
collectUseTable(&pStbRowsCxt->ctbName, pStmt->pTableNameHashObj);
}
return code;
}
@ -2128,7 +2165,7 @@ static int32_t parseCsvFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt
bool gotRow = false;
if (TSDB_CODE_SUCCESS == code) {
SToken token;
strtolower(pLine, pLine);
(void)strtolower(pLine, pLine);
const char* pRow = pLine;
if (!pStmt->stbSyntax) {
code = parseOneRow(pCxt, (const char**)&pRow, rowsDataCxt.pTableDataCxt, &gotRow, &token);
@ -2139,8 +2176,11 @@ static int32_t parseCsvFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt
if (code == TSDB_CODE_SUCCESS) {
SStbRowsDataContext* pStbRowsCxt = rowsDataCxt.pStbRowsCxt;
void* pData = pTableDataCxt;
taosHashPut(pStmt->pTableCxtHashObj, &pStbRowsCxt->pCtbMeta->uid, sizeof(pStbRowsCxt->pCtbMeta->uid), &pData,
code = taosHashPut(pStmt->pTableCxtHashObj, &pStbRowsCxt->pCtbMeta->uid, sizeof(pStbRowsCxt->pCtbMeta->uid), &pData,
POINTER_BYTES);
if (TSDB_CODE_SUCCESS != code) {
break;
}
}
}
if (code && firstLine) {
@ -2188,7 +2228,10 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt
rowsDataCxt.pTableDataCxt->pData->flags |= SUBMIT_REQ_FROM_FILE;
}
if (!pStmt->fileProcessing) {
taosCloseFile(&pStmt->fp);
code = taosCloseFile(&pStmt->fp);
if (TSDB_CODE_SUCCESS != code) {
parserWarn("0x%" PRIx64 " failed to close file.", pCxt->pComCxt->requestId);
}
} else {
parserDebug("0x%" PRIx64 " insert from csv. File is too large, do it in batches.", pCxt->pComCxt->requestId);
}
@ -2200,7 +2243,7 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt
// just record pTableCxt whose data come from file
if (!pStmt->stbSyntax && numOfRows > 0) {
void* pData = rowsDataCxt.pTableDataCxt;
taosHashPut(pStmt->pTableCxtHashObj, &pStmt->pTableMeta->uid, sizeof(pStmt->pTableMeta->uid), &pData,
code = taosHashPut(pStmt->pTableCxtHashObj, &pStmt->pTableMeta->uid, sizeof(pStmt->pTableMeta->uid), &pData,
POINTER_BYTES);
}
@ -2211,7 +2254,7 @@ static int32_t parseDataFromFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
SRowsDataContext rowsDataCxt) {
char filePathStr[TSDB_FILENAME_LEN] = {0};
if (TK_NK_STRING == pFilePath->type) {
trimString(pFilePath->z, pFilePath->n, filePathStr, sizeof(filePathStr));
(void)trimString(pFilePath->z, pFilePath->n, filePathStr, sizeof(filePathStr));
} else {
strncpy(filePathStr, pFilePath->z, pFilePath->n);
}
@ -2296,18 +2339,35 @@ static int32_t constructStbRowsDataContext(SVnodeModifyOpStmt* pStmt, SStbRowsDa
pStbRowsCxt->pCtbMeta->suid = pStbRowsCxt->pStbMeta->uid;
pStbRowsCxt->aTagNames = taosArrayInit(8, TSDB_COL_NAME_LEN);
if (!pStbRowsCxt->aTagNames) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
}
pStbRowsCxt->aTagVals = taosArrayInit(8, sizeof(STagVal));
// col values and bound cols info of STableDataContext is not used
pStbRowsCxt->aColVals = taosArrayInit(getNumOfColumns(pStbRowsCxt->pStbMeta), sizeof(SColVal));
insInitColValues(pStbRowsCxt->pStbMeta, pStbRowsCxt->aColVals);
STableComInfo tblInfo = getTableInfo(pStmt->pTableMeta);
insInitBoundColsInfo(tblInfo.numOfColumns + tblInfo.numOfTags + 1, &pStbRowsCxt->boundColsInfo);
*ppStbRowsCxt = pStbRowsCxt;
return TSDB_CODE_SUCCESS;
if (TSDB_CODE_SUCCESS == code) {
pStbRowsCxt->aTagVals = taosArrayInit(8, sizeof(STagVal));
if (!pStbRowsCxt->aTagVals) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
}
if (TSDB_CODE_SUCCESS == code) {
// col values and bound cols info of STableDataContext is not used
pStbRowsCxt->aColVals = taosArrayInit(getNumOfColumns(pStbRowsCxt->pStbMeta), sizeof(SColVal));
if (!pStbRowsCxt->aColVals)
code = TSDB_CODE_OUT_OF_MEMORY;
}
if (TSDB_CODE_SUCCESS == code) {
code = insInitColValues(pStbRowsCxt->pStbMeta, pStbRowsCxt->aColVals);
}
if (TSDB_CODE_SUCCESS == code) {
STableComInfo tblInfo = getTableInfo(pStmt->pTableMeta);
code = insInitBoundColsInfo(tblInfo.numOfColumns + tblInfo.numOfTags + 1, &pStbRowsCxt->boundColsInfo);
}
if (TSDB_CODE_SUCCESS == code) {
*ppStbRowsCxt = pStbRowsCxt;
} else {
clearStbRowsDataContext(pStbRowsCxt);
}
return code;
}
static int32_t parseInsertStbClauseBottom(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) {

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

@ -39,8 +39,17 @@ int32_t qCloneCurrentTbData(STableDataCxt* pDataBlock, SSubmitTbData** pData) {
*pNew = *pDataBlock->pData;
cloneSVreateTbReq(pDataBlock->pData->pCreateTbReq, &pNew->pCreateTbReq);
int32_t code = cloneSVreateTbReq(pDataBlock->pData->pCreateTbReq, &pNew->pCreateTbReq);
if (TSDB_CODE_SUCCESS != code) {
taosMemoryFreeClear(*pData);
return code;
}
pNew->aCol = taosArrayDup(pDataBlock->pData->aCol, NULL);
if (!pNew->aCol) {
code = TSDB_CODE_OUT_OF_MEMORY;
taosMemoryFreeClear(*pData);
return code;
}
int32_t colNum = taosArrayGetSize(pNew->aCol);
for (int32_t i = 0; i < colNum; ++i) {
@ -152,7 +161,10 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch
goto end;
}
}
taosArrayPush(tagName, pTagSchema->name);
if (NULL == taosArrayPush(tagName, pTagSchema->name)) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto end;
}
if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
if (colLen > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
code = buildSyntaxErrMsg(&pBuf, "json string too long than 4095", bind[c].buffer);
@ -198,7 +210,10 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch
} else {
memcpy(&val.i64, bind[c].buffer, colLen);
}
taosArrayPush(pTagArray, &val);
if (NULL == taosArrayPush(pTagArray, &val)) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto end;
}
}
}
@ -433,7 +448,7 @@ int32_t qBindStmtSingleColValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bi
pBind = bind;
}
tColDataAddValueByBind(pCol, pBind, IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1);
code = tColDataAddValueByBind(pCol, pBind, IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1);
qDebug("stmt col %d bind %d rows data", colIdx, rowNum);

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

@ -94,7 +94,7 @@ int32_t insCreateSName(SName* pName, SToken* pTableName, int32_t acctId, const c
char tbname[TSDB_TABLE_FNAME_LEN] = {0};
strncpy(tbname, p + 1, tbLen);
/*tbLen = */ strdequote(tbname);
/*tbLen = */ (void)strdequote(tbname);
code = tNameFromString(pName, tbname, T_NAME_TABLE);
if (code != 0) {
@ -110,7 +110,7 @@ int32_t insCreateSName(SName* pName, SToken* pTableName, int32_t acctId, const c
char name[TSDB_TABLE_FNAME_LEN] = {0};
strncpy(name, pTableName->z, pTableName->n);
strdequote(name);
(void)strdequote(name);
if (dbName == NULL) {
return buildInvalidOperationMsg(pMsgBuf, msg3);
@ -167,15 +167,20 @@ static void initBoundCols(int32_t ncols, int16_t* pBoundCols) {
}
}
static void initColValues(STableMeta* pTableMeta, SArray* pValues) {
static int32_t initColValues(STableMeta* pTableMeta, SArray* pValues) {
SSchema* pSchemas = getTableColumnSchema(pTableMeta);
int32_t code = 0;
for (int32_t i = 0; i < pTableMeta->tableInfo.numOfColumns; ++i) {
SColVal val = COL_VAL_NONE(pSchemas[i].colId, pSchemas[i].type);
taosArrayPush(pValues, &val);
if (NULL == taosArrayPush(pValues, &val)) {
code = TSDB_CODE_OUT_OF_MEMORY;
break;
}
}
return code;
}
void insInitColValues(STableMeta* pTableMeta, SArray* aColValues) { initColValues(pTableMeta, aColValues); }
int32_t insInitColValues(STableMeta* pTableMeta, SArray* aColValues) { return initColValues(pTableMeta, aColValues); }
int32_t insInitBoundColsInfo(int32_t numOfBound, SBoundColInfo* pInfo) {
pInfo->numOfCols = numOfBound;
@ -253,7 +258,7 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat
if (NULL == pTableCxt->pValues) {
code = TSDB_CODE_OUT_OF_MEMORY;
} else {
initColValues(pTableMeta, pTableCxt->pValues);
code = initColValues(pTableMeta, pTableCxt->pValues);
}
}
if (TSDB_CODE_SUCCESS == code) {
@ -281,9 +286,12 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat
}
}
}
*pOutput = pTableCxt;
qDebug("tableDataCxt created, code:%d, uid:%" PRId64 ", vgId:%d", code, pTableMeta->uid, pTableMeta->vgId);
if (TSDB_CODE_SUCCESS == code) {
*pOutput = pTableCxt;
qDebug("tableDataCxt created, code:%d, uid:%" PRId64 ", vgId:%d", code, pTableMeta->uid, pTableMeta->vgId);
} else {
insDestroyTableDataCxt(pTableCxt);
}
return code;
}
@ -301,24 +309,27 @@ static int32_t rebuildTableData(SSubmitTbData* pSrc, SSubmitTbData** pDst) {
pTmp->pCreateTbReq = NULL;
if (pTmp->flags & SUBMIT_REQ_AUTO_CREATE_TABLE) {
if (pSrc->pCreateTbReq) {
cloneSVreateTbReq(pSrc->pCreateTbReq, &pTmp->pCreateTbReq);
code = cloneSVreateTbReq(pSrc->pCreateTbReq, &pTmp->pCreateTbReq);
} else {
pTmp->flags &= ~SUBMIT_REQ_AUTO_CREATE_TABLE;
}
}
if (pTmp->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
pTmp->aCol = taosArrayInit(128, sizeof(SColData));
if (NULL == pTmp->aCol) {
code = TSDB_CODE_OUT_OF_MEMORY;
taosMemoryFree(pTmp);
if (TSDB_CODE_SUCCESS == code) {
if (pTmp->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
pTmp->aCol = taosArrayInit(128, sizeof(SColData));
if (NULL == pTmp->aCol) {
code = TSDB_CODE_OUT_OF_MEMORY;
taosMemoryFree(pTmp);
}
} else {
pTmp->aRowP = taosArrayInit(128, POINTER_BYTES);
if (NULL == pTmp->aRowP) {
code = TSDB_CODE_OUT_OF_MEMORY;
taosMemoryFree(pTmp);
}
}
} else {
pTmp->aRowP = taosArrayInit(128, POINTER_BYTES);
if (NULL == pTmp->aRowP) {
code = TSDB_CODE_OUT_OF_MEMORY;
taosMemoryFree(pTmp);
}
taosMemoryFree(pTmp);
}
}
@ -447,16 +458,19 @@ static int32_t fillVgroupDataCxt(STableDataCxt* pTableCxt, SVgroupDataCxt* pVgCx
}
// push data to submit, rebuild empty data for next submit
taosArrayPush(pVgCxt->pData->aSubmitTbData, pTableCxt->pData);
if (NULL == taosArrayPush(pVgCxt->pData->aSubmitTbData, pTableCxt->pData)) {
return TSDB_CODE_OUT_OF_MEMORY;
}
int32_t code = 0;
if (isRebuild) {
rebuildTableData(pTableCxt->pData, &pTableCxt->pData);
code = rebuildTableData(pTableCxt->pData, &pTableCxt->pData);
} else if (clear) {
taosMemoryFreeClear(pTableCxt->pData);
}
qDebug("add tableDataCxt uid:%" PRId64 " to vgId:%d", pTableCxt->pMeta->uid, pVgCxt->vgId);
return TSDB_CODE_SUCCESS;
return code;
}
static int32_t createVgroupDataCxt(STableDataCxt* pTableCxt, SHashObj* pVgroupHash, SArray* pVgroupList,
@ -474,7 +488,11 @@ static int32_t createVgroupDataCxt(STableDataCxt* pTableCxt, SHashObj* pVgroupHa
pVgCxt->vgId = pTableCxt->pMeta->vgId;
int32_t code = taosHashPut(pVgroupHash, &pVgCxt->vgId, sizeof(pVgCxt->vgId), &pVgCxt, POINTER_BYTES);
if (TSDB_CODE_SUCCESS == code) {
taosArrayPush(pVgroupList, &pVgCxt);
if (NULL == taosArrayPush(pVgroupList, &pVgCxt)) {
code = TSDB_CODE_OUT_OF_MEMORY;
insDestroyVgroupDataCxt(pVgCxt);
return code;
}
// uDebug("td23101 2vgId:%d, uid:%" PRIu64, pVgCxt->vgId, pTableCxt->pMeta->uid);
*pOutput = pVgCxt;
} else {
@ -531,7 +549,10 @@ int32_t insGetStmtTableVgUid(SHashObj* pAllVgHash, SStbInterlaceInfo* pBuildInfo
if (NULL == pTbInfo) {
SName sname;
qCreateSName(&sname, pTbData->tbName, pBuildInfo->acctId, pBuildInfo->dbname, NULL, 0);
code = qCreateSName(&sname, pTbData->tbName, pBuildInfo->acctId, pBuildInfo->dbname, NULL, 0);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
STableMeta* pTableMeta = NULL;
SRequestConnInfo conn = {.pTrans = pBuildInfo->transport,
@ -553,9 +574,10 @@ int32_t insGetStmtTableVgUid(SHashObj* pAllVgHash, SStbInterlaceInfo* pBuildInfo
*vgId = pTableMeta->vgId;
STableVgUid tbInfo = {.uid = *uid, .vgid = *vgId};
tSimpleHashPut(pBuildInfo->pTableHash, pTbData->tbName, strlen(pTbData->tbName), &tbInfo, sizeof(tbInfo));
code = insTryAddTableVgroupInfo(pAllVgHash, pBuildInfo, vgId, pTbData, &sname);
code = tSimpleHashPut(pBuildInfo->pTableHash, pTbData->tbName, strlen(pTbData->tbName), &tbInfo, sizeof(tbInfo));
if (TSDB_CODE_SUCCESS == code) {
code = insTryAddTableVgroupInfo(pAllVgHash, pBuildInfo, vgId, pTbData, &sname);
}
taosMemoryFree(pTableMeta);
} else {

19
source/libs/parser/src/parTokenizer.c
View File

@ -352,22 +352,23 @@ static const char isIdChar[] = {
static void* keywordHashTable = NULL;
static void doInitKeywordsTable(void) {
static int32_t doInitKeywordsTable(void) {
int numOfEntries = tListLen(keywordTable);
keywordHashTable = taosHashInit(numOfEntries, MurmurHash3_32, true, false);
for (int32_t i = 0; i < numOfEntries; i++) {
keywordTable[i].len = (uint8_t)strlen(keywordTable[i].name);
void* ptr = &keywordTable[i];
taosHashPut(keywordHashTable, keywordTable[i].name, keywordTable[i].len, (void*)&ptr, POINTER_BYTES);
int32_t code = taosHashPut(keywordHashTable, keywordTable[i].name, keywordTable[i].len, (void*)&ptr, POINTER_BYTES);
if (TSDB_CODE_SUCCESS != code) {
taosHashCleanup(keywordHashTable);
return code;
}
}
return TSDB_CODE_SUCCESS;
}
static TdThreadOnce keywordsHashTableInit = PTHREAD_ONCE_INIT;
static int32_t tKeywordCode(const char* z, int n) {
taosThreadOnce(&keywordsHashTableInit, doInitKeywordsTable);
char key[512] = {0};
if (n > tListLen(key)) { // too long token, can not be any other token type
return TK_NK_ID;
@ -792,7 +793,7 @@ SToken tStrGetToken(const char* str, int32_t* i, bool isPrevOptr, bool* pIgnoreC
// check the table name is '?', db.?asf is not valid.
if (TK_NK_QUESTION == type) {
tGetToken(&str[*i + t0.n + 2], &type);
(void)tGetToken(&str[*i + t0.n + 2], &type);
if (TK_NK_SPACE != type) {
t0.type = TK_NK_ILLEGAL;
t0.n = 0;
@ -821,6 +822,10 @@ SToken tStrGetToken(const char* str, int32_t* i, bool isPrevOptr, bool* pIgnoreC
bool taosIsKeyWordToken(const char* z, int32_t len) { return (tKeywordCode((char*)z, len) != TK_NK_ID); }
int32_t taosInitKeywordsTable() {
return doInitKeywordsTable();
}
void taosCleanupKeywordsTable() {
void* m = keywordHashTable;
if (m != NULL && atomic_val_compare_exchange_ptr(&keywordHashTable, m, 0) == m) {

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

@ -3183,9 +3183,9 @@ static EDealRes rewriteExprToGroupKeyFunc(STranslateContext* pCxt, SNode** pNode
}
static EDealRes rewriteExprToSelectTagFunc(STranslateContext* pCxt, SNode** pNode) {
SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
SFunctionNode* pFunc = NULL;
pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
if (NULL == pFunc) {
pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
return DEAL_RES_ERROR;
}
@ -7537,6 +7537,9 @@ static int32_t buildCmdMsg(STranslateContext* pCxt, int16_t msgType, FSerializeF
pCxt->pCmdMsg->epSet = pCxt->pParseCxt->mgmtEpSet;
pCxt->pCmdMsg->msgType = msgType;
pCxt->pCmdMsg->msgLen = func(NULL, 0, pReq);
if (pCxt->pCmdMsg->msgLen < 0) {
return terrno;
}
pCxt->pCmdMsg->pMsg = taosMemoryMalloc(pCxt->pCmdMsg->msgLen);
if (NULL == pCxt->pCmdMsg->pMsg) {
taosMemoryFreeClear(pCxt->pCmdMsg);

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

@ -233,7 +233,7 @@ static char* getSyntaxErrFormat(int32_t errCode) {
int32_t generateSyntaxErrMsg(SMsgBuf* pBuf, int32_t errCode, ...) {
va_list vArgList;
va_start(vArgList, errCode);
vsnprintf(pBuf->buf, pBuf->len, getSyntaxErrFormat(errCode), vArgList);
(void)vsnprintf(pBuf->buf, pBuf->len, getSyntaxErrFormat(errCode), vArgList);
va_end(vArgList);
return errCode;
}
@ -241,7 +241,7 @@ int32_t generateSyntaxErrMsg(SMsgBuf* pBuf, int32_t errCode, ...) {
int32_t generateSyntaxErrMsgExt(SMsgBuf* pBuf, int32_t errCode, const char* pFormat, ...) {
va_list vArgList;
va_start(vArgList, pFormat);
vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList);
(void)vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList);
va_end(vArgList);
return errCode;
}
@ -254,7 +254,7 @@ int32_t buildInvalidOperationMsg(SMsgBuf* pBuf, const char* msg) {
int32_t buildInvalidOperationMsgExt(SMsgBuf* pBuf, const char* pFormat, ...) {
va_list vArgList;
va_start(vArgList, pFormat);
vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList);
(void)vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList);
va_end(vArgList);
return TSDB_CODE_TSC_INVALID_OPERATION;
}
@ -423,6 +423,10 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi
}
keyHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, false);
if (!keyHash) {
retCode = TSDB_CODE_OUT_OF_MEMORY;
goto end;
}
for (int32_t i = 0; i < size; i++) {
cJSON* item = cJSON_GetArrayItem(root, i);
if (!item) {
@ -448,8 +452,11 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi
STagVal val = {0};
// strcpy(val.colName, colName);
val.pKey = jsonKey;
taosHashPut(keyHash, jsonKey, keyLen, &keyLen,
CHAR_BYTES); // add key to hash to remove dumplicate, value is useless
retCode = taosHashPut(keyHash, jsonKey, keyLen, &keyLen,
CHAR_BYTES); // add key to hash to remove dumplicate, value is useless
if (TSDB_CODE_SUCCESS != retCode) {
goto end;
}
if (item->type == cJSON_String) { // add json value format: type|data
char* jsonValue = item->valuestring;
@ -486,7 +493,10 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi
retCode = buildSyntaxErrMsg(pMsgBuf, "invalidate json value", json);
goto end;
}
taosArrayPush(pTagVals, &val);
if (NULL == taosArrayPush(pTagVals, &val)) {
retCode = TSDB_CODE_OUT_OF_MEMORY;
goto end;
}
}
end:
@ -534,10 +544,11 @@ static int32_t getInsTagsTableTargetNameFromOp(int32_t acctId, SOperatorNode* pO
return TSDB_CODE_SUCCESS;
}
static void getInsTagsTableTargetObjName(int32_t acctId, SNode* pNode, SName* pName) {
static int32_t getInsTagsTableTargetObjName(int32_t acctId, SNode* pNode, SName* pName) {
if (QUERY_NODE_OPERATOR == nodeType(pNode)) {
getInsTagsTableTargetNameFromOp(acctId, (SOperatorNode*)pNode, pName);
return getInsTagsTableTargetNameFromOp(acctId, (SOperatorNode*)pNode, pName);
}
return TSDB_CODE_SUCCESS;
}
static int32_t getInsTagsTableTargetNameFromCond(int32_t acctId, SLogicConditionNode* pCond, SName* pName) {
@ -546,7 +557,12 @@ static int32_t getInsTagsTableTargetNameFromCond(int32_t acctId, SLogicCondition
}
SNode* pNode = NULL;
FOREACH(pNode, pCond->pParameterList) { getInsTagsTableTargetObjName(acctId, pNode, pName); }
FOREACH(pNode, pCond->pParameterList) {
int32_t code = getInsTagsTableTargetObjName(acctId, pNode, pName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
}
if ('\0' == pName->dbname[0]) {
pName->type = 0;
}
@ -634,8 +650,18 @@ static int32_t buildTableReq(SHashObj* pTablesHash, SArray** pTables) {
char fullName[TSDB_TABLE_FNAME_LEN] = {0};
strncpy(fullName, pKey, len);
SName name = {0};
tNameFromString(&name, fullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
taosArrayPush(*pTables, &name);
int32_t code = tNameFromString(&name, fullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
if (TSDB_CODE_SUCCESS == code) {
if (NULL == taosArrayPush(*pTables, &name)) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
}
if (TSDB_CODE_SUCCESS != code) {
taosHashCancelIterate(pTablesHash, p);
taosArrayDestroy(*pTables);
*pTables = NULL;
return code;
}
p = taosHashIterate(pTablesHash, p);
}
}
@ -654,7 +680,12 @@ static int32_t buildDbReq(SHashObj* pDbsHash, SArray** pDbs) {
char* pKey = taosHashGetKey(p, &len);
char fullName[TSDB_DB_FNAME_LEN] = {0};
strncpy(fullName, pKey, len);
taosArrayPush(*pDbs, fullName);
if (NULL == taosArrayPush(*pDbs, fullName)) {
taosHashCancelIterate(pDbsHash, p);
taosArrayDestroy(*pDbs);
*pDbs = NULL;
return TSDB_CODE_OUT_OF_MEMORY;
}
p = taosHashIterate(pDbsHash, p);
}
}
@ -673,8 +704,18 @@ static int32_t buildTableReqFromDb(SHashObj* pDbsHash, SArray** pDbs) {
while (NULL != p) {
STablesReq req = {0};
strcpy(req.dbFName, p->dbFName);
buildTableReq(p->pTables, &req.pTables);
taosArrayPush(*pDbs, &req);
int32_t code = buildTableReq(p->pTables, &req.pTables);
if (TSDB_CODE_SUCCESS == code) {
if (NULL == taosArrayPush(*pDbs, &req)) {
code = TSDB_CODE_OUT_OF_MEMORY;
}
}
if (TSDB_CODE_SUCCESS != code) {
taosHashCancelIterate(pDbsHash, p);
taosArrayDestroy(*pDbs);
*pDbs = NULL;
return code;
}
p = taosHashIterate(pDbsHash, p);
}
}
@ -695,7 +736,12 @@ static int32_t buildUserAuthReq(SHashObj* pUserAuthHash, SArray** pUserAuth) {
strncpy(key, pKey, len);
SUserAuthInfo userAuth = {0};
stringToUserAuth(key, len, &userAuth);
taosArrayPush(*pUserAuth, &userAuth);
if (NULL == taosArrayPush(*pUserAuth, &userAuth)) {
taosHashCancelIterate(pUserAuthHash, p);
taosArrayDestroy(*pUserAuth);
*pUserAuth = NULL;
return TSDB_CODE_OUT_OF_MEMORY;
}
p = taosHashIterate(pUserAuthHash, p);
}
}
@ -714,7 +760,12 @@ static int32_t buildUdfReq(SHashObj* pUdfHash, SArray** pUdf) {
char* pFunc = taosHashGetKey(p, &len);
char func[TSDB_FUNC_NAME_LEN] = {0};
strncpy(func, pFunc, len);
taosArrayPush(*pUdf, func);
if (NULL == taosArrayPush(*pUdf, func)) {
taosHashCancelIterate(pUdfHash, p);
taosArrayDestroy(*pUdf);
*pUdf = NULL;
return TSDB_CODE_OUT_OF_MEMORY;
}
p = taosHashIterate(pUdfHash, p);
}
}
@ -808,7 +859,10 @@ static int32_t putTableDataToCache(const SArray* pTableReq, const SArray* pTable
int32_t ntables = taosArrayGetSize(pTableReq);
for (int32_t i = 0; i < ntables; ++i) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(taosArrayGet(pTableReq, i), fullName);
int32_t code = tNameExtractFullName(taosArrayGet(pTableReq, i), fullName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
if (TSDB_CODE_SUCCESS != putMetaDataToHash(fullName, strlen(fullName), pTableData, i, pTable)) {
return TSDB_CODE_OUT_OF_MEMORY;
}
@ -836,7 +890,10 @@ static int32_t putDbTableDataToCache(const SArray* pDbReq, const SArray* pTableD
int32_t ntables = taosArrayGetSize(pReq->pTables);
for (int32_t j = 0; j < ntables; ++j) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(taosArrayGet(pReq->pTables, j), fullName);
int32_t code = tNameExtractFullName(taosArrayGet(pReq->pTables, j), fullName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
if (TSDB_CODE_SUCCESS != putMetaDataToHash(fullName, strlen(fullName), pTableData, tableNo, pTable)) {
return TSDB_CODE_OUT_OF_MEMORY;
}
@ -964,9 +1021,12 @@ int32_t reserveTableMetaInCacheExt(const SName* pName, SParseMetaCache* pMetaCac
int32_t getTableMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pName, fullName);
int32_t code = tNameExtractFullName(pName, fullName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
STableMeta* pTableMeta = NULL;
int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableMeta, (void**)&pTableMeta);
code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableMeta, (void**)&pTableMeta);
if (TSDB_CODE_SUCCESS == code) {
*pMeta = tableMetaDup(pTableMeta);
if (NULL == *pMeta) {
@ -998,9 +1058,12 @@ int32_t buildTableMetaFromViewMeta(STableMeta** pMeta, SViewMeta* pViewMeta) {
int32_t getViewMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pName, fullName);
int32_t code = tNameExtractFullName(pName, fullName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
SViewMeta* pViewMeta = NULL;
int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pViews, (void**)&pViewMeta);
code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pViews, (void**)&pViewMeta);
if (TSDB_CODE_SUCCESS == code) {
code = buildTableMetaFromViewMeta(pMeta, pViewMeta);
}
@ -1046,9 +1109,12 @@ int32_t reserveTableVgroupInCacheExt(const SName* pName, SParseMetaCache* pMetaC
int32_t getTableVgroupFromCache(SParseMetaCache* pMetaCache, const SName* pName, SVgroupInfo* pVgroup) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pName, fullName);
int32_t code = tNameExtractFullName(pName, fullName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
SVgroupInfo* pVg = NULL;
int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableVgroup, (void**)&pVg);
code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableVgroup, (void**)&pVg);
if (TSDB_CODE_SUCCESS == code) {
memcpy(pVgroup, pVg, sizeof(SVgroupInfo));
}
@ -1180,9 +1246,10 @@ int32_t reserveTSMAInfoInCache(int32_t acctId, const char* pDb, const char* pTsm
int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, SArray** pIndexes) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pName, fullName);
int32_t code = tNameExtractFullName(pName, fullName);
if (TSDB_CODE_SUCCESS != code) return code;;
SArray* pSmaIndexes = NULL;
int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableIndex, (void**)&pSmaIndexes);
code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableIndex, (void**)&pSmaIndexes);
if (TSDB_CODE_SUCCESS == code && NULL != pSmaIndexes) {
*pIndexes = smaIndexesDup(pSmaIndexes);
if (NULL == *pIndexes) {
@ -1194,9 +1261,12 @@ int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName,
int32_t getTableTsmasFromCache(SParseMetaCache* pMetaCache, const SName* pTbName, SArray** pTsmas) {
char tbFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pTbName, tbFName);
int32_t code = tNameExtractFullName(pTbName, tbFName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
STableTSMAInfoRsp* pTsmasRsp = NULL;
int32_t code = getMetaDataFromHash(tbFName, strlen(tbFName), pMetaCache->pTableTSMAs, (void**)&pTsmasRsp);
code = getMetaDataFromHash(tbFName, strlen(tbFName), pMetaCache->pTableTSMAs, (void**)&pTsmasRsp);
if (TSDB_CODE_SUCCESS == code && pTsmasRsp) {
*pTsmas = pTsmasRsp->pTsmas;
}
@ -1205,9 +1275,12 @@ int32_t getTableTsmasFromCache(SParseMetaCache* pMetaCache, const SName* pTbName
int32_t getTsmaFromCache(SParseMetaCache* pMetaCache, const SName* pTsmaName, STableTSMAInfo** pTsma) {
char tsmaFName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pTsmaName, tsmaFName);
int32_t code = tNameExtractFullName(pTsmaName, tsmaFName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
STableTSMAInfoRsp* pTsmaRsp = NULL;
int32_t code = getMetaDataFromHash(tsmaFName, strlen(tsmaFName), pMetaCache->pTSMAs, (void**)&pTsmaRsp);
code = getMetaDataFromHash(tsmaFName, strlen(tsmaFName), pMetaCache->pTSMAs, (void**)&pTsmaRsp);
if (TSDB_CODE_SUCCESS == code && pTsmaRsp) {
ASSERT(pTsmaRsp->pTsmas->size == 1);
*pTsma = taosArrayGetP(pTsmaRsp->pTsmas, 0);
@ -1252,9 +1325,12 @@ STableCfg* tableCfgDup(STableCfg* pCfg) {
int32_t getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput) {
char fullName[TSDB_TABLE_FNAME_LEN];
tNameExtractFullName(pName, fullName);
int32_t code = tNameExtractFullName(pName, fullName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
STableCfg* pCfg = NULL;
int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableCfg, (void**)&pCfg);
code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableCfg, (void**)&pCfg);
if (TSDB_CODE_SUCCESS == code && NULL != pCfg) {
*pOutput = tableCfgDup(pCfg);
if (NULL == *pOutput) {

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

@ -283,7 +283,7 @@ int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq
code = parseQuerySyntax(pCxt, pQuery, pCatalogReq);
}
}
nodesReleaseAllocator(pCxt->allocatorId);
(void)nodesReleaseAllocator(pCxt->allocatorId);
terrno = code;
return code;
}
@ -298,7 +298,7 @@ int32_t qAnalyseSqlSemantic(SParseContext* pCxt, const struct SCatalogReq* pCata
if (TSDB_CODE_SUCCESS == code) {
code = analyseSemantic(pCxt, pQuery, &metaCache);
}
nodesReleaseAllocator(pCxt->allocatorId);
(void)nodesReleaseAllocator(pCxt->allocatorId);
destoryParseMetaCache(&metaCache, false);
terrno = code;
return code;
@ -410,6 +410,10 @@ int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid) {
return TSDB_CODE_FAILED;
}
int32_t qInitKeywordsTable() {
return taosInitKeywordsTable();
}
void qCleanupKeywordsTable() { taosCleanupKeywordsTable(); }
int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx) {

212
source/libs/parser/test/mockCatalogService.cpp
View File

@ -46,12 +46,12 @@ class TableBuilder : public ITableBuilder {
schema()->vgId = vgid;
SVgroupInfo vgroup = {vgid, 0, 0, {0}, 0};
addEpIntoEpSet(&vgroup.epSet, "dnode_1", 6030);
addEpIntoEpSet(&vgroup.epSet, "dnode_2", 6030);
addEpIntoEpSet(&vgroup.epSet, "dnode_3", 6030);
assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(&vgroup.epSet, "dnode_1", 6030));
assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(&vgroup.epSet, "dnode_2", 6030));
assert(TSDB_CODE_FAILED == addEpIntoEpSet(&vgroup.epSet, "dnode_3", 6030));
vgroup.epSet.inUse = 0;
meta_->vgs.emplace_back(vgroup);
(void)meta_->vgs.emplace_back(vgroup);
return *this;
}
@ -117,7 +117,7 @@ class MockCatalogServiceImpl {
std::unique_ptr<STableMeta> table;
char db[TSDB_DB_NAME_LEN] = {0};
tNameGetDbName(pTableName, db);
(void)tNameGetDbName(pTableName, db);
const char* tname = tNameGetTableName(pTableName);
int32_t code = copyTableSchemaMeta(db, tname, &table);
@ -140,7 +140,7 @@ class MockCatalogServiceImpl {
int32_t catalogGetTableDistVgInfo(const SName* pTableName, SArray** vgList) const {
char db[TSDB_DB_NAME_LEN] = {0};
tNameGetDbName(pTableName, db);
(void)tNameGetDbName(pTableName, db);
return copyTableVgroup(db, tNameGetTableName(pTableName), vgList);
}
@ -174,7 +174,10 @@ class MockCatalogServiceImpl {
int32_t catalogGetTableIndex(const SName* pTableName, SArray** pIndexes) const {
char tbFName[TSDB_TABLE_FNAME_LEN] = {0};
tNameExtractFullName(pTableName, tbFName);
int32_t code = tNameExtractFullName(pTableName, tbFName);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
auto it = index_.find(tbFName);
if (index_.end() == it) {
return TSDB_CODE_SUCCESS;
@ -183,15 +186,26 @@ class MockCatalogServiceImpl {
for (const auto& index : it->second) {
STableIndexInfo info;
taosArrayPush(*pIndexes, copyTableIndexInfo(&info, &index));
if (nullptr == taosArrayPush(*pIndexes, copyTableIndexInfo(&info, &index))) {
taosArrayDestroy(*pIndexes);
*pIndexes = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
return TSDB_CODE_SUCCESS;
}
int32_t catalogGetDnodeList(SArray** pDnodes) const {
*pDnodes = taosArrayInit(dnode_.size(), sizeof(SEpSet));
if (!pDnodes) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (const auto& dnode : dnode_) {
taosArrayPush(*pDnodes, &dnode.second);
if (nullptr == taosArrayPush(*pDnodes, &dnode.second)) {
taosArrayDestroy(*pDnodes);
*pDnodes = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
return TSDB_CODE_SUCCESS;
}
@ -252,9 +266,9 @@ class MockCatalogServiceImpl {
SVgroupInfo vgroup = {vgid, 0, 0, {0}, 0};
genEpSet(&vgroup.epSet);
meta_[db][tbname]->vgs.emplace_back(vgroup);
(void)meta_[db][tbname]->vgs.emplace_back(vgroup);
// super table
meta_[db][stbname]->vgs.emplace_back(vgroup);
(void)meta_[db][stbname]->vgs.emplace_back(vgroup);
}
void showTables() const {
@ -345,7 +359,7 @@ class MockCatalogServiceImpl {
void createDnode(int32_t dnodeId, const string& host, int16_t port) {
SEpSet epSet = {0};
addEpIntoEpSet(&epSet, host.c_str(), port);
assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(&epSet, host.c_str(), port));
dnode_.insert(std::make_pair(dnodeId, epSet));
}
@ -370,9 +384,9 @@ class MockCatalogServiceImpl {
uint64_t getNextId() { return id_++; }
void genEpSet(SEpSet* pEpSet) {
addEpIntoEpSet(pEpSet, "dnode_1", 6030);
addEpIntoEpSet(pEpSet, "dnode_2", 6030);
addEpIntoEpSet(pEpSet, "dnode_3", 6030);
assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(pEpSet, "dnode_1", 6030));
assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(pEpSet, "dnode_2", 6030));
assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(pEpSet, "dnode_3", 6030));
pEpSet->inUse = 0;
}
@ -456,8 +470,15 @@ class MockCatalogServiceImpl {
return TSDB_CODE_SUCCESS;
}
*vgList = taosArrayInit(table->vgs.size(), sizeof(SVgroupInfo));
if (!*vgList) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (const SVgroupInfo& vg : table->vgs) {
taosArrayPush(*vgList, &vg);
if (nullptr == taosArrayPush(*vgList, &vg)) {
taosArrayDestroy(*vgList);
*vgList = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
return TSDB_CODE_SUCCESS;
}
@ -478,13 +499,21 @@ class MockCatalogServiceImpl {
if (NULL != pTableMetaReq) {
int32_t ndbs = taosArrayGetSize(pTableMetaReq);
*pTableMetaData = taosArrayInit(ndbs, sizeof(SMetaRes));
if (!*pTableMetaData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < ndbs; ++i) {
STablesReq* pReq = (STablesReq*)taosArrayGet(pTableMetaReq, i);
int32_t ntables = taosArrayGetSize(pReq->pTables);
for (int32_t j = 0; j < ntables; ++j) {
SMetaRes res = {0};
res.code = catalogGetTableMeta((const SName*)taosArrayGet(pReq->pTables, j), (STableMeta**)&res.pRes);
taosArrayPush(*pTableMetaData, &res);
if (nullptr == taosArrayPush(*pTableMetaData, &res)) {
MockCatalogService::destoryMetaRes(&res);
taosArrayDestroyEx(*pTableMetaData, MockCatalogService::destoryMetaRes);
*pTableMetaData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
}
@ -495,14 +524,27 @@ class MockCatalogServiceImpl {
if (NULL != pTableVgroupReq) {
int32_t ndbs = taosArrayGetSize(pTableVgroupReq);
*pTableVgroupData = taosArrayInit(ndbs, sizeof(SMetaRes));
if (!*pTableVgroupData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < ndbs; ++i) {
STablesReq* pReq = (STablesReq*)taosArrayGet(pTableVgroupReq, i);
int32_t ntables = taosArrayGetSize(pReq->pTables);
for (int32_t j = 0; j < ntables; ++j) {
SMetaRes res = {0};
res.pRes = taosMemoryCalloc(1, sizeof(SVgroupInfo));
if (!res.pRes) {
taosArrayDestroyEx(*pTableVgroupData, MockCatalogService::destoryMetaRes);
*pTableVgroupData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
res.code = catalogGetTableHashVgroup((const SName*)taosArrayGet(pReq->pTables, j), (SVgroupInfo*)res.pRes);
taosArrayPush(*pTableVgroupData, &res);
if (nullptr == taosArrayPush(*pTableVgroupData, &res)) {
MockCatalogService::destoryMetaRes(&res);
taosArrayDestroyEx(*pTableVgroupData, MockCatalogService::destoryMetaRes);
*pTableVgroupData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
}
@ -514,9 +556,16 @@ class MockCatalogServiceImpl {
if (NULL != pDbVgroupReq) {
int32_t ndbs = taosArrayGetSize(pDbVgroupReq);
*pDbVgroupData = taosArrayInit(ndbs, sizeof(SMetaRes));
if (!*pDbVgroupData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < ndbs; ++i) {
SMetaRes res = {0};
taosArrayPush(*pDbVgroupData, &res);
if (nullptr == taosArrayPush(*pDbVgroupData, &res)) {
taosArrayDestroyEx(*pDbVgroupData, MockCatalogService::destoryMetaRes);
*pDbVgroupData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return code;
@ -529,11 +578,17 @@ class MockCatalogServiceImpl {
}
std::set<int32_t> vgSet;
*pVgList = taosArrayInit(it->second.size(), sizeof(SVgroupInfo));
if (!*pVgList) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (const auto& vgs : it->second) {
for (const auto& vg : vgs.second->vgs) {
if (0 == vgSet.count(vg.vgId)) {
taosArrayPush(*pVgList, &vg);
vgSet.insert(vg.vgId);
if (nullptr == taosArrayPush(*pVgList, &vg)) {
taosArrayDestroy(*pVgList);
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)vgSet.insert(vg.vgId);
}
}
}
@ -543,12 +598,18 @@ class MockCatalogServiceImpl {
int32_t catalogGetAllDBVgList(SArray** pVgList) const {
std::set<int32_t> vgSet;
*pVgList = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVgroupInfo));
if (!*pVgList) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (const auto& db : meta_) {
for (const auto& vgs : db.second) {
for (const auto& vg : vgs.second->vgs) {
if (0 == vgSet.count(vg.vgId)) {
taosArrayPush(*pVgList, &vg);
vgSet.insert(vg.vgId);
if (nullptr == taosArrayPush(*pVgList, &vg)) {
taosArrayDestroy(*pVgList);
return TSDB_CODE_OUT_OF_MEMORY;
}
(void)vgSet.insert(vg.vgId);
}
}
}
@ -561,11 +622,24 @@ class MockCatalogServiceImpl {
if (NULL != pDbCfgReq) {
int32_t ndbs = taosArrayGetSize(pDbCfgReq);
*pDbCfgData = taosArrayInit(ndbs, sizeof(SMetaRes));
if (!*pDbCfgData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < ndbs; ++i) {
SMetaRes res = {0};
res.pRes = taosMemoryCalloc(1, sizeof(SDbCfgInfo));
if (!res.pRes) {
taosArrayDestroyEx(*pDbCfgData, MockCatalogService::destoryMetaRes);
*pDbCfgData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
res.code = catalogGetDBCfg((const char*)taosArrayGet(pDbCfgReq, i), (SDbCfgInfo*)res.pRes);
taosArrayPush(*pDbCfgData, &res);
if (nullptr == taosArrayPush(*pDbCfgData, &res)) {
MockCatalogService::destoryMetaRes(&res);
taosArrayDestroyEx(*pDbCfgData, MockCatalogService::destoryMetaRes);
*pDbCfgData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return code;
@ -576,10 +650,18 @@ class MockCatalogServiceImpl {
if (NULL != pDbInfoReq) {
int32_t ndbs = taosArrayGetSize(pDbInfoReq);
*pDbInfoData = taosArrayInit(ndbs, sizeof(SMetaRes));
if (!*pDbInfoData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < ndbs; ++i) {
SMetaRes res = {0};
res.pRes = taosMemoryCalloc(1, sizeof(SDbInfo));
taosArrayPush(*pDbInfoData, &res);
if (!res.pRes || (nullptr == taosArrayPush(*pDbInfoData, &res))) {
MockCatalogService::destoryMetaRes(&res);
taosArrayDestroyEx(*pDbInfoData, MockCatalogService::destoryMetaRes);
*pDbInfoData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return code;
@ -590,11 +672,25 @@ class MockCatalogServiceImpl {
if (NULL != pUserAuthReq) {
int32_t num = taosArrayGetSize(pUserAuthReq);
*pUserAuthData = taosArrayInit(num, sizeof(SMetaRes));
if (!*pUserAuthData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
int32_t code = TSDB_CODE_SUCCESS;
for (int32_t i = 0; i < num; ++i) {
SMetaRes res = {0};
res.pRes = taosMemoryCalloc(1, sizeof(SUserAuthRes));
if (!res.pRes) {
taosArrayDestroy(*pUserAuthData);
*pUserAuthData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
((SUserAuthRes*)res.pRes)->pass[0] = true;
taosArrayPush(*pUserAuthData, &res);
if (nullptr == taosArrayPush(*pUserAuthData, &res)) {
MockCatalogService::destoryMetaRes(&res);
taosArrayDestroyEx(*pUserAuthData, MockCatalogService::destoryMetaRes);
*pUserAuthData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return code;
@ -604,11 +700,24 @@ class MockCatalogServiceImpl {
if (NULL != pUdfReq) {
int32_t num = taosArrayGetSize(pUdfReq);
*pUdfData = taosArrayInit(num, sizeof(SMetaRes));
if (!*pUdfData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < num; ++i) {
SMetaRes res = {0};
res.pRes = taosMemoryCalloc(1, sizeof(SFuncInfo));
if (!res.pRes) {
taosArrayDestroyEx(*pUdfData, MockCatalogService::destoryMetaRes);
*pUdfData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
res.code = catalogGetUdfInfo((char*)taosArrayGet(pUdfReq, i), (SFuncInfo*)res.pRes);
taosArrayPush(*pUdfData, &res);
if (nullptr == taosArrayPush(*pUdfData, &res)) {
MockCatalogService::destoryMetaRes(&res);
taosArrayDestroyEx(*pUdfData, MockCatalogService::destoryMetaRes);
*pUdfData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return TSDB_CODE_SUCCESS;
@ -618,10 +727,18 @@ class MockCatalogServiceImpl {
if (NULL != pTableIndex) {
int32_t num = taosArrayGetSize(pTableIndex);
*pTableIndexData = taosArrayInit(num, sizeof(SMetaRes));
if (!*pTableIndexData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < num; ++i) {
SMetaRes res = {0};
res.code = catalogGetTableIndex((const SName*)taosArrayGet(pTableIndex, i), (SArray**)(&res.pRes));
taosArrayPush(*pTableIndexData, &res);
if (nullptr == taosArrayPush(*pTableIndexData, &res)) {
MockCatalogService::destoryMetaRes(&res);
taosArrayDestroyEx(*pTableIndexData, MockCatalogService::destoryMetaRes);
*pTableIndexData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return TSDB_CODE_SUCCESS;
@ -631,11 +748,20 @@ class MockCatalogServiceImpl {
if (NULL != pTableCfgReq) {
int32_t ntables = taosArrayGetSize(pTableCfgReq);
*pTableCfgData = taosArrayInit(ntables, sizeof(SMetaRes));
if (!*pTableCfgData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
int32_t code = 0;
for (int32_t i = 0; i < ntables; ++i) {
SMetaRes res = {0};
res.pRes = taosMemoryCalloc(1, sizeof(STableCfg));
res.code = TSDB_CODE_SUCCESS;
taosArrayPush(*pTableCfgData, &res);
res.pRes = taosMemoryCalloc(1, sizeof(STableCfg));
if (!res.pRes || (nullptr == taosArrayPush(*pTableCfgData, &res))) {
taosMemoryFree(res.pRes);
taosArrayDestroy(*pTableCfgData);
*pTableCfgData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return TSDB_CODE_SUCCESS;
@ -645,11 +771,18 @@ class MockCatalogServiceImpl {
if (NULL != pViewMetaReq) {
int32_t nviews = taosArrayGetSize(pViewMetaReq);
*pViewMetaData = taosArrayInit(nviews, sizeof(SMetaRes));
if (!*pViewMetaData) {
return TSDB_CODE_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < nviews; ++i) {
SMetaRes res = {0};
res.pRes = NULL;
res.pRes = nullptr;
res.code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
taosArrayPush(*pViewMetaData, &res);
if (nullptr == taosArrayPush(*pViewMetaData, &res)) {
taosArrayDestroyEx(*pViewMetaData, MockCatalogService::destoryMetaRes);
*pViewMetaData = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
}
}
return TSDB_CODE_SUCCESS;
@ -657,9 +790,20 @@ class MockCatalogServiceImpl {
int32_t getAllDnodeList(SArray** pDnodes) const {
SMetaRes res = {0};
catalogGetDnodeList((SArray**)&res.pRes);
int32_t code = catalogGetDnodeList((SArray**)&res.pRes);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
*pDnodes = taosArrayInit(1, sizeof(SMetaRes));
taosArrayPush(*pDnodes, &res);
if (!*pDnodes) {
return TSDB_CODE_OUT_OF_MEMORY;
}
if (nullptr == taosArrayPush(*pDnodes, &res)) {
MockCatalogService::destoryMetaArrayRes(&res);
taosArrayDestroyEx(*pDnodes, MockCatalogService::destoryMetaArrayRes);
*pDnodes = nullptr;
return TSDB_CODE_OUT_OF_MEMORY;
}
return TSDB_CODE_SUCCESS;
}

14
source/libs/parser/test/parAlterToBalanceTest.cpp
View File

@ -358,9 +358,9 @@ TEST_F(ParserInitialATest, alterLocal) {
};
auto setAlterLocal = [&](const char* pConfig, const char* pValue = nullptr) {
expect.first.assign(pConfig);
(void)expect.first.assign(pConfig);
if (nullptr != pValue) {
expect.second.assign(pValue);
(void)expect.second.assign(pValue);
}
};
@ -429,9 +429,10 @@ TEST_F(ParserInitialATest, alterSTable) {
expect.numOfFields = numOfFields;
if (NULL == expect.pFields) {
expect.pFields = taosArrayInit(2, sizeof(TAOS_FIELD));
ASSERT_TRUE(expect.pFields);
TAOS_FIELD field = {0};
taosArrayPush(expect.pFields, &field);
taosArrayPush(expect.pFields, &field);
ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field));
ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field));
}
TAOS_FIELD* pField = (TAOS_FIELD*)taosArrayGet(expect.pFields, 0);
@ -706,9 +707,10 @@ TEST_F(ParserInitialATest, alterTable) {
expect.numOfFields = numOfFields;
if (NULL == expect.pFields) {
expect.pFields = taosArrayInit(2, sizeof(TAOS_FIELD));
ASSERT_TRUE(expect.pFields);
TAOS_FIELD field = {0};
taosArrayPush(expect.pFields, &field);
taosArrayPush(expect.pFields, &field);
ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field));
ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field));
}
TAOS_FIELD* pField = (TAOS_FIELD*)taosArrayGet(expect.pFields, 0);

24
source/libs/parser/test/parInitialCTest.cpp
View File

@ -192,8 +192,9 @@ TEST_F(ParserInitialCTest, createDatabase) {
retention.keepUnit = keepUnit;
if (NULL == expect.pRetensions) {
expect.pRetensions = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SRetention));
ASSERT_TRUE(expect.pRetensions);
}
taosArrayPush(expect.pRetensions, &retention);
ASSERT_TRUE(taosArrayPush(expect.pRetensions, &retention) != nullptr);
++expect.numOfRetensions;
};
auto setDbSchemaless = [&](int8_t schemaless) { expect.schemaless = schemaless; };
@ -449,7 +450,7 @@ TEST_F(ParserInitialCTest, createFunction) {
file << 123 << "abc" << '\n';
file.close();
}
~udfFile() { remove(path_.c_str()); }
~udfFile() { assert(0 == remove(path_.c_str())); }
std::string path_;
} udffile("udf");
@ -506,7 +507,7 @@ TEST_F(ParserInitialCTest, createView) {
if (NULL == expect.pTags) {
expect.pTags = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField));
}
taosArrayPush(expect.pTags, &field);
ASSERT_TRUE(nullptr != taosArrayPush(expect.pTags, &field));
expect.numOfTags += 1;
};
@ -684,7 +685,7 @@ TEST_F(ParserInitialCTest, createSmaIndex) {
pCmdMsg->msgLen = tSerializeSMCreateSmaReq(NULL, 0, pStmt->pReq);
pCmdMsg->pMsg = taosMemoryMalloc(pCmdMsg->msgLen);
if (!pCmdMsg->pMsg) FAIL();
tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq);
ASSERT_EQ(TSDB_CODE_SUCCESS, tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq));
((SQuery*)pQuery)->pCmdMsg = pCmdMsg;
ASSERT_TRUE(TSDB_CODE_SUCCESS == tDeserializeSMCreateSmaReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req));
@ -797,13 +798,13 @@ TEST_F(ParserInitialCTest, createStable) {
if (NULL == expect.pColumns) {
expect.pColumns = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField));
}
taosArrayPush(expect.pColumns, &field);
ASSERT_TRUE(nullptr != taosArrayPush(expect.pColumns, &field));
expect.numOfColumns += 1;
} else {
if (NULL == expect.pTags) {
expect.pTags = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField));
}
taosArrayPush(expect.pTags, &field);
ASSERT_TRUE(taosArrayPush(expect.pTags, &field) != nullptr);
expect.numOfTags += 1;
}
};
@ -983,7 +984,7 @@ TEST_F(ParserInitialCTest, createStream) {
if (NULL == expect.pTags) {
expect.pTags = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField));
}
taosArrayPush(expect.pTags, &field);
ASSERT_TRUE(taosArrayPush(expect.pTags, &field) != nullptr);
expect.numOfTags += 1;
};
@ -1123,8 +1124,9 @@ TEST_F(ParserInitialCTest, createTable) {
++expect.nReqs;
if (nullptr == expect.pArray) {
expect.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVCreateTbReq));
ASSERT_TRUE(expect.pArray != nullptr);
}
taosArrayPush(expect.pArray, &req);
ASSERT_TRUE(taosArrayPush(expect.pArray, &req) != nullptr);
};
setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
@ -1200,11 +1202,11 @@ TEST_F(ParserInitialCTest, createTableSemanticCheck) {
string sql = "CREATE TABLE st1(ts TIMESTAMP, ";
for (int32_t i = 1; i < 4096; ++i) {
if (i > 1) {
sql.append(", ");
(void)sql.append(", ");
}
sql.append("c" + to_string(i) + " INT");
(void)sql.append("c" + to_string(i) + " INT");
}
sql.append(") TAGS (t1 int)");
(void)sql.append(") TAGS (t1 int)");
run(sql, TSDB_CODE_PAR_TOO_MANY_COLUMNS);
}

7
source/libs/parser/test/parTestMain.cpp
View File

@ -35,8 +35,7 @@ namespace ParserTest {
class ParserEnv : public testing::Environment {
public:
virtual void SetUp() {
// TODO(smj) : How to handle return value of fmFuncMgtInit
(void)fmFuncMgtInit();
ASSERT_EQ(TSDB_CODE_SUCCESS, fmFuncMgtInit());
initMetaDataEnv();
generateMetaData();
initLog(TD_TMP_DIR_PATH "td");
@ -71,7 +70,7 @@ class ParserEnv : public testing::Environment {
tsAsyncLog = 0;
taosRemoveDir(path);
taosMkDir(path);
ASSERT_EQ(TSDB_CODE_SUCCESS, taosMkDir(path));
tstrncpy(tsLogDir, path, PATH_MAX);
if (taosInitLog("taoslog", 1) != 0) {
std::cout << "failed to init log file" << std::endl;
@ -118,7 +117,7 @@ static void parseArg(int argc, char* argv[]) {
} // namespace ParserTest
int main(int argc, char* argv[]) {
testing::AddGlobalTestEnvironment(new ParserTest::ParserEnv());
(void)testing::AddGlobalTestEnvironment(new ParserTest::ParserEnv());
testing::InitGoogleTest(&argc, argv);
ParserTest::parseArg(argc, argv);
return RUN_ALL_TESTS();

2
source/libs/parser/test/parTestUtil.cpp
View File

@ -216,7 +216,7 @@ class ParserTestBaseImpl {
void setParseContext(const string& sql, SParseContext* pCxt, bool async = false) {
stmtEnv_.sql_ = sql;
strtolower((char*)stmtEnv_.sql_.c_str(), sql.c_str());
(void)strtolower((char*)stmtEnv_.sql_.c_str(), sql.c_str());
pCxt->acctId = atoi(caseEnv_.acctId_.c_str());
pCxt->db = caseEnv_.db_.c_str();

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

@ -506,10 +506,17 @@ static int32_t createSubqueryLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe
int32_t collectJoinResColumns(SSelectStmt* pSelect, SJoinLogicNode* pJoin, SNodeList** pCols) {
SSHashObj* pTables = NULL;
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables);
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables);
int32_t code = nodesCollectColumnsExt(pSelect, SQL_CLAUSE_WHERE, pTables, COLLECT_COL_TYPE_ALL, pCols);
int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables);
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(pTables);
return code;
} else {
code = nodesCollectColumnsExt(pSelect, SQL_CLAUSE_WHERE, pTables, COLLECT_COL_TYPE_ALL, pCols);
}
tSimpleHashCleanup(pTables);

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

@ -113,7 +113,7 @@ typedef struct SJoinOptimizeOpt {
int8_t pushDownFlag;
} SJoinOptimizeOpt;
typedef bool (*FMayBeOptimized)(SLogicNode* pNode);
typedef bool (*FMayBeOptimized)(SLogicNode* pNode, void* pCtx);
typedef bool (*FShouldBeOptimized)(SLogicNode* pNode, void* pInfo);
#if 0
@ -144,13 +144,13 @@ static SJoinOptimizeOpt gJoinOnOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] =
#endif
static SLogicNode* optFindPossibleNode(SLogicNode* pNode, FMayBeOptimized func) {
if (func(pNode)) {
static SLogicNode* optFindPossibleNode(SLogicNode* pNode, FMayBeOptimized func, void* pCtx) {
if (func(pNode, pCtx)) {
return pNode;
}
SNode* pChild;
FOREACH(pChild, pNode->pChildren) {
SLogicNode* pScanNode = optFindPossibleNode((SLogicNode*)pChild, func);
SLogicNode* pScanNode = optFindPossibleNode((SLogicNode*)pChild, func, pCtx);
if (NULL != pScanNode) {
return pScanNode;
}
@ -240,7 +240,7 @@ static bool scanPathOptHaveNormalCol(SNodeList* pList) {
return res;
}
static bool scanPathOptMayBeOptimized(SLogicNode* pNode) {
static bool scanPathOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_SCAN_PATH)) {
return false;
}
@ -372,7 +372,7 @@ static int32_t scanPathOptSetOsdInfo(SOsdInfo* pInfo) {
}
static int32_t scanPathOptMatch(SOptimizeContext* pCxt, SLogicNode* pLogicNode, SOsdInfo* pInfo) {
pInfo->pScan = (SScanLogicNode*)optFindPossibleNode(pLogicNode, scanPathOptMayBeOptimized);
pInfo->pScan = (SScanLogicNode*)optFindPossibleNode(pLogicNode, scanPathOptMayBeOptimized, NULL);
if (NULL == pInfo->pScan) {
return TSDB_CODE_SUCCESS;
}
@ -674,8 +674,15 @@ static int32_t pdcJoinSplitLogicCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SN
int32_t code = TSDB_CODE_SUCCESS;
SSHashObj* pLeftTables = NULL;
SSHashObj* pRightTables = NULL;
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(pLeftTables);
return code;
}
SNodeList* pOnConds = NULL;
SNodeList* pLeftChildConds = NULL;
@ -747,8 +754,15 @@ static int32_t pdcJoinSplitOpCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SNode
SNode** pRightChildCond, bool whereCond) {
SSHashObj* pLeftTables = NULL;
SSHashObj* pRightTables = NULL;
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(pLeftTables);
return code;
}
ECondAction condAction = pdcJoinGetCondAction(pJoin, pLeftTables, pRightTables, *pSrcCond, whereCond);
@ -829,8 +843,15 @@ static bool pdcJoinIsPrimEqualCond(SJoinLogicNode* pJoin, SNode* pCond) {
SSHashObj* pLeftTables = NULL;
SSHashObj* pRightTables = NULL;
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(pLeftTables);
return code;
}
bool res = false;
if (pdcJoinIsPrim(pOper->pLeft, pLeftTables)) {
@ -1200,8 +1221,15 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic
}
SSHashObj* pTables = NULL;
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables);
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables);
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables);
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(pTables);
return code;
}
SJoinLogicNode* pTmp = (SJoinLogicNode*)pJoin->node.pParent;
do {
@ -1545,15 +1573,24 @@ static int32_t pdcRewriteTypeBasedOnConds(SOptimizeContext* pCxt, SJoinLogicNode
SSHashObj* pLeftTables = NULL;
SSHashObj* pRightTables = NULL;
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(pLeftTables);
return code;
}
bool tableCondTypes[4] = {0};
int32_t code = pdcGetTableCondTypes(pJoin->node.pConditions, pLeftTables, pRightTables, tableCondTypes);
code = pdcGetTableCondTypes(pJoin->node.pConditions, pLeftTables, pRightTables, tableCondTypes);
tSimpleHashCleanup(pLeftTables);
tSimpleHashCleanup(pRightTables);
if (TSDB_CODE_SUCCESS != code) return code;
switch (pJoin->joinType) {
case JOIN_TYPE_LEFT:
if (tableCondTypes[2] && !tableCondTypes[3]) {
@ -1658,8 +1695,15 @@ static int32_t pdcRewriteTypeBasedOnJoinRes(SOptimizeContext* pCxt, SJoinLogicNo
int32_t code = 0;
SSHashObj* pLeftTables = NULL;
SSHashObj* pRightTables = NULL;
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(pLeftTables);
return code;
}
SLogicNode* pParent = pJoin->node.pParent;
bool tableResNonNull[2] = {true, true};
@ -2101,7 +2145,7 @@ static int32_t pdcOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan)
}
static bool eliminateNotNullCondMayBeOptimized(SLogicNode* pNode) {
static bool eliminateNotNullCondMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pNode)) {
return false;
}
@ -2161,7 +2205,7 @@ static bool eliminateNotNullCondMayBeOptimized(SLogicNode* pNode) {
}
static int32_t eliminateNotNullCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pNode = (SLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateNotNullCondMayBeOptimized);
SLogicNode* pNode = (SLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateNotNullCondMayBeOptimized, NULL);
if (NULL == pNode) {
return TSDB_CODE_SUCCESS;
}
@ -2184,7 +2228,7 @@ static bool sortPriKeyOptIsPriKeyOrderBy(SNodeList* pSortKeys) {
return (QUERY_NODE_COLUMN == nodeType(pNode) ? isPrimaryKeyImpl(pNode) : false);
}
static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode) {
static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_SORT != nodeType(pNode)) {
return false;
}
@ -2202,7 +2246,7 @@ static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode) {
}
FOREACH(pChild, pSort->node.pChildren) {
SLogicNode* pSortDescendent = optFindPossibleNode((SLogicNode*)pChild, sortPriKeyOptMayBeOptimized);
SLogicNode* pSortDescendent = optFindPossibleNode((SLogicNode*)pChild, sortPriKeyOptMayBeOptimized, NULL);
if (pSortDescendent != NULL) {
return false;
}
@ -2493,7 +2537,7 @@ static int32_t sortPrimaryKeyOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
}
static int32_t sortPrimaryKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SSortLogicNode* pSort = (SSortLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortPriKeyOptMayBeOptimized);
SSortLogicNode* pSort = (SSortLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortPriKeyOptMayBeOptimized, NULL);
if (NULL == pSort) {
return TSDB_CODE_SUCCESS;
}
@ -2537,7 +2581,10 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
SNode* pOrderByNode = NULL;
collectTableAliasFromNodes((SNode*)pChild, &pTables);
int32_t code = collectTableAliasFromNodes((SNode*)pChild, &pTables);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
if (NULL != tSimpleHashGet(pTables, ((SColumnNode*)pOp->pLeft)->tableAlias, strlen(((SColumnNode*)pOp->pLeft)->tableAlias))) {
pOrderByNode = pOp->pLeft;
} else if (NULL != tSimpleHashGet(pTables, ((SColumnNode*)pOp->pRight)->tableAlias, strlen(((SColumnNode*)pOp->pRight)->tableAlias))) {
@ -2551,7 +2598,7 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
}
SSortLogicNode* pSort = NULL;
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
if (NULL == pSort) {
return code;
}
@ -2602,7 +2649,7 @@ _return:
}
static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode) {
static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) {
return false;
}
@ -2631,7 +2678,7 @@ static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode) {
static int32_t sortForJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortForJoinOptMayBeOptimized);
SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortForJoinOptMayBeOptimized, NULL);
if (NULL == pJoin) {
return TSDB_CODE_SUCCESS;
}
@ -2675,7 +2722,7 @@ static int32_t joinCondGetAllScanNodes(SLogicNode* pNode, SNodeList** pList) {
}
static bool joinCondMayBeOptimized(SLogicNode* pNode) {
static bool joinCondMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode) || OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND)) {
return false;
}
@ -2734,7 +2781,7 @@ static void joinCondMergeScanRand(STimeWindow* pDst, STimeWindow* pSrc) {
}
static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, joinCondMayBeOptimized);
SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, joinCondMayBeOptimized, NULL);
if (NULL == pJoin) {
return TSDB_CODE_SUCCESS;
}
@ -2797,7 +2844,7 @@ static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
return TSDB_CODE_SUCCESS;
}
static bool smaIndexOptMayBeOptimized(SLogicNode* pNode) {
static bool smaIndexOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pNode) || NULL == pNode->pParent ||
QUERY_NODE_LOGIC_PLAN_WINDOW != nodeType(pNode->pParent) ||
WINDOW_TYPE_INTERVAL != ((SWindowLogicNode*)pNode->pParent)->winType) {
@ -3014,7 +3061,7 @@ static int32_t smaIndexOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogi
}
static int32_t smaIndexOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, smaIndexOptMayBeOptimized);
SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, smaIndexOptMayBeOptimized, NULL);
if (NULL == pScan) {
return TSDB_CODE_SUCCESS;
}
@ -3098,7 +3145,7 @@ static bool partTagsOptAreSupportedFuncs(SNodeList* pFuncs) {
return true;
}
static bool partTagsOptMayBeOptimized(SLogicNode* pNode) {
static bool partTagsOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (!partTagsIsOptimizableNode(pNode)) {
return false;
}
@ -3117,7 +3164,7 @@ static void partTagsSetAlias(char* pAlias, const char* pTableAlias, const char*
char name[TSDB_COL_FNAME_LEN + 1] = {0};
int32_t len = snprintf(name, TSDB_COL_FNAME_LEN, "%s.%s", pTableAlias, pColName);
taosCreateMD5Hash(name, len);
(void)taosCreateMD5Hash(name, len);
strncpy(pAlias, name, TSDB_COL_NAME_LEN - 1);
}
@ -3207,7 +3254,7 @@ static int32_t partTagsRewriteGroupTagsToFuncs(SNodeList* pGroupTags, int32_t st
}
static int32_t partTagsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, partTagsOptMayBeOptimized);
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, partTagsOptMayBeOptimized, NULL);
if (NULL == pNode) {
return TSDB_CODE_SUCCESS;
}
@ -3274,7 +3321,8 @@ static int32_t partTagsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
return code;
}
static bool eliminateProjOptCheckProjColumnNames(SProjectLogicNode* pProjectNode) {
static int32_t eliminateProjOptCheckProjColumnNames(SProjectLogicNode* pProjectNode, bool* pRet) {
int32_t code = 0;
SHashObj* pProjColNameHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
SNode* pProjection;
FOREACH(pProjection, pProjectNode->pProjections) {
@ -3285,14 +3333,18 @@ static bool eliminateProjOptCheckProjColumnNames(SProjectLogicNode* pProjectNode
return false;
} else {
int32_t exist = 1;
taosHashPut(pProjColNameHash, projColumnName, strlen(projColumnName), &exist, sizeof(exist));
code = taosHashPut(pProjColNameHash, projColumnName, strlen(projColumnName), &exist, sizeof(exist));
if (TSDB_CODE_SUCCESS != code) {
break;
}
}
}
taosHashCleanup(pProjColNameHash);
return true;
*pRet = true;
return code;
}
static bool eliminateProjOptMayBeOptimized(SLogicNode* pNode) {
static bool eliminateProjOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
// Super table scan requires project operator to merge packets to improve performance.
if (NULL == pNode->pParent && (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) ||
(QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(nodesListGetNode(pNode->pChildren, 0)) &&
@ -3337,8 +3389,13 @@ static bool eliminateProjOptMayBeOptimized(SLogicNode* pNode) {
return false;
}
}
return eliminateProjOptCheckProjColumnNames(pProjectNode);
int32_t* pCode = pCtx;
bool ret = false;
int32_t code = eliminateProjOptCheckProjColumnNames(pProjectNode, &ret);
if (TSDB_CODE_SUCCESS != code) {
*pCode = code;
}
return ret;
}
typedef struct CheckNewChildTargetsCxt {
@ -3398,7 +3455,7 @@ static void alignProjectionWithTarget(SLogicNode* pNode) {
}
}
if (!keep) {
nodesListErase(pProjectNode->pProjections, cell);
(void)nodesListErase(pProjectNode->pProjections, cell);
}
}
}
@ -3506,8 +3563,9 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
}
static int32_t eliminateProjOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
int32_t code = 0;
SProjectLogicNode* pProjectNode =
(SProjectLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateProjOptMayBeOptimized);
(SProjectLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateProjOptMayBeOptimized, &code);
if (NULL == pProjectNode) {
return TSDB_CODE_SUCCESS;
@ -3516,7 +3574,7 @@ static int32_t eliminateProjOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog
return eliminateProjOptimizeImpl(pCxt, pLogicSubplan, pProjectNode);
}
static bool rewriteTailOptMayBeOptimized(SLogicNode* pNode) {
static bool rewriteTailOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
return QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC == nodeType(pNode) && ((SIndefRowsFuncLogicNode*)pNode)->isTailFunc;
}
@ -3681,7 +3739,7 @@ static int32_t rewriteTailOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
static int32_t rewriteTailOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SIndefRowsFuncLogicNode* pIndef =
(SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteTailOptMayBeOptimized);
(SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteTailOptMayBeOptimized, NULL);
if (NULL == pIndef) {
return TSDB_CODE_SUCCESS;
@ -3690,7 +3748,7 @@ static int32_t rewriteTailOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
return rewriteTailOptimizeImpl(pCxt, pLogicSubplan, pIndef);
}
static bool eliminateSetOpMayBeOptimized(SLogicNode* pNode) {
static bool eliminateSetOpMayBeOptimized(SLogicNode* pNode, void* pCtx) {
SLogicNode* pParent = pNode->pParent;
if (NULL == pParent ||
QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pParent) && QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pParent) ||
@ -3723,7 +3781,7 @@ static int32_t eliminateSetOpOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
}
static int32_t eliminateSetOpOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pSetOpNode = optFindPossibleNode(pLogicSubplan->pNode, eliminateSetOpMayBeOptimized);
SLogicNode* pSetOpNode = optFindPossibleNode(pLogicSubplan->pNode, eliminateSetOpMayBeOptimized, NULL);
if (NULL == pSetOpNode) {
return TSDB_CODE_SUCCESS;
}
@ -3731,7 +3789,7 @@ static int32_t eliminateSetOpOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLo
return eliminateSetOpOptimizeImpl(pCxt, pLogicSubplan, pSetOpNode);
}
static bool rewriteUniqueOptMayBeOptimized(SLogicNode* pNode) {
static bool rewriteUniqueOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
return QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC == nodeType(pNode) && ((SIndefRowsFuncLogicNode*)pNode)->isUniqueFunc;
}
@ -3769,7 +3827,7 @@ static int32_t rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNod
int64_t pointer = (int64_t)pFunc;
char name[TSDB_FUNC_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pFunc->functionName, pointer);
taosCreateMD5Hash(name, len);
(void)taosCreateMD5Hash(name, len);
strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
}
SNode* pNew = NULL;
@ -3946,7 +4004,7 @@ static int32_t rewriteUniqueOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
static int32_t rewriteUniqueOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SIndefRowsFuncLogicNode* pIndef =
(SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteUniqueOptMayBeOptimized);
(SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteUniqueOptMayBeOptimized, NULL);
if (NULL == pIndef) {
return TSDB_CODE_SUCCESS;
@ -4105,7 +4163,7 @@ static bool lastRowScanOptCheckLastCache(SAggLogicNode* pAgg, SScanLogicNode* pS
return true;
}
static bool lastRowScanOptMayBeOptimized(SLogicNode* pNode) {
static bool lastRowScanOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) ||
QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(nodesListGetNode(pNode->pChildren, 0))) {
return false;
@ -4238,14 +4296,17 @@ static int32_t lastRowScanBuildFuncTypes(SScanLogicNode* pScan, SColumnNode* pCo
}
pFuncTypeParam->pCol->colId = pColNode->colId;
strcpy(pFuncTypeParam->pCol->name, pColNode->colName);
taosArrayPush(pScan->pFuncTypes, pFuncTypeParam);
if (NULL == taosArrayPush(pScan->pFuncTypes, pFuncTypeParam)) {
taosMemoryFree(pFuncTypeParam);
return TSDB_CODE_OUT_OF_MEMORY;
}
taosMemoryFree(pFuncTypeParam);
return TSDB_CODE_SUCCESS;
}
static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, lastRowScanOptMayBeOptimized);
SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, lastRowScanOptMayBeOptimized, NULL);
if (NULL == pAgg) {
return TSDB_CODE_SUCCESS;
@ -4269,7 +4330,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
int32_t funcType = pFunc->funcType;
SNode* pParamNode = NULL;
if (FUNCTION_TYPE_LAST == funcType) {
nodesListErase(pFunc->pParameterList, nodesListGetCell(pFunc->pParameterList, 1));
(void)nodesListErase(pFunc->pParameterList, nodesListGetCell(pFunc->pParameterList, 1));
nodesWalkExpr(nodesListGetNode(pFunc->pParameterList, 0), lastRowScanOptSetColDataType, &cxt);
if (TSDB_CODE_SUCCESS != cxt.code) break;
}
@ -4478,7 +4539,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
return TSDB_CODE_SUCCESS;
}
static bool splitCacheLastFuncOptMayBeOptimized(SLogicNode* pNode) {
static bool splitCacheLastFuncOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) ||
QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(nodesListGetNode(pNode->pChildren, 0))) {
return false;
@ -4691,7 +4752,7 @@ static int32_t splitCacheLastFuncOptCreateMergeLogicNode(SMergeLogicNode** pNew,
}
static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, splitCacheLastFuncOptMayBeOptimized);
SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, splitCacheLastFuncOptMayBeOptimized, NULL);
if (NULL == pAgg) {
return TSDB_CODE_SUCCESS;
@ -4804,7 +4865,7 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan*
}
// merge projects
static bool mergeProjectsMayBeOptimized(SLogicNode* pNode) {
static bool mergeProjectsMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren)) {
return false;
}
@ -4877,7 +4938,7 @@ static int32_t mergeProjectsOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
}
static int32_t mergeProjectsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pProjectNode = optFindPossibleNode(pLogicSubplan->pNode, mergeProjectsMayBeOptimized);
SLogicNode* pProjectNode = optFindPossibleNode(pLogicSubplan->pNode, mergeProjectsMayBeOptimized, NULL);
if (NULL == pProjectNode) {
return TSDB_CODE_SUCCESS;
}
@ -4885,7 +4946,7 @@ static int32_t mergeProjectsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog
return mergeProjectsOptimizeImpl(pCxt, pLogicSubplan, pProjectNode);
}
static bool tagScanOptShouldBeOptimized(SLogicNode* pNode) {
static bool tagScanOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pNode) || (SCAN_TYPE_TAG == ((SScanLogicNode*)pNode)->scanType)) {
return false;
}
@ -4920,7 +4981,7 @@ static bool tagScanOptShouldBeOptimized(SLogicNode* pNode) {
}
static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SScanLogicNode* pScanNode = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tagScanOptShouldBeOptimized);
SScanLogicNode* pScanNode = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tagScanOptShouldBeOptimized, NULL);
if (NULL == pScanNode) {
return TSDB_CODE_SUCCESS;
}
@ -4971,7 +5032,7 @@ static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubp
return TSDB_CODE_SUCCESS;
}
static bool pushDownLimitOptShouldBeOptimized(SLogicNode* pNode) {
static bool pushDownLimitOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
if ((NULL == pNode->pLimit && pNode->pSlimit == NULL) || 1 != LIST_LENGTH(pNode->pChildren)) {
return false;
}
@ -5096,7 +5157,7 @@ static int32_t pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLim
}
static int32_t pushDownLimitOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, pushDownLimitOptShouldBeOptimized);
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, pushDownLimitOptShouldBeOptimized, NULL);
if (NULL == pNode) {
return TSDB_CODE_SUCCESS;
}
@ -5418,7 +5479,7 @@ static int32_t sortNonPriKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog
return code;
}
SOptimizePKCtx ctx = {.pList = pNodeList, .code = 0};
optFindEligibleNode(pLogicSubplan->pNode, sortNonPriKeyShouldOptimize, &ctx);
(void)optFindEligibleNode(pLogicSubplan->pNode, sortNonPriKeyShouldOptimize, &ctx);
if (TSDB_CODE_SUCCESS != ctx.code) {
nodesClearList(pNodeList);
return code;
@ -5435,7 +5496,7 @@ static int32_t sortNonPriKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog
return TSDB_CODE_SUCCESS;
}
static bool hashJoinOptShouldBeOptimized(SLogicNode* pNode) {
static bool hashJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
bool res = false;
if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) {
return res;
@ -5460,7 +5521,11 @@ _return:
if (!res && DATA_ORDER_LEVEL_NONE == pJoin->node.requireDataOrder) {
pJoin->node.requireDataOrder = DATA_ORDER_LEVEL_GLOBAL;
(void)adjustLogicNodeDataRequirement(pNode, pJoin->node.requireDataOrder);
int32_t *pCode = pCtx;
int32_t code = adjustLogicNodeDataRequirement(pNode, pJoin->node.requireDataOrder);
if (TSDB_CODE_SUCCESS != code) {
*pCode = code;
}
}
return res;
@ -5737,7 +5802,11 @@ static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode,
static int32_t hashJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, hashJoinOptShouldBeOptimized);
int32_t code = 0;
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, hashJoinOptShouldBeOptimized, &code);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
if (NULL == pNode) {
return TSDB_CODE_SUCCESS;
}
@ -5745,7 +5814,7 @@ static int32_t hashJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
return hashJoinOptRewriteJoin(pCxt, pNode, pLogicSubplan);
}
static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode) {
static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode) || OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_STB_JOIN)) {
return false;
}
@ -5829,7 +5898,9 @@ int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) {
code = stbJoinOptAddFuncToScanNode("_vgid", pScan);
}
tagScanSetExecutionMode(pScan);
if (TSDB_CODE_SUCCESS == code) {
code = tagScanSetExecutionMode(pScan);
}
if (code) {
nodesDestroyList(pTags);
@ -5912,15 +5983,16 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh
}
SNodeList* pCols = NULL;
nodesCollectColumnsFromNode(pJoin->pFullOnCond, NULL, COLLECT_COL_TYPE_ALL, &pCols);
code = nodesCollectColumnsFromNode(pJoin->pFullOnCond, NULL, COLLECT_COL_TYPE_ALL, &pCols);
FOREACH(pNode, pCols) {
code = createColumnByRewriteExpr(pNode, &pJoin->node.pTargets);
if (code) {
break;
if (TSDB_CODE_SUCCESS == code) {
FOREACH(pNode, pCols) {
code = createColumnByRewriteExpr(pNode, &pJoin->node.pTargets);
if (code) {
break;
}
}
}
nodesDestroyList(pCols);
if (TSDB_CODE_SUCCESS == code) {
@ -6121,10 +6193,16 @@ static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* p
}
SJoinLogicNode* pHJoin = (SJoinLogicNode*)pPrev;
nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 0));
nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 2));
nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 1));
nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 3));
code = nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 0));
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 2));
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 1));
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 3));
}
if (TSDB_CODE_SUCCESS == code) {
code = nodesListStrictAppend(pDynCtrl->node.pChildren, (SNode*)pPrev);
@ -6189,7 +6267,7 @@ static int32_t stbJoinOptRewriteStableJoin(SOptimizeContext* pCxt, SLogicNode* p
}
static int32_t stableJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, stbJoinOptShouldBeOptimized);
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, stbJoinOptShouldBeOptimized, NULL);
if (NULL == pNode) {
return TSDB_CODE_SUCCESS;
}
@ -6197,7 +6275,7 @@ static int32_t stableJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicS
return stbJoinOptRewriteStableJoin(pCxt, pNode, pLogicSubplan);
}
static bool grpJoinOptShouldBeOptimized(SLogicNode* pNode) {
static bool grpJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) {
return false;
}
@ -6283,10 +6361,10 @@ static int32_t grpJoinOptPartByTags(SLogicNode* pNode) {
code = nodesCloneList(pJoin->pLeftEqNodes, &pNewList);
if (TSDB_CODE_SUCCESS == code) {
if (leftChild) {
nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList);
code = nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList);
leftChild = false;
} else {
nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList);
code = nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList);
}
}
if (TSDB_CODE_SUCCESS != code) {
@ -6312,7 +6390,7 @@ static int32_t grpJoinOptRewriteGroupJoin(SOptimizeContext* pCxt, SLogicNode* pN
static int32_t groupJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, grpJoinOptShouldBeOptimized);
SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, grpJoinOptShouldBeOptimized, NULL);
if (NULL == pNode) {
return TSDB_CODE_SUCCESS;
}
@ -6320,7 +6398,7 @@ static int32_t groupJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSu
return grpJoinOptRewriteGroupJoin(pCxt, pNode, pLogicSubplan);
}
static bool partColOptShouldBeOptimized(SLogicNode* pNode) {
static bool partColOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_PARTITION == nodeType(pNode)) {
SPartitionLogicNode* pPartition = (SPartitionLogicNode*)pNode;
if (keysHasCol(pPartition->pPartitionKeys)) return true;
@ -6397,7 +6475,7 @@ static int32_t partitionColsOpt(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
SNode* node;
int32_t code = TSDB_CODE_SUCCESS;
SPartitionLogicNode* pNode =
(SPartitionLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, partColOptShouldBeOptimized);
(SPartitionLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, partColOptShouldBeOptimized, NULL);
if (NULL == pNode) return TSDB_CODE_SUCCESS;
SLogicNode* pRootNode = getLogicNodeRootNode((SLogicNode*)pNode);
@ -6469,7 +6547,7 @@ static int32_t partitionColsOpt(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
return code;
}
static bool tsmaOptMayBeOptimized(SLogicNode* pNode) {
static bool tsmaOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode)) {
SNode* pTmpNode;
SNodeList* pFuncs = NULL;
@ -6603,7 +6681,8 @@ static bool tsmaOptCheckValidInterval(int64_t tsmaInterval, int8_t unit, const S
return validInterval && validSliding && validOffset;
}
static bool tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList* pQueryFuncs, SArray* pTsmaScanCols) {
static int32_t tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList* pQueryFuncs, SArray* pTsmaScanCols,
bool* pIsValid) {
SNode* pNode;
bool failed = false, found = false;
@ -6632,14 +6711,17 @@ static bool tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList* pQ
continue;
}
found = true;
taosArrayPush(pTsmaScanCols, &i);
if (NULL == taosArrayPush(pTsmaScanCols, &i)) {
return TSDB_CODE_OUT_OF_MEMORY;
}
break;
}
if (failed || !found) {
break;
}
}
return found;
*pIsValid = found;
return TSDB_CODE_SUCCESS;
}
typedef struct STsmaOptTagCheckCtx {
@ -6683,6 +6765,7 @@ static int32_t tsmaOptFilterTsmas(STSMAOptCtx* pTsmaOptCtx) {
STSMAOptUsefulTsma usefulTsma = {
.pTsma = NULL, .scanRange = {.skey = TSKEY_MIN, .ekey = TSKEY_MAX}, .precision = pTsmaOptCtx->precision};
SArray* pTsmaScanCols = NULL;
int32_t code = 0;
for (int32_t i = 0; i < pTsmaOptCtx->pTsmas->size; ++i) {
if (!pTsmaScanCols) {
@ -6703,18 +6786,24 @@ static int32_t tsmaOptFilterTsmas(STSMAOptCtx* pTsmaOptCtx) {
continue;
}
// filter with funcs, note that tsma funcs has been sorted by funcId and ColId
if (!tsmaOptCheckValidFuncs(pTsma->pFuncs, pTsmaOptCtx->pAggFuncs, pTsmaScanCols)) {
continue;
}
bool valid = false;
int32_t code = tsmaOptCheckValidFuncs(pTsma->pFuncs, pTsmaOptCtx->pAggFuncs, pTsmaScanCols, &valid);
if (TSDB_CODE_SUCCESS != code) break;
if (!valid) continue;
if (!tsmaOptCheckTags(pTsmaOptCtx, pTsma)) continue;
usefulTsma.pTsma = pTsma;
usefulTsma.pTsmaScanCols = pTsmaScanCols;
pTsmaScanCols = NULL;
taosArrayPush(pTsmaOptCtx->pUsefulTsmas, &usefulTsma);
if (NULL == taosArrayPush(pTsmaOptCtx->pUsefulTsmas, &usefulTsma)) {
if (pTsmaScanCols) {
taosArrayDestroy(pTsmaScanCols);
}
return TSDB_CODE_OUT_OF_MEMORY;
}
}
if (pTsmaScanCols) taosArrayDestroy(pTsmaScanCols);
return TSDB_CODE_SUCCESS;
return code;
}
static int32_t tsmaInfoCompWithIntervalDesc(const void* pLeft, const void* pRight) {
@ -6763,9 +6852,10 @@ static const STSMAOptUsefulTsma* tsmaOptFindUsefulTsma(const SArray* pUsefulTsma
return NULL;
}
static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pScanRange) {
static int32_t tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pScanRange) {
bool needTailWindow = false;
bool isSkeyAlignedWithTsma = true, isEkeyAlignedWithTsma = true;
int32_t code = 0;
int64_t winSkey = TSKEY_MIN, winEkey = TSKEY_MAX;
int64_t startOfSkeyFirstWin = pScanRange->skey, endOfSkeyFirstWin;
int64_t startOfEkeyFirstWin = pScanRange->ekey, endOfEkeyFirstWin;
@ -6775,7 +6865,7 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc
const STSMAOptUsefulTsma* pUsefulTsma = taosArrayGet(pTsmaOptCtx->pUsefulTsmas, 0);
const STableTSMAInfo* pTsma = pUsefulTsma->pTsma;
if (pScanRange->ekey <= pScanRange->skey) return;
if (pScanRange->ekey <= pScanRange->skey) return code;
if (!pInterval) {
tsmaOptInitIntervalFromTsma(&interval, pTsma, pTsmaOptCtx->precision);
@ -6815,7 +6905,8 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc
STSMAOptUsefulTsma usefulTsma = {.pTsma = pTsmaFound ? pTsmaFound->pTsma : NULL,
.scanRange = scanRange,
.pTsmaScanCols = pTsmaFound ? pTsmaFound->pTsmaScanCols : NULL};
taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma);
if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma))
return TSDB_CODE_OUT_OF_MEMORY;
}
// the main tsma
@ -6827,7 +6918,8 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc
}
STSMAOptUsefulTsma usefulTsma = {
.pTsma = pTsma, .scanRange = scanRange, .pTsmaScanCols = pUsefulTsma->pTsmaScanCols};
taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma);
if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma))
return TSDB_CODE_OUT_OF_MEMORY;
}
// add tail tsma if possible
@ -6840,8 +6932,10 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc
STSMAOptUsefulTsma usefulTsma = {.pTsma = pTsmaFound ? pTsmaFound->pTsma : NULL,
.scanRange = scanRange,
.pTsmaScanCols = pTsmaFound ? pTsmaFound->pTsmaScanCols : NULL};
taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma);
if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma))
return TSDB_CODE_OUT_OF_MEMORY;
}
return code;
}
int32_t tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNodeList* pAggFuncs, SNodeList** ppList) {
@ -7039,11 +7133,9 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew
tstrncpy(pPkTsCol->tableName, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
tstrncpy(pPkTsCol->tableAlias, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
pPkTsCol->tableId = pTsma->targetTbUid;
SNode* pNew = NULL;
code = nodesCloneNode((SNode*)pPkTsCol, &pNew);
if (TSDB_CODE_SUCCESS == code) {
code = nodesListMakeStrictAppend(&pNewScan->pScanCols, pNew);
}
code = nodesListMakeStrictAppend(&pNewScan->pScanCols, (SNode*)pPkTsCol);
} else if (pPkTsCol){
nodesDestroyNode((SNode*)pPkTsCol);
}
if (code == TSDB_CODE_SUCCESS) {
pNewScan->stableId = pTsma->pTsma->destTbUid;
@ -7059,17 +7151,23 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew
if (code == TSDB_CODE_SUCCESS) {
code = tsmaOptRewriteNodeList(pNewScan->pGroupTags, pTsmaOptCtx, pTsma, true, true);
}
pTsmaOptCtx->pScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD;
if (pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo && pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo->size > 0) {
for (int32_t i = 0; i < taosArrayGetSize(pTsmaOptCtx->pScan->pTsmas); ++i) {
STableTSMAInfo* pTsmaInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmas, i);
if (pTsmaInfo == pTsma->pTsma) {
const SVgroupsInfo* pVgpsInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo, i);
taosMemoryFreeClear(pNewScan->pVgroupList);
int32_t len = sizeof(int32_t) + sizeof(SVgroupInfo) * pVgpsInfo->numOfVgroups;
pNewScan->pVgroupList = taosMemoryCalloc(1, len);
memcpy(pNewScan->pVgroupList, pVgpsInfo, len);
break;
if (TSDB_CODE_SUCCESS == code) {
pTsmaOptCtx->pScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD;
if (pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo && pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo->size > 0) {
for (int32_t i = 0; i < taosArrayGetSize(pTsmaOptCtx->pScan->pTsmas); ++i) {
STableTSMAInfo* pTsmaInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmas, i);
if (pTsmaInfo == pTsma->pTsma) {
const SVgroupsInfo* pVgpsInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo, i);
taosMemoryFreeClear(pNewScan->pVgroupList);
int32_t len = sizeof(int32_t) + sizeof(SVgroupInfo) * pVgpsInfo->numOfVgroups;
pNewScan->pVgroupList = taosMemoryCalloc(1, len);
if (!pNewScan->pVgroupList) {
code = TSDB_CODE_OUT_OF_MEMORY;
break;
}
memcpy(pNewScan->pVgroupList, pVgpsInfo, len);
break;
}
}
}
}
@ -7099,7 +7197,7 @@ static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut)
int64_t pointer = (int64_t)pWStart;
char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer);
taosCreateMD5Hash(name, len);
(void)taosCreateMD5Hash(name, len);
strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
pWStart->node.resType.precision = precision;
@ -7157,7 +7255,7 @@ static int32_t tsmaOptRewriteParent(STSMAOptCtx* pTsmaOptCtx, SLogicNode* pParen
pScanListCell = pScanListCell->pNext;
pColNode->node.resType = pPartial->node.resType;
// currently we assume that the first parameter must be the scan column
nodesListErase(pMerge->pParameterList, pMerge->pParameterList->pHead);
(void)nodesListErase(pMerge->pParameterList, pMerge->pParameterList->pHead);
SNode* pNew = NULL;
code = nodesCloneNode((SNode*)pColNode, &pNew);
if (TSDB_CODE_SUCCESS == code) {
@ -7266,7 +7364,7 @@ static bool tsmaOptIsUsingTsmas(STSMAOptCtx* pCtx) {
static int32_t tsmaOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
int32_t code = 0;
STSMAOptCtx tsmaOptCtx = {0};
SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tsmaOptMayBeOptimized);
SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tsmaOptMayBeOptimized, NULL);
if (!pScan) return code;
SLogicNode* pRootNode = getLogicNodeRootNode((SLogicNode*)pScan);
@ -7281,17 +7379,17 @@ static int32_t tsmaOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan
// 2. sort useful tsmas with interval
taosArraySort(tsmaOptCtx.pUsefulTsmas, tsmaInfoCompWithIntervalDesc);
// 3. split windows
tsmaOptSplitWindows(&tsmaOptCtx, tsmaOptCtx.pTimeRange);
if (tsmaOptIsUsingTsmas(&tsmaOptCtx)) {
code = tsmaOptSplitWindows(&tsmaOptCtx, tsmaOptCtx.pTimeRange);
if (TSDB_CODE_SUCCESS == code && tsmaOptIsUsingTsmas(&tsmaOptCtx)) {
// 4. create logic plan
code = tsmaOptGeneratePlan(&tsmaOptCtx);
if (TSDB_CODE_SUCCESS == code) {
for (int32_t i = 0; i < 2; i++) {
for (int32_t i = 0; i < 2 && (TSDB_CODE_SUCCESS == code); i++) {
SLogicSubplan* pSubplan = tsmaOptCtx.generatedSubPlans[i];
if (!pSubplan) continue;
pSubplan->subplanType = SUBPLAN_TYPE_SCAN;
nodesListMakeAppend(tsmaOptCtx.ppParentTsmaSubplans, (SNode*)pSubplan);
code = nodesListMakeAppend(tsmaOptCtx.ppParentTsmaSubplans, (SNode*)pSubplan);
}
pCxt->optimized = true;
}
@ -7334,24 +7432,31 @@ static const SOptimizeRule optimizeRuleSet[] = {
static const int32_t optimizeRuleNum = (sizeof(optimizeRuleSet) / sizeof(SOptimizeRule));
static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
static int32_t dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
int32_t code = 0;
if (!tsQueryPlannerTrace) {
return;
return code;
}
char* pStr = NULL;
nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
if (NULL == pRuleName) {
qDebugL("before optimize, JsonPlan: %s", pStr);
} else {
qDebugL("apply optimize %s rule, JsonPlan: %s", pRuleName, pStr);
code = nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
if (TSDB_CODE_SUCCESS == code) {
if (NULL == pRuleName) {
qDebugL("before optimize, JsonPlan: %s", pStr);
} else {
qDebugL("apply optimize %s rule, JsonPlan: %s", pRuleName, pStr);
}
taosMemoryFree(pStr);
}
taosMemoryFree(pStr);
return code;
}
static int32_t applyOptimizeRule(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan) {
SOptimizeContext cxt = {.pPlanCxt = pCxt, .optimized = false};
bool optimized = false;
dumpLogicSubplan(NULL, pLogicSubplan);
int32_t code = dumpLogicSubplan(NULL, pLogicSubplan);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
do {
optimized = false;
for (int32_t i = 0; i < optimizeRuleNum; ++i) {
@ -7362,12 +7467,12 @@ static int32_t applyOptimizeRule(SPlanContext* pCxt, SLogicSubplan* pLogicSubpla
}
if (cxt.optimized) {
optimized = true;
dumpLogicSubplan(optimizeRuleSet[i].pName, pLogicSubplan);
code = dumpLogicSubplan(optimizeRuleSet[i].pName, pLogicSubplan);
break;
}
}
} while (optimized);
return TSDB_CODE_SUCCESS;
} while (optimized && (TSDB_CODE_SUCCESS == code));
return code;
}
int32_t optimizeLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan) {

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

@ -115,7 +115,9 @@ static int32_t putSlotToHashImpl(int16_t dataBlockId, int16_t slotId, const char
SSlotIndex* pIndex = taosHashGet(pHash, pName, len);
if (NULL != pIndex) {
SSlotIdInfo info = {.slotId = slotId, .set = false};
taosArrayPush(pIndex->pSlotIdsInfo, &info);
if (NULL == taosArrayPush(pIndex->pSlotIdsInfo, &info)) {
return TSDB_CODE_OUT_OF_MEMORY;
}
return TSDB_CODE_SUCCESS;
}
@ -124,7 +126,9 @@ static int32_t putSlotToHashImpl(int16_t dataBlockId, int16_t slotId, const char
return TSDB_CODE_OUT_OF_MEMORY;
}
SSlotIdInfo info = {.slotId = slotId, .set = false};
taosArrayPush(index.pSlotIdsInfo, &info);
if (NULL == taosArrayPush(index.pSlotIdsInfo, &info)) {
return TSDB_CODE_OUT_OF_MEMORY;
}
return taosHashPut(pHash, pName, len, &index, sizeof(SSlotIndex));
}
@ -159,7 +163,7 @@ static int32_t buildDataBlockSlots(SPhysiPlanContext* pCxt, SNodeList* pList, SD
SNode* pNode = NULL;
FOREACH(pNode, pList) {
char name[TSDB_COL_FNAME_LEN + 1] = {0};
getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN);
(void)getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN);
code = nodesListStrictAppend(pDataBlockDesc->pSlots, createSlotDesc(pCxt, name, pNode, slotId, true, false));
if (TSDB_CODE_SUCCESS == code) {
code = putSlotToHash(name, pDataBlockDesc->dataBlockId, slotId, pNode, pHash);
@ -736,7 +740,7 @@ static int32_t createSystemTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan*
} else {
pScan->mgmtEpSet = pCxt->pPlanCxt->mgmtEpSet;
}
tNameGetFullDbName(&pScanLogicNode->tableName, pSubplan->dbFName);
(void)tNameGetFullDbName(&pScanLogicNode->tableName, pSubplan->dbFName);
pCxt->hasSysScan = true;
return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode);
@ -2921,14 +2925,17 @@ static void setExplainInfo(SPlanContext* pCxt, SQueryPlan* pPlan) {
}
}
static void setExecNodeList(SPhysiPlanContext* pCxt, SArray* pExecNodeList) {
static int32_t setExecNodeList(SPhysiPlanContext* pCxt, SArray* pExecNodeList) {
int32_t code = 0;
if (NULL == pExecNodeList) {
return;
return code;
}
if (pCxt->hasSysScan || !pCxt->hasScan) {
SQueryNodeLoad node = {.addr = {.nodeId = MNODE_HANDLE, .epSet = pCxt->pPlanCxt->mgmtEpSet}, .load = 0};
taosArrayPush(pExecNodeList, &node);
if (NULL == taosArrayPush(pExecNodeList, &node))
code = TSDB_CODE_OUT_OF_MEMORY;
}
return code;
}
int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan, SArray* pExecNodeList) {
@ -2945,7 +2952,7 @@ int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryP
int32_t code = doCreatePhysiPlan(&cxt, pLogicPlan, pPlan);
if (TSDB_CODE_SUCCESS == code) {
setExplainInfo(pCxt, *pPlan);
setExecNodeList(&cxt, pExecNodeList);
code = setExecNodeList(&cxt, pExecNodeList);
}
destoryPhysiPlanContext(&cxt);

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

@ -432,7 +432,7 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr
int64_t pointer = (int64_t)pWStart;
char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer);
taosCreateMD5Hash(name, len);
(void)taosCreateMD5Hash(name, len);
strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
pWStart->node.resType.precision = precision;
@ -464,7 +464,7 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) {
int64_t pointer = (int64_t)pWEnd;
char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWEnd->functionName, pointer);
taosCreateMD5Hash(name, len);
(void)taosCreateMD5Hash(name, len);
strncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
code = fmGetFuncInfo(pWEnd, NULL, 0);
@ -1108,7 +1108,7 @@ static int32_t stbSplAggNodeCreateMerge(SSplitContext* pCtx, SStableSplitInfo* p
code = createColumnByRewriteExprs(extraAggFuncs, &pChildAgg->pTargets);
}
if (code == TSDB_CODE_SUCCESS) {
nodesListAppendList(((SAggLogicNode*)pChildAgg)->pAggFuncs, extraAggFuncs);
code = nodesListAppendList(((SAggLogicNode*)pChildAgg)->pAggFuncs, extraAggFuncs);
extraAggFuncs = NULL;
}
@ -1781,7 +1781,7 @@ static int32_t unionSplitSubplan(SSplitContext* pCxt, SLogicSubplan* pUnionSubpl
if (TSDB_CODE_SUCCESS == code) {
if (NULL != pSubplanChildren) {
if (pSubplanChildren->length > 0) {
nodesListMakeStrictAppendList(&pUnionSubplan->pChildren, pSubplanChildren);
code = nodesListMakeStrictAppendList(&pUnionSubplan->pChildren, pSubplanChildren);
} else {
nodesDestroyList(pSubplanChildren);
}
@ -2053,25 +2053,32 @@ static const SSplitRule splitRuleSet[] = {
static const int32_t splitRuleNum = (sizeof(splitRuleSet) / sizeof(SSplitRule));
static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
static int32_t dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) {
int32_t code = 0;
if (!tsQueryPlannerTrace) {
return;
return code;
}
char* pStr = NULL;
nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
if (NULL == pRuleName) {
qDebugL("before split, JsonPlan: %s", pStr);
} else {
qDebugL("apply split %s rule, JsonPlan: %s", pRuleName, pStr);
code = nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL);
if (TSDB_CODE_SUCCESS == code) {
if (NULL == pRuleName) {
qDebugL("before split, JsonPlan: %s", pStr);
} else {
qDebugL("apply split %s rule, JsonPlan: %s", pRuleName, pStr);
}
taosMemoryFree(pStr);
}
taosMemoryFree(pStr);
return code;
}
static int32_t applySplitRule(SPlanContext* pCxt, SLogicSubplan* pSubplan) {
SSplitContext cxt = {
.pPlanCxt = pCxt, .queryId = pSubplan->id.queryId, .groupId = pSubplan->id.groupId + 1, .split = false};
bool split = false;
dumpLogicSubplan(NULL, pSubplan);
int32_t code = dumpLogicSubplan(NULL, pSubplan);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
do {
split = false;
for (int32_t i = 0; i < splitRuleNum; ++i) {
@ -2082,7 +2089,10 @@ static int32_t applySplitRule(SPlanContext* pCxt, SLogicSubplan* pSubplan) {
}
if (cxt.split) {
split = true;
dumpLogicSubplan(splitRuleSet[i].pName, pSubplan);
code = dumpLogicSubplan(splitRuleSet[i].pName, pSubplan);
if (TSDB_CODE_SUCCESS != code) {
return code;
}
}
}
} while (split);

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

@ -35,7 +35,7 @@ static char* getUsageErrFormat(int32_t errCode) {
int32_t generateUsageErrMsg(char* pBuf, int32_t len, int32_t errCode, ...) {
va_list vArgList;
va_start(vArgList, errCode);
vsnprintf(pBuf, len, getUsageErrFormat(errCode), vArgList);
(void)vsnprintf(pBuf, len, getUsageErrFormat(errCode), vArgList);
va_end(vArgList);
return errCode;
}
@ -525,17 +525,26 @@ int32_t collectTableAliasFromNodes(SNode* pNode, SSHashObj** ppRes) {
}
}
tSimpleHashPut(*ppRes, pCol->tableAlias, strlen(pCol->tableAlias), NULL, 0);
}
FOREACH(pNode, pCurr->pChildren) {
code = collectTableAliasFromNodes(pNode, ppRes);
code = tSimpleHashPut(*ppRes, pCol->tableAlias, strlen(pCol->tableAlias), NULL, 0);
if (TSDB_CODE_SUCCESS != code) {
return code;
break;
}
}
return TSDB_CODE_SUCCESS;
if (TSDB_CODE_SUCCESS == code) {
FOREACH(pNode, pCurr->pChildren) {
code = collectTableAliasFromNodes(pNode, ppRes);
if (TSDB_CODE_SUCCESS != code) {
break;
}
}
}
if (TSDB_CODE_SUCCESS != code) {
tSimpleHashCleanup(*ppRes);
*ppRes = NULL;
}
return code;
}
bool isPartTagAgg(SAggLogicNode* pAgg) {
@ -622,7 +631,7 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) {
if (TSDB_CODE_SUCCESS == code) {
char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc);
taosCreateMD5Hash(name, len);
(void)taosCreateMD5Hash(name, len);
strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
}
}

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

@ -19,22 +19,28 @@
#include "scalar.h"
#include "tglobal.h"
static void debugPrintNode(SNode* pNode) {
static int32_t debugPrintNode(SNode* pNode) {
char* pStr = NULL;
nodesNodeToString(pNode, false, &pStr, NULL);
printf("%s\n", pStr);
taosMemoryFree(pStr);
return;
int32_t code = nodesNodeToString(pNode, false, &pStr, NULL);
if (TSDB_CODE_SUCCESS == code) {
(void)printf("%s\n", pStr);
taosMemoryFree(pStr);
}
return code;
}
static void dumpQueryPlan(SQueryPlan* pPlan) {
static int32_t dumpQueryPlan(SQueryPlan* pPlan) {
int32_t code = 0;
if (!tsQueryPlannerTrace) {
return;
return code;
}
char* pStr = NULL;
nodesNodeToString((SNode*)pPlan, false, &pStr, NULL);
planDebugL("QID:0x%" PRIx64 " Query Plan, JsonPlan: %s", pPlan->queryId, pStr);
taosMemoryFree(pStr);
code = nodesNodeToString((SNode*)pPlan, false, &pStr, NULL);
if (TSDB_CODE_SUCCESS == code) {
planDebugL("QID:0x%" PRIx64 " Query Plan, JsonPlan: %s", pPlan->queryId, pStr);
taosMemoryFree(pStr);
}
return code;
}
int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNodeList) {
@ -61,9 +67,9 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo
code = validateQueryPlan(pCxt, *pPlan);
}
if (TSDB_CODE_SUCCESS == code) {
dumpQueryPlan(*pPlan);
code = dumpQueryPlan(*pPlan);
}
nodesReleaseAllocator(pCxt->allocatorId);
(void)nodesReleaseAllocator(pCxt->allocatorId);
nodesDestroyNode((SNode*)pLogicSubplan);
nodesDestroyNode((SNode*)pLogicPlan);

8
source/libs/planner/test/planStmtTest.cpp
View File

@ -146,8 +146,8 @@ TEST_F(PlanStmtTest, basic) {
{
prepare("SELECT * FROM t1 WHERE c1 = ? AND c2 = ?");
TAOS_MULTI_BIND* pBindParams = createBindParams(2);
buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_INT);
buildStringParam(pBindParams, 1, "abc", TSDB_DATA_TYPE_VARCHAR, strlen("abc"));
(void)buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_INT);
(void)buildStringParam(pBindParams, 1, "abc", TSDB_DATA_TYPE_VARCHAR, strlen("abc"));
bindParams(pBindParams, -1);
exec();
destoryBindParams(pBindParams, 2);
@ -156,8 +156,8 @@ TEST_F(PlanStmtTest, basic) {
{
prepare("SELECT MAX(?), MAX(?) FROM t1");
TAOS_MULTI_BIND* pBindParams = createBindParams(2);
buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_TINYINT);
buildIntegerParam(pBindParams, 1, 20, TSDB_DATA_TYPE_INT);
(void)buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_TINYINT);
(void)buildIntegerParam(pBindParams, 1, 20, TSDB_DATA_TYPE_INT);
bindParams(pBindParams, -1);
exec();
destoryBindParams(pBindParams, 2);

9
source/libs/planner/test/planTestMain.cpp
View File

@ -27,13 +27,12 @@
class PlannerEnv : public testing::Environment {
public:
virtual void SetUp() {
// TODO(smj) : How to handle return value of fmFuncMgtInit
(void)fmFuncMgtInit();
ASSERT_EQ(TSDB_CODE_SUCCESS, fmFuncMgtInit());
initMetaDataEnv();
generateMetaData();
initLog(TD_TMP_DIR_PATH "td");
initCfg();
nodesInitAllocatorSet();
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesInitAllocatorSet());
}
virtual void TearDown() {
@ -66,7 +65,7 @@ class PlannerEnv : public testing::Environment {
tsAsyncLog = 0;
taosRemoveDir(path);
taosMkDir(path);
ASSERT_EQ(TSDB_CODE_SUCCESS,taosMkDir(path));
tstrncpy(tsLogDir, path, PATH_MAX);
if (taosInitLog("taoslog", 1) != 0) {
std::cout << "failed to init log file" << std::endl;
@ -117,7 +116,7 @@ static void parseArg(int argc, char* argv[]) {
}
int main(int argc, char* argv[]) {
testing::AddGlobalTestEnvironment(new PlannerEnv());
(void)testing::AddGlobalTestEnvironment(new PlannerEnv());
testing::InitGoogleTest(&argc, argv);
parseArg(argc, argv);
return RUN_ALL_TESTS();

14
source/libs/planner/test/planTestUtil.cpp
View File

@ -131,8 +131,8 @@ class PlannerTestBaseImpl {
void runImpl(const string& sql, int32_t queryPolicy) {
int64_t allocatorId = 0;
if (g_useNodeAllocator) {
nodesCreateAllocator(sqlNo_, 32 * 1024, &allocatorId);
nodesAcquireAllocator(allocatorId);
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesCreateAllocator(sqlNo_, 32 * 1024, &allocatorId));
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesAcquireAllocator(allocatorId));
}
reset();
@ -166,12 +166,12 @@ class PlannerTestBaseImpl {
dump(g_dumpModule);
} catch (...) {
dump(DUMP_MODULE_ALL);
nodesReleaseAllocator(allocatorId);
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesReleaseAllocator(allocatorId));
nodesDestroyAllocator(allocatorId);
throw;
}
nodesReleaseAllocator(allocatorId);
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesReleaseAllocator(allocatorId));
nodesDestroyAllocator(allocatorId);
}
@ -448,12 +448,12 @@ class PlannerTestBaseImpl {
pCmdMsg->msgLen = tSerializeSMCreateSmaReq(NULL, 0, pStmt->pReq);
pCmdMsg->pMsg = taosMemoryMalloc(pCmdMsg->msgLen);
if (!pCmdMsg->pMsg) FAIL();
tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq);
ASSERT_EQ(TSDB_CODE_SUCCESS, tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq));
((SQuery*)pQuery)->pCmdMsg = pCmdMsg;
tDeserializeSMCreateSmaReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req);
ASSERT_EQ(TSDB_CODE_SUCCESS, tDeserializeSMCreateSmaReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req));
g_mockCatalogService->createSmaIndex(&req);
nodesStringToNode(req.ast, &pCxt->pAstRoot);
ASSERT_EQ(TSDB_CODE_SUCCESS, nodesStringToNode(req.ast, &pCxt->pAstRoot));
pCxt->deleteMark = req.deleteMark;
tFreeSMCreateSmaReq(&req);
nodesDestroyNode(pQuery->pRoot);