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

[td-10564] fix bug in parser nested function

This commit is contained in:
Haojun Liao 2021-11-08 17:14:01 +08:00
parent 20406dd43b
commit f4bafd6f4c
5 changed files with 569 additions and 545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/common/taosmsg.h
View File

@ -203,15 +203,14 @@ enum _mgmt_table {
#define TSDB_COL_NORMAL 0x0u // the normal column of the table #define TSDB_COL_NORMAL 0x0u // the normal column of the table
#define TSDB_COL_TAG 0x1u // the tag column type #define TSDB_COL_TAG 0x1u // the tag column type
#define TSDB_COL_UDC 0x2u // the user specified normal string column, it is a dummy column #define TSDB_COL_UDC 0x2u // the user specified normal string column, it is a dummy column
#define TSDB_COL_TMP 0x3u // internal column generated by the previous operators #define TSDB_COL_TMP 0x4u // internal column generated by the previous operators
#define TSDB_COL_NULL 0x4u // the column filter NULL or not #define TSDB_COL_NULL 0x8u // the column filter NULL or not
#define TSDB_COL_IS_TAG(f) (((f&(~(TSDB_COL_NULL)))&TSDB_COL_TAG) != 0) #define TSDB_COL_IS_TAG(f) (((f&(~(TSDB_COL_NULL)))&TSDB_COL_TAG) != 0)
#define TSDB_COL_IS_NORMAL_COL(f) ((f&(~(TSDB_COL_NULL))) == TSDB_COL_NORMAL) #define TSDB_COL_IS_NORMAL_COL(f) ((f&(~(TSDB_COL_NULL))) == TSDB_COL_NORMAL)
#define TSDB_COL_IS_UD_COL(f) ((f&(~(TSDB_COL_NULL))) == TSDB_COL_UDC) #define TSDB_COL_IS_UD_COL(f) ((f&(~(TSDB_COL_NULL))) == TSDB_COL_UDC)
#define TSDB_COL_REQ_NULL(f) (((f)&TSDB_COL_NULL) != 0) #define TSDB_COL_REQ_NULL(f) (((f)&TSDB_COL_NULL) != 0)
extern char *taosMsg[]; extern char *taosMsg[];
#pragma pack(push, 1) #pragma pack(push, 1)

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

@ -30,7 +30,7 @@ SSchema *getTableTagSchema(const STableMeta* pTableMeta);
SArray *getCurrentExprList(SQueryStmtInfo* pQueryInfo); SArray *getCurrentExprList(SQueryStmtInfo* pQueryInfo);
size_t getNumOfExprs(SQueryStmtInfo* pQueryInfo); size_t getNumOfExprs(SQueryStmtInfo* pQueryInfo);
SExprInfo* createBinaryExprInfo(struct tExprNode* pNode, SSchema* pResSchema, const char* funcName); SExprInfo* createBinaryExprInfo(struct tExprNode* pNode, SSchema* pResSchema);
void addExprInfo(SArray* pExprList, int32_t index, SExprInfo* pExprInfo, int32_t level); void addExprInfo(SArray* pExprList, int32_t index, SExprInfo* pExprInfo, int32_t level);
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);

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

