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

[td-10564] Refactor the sql function parse procedure.

This commit is contained in:
Haojun Liao 2021-11-08 10:32:06 +08:00
parent f80294fc3d
commit b4bba7ee0d
8 changed files with 25 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/libs/function/function.h
View File

@ -182,8 +182,8 @@ typedef struct tExprNode {
struct SVariant *pVal; // value node struct SVariant *pVal; // value node
struct {// function node struct {// function node
char *functionName; char functionName[FUNCTIONS_NAME_MAX_LENGTH];
int32_t functionId; // int32_t functionId;
int32_t num; int32_t num;
// Note that the attribute of pChild is not the parameter of function, it is the columns that involved in the // Note that the attribute of pChild is not the parameter of function, it is the columns that involved in the

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

@ -175,7 +175,7 @@ typedef struct SSourceParam {
int32_t num; int32_t num;
} SSourceParam; } SSourceParam;
SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, int16_t functionId, SSourceParam* pSource, SSchema* pResSchema, int16_t interSize); SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, const char* funcName, SSourceParam* pSource, SSchema* pResSchema, int16_t interSize);
int32_t copyExprInfoList(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy); int32_t copyExprInfoList(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
STableMetaInfo* getMetaInfo(SQueryStmtInfo* pQueryInfo, int32_t tableIndex); STableMetaInfo* getMetaInfo(SQueryStmtInfo* pQueryInfo, int32_t tableIndex);

2
source/libs/executor/src/executorimpl.c
View File

@ -162,7 +162,7 @@ int64_t genQueryId(void) {
static int32_t getExprFunctionId(SExprInfo *pExprInfo) { static int32_t getExprFunctionId(SExprInfo *pExprInfo) {
assert(pExprInfo != NULL && pExprInfo->pExpr != NULL && pExprInfo->pExpr->nodeType == TEXPR_UNARYEXPR_NODE); assert(pExprInfo != NULL && pExprInfo->pExpr != NULL && pExprInfo->pExpr->nodeType == TEXPR_UNARYEXPR_NODE);
return pExprInfo->pExpr->_function.functionId; return 0;
} }
static void getNextTimeWindow(SQueryAttr* pQueryAttr, STimeWindow* tw) { static void getNextTimeWindow(SQueryAttr* pQueryAttr, STimeWindow* tw) {

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

@ -4810,7 +4810,7 @@ SAggFunctionInfo aggFunc[35] = {{
}, },
{ {
// 33 // 33
"_block_dist", // return table id and the corresponding tags for join match and subscribe "block_dist", // return table id and the corresponding tags for join match and subscribe
FUNCTION_TYPE_AGG, FUNCTION_TYPE_AGG,
FUNCTION_BLKINFO, FUNCTION_BLKINFO,
FUNCTION_BLKINFO, FUNCTION_BLKINFO,

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

@ -544,7 +544,7 @@ struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, co
pFillCol[i].col.colId = pExprInfo->base.resSchema.colId; pFillCol[i].col.colId = pExprInfo->base.resSchema.colId;
pFillCol[i].tagIndex = -2; pFillCol[i].tagIndex = -2;
pFillCol[i].flag = pExprInfo->base.pColumns->flag; // always be the normal column for table query pFillCol[i].flag = pExprInfo->base.pColumns->flag; // always be the normal column for table query
pFillCol[i].functionId = pExprInfo->pExpr->_function.functionId; // pFillCol[i].functionId = pExprInfo->pExpr->_function.functionId;
pFillCol[i].fillVal.i = fillVal[i]; pFillCol[i].fillVal.i = fillVal[i];
offset += pExprInfo->base.resSchema.bytes; offset += pExprInfo->base.resSchema.bytes;

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

@ -43,7 +43,7 @@ void addExprInfoParam(SSqlExpr* pExpr, char* argument, int32_t type, int32
void cleanupFieldInfo(SFieldInfo* pFieldInfo); void cleanupFieldInfo(SFieldInfo* pFieldInfo);
STableComInfo getTableInfo(const STableMeta* pTableMeta); STableComInfo getTableInfo(const STableMeta* pTableMeta);
SArray* extractFunctionIdList(SArray* pExprInfoList); SArray *extractFunctionList(SArray* pExprInfoList);
#ifdef __cplusplus #ifdef __cplusplus
} }

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

@ -1709,9 +1709,9 @@ void setResultColName(char* name, tSqlExprItem* pItem, SToken* pToken, SToken* f
} }
SExprInfo* doAddOneExprInfo(SQueryStmtInfo* pQueryInfo, int16_t functionId, SSourceParam* pSourceParam, int32_t outputIndex, SExprInfo* doAddOneExprInfo(SQueryStmtInfo* pQueryInfo, const char* funcName, SSourceParam* pSourceParam, int32_t outputIndex,
STableMetaInfo* pTableMetaInfo, SSchema* pResultSchema, int32_t interSize, const char* token, bool finalResult) { STableMetaInfo* pTableMetaInfo, SSchema* pResultSchema, int32_t interSize, const char* token, bool finalResult) {
SExprInfo* pExpr = createExprInfo(pTableMetaInfo, functionId, pSourceParam, pResultSchema, interSize); SExprInfo* pExpr = createExprInfo(pTableMetaInfo, funcName, pSourceParam, pResultSchema, interSize);
SArray* pExprList = getCurrentExprList(pQueryInfo); SArray* pExprList = getCurrentExprList(pQueryInfo);
addExprInfo(pExprList, outputIndex, pExpr, pQueryInfo->exprListLevelIndex); addExprInfo(pExprList, outputIndex, pExpr, pQueryInfo->exprListLevelIndex);
@ -2978,8 +2978,8 @@ int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQuerySt
(*pExpr)->nodeType = TEXPR_FUNCTION_NODE; (*pExpr)->nodeType = TEXPR_FUNCTION_NODE;
(*pExpr)->_function.pChild = p; (*pExpr)->_function.pChild = p;
(*pExpr)->_function.functionId = functionId; // (*pExpr)->_function.functionId = functionId;
(*pExpr)->_function.functionName = strndup(pSqlExpr->Expr.operand.z, pSqlExpr->Expr.operand.n); strncpy((*pExpr)->_function.functionName, pSqlExpr->Expr.operand.z, pSqlExpr->Expr.operand.n);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} else { } else {
printf("agg function found, %s\n", pSqlExpr->exprToken.z); printf("agg function found, %s\n", pSqlExpr->exprToken.z);
@ -3826,7 +3826,7 @@ int32_t qParserValidateSqlNode(struct SCatalog* pCatalog, SSqlInfo* pInfo, SQuer
validateSqlNode(p, pQueryInfo, &buf); validateSqlNode(p, pQueryInfo, &buf);
} }
SArray* functionList = extractFunctionIdList(pQueryInfo->exprList[0]); SArray* functionList = extractFunctionList(pQueryInfo->exprList[0]);
extractFunctionDesc(functionList, &pQueryInfo->info); extractFunctionDesc(functionList, &pQueryInfo->info);
if ((code = checkForInvalidExpr(pQueryInfo, &buf)) != TSDB_CODE_SUCCESS) { if ((code = checkForInvalidExpr(pQueryInfo, &buf)) != TSDB_CODE_SUCCESS) {

27
source/libs/parser/src/queryInfoUtil.c
View File

@ -61,7 +61,7 @@ SSchema* getTableTagSchema(const STableMeta* pTableMeta) {
return getOneColumnSchema(pTableMeta, getTableInfo(pTableMeta).numOfColumns); return getOneColumnSchema(pTableMeta, getTableInfo(pTableMeta).numOfColumns);
} }
static tExprNode* createFunctionExprNode(int32_t functionId, struct SSourceParam *pParam) {//SSchema* pSchema, tExprNode* pColumnNode, int32_t numOfCols) { static tExprNode* createFunctionExprNode(const char* funcName, struct SSourceParam *pParam) {
tExprNode** p = malloc(pParam->num * POINTER_BYTES); tExprNode** p = malloc(pParam->num * POINTER_BYTES);
if (pParam->pColumnList != NULL) { if (pParam->pColumnList != NULL) {
@ -81,7 +81,7 @@ static tExprNode* createFunctionExprNode(int32_t functionId, struct SSourceParam
tExprNode* pNode = calloc(1, sizeof(tExprNode)); tExprNode* pNode = calloc(1, sizeof(tExprNode));
pNode->nodeType = TEXPR_FUNCTION_NODE; pNode->nodeType = TEXPR_FUNCTION_NODE;
pNode->_function.functionId = functionId; tstrncpy(pNode->_function.functionName, funcName, tListLen(pNode->_function.functionName));
pNode->_function.pChild = p; pNode->_function.pChild = p;
pNode->_function.num = pParam->num; pNode->_function.num = pParam->num;
@ -101,7 +101,7 @@ SExprInfo* createBinaryExprInfo(tExprNode* pNode, SSchema* pResSchema) {
return pExpr; return pExpr;
} }
SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, int16_t functionId, SSourceParam* pSourceParam, SSchema* pResSchema, int16_t interSize) { SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, const char* funcName, SSourceParam* pSourceParam, SSchema* pResSchema, int16_t interSize) {
SExprInfo* pExpr = calloc(1, sizeof(SExprInfo)); SExprInfo* pExpr = calloc(1, sizeof(SExprInfo));
if (pExpr == NULL) { if (pExpr == NULL) {
return NULL; return NULL;
@ -120,7 +120,7 @@ SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, int16_t functionId, SS
memcpy(&p->resSchema, pResSchema, sizeof(SSchema)); memcpy(&p->resSchema, pResSchema, sizeof(SSchema));
if (pSourceParam->pExprNodeList != NULL) { if (pSourceParam->pExprNodeList != NULL) {
pExpr->pExpr = createFunctionExprNode(functionId, pSourceParam); pExpr->pExpr = createFunctionExprNode(funcName, pSourceParam);
return pExpr; return pExpr;
} }
@ -131,16 +131,16 @@ SExprInfo* createExprInfo(STableMetaInfo* pTableMetaInfo, int16_t functionId, SS
SSchema* s = getTbnameColumnSchema(); SSchema* s = getTbnameColumnSchema();
setColumn(p->pColumns, uid, pTableMetaInfo->aliasName, TSDB_COL_TAG, s); setColumn(p->pColumns, uid, pTableMetaInfo->aliasName, TSDB_COL_TAG, s);
pExpr->pExpr = createFunctionExprNode(functionId, pSourceParam); pExpr->pExpr = createFunctionExprNode(funcName, pSourceParam);
} else if (TSDB_COL_IS_UD_COL(pCol->flag) || functionId == FUNCTION_BLKINFO) { } else if (TSDB_COL_IS_UD_COL(pCol->flag) || strcmp(funcName, "block_dist") == 0) {
setColumn(p->pColumns, uid, pTableMetaInfo->aliasName, TSDB_COL_UDC, pResSchema); setColumn(p->pColumns, uid, pTableMetaInfo->aliasName, TSDB_COL_UDC, pResSchema);
pExpr->pExpr = createFunctionExprNode(functionId, pSourceParam); pExpr->pExpr = createFunctionExprNode(funcName, pSourceParam);
} else { } else {
for(int32_t i = 0; i < pSourceParam->num; ++i) { for(int32_t i = 0; i < pSourceParam->num; ++i) {
SColumn* c = taosArrayGetP(pSourceParam->pColumnList, i); SColumn* c = taosArrayGetP(pSourceParam->pColumnList, i);
p->pColumns[i] = *c; p->pColumns[i] = *c;
} }
pExpr->pExpr = createFunctionExprNode(functionId, pSourceParam); pExpr->pExpr = createFunctionExprNode(funcName, pSourceParam);
} }
return pExpr; return pExpr;
@ -156,14 +156,13 @@ void addExprInfo(SArray* pExprList, int32_t index, SExprInfo* pExprInfo, int32_t
taosArrayInsert(pExprList, index, &pExprInfo); taosArrayInsert(pExprList, index, &pExprInfo);
} }
printf("add function, id:%d, level:%d, total:%ld\n", pExprInfo->pExpr->_function.functionId, level, taosArrayGetSize(pExprList)); printf("add function, id:%s, level:%d, total:%ld\n", pExprInfo->pExpr->_function.functionName, level, taosArrayGetSize(pExprList));
} }
void updateExprInfo(SExprInfo* pExprInfo, int16_t functionId, int32_t colId, int16_t srcColumnIndex, int16_t resType, int16_t resSize) { void updateExprInfo(SExprInfo* pExprInfo, int16_t functionId, int32_t colId, int16_t srcColumnIndex, int16_t resType, int16_t resSize) {
assert(pExprInfo != NULL); assert(pExprInfo != NULL);
SSqlExpr* pse = &pExprInfo->base; SSqlExpr* pse = &pExprInfo->base;
pExprInfo->pExpr->_function.functionId = functionId;
assert(0); assert(0);
pse->resSchema.type = resType; pse->resSchema.type = resType;
@ -172,7 +171,7 @@ void updateExprInfo(SExprInfo* pExprInfo, int16_t functionId, int32_t colId, int
SExprInfo* getExprInfo(SQueryStmtInfo* pQueryInfo, int32_t index) { SExprInfo* getExprInfo(SQueryStmtInfo* pQueryInfo, int32_t index) {
assert(pQueryInfo != NULL && pQueryInfo->exprList && index >= 0); assert(pQueryInfo != NULL && pQueryInfo->exprList && index >= 0);
return taosArrayGetP(pQueryInfo->exprList, index); return taosArrayGetP(getCurrentExprList(pQueryInfo->exprList), index);
} }
void destroyExprInfo(SExprInfo* pExprInfo) { void destroyExprInfo(SExprInfo* pExprInfo) {
@ -214,7 +213,7 @@ void addExprInfoParam(SSqlExpr* pExpr, char* argument, int32_t type, int32_t byt
int32_t getExprFunctionId(SExprInfo *pExprInfo) { int32_t getExprFunctionId(SExprInfo *pExprInfo) {
assert(pExprInfo != NULL && pExprInfo->pExpr != NULL && pExprInfo->pExpr->nodeType == TEXPR_UNARYEXPR_NODE); assert(pExprInfo != NULL && pExprInfo->pExpr != NULL && pExprInfo->pExpr->nodeType == TEXPR_UNARYEXPR_NODE);
return pExprInfo->pExpr->_function.functionId; return 0;
} }
void assignExprInfo(SExprInfo* dst, const SExprInfo* src) { void assignExprInfo(SExprInfo* dst, const SExprInfo* src) {
@ -310,14 +309,14 @@ int32_t getResRowLength(SArray* pExprList) {
return size; return size;
} }
SArray* extractFunctionIdList(SArray* pExprInfoList) { SArray* extractFunctionList(SArray* pExprInfoList) {
assert(pExprInfoList != NULL); assert(pExprInfoList != NULL);
size_t len = taosArrayGetSize(pExprInfoList); size_t len = taosArrayGetSize(pExprInfoList);
SArray* p = taosArrayInit(len, sizeof(int32_t)); SArray* p = taosArrayInit(len, sizeof(int32_t));
for(int32_t i = 0; i < len; ++i) { for(int32_t i = 0; i < len; ++i) {
SExprInfo* pExprInfo = taosArrayGetP(pExprInfoList, i); SExprInfo* pExprInfo = taosArrayGetP(pExprInfoList, i);
taosArrayPush(p, &pExprInfo->pExpr->_function.functionId); taosArrayPush(p, &pExprInfo->pExpr->_function.functionName);
} }
return p; return p;