@ -1711,11 +1711,11 @@ void setResultColName(char* name, tSqlExprItem* pItem, SToken* pToken, SToken* f
SExprInfo* doAddOneExprInfo(SQueryStmtInfo* pQueryInfo, const char* funcName, 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, funcName, pSourceParam, pResultSchema, interSize); SExprInfo* pExpr = createExprInfo(pTableMetaInfo, funcName, pSourceParam, pResultSchema, interSize);
tstrncpy(pExpr->base.token, token, sizeof(pExpr->base.token));
SArray* pExprList = getCurrentExprList(pQueryInfo); SArray* pExprList = getCurrentExprList(pQueryInfo);
addExprInfo(pExprList, outputIndex, pExpr, pQueryInfo->exprListLevelIndex); addExprInfo(pExprList, outputIndex, pExpr, pQueryInfo->exprListLevelIndex);
tstrncpy(pExpr->base.token, token, sizeof(pExpr->base.token));
uint64_t uid = pTableMetaInfo->pTableMeta->uid; uint64_t uid = pTableMetaInfo->pTableMeta->uid;
if (pSourceParam->pColumnList != NULL) { if (pSourceParam->pColumnList != NULL) {
@ -1789,7 +1789,7 @@ static int32_t checkForAliasName(SMsgBuf* pMsgBuf, char* aliasName) {
} }
static int32_t validateComplexExpr(tSqlExpr* pExpr, SQueryStmtInfo* pQueryInfo, SArray* pColList, int32_t* type, SMsgBuf* pMsgBuf); static int32_t validateComplexExpr(tSqlExpr* pExpr, SQueryStmtInfo* pQueryInfo, SArray* pColList, int32_t* type, SMsgBuf* pMsgBuf);
static int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQueryStmtInfo* pQueryInfo, SArray* pCols, SMsgBuf* pMsgBuf); static int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQueryStmtInfo* pQueryInfo, SArray* pCols, bool* keepTableCols, SMsgBuf* pMsgBuf);
static int64_t getTickPerSecond(SVariant* pVariant, int32_t precision, int64_t* tickPerSec, SMsgBuf *pMsgBuf) { static int64_t getTickPerSecond(SVariant* pVariant, int32_t precision, int64_t* tickPerSec, SMsgBuf *pMsgBuf) {
const char* msg10 = "derivative duration should be greater than 1 Second"; const char* msg10 = "derivative duration should be greater than 1 Second";
@ -2385,7 +2385,7 @@ int32_t addAggExprAndResColumn(SQueryStmtInfo* pQueryInfo, int32_t colIndex, tSq
SSourceParam param = {0}; SSourceParam param = {0};
addIntoSourceParam(&param, NULL, &c); addIntoSourceParam(&param, NULL, &c);
/*SExprInfo* pExpr = */doAddOneExprInfo(pQueryInfo, FUNCTION_TID_TAG, &param, 0, pTableMetaInfo, &result, 0, s.name, true); /*SExprInfo* pExpr = */doAddOneExprInfo(pQueryInfo, "tbid", &param, 0, pTableMetaInfo, &result, 0, s.name, true);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -2522,7 +2522,9 @@ int32_t addAggExprAndResColumn(SQueryStmtInfo* pQueryInfo, int32_t colIndex, tSq
SSourceParam param = {0}; SSourceParam param = {0};
addIntoSourceParam(&param, NULL, &c); addIntoSourceParam(&param, NULL, &c);
doAddOneExprInfo(pQueryInfo, functionId, &param, colIndex, pTableMetaInfo, &s, resInfo.intermediateBytes, token, finalResult); char funcName[FUNCTIONS_NAME_MAX_LENGTH] = {0};
extractFunctionName(funcName, pItem);
doAddOneExprInfo(pQueryInfo, funcName, &param, colIndex, pTableMetaInfo, &s, resInfo.intermediateBytes, token, finalResult);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
} }
@ -2764,7 +2766,7 @@ static int32_t handleTbnameProjection(SQueryStmtInfo* pQueryInfo, tSqlExprItem*
SSourceParam param = {0}; SSourceParam param = {0};
addIntoSourceParam(&param, NULL, &c); addIntoSourceParam(&param, NULL, &c);
doAddOneExprInfo(pQueryInfo, "project_tab", &param, startPos, pTableMetaInfo, &colSchema, 0, rawName, true); doAddOneExprInfo(pQueryInfo, "project_tag", &param, startPos, pTableMetaInfo, &colSchema, 0, rawName, true);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
@ -2931,21 +2933,49 @@ int32_t validateComplexExpr(tSqlExpr * pExpr, SQueryStmtInfo* pQueryInfo, SArray
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQueryStmtInfo* pQueryInfo, SArray* pCols, SMsgBuf* pMsgBuf) { static uint64_t findTmpSourceColumnInNextLevel(SQueryStmtInfo* pQueryInfo, tExprNode *pExpr) {
// This function must be a aggregate function, so it must be in the next level
pQueryInfo->exprListLevelIndex += 1;
// set the input column data byte and type.
SArray* pExprList = getCurrentExprList(pQueryInfo);
bool found = false;
uint64_t uid = 0;
size_t size = taosArrayGetSize(pExprList);
for (int32_t i = 0; i < size; ++i) {
SExprInfo* p1 = taosArrayGetP(pExprList, i);
if (strcmp((pExpr)->pSchema->name, p1->base.resSchema.name) == 0) {
memcpy((pExpr)->pSchema, &p1->base.resSchema, sizeof(SSchema));
found = true;
uid = p1->base.pColumns->uid;
break;
}
}
assert(found);
pQueryInfo->exprListLevelIndex -= 1;
return uid;
}
int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQueryStmtInfo* pQueryInfo, SArray* pCols, bool* keepTableCols, SMsgBuf* pMsgBuf) {
tExprNode* pLeft = NULL; tExprNode* pLeft = NULL;
tExprNode* pRight= NULL; tExprNode* pRight= NULL;
SColumnIndex index = COLUMN_INDEX_INITIALIZER; SColumnIndex index = COLUMN_INDEX_INITIALIZER;
if (pSqlExpr->type == SQL_NODE_EXPR) { if (pSqlExpr->type == SQL_NODE_EXPR) {
if (pSqlExpr->pLeft != NULL) { if (pSqlExpr->pLeft != NULL) {
int32_t ret = sqlExprToExprNode(&pLeft, pSqlExpr->pLeft, pQueryInfo, pCols, pMsgBuf); int32_t ret = sqlExprToExprNode(&pLeft, pSqlExpr->pLeft, pQueryInfo, pCols, keepTableCols, pMsgBuf);
if (ret != TSDB_CODE_SUCCESS) { if (ret != TSDB_CODE_SUCCESS) {
return ret; return ret;
} }
} }
if (pSqlExpr->pRight != NULL) { if (pSqlExpr->pRight != NULL) {
int32_t ret = sqlExprToExprNode(&pRight, pSqlExpr->pRight, pQueryInfo, pCols, pMsgBuf); int32_t ret = sqlExprToExprNode(&pRight, pSqlExpr->pRight, pQueryInfo, pCols, keepTableCols, pMsgBuf);
if (ret != TSDB_CODE_SUCCESS) { if (ret != TSDB_CODE_SUCCESS) {
tExprTreeDestroy(pLeft, NULL); tExprTreeDestroy(pLeft, NULL);
return ret; return ret;
@ -2960,27 +2990,32 @@ int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQuerySt
SArray* pParamList = pSqlExpr->Expr.paramList; SArray* pParamList = pSqlExpr->Expr.paramList;
if (pParamList != NULL && taosArrayGetSize(pParamList) > 0) { if (pParamList != NULL && taosArrayGetSize(pParamList) > 0) {
size_t num = taosArrayGetSize(pParamList);
tExprNode** p = calloc(num, POINTER_BYTES);
pQueryInfo->exprListLevelIndex += 1;
for(int32_t i = 0; i < num; ++i) {
tSqlExprItem* pItem = taosArrayGet(pParamList, i);
int32_t code = sqlExprToExprNode(&p[i], pItem->pNode, pQueryInfo, pCols, pMsgBuf);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
}
pQueryInfo->exprListLevelIndex -= 1;
bool scalar = false; bool scalar = false;
int32_t functionId = qIsBuiltinFunction(pSqlExpr->Expr.operand.z, pSqlExpr->Expr.operand.n, &scalar); int32_t functionId = qIsBuiltinFunction(pSqlExpr->Expr.operand.z, pSqlExpr->Expr.operand.n, &scalar);
if (functionId < 0) { if (functionId < 0) {
return TSDB_CODE_TSC_INVALID_OPERATION; return TSDB_CODE_TSC_INVALID_OPERATION;
} }
if (!scalar) {
pQueryInfo->exprListLevelIndex += 1;
}
*keepTableCols = false;
size_t num = taosArrayGetSize(pParamList);
tExprNode** p = calloc(num, POINTER_BYTES);
pQueryInfo->exprListLevelIndex += 1;
for(int32_t i = 0; i < num; ++i) {
tSqlExprItem* pItem = taosArrayGet(pParamList, i);
int32_t code = sqlExprToExprNode(&p[i], pItem->pNode, pQueryInfo, pCols, keepTableCols, pMsgBuf);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
}
pQueryInfo->exprListLevelIndex -= 1;
int32_t outputIndex = (int32_t)getNumOfExprs(pQueryInfo); int32_t outputIndex = (int32_t)getNumOfExprs(pQueryInfo);
if (scalar) { if (scalar) {
@ -3000,6 +3035,7 @@ int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQuerySt
return TSDB_CODE_TSC_INVALID_OPERATION; return TSDB_CODE_TSC_INVALID_OPERATION;
} }
pQueryInfo->exprListLevelIndex -= 1;
// convert the aggregate function to be the input data columns for the outer function. // convert the aggregate function to be the input data columns for the outer function.
} }
} }
@ -3035,30 +3071,11 @@ int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQuerySt
(*pExpr)->pSchema = calloc(1, sizeof(SSchema)); (*pExpr)->pSchema = calloc(1, sizeof(SSchema));
strncpy((*pExpr)->pSchema->name, pSqlExpr->exprToken.z, pSqlExpr->exprToken.n); strncpy((*pExpr)->pSchema->name, pSqlExpr->exprToken.z, pSqlExpr->exprToken.n);
// set the input column data byte and type. uint64_t uid = findTmpSourceColumnInNextLevel(pQueryInfo, *pExpr);
SArray* pExprList = getCurrentExprList(pQueryInfo); if (!(*keepTableCols)) {
size_t size = taosArrayGetSize(pExprList); SColumn c = createColumn(uid, NULL, TSDB_COL_TMP, (*pExpr)->pSchema);
bool found = false;
uint64_t uid = 0;
for (int32_t i = 0; i < size; ++i) {
SExprInfo* p1 = taosArrayGetP(pExprList, i);
if (strcmp((*pExpr)->pSchema->name, p1->base.resSchema.name) == 0) {
memcpy((*pExpr)->pSchema, &p1->base.resSchema, sizeof(SSchema));
found = true;
uid = p1->base.pColumns->uid;
break;
}
}
assert(found);
if (pCols != NULL) { // record the involved columns
SColumn c = createColumn(uid, NULL, TSDB_COL_TMP, (*pExpr)->pSchema);
taosArrayPush(pCols, &c); taosArrayPush(pCols, &c);
} }
} else if (pSqlExpr->type == SQL_NODE_TABLE_COLUMN) { // column name, normal column expression } else if (pSqlExpr->type == SQL_NODE_TABLE_COLUMN) { // column name, normal column expression
int32_t ret = getColumnIndexByName(&pSqlExpr->columnName, pQueryInfo, &index, pMsgBuf); int32_t ret = getColumnIndexByName(&pSqlExpr->columnName, pQueryInfo, &index, pMsgBuf);
if (ret != TSDB_CODE_SUCCESS) { if (ret != TSDB_CODE_SUCCESS) {
@ -3071,11 +3088,16 @@ int32_t sqlExprToExprNode(tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQuerySt
*pExpr = calloc(1, sizeof(tExprNode)); *pExpr = calloc(1, sizeof(tExprNode));
(*pExpr)->nodeType = TEXPR_COL_NODE; (*pExpr)->nodeType = TEXPR_COL_NODE;
(*pExpr)->pSchema = calloc(1, sizeof(SSchema));
(*pExpr)->pSchema = calloc(1, sizeof(SSchema));
SSchema* pSchema = getOneColumnSchema(pTableMeta, index.columnIndex); SSchema* pSchema = getOneColumnSchema(pTableMeta, index.columnIndex);
*(*pExpr)->pSchema = *pSchema; *(*pExpr)->pSchema = *pSchema;
if (*keepTableCols) {
SColumn c = createColumn(pTableMeta->uid, pTableMetaInfo->aliasName, index.type, (*pExpr)->pSchema);
taosArrayPush(pCols, &c);
}
columnListInsert(pQueryInfo->colList, pTableMeta->uid, pSchema, TSDB_COL_NORMAL); columnListInsert(pQueryInfo->colList, pTableMeta->uid, pSchema, TSDB_COL_NORMAL);
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} else if (pSqlExpr->tokenId == TK_SET) { } else if (pSqlExpr->tokenId == TK_SET) {
@ -3160,23 +3182,22 @@ static int32_t multiColumnListInsert(SQueryStmtInfo* pQueryInfo, SArray* pColumn
static int32_t addScalarExprAndResColumn(SQueryStmtInfo* pQueryInfo, int32_t exprIndex, tSqlExprItem* pItem, SMsgBuf* pMsgBuf) { static int32_t addScalarExprAndResColumn(SQueryStmtInfo* pQueryInfo, int32_t exprIndex, tSqlExprItem* pItem, SMsgBuf* pMsgBuf) {
SArray* pColumnList = taosArrayInit(4, sizeof(SColumn)); SArray* pColumnList = taosArrayInit(4, sizeof(SColumn));
SSchema s = createSchema(TSDB_DATA_TYPE_DOUBLE, sizeof(double), getNewResColId(), ""); SSchema s = createSchema(TSDB_DATA_TYPE_DOUBLE, sizeof(double), getNewResColId(), "");
assert(taosArrayGetSize(pColumnList) == 0);
tExprNode* pNode = NULL; tExprNode* pNode = NULL;
int32_t ret = sqlExprToExprNode(&pNode, pItem->pNode, pQueryInfo, pColumnList, pMsgBuf); bool keepTableCols = true;
int32_t ret = sqlExprToExprNode(&pNode, pItem->pNode, pQueryInfo, pColumnList, &keepTableCols, pMsgBuf);
if (ret != TSDB_CODE_SUCCESS) { if (ret != TSDB_CODE_SUCCESS) {
tExprTreeDestroy(pNode, NULL); tExprTreeDestroy(pNode, NULL);
return buildInvalidOperationMsg(pMsgBuf, "invalid expression in select clause"); return buildInvalidOperationMsg(pMsgBuf, "invalid expression in select clause");
} }
SExprInfo* pExpr = createBinaryExprInfo(pNode, &s, "project"); SExprInfo* pExpr = createBinaryExprInfo(pNode, &s);
setTokenAndResColumnName(pItem, pExpr->base.resSchema.name, pExpr->base.token, TSDB_COL_NAME_LEN);
SArray* pExprList = getCurrentExprList(pQueryInfo); SArray* pExprList = getCurrentExprList(pQueryInfo);
addExprInfo(pExprList, exprIndex, pExpr, pQueryInfo->exprListLevelIndex); addExprInfo(pExprList, exprIndex, pExpr, pQueryInfo->exprListLevelIndex);
setTokenAndResColumnName(pItem, pExpr->base.resSchema.name, pExpr->base.token, TSDB_COL_NAME_LEN);
// extract columns according to the tExprNode tree // extract columns according to the tExprNode tree
size_t num = taosArrayGetSize(pColumnList); size_t num = taosArrayGetSize(pColumnList);
pExpr->base.pColumns = calloc(num, sizeof(SColumn)); pExpr->base.pColumns = calloc(num, sizeof(SColumn));

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

@ -95,7 +95,7 @@ static tExprNode* createFunctionExprNode(const char* funcName, struct SSourcePar
return pNode; return pNode;
} }
SExprInfo* createBinaryExprInfo(tExprNode* pNode, SSchema* pResSchema, const char* funcName) { SExprInfo* createBinaryExprInfo(tExprNode* pNode, SSchema* pResSchema) {
assert(pNode != NULL && pResSchema != NULL); assert(pNode != NULL && pResSchema != NULL);
SExprInfo* pExpr = calloc(1, sizeof(SExprInfo)); SExprInfo* pExpr = calloc(1, sizeof(SExprInfo));
@ -104,10 +104,6 @@ SExprInfo* createBinaryExprInfo(tExprNode* pNode, SSchema* pResSchema, const cha
} }
pExpr->pExpr = pNode; pExpr->pExpr = pNode;
char* fName = pExpr->pExpr->_function.functionName;
tstrncpy(fName, funcName, tListLen(pExpr->pExpr->_function.functionName));
memcpy(&pExpr->base.resSchema, pResSchema, sizeof(SSchema)); memcpy(&pExpr->base.resSchema, pResSchema, sizeof(SSchema));
return pExpr; return pExpr;
} }
@ -167,7 +163,11 @@ void addExprInfo(SArray* pExprList, int32_t index, SExprInfo* pExprInfo, int32_t
taosArrayInsert(pExprList, index, &pExprInfo); taosArrayInsert(pExprList, index, &pExprInfo);
} }
printf("add function: %s, level:%d, total:%ld\n", pExprInfo->pExpr->_function.functionName, level, taosArrayGetSize(pExprList)); if (pExprInfo->pExpr->nodeType == TEXPR_FUNCTION_NODE) {
printf("add function: %s, level:%d, total:%ld\n", pExprInfo->pExpr->_function.functionName, level, taosArrayGetSize(pExprList));
} else {
printf("add operator: %s, level:%d, total:%ld\n", pExprInfo->base.resSchema.name, 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) {

970
source/libs/parser/test/parserTests.cpp
View File

@ -103,246 +103,246 @@ void sqlCheck(const char* sql, bool valid) {
} // namespace } // namespace
//TEST(testCase, validateAST_test) { TEST(testCase, validateAST_test) {
// SSqlInfo info1 = doGenerateAST("select a a1111, a+b + 22, tbname from `t.1abc` where ts<now+2h and `col` < 20 + 99"); SSqlInfo info1 = doGenerateAST("select a a1111, a+b + 22, tbname from `t.1abc` where ts<now+2h and `col` < 20 + 99");
// ASSERT_EQ(info1.valid, true); ASSERT_EQ(info1.valid, true);
//
// char msg[128] = {0}; char msg[128] = {0};
// SMsgBuf buf; SMsgBuf buf;
// buf.len = 128; buf.len = 128;
// buf.buf = msg; buf.buf = msg;
//
// SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0); SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
//
// SMetaReq req = {0}; SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// SQueryStmtInfo* pQueryInfo = createQueryInfo(); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); setTableMetaInfo(pQueryInfo, &req);
//
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
//
// SArray* pExprList = pQueryInfo->exprList[0]; SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 3); ASSERT_EQ(taosArrayGetSize(pExprList), 3);
//
// SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0); SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.pColumns->uid, 110); ASSERT_EQ(p1->base.pColumns->uid, 110);
// ASSERT_EQ(p1->base.numOfParams, 0); ASSERT_EQ(p1->base.numOfParams, 0);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_INT); ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_INT);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "a1111"); ASSERT_STRCASEEQ(p1->base.resSchema.name, "a1111");
// ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.a"); ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.a");
// ASSERT_EQ(p1->base.pColumns->info.colId, 1); ASSERT_EQ(p1->base.pColumns->info.colId, 1);
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL); ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL);
// ASSERT_STRCASEEQ(p1->base.token, "a1111"); ASSERT_STRCASEEQ(p1->base.token, "a1111");
//
// ASSERT_EQ(taosArrayGetSize(pExprList), 3); ASSERT_EQ(taosArrayGetSize(pExprList), 3);
//
// SExprInfo* p2 = (SExprInfo*)taosArrayGetP(pExprList, 1); SExprInfo* p2 = (SExprInfo*)taosArrayGetP(pExprList, 1);
// ASSERT_EQ(p2->base.pColumns->uid, 110); ASSERT_EQ(p2->base.pColumns->uid, 110);
// ASSERT_EQ(p2->base.numOfParams, 1); // it is the serialized binary string of expression. ASSERT_EQ(p2->base.numOfParams, 1); // it is the serialized binary string of expression.
// ASSERT_EQ(p2->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE); ASSERT_EQ(p2->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE);
// ASSERT_STRCASEEQ(p2->base.resSchema.name, "a+b + 22"); ASSERT_STRCASEEQ(p2->base.resSchema.name, "a+b + 22");
//
// // ASSERT_STRCASEEQ(p2->base.colInfo.name, "t.1abc.a"); // ASSERT_STRCASEEQ(p2->base.colInfo.name, "t.1abc.a");
// // ASSERT_EQ(p1->base.colInfo.colId, 1); // ASSERT_EQ(p1->base.colInfo.colId, 1);
// // ASSERT_EQ(p1->base.colInfo.flag, TSDB_COL_NORMAL); // ASSERT_EQ(p1->base.colInfo.flag, TSDB_COL_NORMAL);
// ASSERT_STRCASEEQ(p2->base.token, "a+b + 22"); ASSERT_STRCASEEQ(p2->base.token, "a+b + 22");
//
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3); ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3);
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 3); ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 3);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
//} }
//
//TEST(testCase, function_Test) { TEST(testCase, function_Test) {
// SSqlInfo info1 = doGenerateAST("select count(a) from `t.1abc`"); SSqlInfo info1 = doGenerateAST("select count(a) from `t.1abc`");
// ASSERT_EQ(info1.valid, true); ASSERT_EQ(info1.valid, true);
//
// char msg[128] = {0}; char msg[128] = {0};
// SMsgBuf buf; SMsgBuf buf;
// buf.len = 128; buf.len = 128;
// buf.buf = msg; buf.buf = msg;
//
// SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0); SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
//
// SMetaReq req = {0}; SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// SQueryStmtInfo* pQueryInfo = createQueryInfo(); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); setTableMetaInfo(pQueryInfo, &req);
//
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
//
// SArray* pExprList = pQueryInfo->exprList[0]; SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 1); ASSERT_EQ(taosArrayGetSize(pExprList), 1);
//
// SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0); SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.pColumns->uid, 110); ASSERT_EQ(p1->base.pColumns->uid, 110);
// ASSERT_EQ(p1->base.numOfParams, 0); ASSERT_EQ(p1->base.numOfParams, 0);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BIGINT); ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BIGINT);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "count(a)"); ASSERT_STRCASEEQ(p1->base.resSchema.name, "count(a)");
// ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.a"); ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.a");
// ASSERT_EQ(p1->base.pColumns->info.colId, 1); ASSERT_EQ(p1->base.pColumns->info.colId, 1);
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL); ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL);
// ASSERT_STRCASEEQ(p1->base.token, "count(a)"); ASSERT_STRCASEEQ(p1->base.token, "count(a)");
// ASSERT_EQ(p1->base.interBytes, 8); ASSERT_EQ(p1->base.interBytes, 8);
//
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 2); ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 2);
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 1); ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 1);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
//} }
//
//TEST(testCase, function_Test2) { TEST(testCase, function_Test2) {
// SSqlInfo info1 = doGenerateAST("select count(a) abc from `t.1abc`"); SSqlInfo info1 = doGenerateAST("select count(a) abc from `t.1abc`");
// ASSERT_EQ(info1.valid, true); ASSERT_EQ(info1.valid, true);
//
// char msg[128] = {0}; char msg[128] = {0};
// SMsgBuf buf; SMsgBuf buf;
// buf.len = 128; buf.len = 128;
// buf.buf = msg; buf.buf = msg;
//
// SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0); SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
//
// SMetaReq req = {0}; SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// SQueryStmtInfo* pQueryInfo = createQueryInfo(); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); setTableMetaInfo(pQueryInfo, &req);
//
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
//
// SArray* pExprList = pQueryInfo->exprList[0]; SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 1); ASSERT_EQ(taosArrayGetSize(pExprList), 1);
//
// SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0); SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.pColumns->uid, 110); ASSERT_EQ(p1->base.pColumns->uid, 110);
// ASSERT_EQ(p1->base.numOfParams, 0); ASSERT_EQ(p1->base.numOfParams, 0);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BIGINT); ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BIGINT);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "abc"); ASSERT_STRCASEEQ(p1->base.resSchema.name, "abc");
// ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.a"); ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.a");
// ASSERT_EQ(p1->base.pColumns->info.colId, 1); ASSERT_EQ(p1->base.pColumns->info.colId, 1);
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL); ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL);
// ASSERT_STRCASEEQ(p1->base.token, "count(a)"); ASSERT_STRCASEEQ(p1->base.token, "count(a)");
// ASSERT_EQ(p1->base.interBytes, 8); ASSERT_EQ(p1->base.interBytes, 8);
//
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 2); ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 2);
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 1); ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 1);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
//} }
//
//TEST(testCase, function_Test3) { TEST(testCase, function_Test3) {
// SSqlInfo info1 = doGenerateAST("select first(*) from `t.1abc`"); SSqlInfo info1 = doGenerateAST("select first(*) from `t.1abc`");
// ASSERT_EQ(info1.valid, true); ASSERT_EQ(info1.valid, true);
//
// char msg[128] = {0}; char msg[128] = {0};
// SMsgBuf buf; SMsgBuf buf;
// buf.len = 128; buf.len = 128;
// buf.buf = msg; buf.buf = msg;
//
// SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0); SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
//
// SMetaReq req = {0}; SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// SQueryStmtInfo* pQueryInfo = createQueryInfo(); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); setTableMetaInfo(pQueryInfo, &req);
//
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
//
// SArray* pExprList = pQueryInfo->exprList[0]; SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 6); ASSERT_EQ(taosArrayGetSize(pExprList), 6);
//
// SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0); SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.pColumns->uid, 110); ASSERT_EQ(p1->base.pColumns->uid, 110);
// ASSERT_EQ(p1->base.numOfParams, 0); ASSERT_EQ(p1->base.numOfParams, 0);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_TIMESTAMP); ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_TIMESTAMP);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "first(ts)"); ASSERT_STRCASEEQ(p1->base.resSchema.name, "first(ts)");
// ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.ts"); ASSERT_STRCASEEQ(p1->base.pColumns->name, "t.1abc.ts");
// ASSERT_EQ(p1->base.pColumns->info.colId, 0); ASSERT_EQ(p1->base.pColumns->info.colId, 0);
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL); ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL);
// ASSERT_STRCASEEQ(p1->base.token, "first(ts)"); ASSERT_STRCASEEQ(p1->base.token, "first(ts)");
// ASSERT_EQ(p1->base.interBytes, 24); ASSERT_EQ(p1->base.interBytes, 24);
//
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 6); ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 6);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
//} }
//
//TEST(testCase, function_Test4) { TEST(testCase, function_Test4) {
// SSqlInfo info1 = doGenerateAST("select block_dist() as a1 from `t.1abc`"); SSqlInfo info1 = doGenerateAST("select block_dist() as a1 from `t.1abc`");
// ASSERT_EQ(info1.valid, true); ASSERT_EQ(info1.valid, true);
//
// char msg[128] = {0}; char msg[128] = {0};
// SMsgBuf buf; SMsgBuf buf;
// buf.len = 128; buf.len = 128;
// buf.buf = msg; buf.buf = msg;
//
// SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0); SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
//
// SMetaReq req = {0}; SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// SQueryStmtInfo* pQueryInfo = createQueryInfo(); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); setTableMetaInfo(pQueryInfo, &req);
//
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
//
// SArray* pExprList = pQueryInfo->exprList[0]; SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 1); ASSERT_EQ(taosArrayGetSize(pExprList), 1);
//
// SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0); SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.pColumns->uid, 110); ASSERT_EQ(p1->base.pColumns->uid, 110);
// ASSERT_EQ(p1->base.numOfParams, 1); ASSERT_EQ(p1->base.numOfParams, 1);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BINARY); ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BINARY);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "a1"); ASSERT_STRCASEEQ(p1->base.resSchema.name, "a1");
// // ASSERT_STRCASEEQ(p1->base.colInfo.name, "t.1abc.ts"); // ASSERT_STRCASEEQ(p1->base.colInfo.name, "t.1abc.ts");
// // ASSERT_EQ(p1->base.colInfo.colId, 0); // ASSERT_EQ(p1->base.colInfo.colId, 0);
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_UDC); ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_UDC);
// ASSERT_STRCASEEQ(p1->base.token, "block_dist()"); ASSERT_STRCASEEQ(p1->base.token, "block_dist()");
// ASSERT_EQ(p1->base.interBytes, 0); ASSERT_EQ(p1->base.interBytes, 0);
//
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 1); ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 1);
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 1); ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 1);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
//} }
TEST(testCase, function_Test5) { TEST(testCase, function_Test5) {
// todo select concat(concat(a, b), concat(b, a)) from `t.1abc`; // todo select concat(concat(a, b), concat(b, a)) from `t.1abc`;
@ -372,7 +372,7 @@ TEST(testCase, function_Test5) {
ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
SArray* pExprList = pQueryInfo->exprList[0]; SArray* pExprList = pQueryInfo->exprList[0];
ASSERT_EQ(taosArrayGetSize(pExprList), 3); ASSERT_EQ(taosArrayGetSize(pExprList), 1);
SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0); SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
ASSERT_EQ(p1->base.numOfCols, 2); ASSERT_EQ(p1->base.numOfCols, 2);
@ -395,249 +395,253 @@ TEST(testCase, function_Test5) {
destroySqlInfo(&info1); destroySqlInfo(&info1);
} }
//TEST(testCase, function_Test10) { TEST(testCase, function_Test10) {
// sqlCheck("select c from `t.1abc`", true); sqlCheck("select c from `t.1abc`", true);
// sqlCheck("select length(c) from `t.1abc`", true); sqlCheck("select length(c) from `t.1abc`", true);
// sqlCheck("select sum(length(a+b)) from `t.1abc`", true); sqlCheck("select sum(length(a+b)) from `t.1abc`", true);
// sqlCheck("select sum(sum(a+b)) from `t.1abc`", false); sqlCheck("select sum(sum(a+b)) from `t.1abc`", false);
// sqlCheck("select sum(length(a) + length(b)) from `t.1abc`", true); sqlCheck("select sum(length(a) + length(b)) from `t.1abc`", true);
// sqlCheck("select length(sum(a) + sum(b)) + length(sum(a) + sum(b)) from `t.1abc`", true); sqlCheck("select length(sum(a) + sum(b)) + length(sum(a) + sum(b)) from `t.1abc`", true);
// sqlCheck("select sum(length(sum(a))) from `t.1abc`", true); sqlCheck("select sum(length(sum(a))) from `t.1abc`", true);
// sqlCheck("select cov(a, b) from `t.1abc`", true); sqlCheck("select cov(a, b) from `t.1abc`", true);
// // sqlCheck("select concat(concat(a,b), concat(a,b)) from `t.1abc`", true); // sqlCheck("select concat(concat(a,b), concat(a,b)) from `t.1abc`", true);
// // sqlCheck("select length(length(length(a))) from `t.1abc`", true); // sqlCheck("select length(length(length(a))) from `t.1abc`", true);
//} }
//
//TEST(testCase, function_Test6) {
// SSqlInfo info1 = doGenerateAST(
// "select sum(a+b) as a1, first(b*a), count(b+b), count(1), count(42.1) from `t.1abc` interval(10s, 1s)");
// ASSERT_EQ(info1.valid, true);
//
// char msg[128] = {0};
// SMsgBuf buf;
// buf.len = 128;
// buf.buf = msg;
//
// SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0);
//
// SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req);
//
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
// ASSERT_EQ(ret, 0);
//
// SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 5);
//
// SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.pColumns->uid, 110);
// ASSERT_EQ(p1->base.numOfParams, 0);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "a1");
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_TMP);
// ASSERT_STRCASEEQ(p1->base.token, "sum(a+b)");
// ASSERT_EQ(p1->base.interBytes, 16);
// ASSERT_EQ(p1->pExpr->nodeType, TEXPR_FUNCTION_NODE);
// ASSERT_STRCASEEQ(p1->pExpr->_function.functionName, "sum");
// ASSERT_EQ(p1->pExpr->_function.num, 1);
//
// tExprNode* pParam = p1->pExpr->_function.pChild[0];
//
// ASSERT_EQ(pParam->nodeType, TEXPR_COL_NODE);
// ASSERT_STREQ(pParam->pSchema->name, "t.1abc.a+b");
//
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3);
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 5);
//
// SExprInfo* p2 = (SExprInfo*)taosArrayGetP(pExprList, 1);
// ASSERT_EQ(p2->base.pColumns->uid, 110);
// ASSERT_EQ(p2->base.numOfParams, 0);
// ASSERT_EQ(p2->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE);
// ASSERT_STRCASEEQ(p2->base.resSchema.name, "first(b*a)");
//
// ASSERT_EQ(p2->base.pColumns->flag, TSDB_COL_TMP);
// ASSERT_STREQ(p2->base.pColumns->name, "t.1abc.b*a");
//
// ASSERT_STRCASEEQ(p2->base.token, "first(b*a)");
// ASSERT_EQ(p2->base.interBytes, 24);
// ASSERT_EQ(p2->pExpr->nodeType, TEXPR_FUNCTION_NODE);
// ASSERT_STRCASEEQ(p2->pExpr->_function.functionName, "first");
// ASSERT_EQ(p2->pExpr->_function.num, 1);
// ASSERT_EQ(p2->pExpr->_function.pChild[0]->nodeType, TEXPR_COL_NODE);
// ASSERT_STREQ(p2->pExpr->_function.pChild[0]->pSchema->name, "t.1abc.b*a");
//
// destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1);
//}
// TEST(testCase, function_Test7) { TEST(testCase, function_Test6) {
// SSqlInfo info1 = doGenerateAST("select count(a+b),count(1) from `t.1abc` interval(10s, 1s)"); SSqlInfo info1 = doGenerateAST(
// ASSERT_EQ(info1.valid, true); "select sum(a+b) as a1, first(b*a), count(b+b), count(1), count(42.1) from `t.1abc` interval(10s, 1s)");
// ASSERT_EQ(info1.valid, true);
// char msg[128] = {0};
// SMsgBuf buf; char msg[128] = {0};
// buf.len = 128; SMsgBuf buf;
// buf.buf = msg; buf.len = 128;
// buf.buf = msg;
// SSqlNode* pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); SSqlNode* pNode = (SSqlNode*)taosArrayGetP(((SArray*)info1.list), 0);
// ASSERT_EQ(code, 0); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0);
// SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); SMetaReq req = {0};
// ASSERT_EQ(ret, 0); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
// SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req);
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ASSERT_EQ(ret, 0); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
// ASSERT_EQ(ret, 0);
// SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 2); SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 5);
// SExprInfo* p1 = (SExprInfo*) taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.pColumns->uid, 110); SExprInfo* p1 = (SExprInfo*)taosArrayGetP(pExprList, 0);
// ASSERT_EQ(p1->base.numOfParams, 0); ASSERT_EQ(p1->base.pColumns->uid, 110);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BIGINT); ASSERT_EQ(p1->base.numOfParams, 0);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "count(a+b)"); ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE);
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL); ASSERT_STRCASEEQ(p1->base.resSchema.name, "a1");
// ASSERT_STRCASEEQ(p1->base.token, "count(a+b)"); ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_TMP);
// ASSERT_EQ(p1->base.interBytes, 8); ASSERT_STRCASEEQ(p1->base.token, "sum(a+b)");
// ASSERT_EQ(p1->pExpr->nodeType, TEXPR_UNARYEXPR_NODE); ASSERT_EQ(p1->base.interBytes, 16);
// ASSERT_STREQ(p1->pExpr->_function.functionName, "count"); ASSERT_EQ(p1->pExpr->nodeType, TEXPR_FUNCTION_NODE);
// ASSERT_TRUE(p1->pExpr->_node.pRight == NULL); ASSERT_STRCASEEQ(p1->pExpr->_function.functionName, "sum");
// ASSERT_EQ(p1->pExpr->_function.num, 1);
// tExprNode* pParam = p1->pExpr->_node.pLeft;
// tExprNode* pParam = p1->pExpr->_function.pChild[0];
// ASSERT_EQ(pParam->nodeType, TEXPR_BINARYEXPR_NODE);
// ASSERT_EQ(pParam->_node.optr, TSDB_BINARY_OP_ADD); ASSERT_EQ(pParam->nodeType, TEXPR_COL_NODE);
// ASSERT_EQ(pParam->_node.pLeft->nodeType, TEXPR_COL_NODE); ASSERT_STREQ(pParam->pSchema->name, "t.1abc.a+b");
// ASSERT_EQ(pParam->_node.pRight->nodeType, TEXPR_COL_NODE);
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3);
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3); ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 5);
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 2);
// SExprInfo* p2 = (SExprInfo*)taosArrayGetP(pExprList, 1);
// destroyQueryInfo(pQueryInfo); ASSERT_EQ(p2->base.pColumns->uid, 110);
// qParserClearupMetaRequestInfo(&req); ASSERT_EQ(p2->base.numOfParams, 0);
// destroySqlInfo(&info1); ASSERT_EQ(p2->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE);
//} ASSERT_STRCASEEQ(p2->base.resSchema.name, "first(b*a)");
//
// TEST(testCase, function_Test8) { ASSERT_EQ(p2->base.pColumns->flag, TSDB_COL_TMP);
// SSqlInfo info1 = doGenerateAST("select top(a*b / 99, 20) from `t.1abc` interval(10s, 1s)"); ASSERT_STREQ(p2->base.pColumns->name, "t.1abc.b*a");
// ASSERT_EQ(info1.valid, true);
// ASSERT_STRCASEEQ(p2->base.token, "first(b*a)");
// char msg[128] = {0}; ASSERT_EQ(p2->base.interBytes, 24);
// SMsgBuf buf; ASSERT_EQ(p2->pExpr->nodeType, TEXPR_FUNCTION_NODE);
// buf.len = 128; ASSERT_STRCASEEQ(p2->pExpr->_function.functionName, "first");
// buf.buf = msg; ASSERT_EQ(p2->pExpr->_function.num, 1);
// ASSERT_EQ(p2->pExpr->_function.pChild[0]->nodeType, TEXPR_COL_NODE);
// SSqlNode* pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0); ASSERT_STREQ(p2->pExpr->_function.pChild[0]->pSchema->name, "t.1abc.b*a");
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req);
// SMetaReq req = {0}; destroySqlInfo(&info1);
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); }
// ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); TEST(testCase, function_Test7) {
// SSqlInfo info1 = doGenerateAST("select count(a+b),count(1) from `t.1abc` interval(10s, 1s)");
// SQueryStmtInfo* pQueryInfo = createQueryInfo(); ASSERT_EQ(info1.valid, true);
// setTableMetaInfo(pQueryInfo, &req);
// char msg[128] = {0};
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); SMsgBuf buf;
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); buf.len = 128;
// ASSERT_EQ(ret, 0); buf.buf = msg;
//
// SArray* pExprList = pQueryInfo->exprList[0]; SSqlNode* pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0);
// ASSERT_EQ(taosArrayGetSize(pExprList), 2); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0);
// SExprInfo* p1 = (SExprInfo*) taosArrayGetP(pExprList, 1);
// ASSERT_EQ(p1->base.pColumns->uid, 110); SMetaReq req = {0};
// ASSERT_EQ(p1->base.numOfParams, 1); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE); ASSERT_EQ(ret, 0);
// ASSERT_STRCASEEQ(p1->base.resSchema.name, "top(a*b / 99, 20)"); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
// ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_NORMAL);
// ASSERT_STRCASEEQ(p1->base.token, "top(a*b / 99, 20)"); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// ASSERT_EQ(p1->base.interBytes, 16); setTableMetaInfo(pQueryInfo, &req);
//
// ASSERT_EQ(p1->pExpr->nodeType, TEXPR_UNARYEXPR_NODE); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ASSERT_STRCASEEQ(p1->pExpr->_function.functionName, "top"); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
// ASSERT_TRUE(p1->pExpr->_node.pRight == NULL); ASSERT_EQ(ret, 0);
//
// tExprNode* pParam = p1->pExpr->_node.pLeft; SArray* pExprList = pQueryInfo->exprList[0];
// ASSERT_EQ(taosArrayGetSize(pExprList), 2);
// ASSERT_EQ(pParam->nodeType, TEXPR_BINARYEXPR_NODE);
SExprInfo* p1 = (SExprInfo*) taosArrayGetP(pExprList, 0);
ASSERT_EQ(p1->base.pColumns->uid, 110);
ASSERT_EQ(p1->base.numOfParams, 0);
ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_BIGINT);
ASSERT_STRCASEEQ(p1->base.resSchema.name, "count(a+b)");
ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_TMP);
ASSERT_STRCASEEQ(p1->base.token, "count(a+b)");
ASSERT_EQ(p1->base.interBytes, 8);
ASSERT_EQ(p1->pExpr->nodeType, TEXPR_FUNCTION_NODE);
ASSERT_STREQ(p1->pExpr->_function.functionName, "count");
tExprNode* pParam = p1->pExpr->_function.pChild[0];
ASSERT_EQ(pParam->nodeType, TEXPR_COL_NODE);
SExprInfo* p2 = (SExprInfo*) taosArrayGetP(pQueryInfo->exprList[1], 0);
ASSERT_EQ(p2->pExpr->nodeType, TEXPR_BINARYEXPR_NODE);
ASSERT_EQ(p2->pExpr->_node.optr, TSDB_BINARY_OP_ADD);
ASSERT_EQ(p2->pExpr->_node.pLeft->nodeType, TEXPR_COL_NODE);
ASSERT_EQ(p2->pExpr->_node.pRight->nodeType, TEXPR_COL_NODE);
ASSERT_EQ(pParam->pSchema->colId, p2->base.resSchema.colId);
ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3);
ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 2);
destroyQueryInfo(pQueryInfo);
qParserClearupMetaRequestInfo(&req);
destroySqlInfo(&info1);
}
TEST(testCase, function_Test8) {
SSqlInfo info1 = doGenerateAST("select top(a*b / 99, 20) from `t.1abc` interval(10s, 1s)");
ASSERT_EQ(info1.valid, true);
char msg[128] = {0};
SMsgBuf buf;
buf.len = 128;
buf.buf = msg;
SSqlNode* pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0);
int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
ASSERT_EQ(code, 0);
SMetaReq req = {0};
int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
ASSERT_EQ(ret, 0);
ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
SQueryStmtInfo* pQueryInfo = createQueryInfo();
setTableMetaInfo(pQueryInfo, &req);
SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
ASSERT_EQ(ret, 0);
SArray* pExprList = pQueryInfo->exprList[0];
ASSERT_EQ(taosArrayGetSize(pExprList), 2);
SExprInfo* p1 = (SExprInfo*) taosArrayGetP(pExprList, 1);
ASSERT_EQ(p1->base.pColumns->uid, 110);
ASSERT_EQ(p1->base.numOfParams, 1);
ASSERT_EQ(p1->base.resSchema.type, TSDB_DATA_TYPE_DOUBLE);
ASSERT_STRCASEEQ(p1->base.resSchema.name, "top(a*b / 99, 20)");
ASSERT_EQ(p1->base.pColumns->flag, TSDB_COL_TMP);
ASSERT_STRCASEEQ(p1->base.token, "top(a*b / 99, 20)");
ASSERT_EQ(p1->base.interBytes, 16);
ASSERT_EQ(p1->pExpr->nodeType, TEXPR_FUNCTION_NODE);
ASSERT_STRCASEEQ(p1->pExpr->_function.functionName, "top");
ASSERT_TRUE(p1->pExpr->_function.num == 1);
tExprNode* pParam = p1->pExpr->_function.pChild[0];
ASSERT_EQ(pParam->nodeType, TSDB_COL_TMP);
// ASSERT_EQ(pParam->_node.optr, TSDB_BINARY_OP_DIVIDE); // ASSERT_EQ(pParam->_node.optr, TSDB_BINARY_OP_DIVIDE);
// ASSERT_EQ(pParam->_node.pLeft->nodeType, TEXPR_BINARYEXPR_NODE); // ASSERT_EQ(pParam->_node.pLeft->nodeType, TEXPR_BINARYEXPR_NODE);
// ASSERT_EQ(pParam->_node.pRight->nodeType, TEXPR_VALUE_NODE); // ASSERT_EQ(pParam->_node.pRight->nodeType, TEXPR_VALUE_NODE);
//
// ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3); ASSERT_EQ(taosArrayGetSize(pQueryInfo->colList), 3);
// ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 2); ASSERT_EQ(pQueryInfo->fieldsInfo.numOfOutput, 2);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
//} }
//
// TEST(testCase, invalid_sql_Test) { TEST(testCase, invalid_sql_Test) {
// char msg[128] = {0}; char msg[128] = {0};
// SMsgBuf buf; SMsgBuf buf;
// buf.len = 128; buf.len = 128;
// buf.buf = msg; buf.buf = msg;
//
// SSqlInfo info1 = doGenerateAST("select count(k) from `t.1abc` interval(10s, 1s)"); SSqlInfo info1 = doGenerateAST("select count(k) from `t.1abc` interval(10s, 1s)");
// ASSERT_EQ(info1.valid, true); ASSERT_EQ(info1.valid, true);
//
// SSqlNode* pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0); SSqlNode* pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0);
// int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); int32_t code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
//
// SMetaReq req = {0}; SMetaReq req = {0};
// int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); int32_t ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// SQueryStmtInfo* pQueryInfo = createQueryInfo(); SQueryStmtInfo* pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); setTableMetaInfo(pQueryInfo, &req);
//
// SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); SSqlNode* pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
// ASSERT_NE(ret, 0); ASSERT_NE(ret, 0);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
////=============================================================================================================== //===============================================================================================================
// info1 = doGenerateAST("select top(a*b, ABC) from `t.1abc` interval(10s, 1s)"); info1 = doGenerateAST("select top(a*b, ABC) from `t.1abc` interval(10s, 1s)");
// ASSERT_EQ(info1.valid, true); ASSERT_EQ(info1.valid, true);
//
// pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0); pNode = (SSqlNode*) taosArrayGetP(((SArray*)info1.list), 0);
// code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf); code = evaluateSqlNode(pNode, TSDB_TIME_PRECISION_NANO, &buf);
// ASSERT_EQ(code, 0); ASSERT_EQ(code, 0);
//
// ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128); ret = qParserExtractRequestedMetaInfo(&info1, &req, msg, 128);
// ASSERT_EQ(ret, 0); ASSERT_EQ(ret, 0);
// ASSERT_EQ(taosArrayGetSize(req.pTableName), 1); ASSERT_EQ(taosArrayGetSize(req.pTableName), 1);
//
// pQueryInfo = createQueryInfo(); pQueryInfo = createQueryInfo();
// setTableMetaInfo(pQueryInfo, &req); setTableMetaInfo(pQueryInfo, &req);
//
// pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0); pSqlNode = (SSqlNode*)taosArrayGetP(info1.list, 0);
// ret = validateSqlNode(pSqlNode, pQueryInfo, &buf); ret = validateSqlNode(pSqlNode, pQueryInfo, &buf);
// ASSERT_NE(ret, 0); ASSERT_NE(ret, 0);
//
// destroyQueryInfo(pQueryInfo); destroyQueryInfo(pQueryInfo);
// qParserClearupMetaRequestInfo(&req); qParserClearupMetaRequestInfo(&req);
// destroySqlInfo(&info1); destroySqlInfo(&info1);
//} }