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

TD-13197 SELECT statement syntax definition

This commit is contained in:
Xiaoyu Wang 2022-01-27 11:28:13 -05:00
parent 9e1e32d307
commit 55bb9cce20
12 changed files with 1362 additions and 1034 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
include/common/ttokendef.h
View File

@ -209,48 +209,76 @@
#define NEW_TK_OR 1 #define NEW_TK_OR 1
#define NEW_TK_AND 2 #define NEW_TK_AND 2
#define NEW_TK_NOT 3 #define NEW_TK_UNION 3
#define NEW_TK_UNION 4 #define NEW_TK_ALL 4
#define NEW_TK_ALL 5 #define NEW_TK_MINUS 5
#define NEW_TK_MINUS 6 #define NEW_TK_EXCEPT 6
#define NEW_TK_EXCEPT 7 #define NEW_TK_INTERSECT 7
#define NEW_TK_INTERSECT 8 #define NEW_TK_NK_PLUS 8
#define NEW_TK_NK_PLUS 9 #define NEW_TK_NK_MINUS 9
#define NEW_TK_NK_MINUS 10 #define NEW_TK_NK_STAR 10
#define NEW_TK_NK_STAR 11 #define NEW_TK_NK_SLASH 11
#define NEW_TK_NK_SLASH 12 #define NEW_TK_NK_REM 12
#define NEW_TK_SHOW 13 #define NEW_TK_SHOW 13
#define NEW_TK_DATABASES 14 #define NEW_TK_DATABASES 14
#define NEW_TK_NK_INTEGER 15 #define NEW_TK_NK_INTEGER 15
#define NEW_TK_NK_FLOAT 16 #define NEW_TK_NK_FLOAT 16
#define NEW_TK_NK_STRING 17 #define NEW_TK_NK_STRING 17
#define NEW_TK_NK_BOOL 18 #define NEW_TK_NK_BOOL 18
#define NEW_TK_NK_NOW 19 #define NEW_TK_TIMESTAMP 19
#define NEW_TK_NK_ID 20 #define NEW_TK_NK_VARIABLE 20
#define NEW_TK_NK_QUESTION 21 #define NEW_TK_NK_COMMA 21
#define NEW_TK_NK_LP 22 #define NEW_TK_NK_ID 22
#define NEW_TK_NK_RP 23 #define NEW_TK_NK_LP 23
#define NEW_TK_NK_DOT 24 #define NEW_TK_NK_RP 24
#define NEW_TK_FROM 25 #define NEW_TK_NK_DOT 25
#define NEW_TK_NK_COMMA 26 #define NEW_TK_BETWEEN 26
#define NEW_TK_AS 27 #define NEW_TK_NOT 27
#define NEW_TK_JOIN 28 #define NEW_TK_IS 28
#define NEW_TK_ON 29 #define NEW_TK_NULL 29
#define NEW_TK_INNER 30 #define NEW_TK_NK_LT 30
#define NEW_TK_SELECT 31 #define NEW_TK_NK_GT 31
#define NEW_TK_DISTINCT 32 #define NEW_TK_NK_LE 32
#define NEW_TK_ORDER 33 #define NEW_TK_NK_GE 33
#define NEW_TK_BY 34 #define NEW_TK_NK_NE 34
#define NEW_TK_SLIMIT 35 #define NEW_TK_NK_EQ 35
#define NEW_TK_SOFFSET 36 #define NEW_TK_LIKE 36
#define NEW_TK_LIMIT 37 #define NEW_TK_MATCH 37
#define NEW_TK_OFFSET 38 #define NEW_TK_NMATCH 38
#define NEW_TK_NK_LR 39 #define NEW_TK_IN 39
#define NEW_TK_ASC 40 #define NEW_TK_FROM 40
#define NEW_TK_DESC 41 #define NEW_TK_AS 41
#define NEW_TK_NULLS 42 #define NEW_TK_JOIN 42
#define NEW_TK_FIRST 43 #define NEW_TK_ON 43
#define NEW_TK_LAST 44 #define NEW_TK_INNER 44
#define NEW_TK_SELECT 45
#define NEW_TK_DISTINCT 46
#define NEW_TK_WHERE 47
#define NEW_TK_PARTITION 48
#define NEW_TK_BY 49
#define NEW_TK_SESSION 50
#define NEW_TK_STATE_WINDOW 51
#define NEW_TK_INTERVAL 52
#define NEW_TK_SLIDING 53
#define NEW_TK_FILL 54
#define NEW_TK_VALUE 55
#define NEW_TK_NONE 56
#define NEW_TK_PREV 57
#define NEW_TK_LINEAR 58
#define NEW_TK_NEXT 59
#define NEW_TK_GROUP 60
#define NEW_TK_HAVING 61
#define NEW_TK_ORDER 62
#define NEW_TK_SLIMIT 63
#define NEW_TK_SOFFSET 64
#define NEW_TK_LIMIT 65
#define NEW_TK_OFFSET 66
#define NEW_TK_NK_LR 67
#define NEW_TK_ASC 68
#define NEW_TK_DESC 69
#define NEW_TK_NULLS 70
#define NEW_TK_FIRST 71
#define NEW_TK_LAST 72
#define TK_SPACE 300 #define TK_SPACE 300
#define TK_COMMENT 301 #define TK_COMMENT 301

37
include/nodes/nodes.h
View File

@ -51,6 +51,8 @@ typedef enum ENodeType {
QUERY_NODE_STATE_WINDOW, QUERY_NODE_STATE_WINDOW,
QUERY_NODE_SESSION_WINDOW, QUERY_NODE_SESSION_WINDOW,
QUERY_NODE_INTERVAL_WINDOW, QUERY_NODE_INTERVAL_WINDOW,
QUERY_NODE_NODE_LIST,
QUERY_NODE_FILL,
QUERY_NODE_SET_OPERATOR, QUERY_NODE_SET_OPERATOR,
QUERY_NODE_SELECT_STMT, QUERY_NODE_SELECT_STMT,
@ -157,14 +159,19 @@ typedef struct SLogicConditionNode {
typedef struct SIsNullCondNode { typedef struct SIsNullCondNode {
ENodeType type; // QUERY_NODE_IS_NULL_CONDITION ENodeType type; // QUERY_NODE_IS_NULL_CONDITION
SNode* pExpr; SNode* pExpr;
bool isNot; bool isNull;
} SIsNullCondNode; } SIsNullCondNode;
typedef struct SNodeListNode {
ENodeType type; // QUERY_NODE_NODE_LIST
SNodeList* pNodeList;
} SNodeListNode;
typedef struct SFunctionNode { typedef struct SFunctionNode {
SExprNode type; // QUERY_NODE_FUNCTION SExprNode type; // QUERY_NODE_FUNCTION
char functionName[TSDB_FUNC_NAME_LEN]; char functionName[TSDB_FUNC_NAME_LEN];
int32_t funcId; int32_t funcId;
SNodeList* pParameterList; // SNode SNodeList* pParameterList;
} SFunctionNode; } SFunctionNode;
typedef struct STableNode { typedef struct STableNode {
@ -242,11 +249,27 @@ typedef struct SSessionWindowNode {
typedef struct SIntervalWindowNode { typedef struct SIntervalWindowNode {
ENodeType type; // QUERY_NODE_INTERVAL_WINDOW ENodeType type; // QUERY_NODE_INTERVAL_WINDOW
int64_t interval; SNode* pInterval; // SValueNode
int64_t sliding; SNode* pOffset; // SValueNode
int64_t offset; SNode* pSliding; // SValueNode
SNode* pFill;
} SIntervalWindowNode; } SIntervalWindowNode;
typedef enum EFillMode {
FILL_MODE_NONE = 1,
FILL_MODE_VALUE,
FILL_MODE_PREV,
FILL_MODE_NULL,
FILL_MODE_LINEAR,
FILL_MODE_NEXT
} EFillMode;
typedef struct SFillNode {
ENodeType type; // QUERY_NODE_FILL
EFillMode mode;
SNode* pValues; // SNodeListNode
} SFillNode;
typedef struct SSelectStmt { typedef struct SSelectStmt {
ENodeType type; // QUERY_NODE_SELECT_STMT ENodeType type; // QUERY_NODE_SELECT_STMT
bool isDistinct; bool isDistinct;
@ -259,8 +282,8 @@ typedef struct SSelectStmt {
SNodeList* pGroupByList; // SGroupingSetNode SNodeList* pGroupByList; // SGroupingSetNode
SNode* pHaving; SNode* pHaving;
SNodeList* pOrderByList; // SOrderByExprNode SNodeList* pOrderByList; // SOrderByExprNode
SLimitNode* pLimit; SNode* pLimit;
SLimitNode* pSlimit; SNode* pSlimit;
} SSelectStmt; } SSelectStmt;
typedef enum ESetOperatorType { typedef enum ESetOperatorType {

8
source/libs/parser/inc/astCreateContext.h
View File

@ -23,11 +23,6 @@ extern "C" {
#include "nodes.h" #include "nodes.h"
#include "parser.h" #include "parser.h"
typedef enum EResourceType {
AST_CXT_RESOURCE_NODE = 1,
AST_CXT_RESOURCE_NODE_LIST
} EResourceType;
typedef struct SAstCreateContext { typedef struct SAstCreateContext {
SParseContext* pQueryCxt; SParseContext* pQueryCxt;
bool notSupport; bool notSupport;
@ -39,9 +34,6 @@ typedef struct SAstCreateContext {
int32_t createAstCreateContext(SParseContext* pQueryCxt, SAstCreateContext* pCxt); int32_t createAstCreateContext(SParseContext* pQueryCxt, SAstCreateContext* pCxt);
int32_t destroyAstCreateContext(SAstCreateContext* pCxt); int32_t destroyAstCreateContext(SAstCreateContext* pCxt);
void* acquireRaii(SAstCreateContext* pCxt, EResourceType type, void* p);
void* releaseRaii(SAstCreateContext* pCxt, void* p);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

13
source/libs/parser/inc/astCreateFuncs.h
View File

@ -32,14 +32,25 @@ SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode
SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName); SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName);
SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral); SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral);
SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral);
SNode* addMinusSign(SAstCreateContext* pCxt, SNode* pNode); SNode* addMinusSign(SAstCreateContext* pCxt, SNode* pNode);
SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias); SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias);
SNode* createLogicConditionNode(SAstCreateContext* pCxt, ELogicConditionType type, SNode* pParam1, SNode* pParam2); SNode* createLogicConditionNode(SAstCreateContext* pCxt, ELogicConditionType type, SNode* pParam1, SNode* pParam2);
SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pLeft, SNode* pRight);
SNode* createBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight);
SNode* createNotBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight);
SNode* createIsNullCondNode(SAstCreateContext* pCxt, SNode* pExpr, bool isNull);
SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNodeList* pParameterList);
SNode* createNodeListNode(SAstCreateContext* pCxt, SNodeList* pList);
SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName, const SToken* pTableAlias); SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName, const SToken* pTableAlias);
SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, const SToken* pTableAlias); SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, const SToken* pTableAlias);
SNode* createJoinTableNode(SAstCreateContext* pCxt, EJoinType type, SNode* pLeft, SNode* pRight, SNode* pJoinCond); SNode* createJoinTableNode(SAstCreateContext* pCxt, EJoinType type, SNode* pLeft, SNode* pRight, SNode* pJoinCond);
SNode* createLimitNode(SAstCreateContext* pCxt, SNode* pLimit, SNode* pOffset); SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const SToken* pOffset);
SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder); SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder);
SNode* createSessionWindowNode(SAstCreateContext* pCxt, SNode* pCol, const SToken* pVal);
SNode* createStateWindowNode(SAstCreateContext* pCxt, SNode* pCol);
SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode* pOffset, SNode* pSliding, SNode* pFill);
SNode* createFillNode(SAstCreateContext* pCxt, EFillMode mode, SNode* pValues);
SNode* addWhereClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWhere); SNode* addWhereClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWhere);
SNode* addPartitionByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pPartitionByList); SNode* addPartitionByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pPartitionByList);

249
source/libs/parser/inc/new_sql.y
View File

@ -22,8 +22,15 @@
#include "ttokendef.h" #include "ttokendef.h"
#include "astCreateFuncs.h" #include "astCreateFuncs.h"
#if 0
#define PARSER_TRACE printf("lemon rule = %s\n", yyRuleName[yyruleno]) #define PARSER_TRACE printf("lemon rule = %s\n", yyRuleName[yyruleno])
#define PARSER_DESTRUCTOR_TRACE printf("lemon destroy token = %s\n", yyTokenName[yymajor]) #define PARSER_DESTRUCTOR_TRACE printf("lemon destroy token = %s\n", yyTokenName[yymajor])
#define PARSER_COMPLETE printf("parsing complete!\n" )
#else
#define PARSER_TRACE
#define PARSER_DESTRUCTOR_TRACE
#define PARSER_COMPLETE
#endif
} }
%syntax_error { %syntax_error {
@ -44,43 +51,37 @@
pCxt->valid = false; pCxt->valid = false;
} }
%parse_accept { printf("parsing complete!\n" );} %parse_accept { PARSER_COMPLETE; }
%left OR. %left OR.
%left AND. %left AND.
%right NOT.
%left UNION ALL MINUS EXCEPT INTERSECT. %left UNION ALL MINUS EXCEPT INTERSECT.
//%left EQ NE ISNULL NOTNULL IS LIKE MATCH NMATCH GLOB BETWEEN IN.
//%left GT GE LT LE.
//%left BITAND BITOR LSHIFT RSHIFT. //%left BITAND BITOR LSHIFT RSHIFT.
%left NK_PLUS NK_MINUS. %left NK_PLUS NK_MINUS.
//%left DIVIDE TIMES. //%left DIVIDE TIMES.
%left NK_STAR NK_SLASH. //REM. %left NK_STAR NK_SLASH NK_REM.
//%left CONCAT. //%left CONCAT.
//%right UMINUS UPLUS BITNOT. //%right UMINUS UPLUS BITNOT.
cmd ::= SHOW DATABASES. { PARSER_TRACE; createShowStmt(pCxt, SHOW_TYPE_DATABASE); } cmd ::= SHOW DATABASES. { PARSER_TRACE; createShowStmt(pCxt, SHOW_TYPE_DATABASE); }
cmd ::= query_expression(A). { PARSER_TRACE; pCxt->pRootNode = A; } cmd ::= query_expression(A). { PARSER_TRACE; pCxt->pRootNode = A; }
/*5.4*********************************************** literal *********************************************************/ /************************************************ literal *************************************************************/
unsigned_integer(A) ::= NK_INTEGER(B). { A = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); } literal(A) ::= NK_INTEGER(B). { PARSER_TRACE; A = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
unsigned_approximate_numeric(A) ::= NK_FLOAT(B). { A = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B); } literal(A) ::= NK_FLOAT(B). { PARSER_TRACE; A = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B); }
literal(A) ::= NK_STRING(B). { PARSER_TRACE; A = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &B); }
literal(A) ::= NK_BOOL(B). { PARSER_TRACE; A = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B); }
literal(A) ::= TIMESTAMP NK_STRING(B). { PARSER_TRACE; A = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &B); }
literal(A) ::= duration_literal(B). { PARSER_TRACE; A = B; }
signed_integer(A) ::= unsigned_integer(B). { A = B; } duration_literal(A) ::= NK_VARIABLE(B). { PARSER_TRACE; A = createDurationValueNode(pCxt, &B); }
signed_integer(A) ::= NK_PLUS unsigned_integer(B). { A = B; }
signed_integer(A) ::= NK_MINUS unsigned_integer(B). { A = addMinusSign(pCxt, B);}
unsigned_literal ::= unsigned_numeric_literal. %type literal_list { SNodeList* }
unsigned_literal ::= general_literal. %destructor literal_list { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); }
literal_list(A) ::= literal(B). { PARSER_TRACE; A = createNodeList(pCxt, B); }
literal_list(A) ::= literal_list(B) NK_COMMA literal(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
unsigned_numeric_literal ::= unsigned_integer. /************************************************ names and identifiers ***********************************************/
unsigned_numeric_literal ::= unsigned_approximate_numeric.
general_literal ::= NK_STRING.
general_literal ::= NK_BOOL.
general_literal ::= NK_NOW.
/*5.4*********************************************** names and identifiers *********************************************************/
%type db_name { SToken } %type db_name { SToken }
%destructor db_name { PARSER_DESTRUCTOR_TRACE; } %destructor db_name { PARSER_DESTRUCTOR_TRACE; }
db_name(A) ::= NK_ID(B). { PARSER_TRACE; A = B; } db_name(A) ::= NK_ID(B). { PARSER_TRACE; A = B; }
@ -93,29 +94,76 @@ table_name(A) ::= NK_ID(B).
%destructor column_name { PARSER_DESTRUCTOR_TRACE; } %destructor column_name { PARSER_DESTRUCTOR_TRACE; }
column_name(A) ::= NK_ID(B). { PARSER_TRACE; A = B; } column_name(A) ::= NK_ID(B). { PARSER_TRACE; A = B; }
%type function_name { SToken }
%destructor function_name { PARSER_DESTRUCTOR_TRACE; }
function_name(A) ::= NK_ID(B). { PARSER_TRACE; A = B; }
%type table_alias { SToken } %type table_alias { SToken }
%destructor table_alias { PARSER_DESTRUCTOR_TRACE; } %destructor table_alias { PARSER_DESTRUCTOR_TRACE; }
table_alias(A) ::= NK_ID(B). { PARSER_TRACE; A = B; } table_alias(A) ::= NK_ID(B). { PARSER_TRACE; A = B; }
/*6.4*********************************************** value_specification *********************************************************/ %type column_alias { SToken }
unsigned_value_specification ::= unsigned_literal. %destructor column_alias { PARSER_DESTRUCTOR_TRACE; }
unsigned_value_specification ::= NK_QUESTION. column_alias(A) ::= NK_ID(B). { PARSER_TRACE; A = B; }
/*6.35 todo *********************************************** value_expression_primary *********************************************************/ /************************************************ expression **********************************************************/
value_expression_primary ::= NK_LP value_expression NK_RP. expression(A) ::= literal(B). { PARSER_TRACE; A = B; }
value_expression_primary ::= nonparenthesized_value_expression_primary. //expression(A) ::= NK_QUESTION(B). { PARSER_TRACE; A = B; }
//expression(A) ::= pseudo_column(B). { PARSER_TRACE; A = B; }
expression(A) ::= column_reference(B). { PARSER_TRACE; A = B; }
expression(A) ::= function_name(B) NK_LP expression_list(C) NK_RP. { PARSER_TRACE; A = createFunctionNode(pCxt, &B, C); }
//expression(A) ::= cast_expression(B). { PARSER_TRACE; A = B; }
//expression(A) ::= case_expression(B). { PARSER_TRACE; A = B; }
expression(A) ::= subquery(B). { PARSER_TRACE; A = B; }
expression(A) ::= NK_LP expression(B) NK_RP. { PARSER_TRACE; A = B; }
expression(A) ::= NK_PLUS expression(B). { PARSER_TRACE; A = B; }
expression(A) ::= NK_MINUS expression(B). { PARSER_TRACE; A = createOperatorNode(pCxt, OP_TYPE_SUB, B, NULL); }
expression(A) ::= expression(B) NK_PLUS expression(C). { PARSER_TRACE; A = createOperatorNode(pCxt, OP_TYPE_ADD, B, C); }
expression(A) ::= expression(B) NK_MINUS expression(C). { PARSER_TRACE; A = createOperatorNode(pCxt, OP_TYPE_SUB, B, C); }
expression(A) ::= expression(B) NK_STAR expression(C). { PARSER_TRACE; A = createOperatorNode(pCxt, OP_TYPE_MULTI, B, C); }
expression(A) ::= expression(B) NK_SLASH expression(C). { PARSER_TRACE; A = createOperatorNode(pCxt, OP_TYPE_DIV, B, C); }
expression(A) ::= expression(B) NK_REM expression(C). { PARSER_TRACE; A = createOperatorNode(pCxt, OP_TYPE_MOD, B, C); }
nonparenthesized_value_expression_primary ::= unsigned_value_specification. %type expression_list { SNodeList* }
nonparenthesized_value_expression_primary ::= column_reference. %destructor expression_list { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); }
//nonparenthesized_value_expression_primary ::= agg_function. expression_list(A) ::= expression(B). { PARSER_TRACE; A = createNodeList(pCxt, B); }
nonparenthesized_value_expression_primary ::= subquery. expression_list(A) ::= expression_list(B) NK_COMMA expression(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
//nonparenthesized_value_expression_primary ::= case_expression. // todo
//nonparenthesized_value_expression_primary ::= cast_specification. // todo
column_reference(A) ::= column_name(B). { PARSER_TRACE; A = createColumnNode(pCxt, NULL, &B); } column_reference(A) ::= column_name(B). { PARSER_TRACE; A = createColumnNode(pCxt, NULL, &B); }
column_reference(A) ::= table_name(B) NK_DOT column_name(C). { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); } column_reference(A) ::= table_name(B) NK_DOT column_name(C). { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); }
/*6.35*********************************************** boolean_value_expression *********************************************************/ //pseudo_column(A) ::= NK_NOW. { PARSER_TRACE; A = createFunctionNode(pCxt, NULL, NULL); }
/************************************************ predicate ***********************************************************/
predicate(A) ::= expression(B) compare_op(C) expression(D). { PARSER_TRACE; A = createOperatorNode(pCxt, C, B, D); }
//predicate(A) ::= expression(B) compare_op sub_type expression(B).
predicate(A) ::= expression(B) BETWEEN expression(C) AND expression(D). { PARSER_TRACE; A = createBetweenAnd(pCxt, B, C, D); }
predicate(A) ::= expression(B) NOT BETWEEN expression(C) AND expression(D). { PARSER_TRACE; A = createNotBetweenAnd(pCxt, C, B, D); }
predicate(A) ::= expression(B) IS NULL. { PARSER_TRACE; A = createIsNullCondNode(pCxt, B, true); }
predicate(A) ::= expression(B) IS NOT NULL. { PARSER_TRACE; A = createIsNullCondNode(pCxt, B, false); }
predicate(A) ::= expression(B) in_op(C) in_predicate_value(D). { PARSER_TRACE; A = createOperatorNode(pCxt, C, B, D); }
%type compare_op { EOperatorType }
%destructor compare_op { PARSER_DESTRUCTOR_TRACE; }
compare_op(A) ::= NK_LT. { PARSER_TRACE; A = OP_TYPE_LOWER_THAN; }
compare_op(A) ::= NK_GT. { PARSER_TRACE; A = OP_TYPE_GREATER_THAN; }
compare_op(A) ::= NK_LE. { PARSER_TRACE; A = OP_TYPE_LOWER_EQUAL; }
compare_op(A) ::= NK_GE. { PARSER_TRACE; A = OP_TYPE_GREATER_EQUAL; }
compare_op(A) ::= NK_NE. { PARSER_TRACE; A = OP_TYPE_NOT_EQUAL; }
compare_op(A) ::= NK_EQ. { PARSER_TRACE; A = OP_TYPE_EQUAL; }
compare_op(A) ::= LIKE. { PARSER_TRACE; A = OP_TYPE_LIKE; }
compare_op(A) ::= NOT LIKE. { PARSER_TRACE; A = OP_TYPE_NOT_LIKE; }
compare_op(A) ::= MATCH. { PARSER_TRACE; A = OP_TYPE_MATCH; }
compare_op(A) ::= NMATCH. { PARSER_TRACE; A = OP_TYPE_NMATCH; }
%type in_op { EOperatorType }
%destructor in_op { PARSER_DESTRUCTOR_TRACE; }
in_op(A) ::= IN. { PARSER_TRACE; A = OP_TYPE_IN; }
in_op(A) ::= NOT IN. { PARSER_TRACE; A = OP_TYPE_NOT_IN; }
in_predicate_value(A) ::= NK_LP expression_list(B) NK_RP. { PARSER_TRACE; A = createNodeListNode(pCxt, B); }
/************************************************ boolean_value_expression ********************************************/
boolean_value_expression(A) ::= boolean_primary(B). { PARSER_TRACE; A = B; } boolean_value_expression(A) ::= boolean_primary(B). { PARSER_TRACE; A = B; }
boolean_value_expression(A) ::= NOT boolean_primary(B). { PARSER_TRACE; A = createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, B, NULL); } boolean_value_expression(A) ::= NOT boolean_primary(B). { PARSER_TRACE; A = createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, B, NULL); }
boolean_value_expression(A) ::= boolean_value_expression(A) ::=
@ -126,32 +174,31 @@ boolean_value_expression(A) ::=
boolean_primary(A) ::= predicate(B). { PARSER_TRACE; A = B; } boolean_primary(A) ::= predicate(B). { PARSER_TRACE; A = B; }
boolean_primary(A) ::= NK_LP boolean_value_expression(B) NK_RP. { PARSER_TRACE; A = B; } boolean_primary(A) ::= NK_LP boolean_value_expression(B) NK_RP. { PARSER_TRACE; A = B; }
/*7.5*********************************************** from_clause *********************************************************/ /************************************************ from_clause *********************************************************/
from_clause(A) ::= FROM table_reference_list(B). { PARSER_TRACE; A = B; } from_clause(A) ::= FROM table_reference_list(B). { PARSER_TRACE; A = B; }
table_reference_list(A) ::= table_reference(B). { PARSER_TRACE; A = B; } table_reference_list(A) ::= table_reference(B). { PARSER_TRACE; A = B; }
table_reference_list(A) ::= table_reference_list(B) NK_COMMA table_reference(C). { PARSER_TRACE; A = createJoinTableNode(pCxt, JOIN_TYPE_INNER, B, C, NULL); } table_reference_list(A) ::= table_reference_list(B) NK_COMMA table_reference(C). { PARSER_TRACE; A = createJoinTableNode(pCxt, JOIN_TYPE_INNER, B, C, NULL); }
/*7.6*********************************************** table_reference *****************************************************/ /************************************************ table_reference *****************************************************/
table_reference(A) ::= table_primary(B). { PARSER_TRACE; A = B; } table_reference(A) ::= table_primary(B). { PARSER_TRACE; A = B; }
table_reference(A) ::= joined_table(B). { PARSER_TRACE; A = B; } table_reference(A) ::= joined_table(B). { PARSER_TRACE; A = B; }
table_primary(A) ::= table_name(B) correlation_or_recognition_opt(C). { PARSER_TRACE; A = createRealTableNode(pCxt, NULL, &B, &C); } table_primary(A) ::= table_name(B) alias_opt(C). { PARSER_TRACE; A = createRealTableNode(pCxt, NULL, &B, &C); }
table_primary(A) ::= table_primary(A) ::= db_name(B) NK_DOT table_name(C) alias_opt(D). { PARSER_TRACE; A = createRealTableNode(pCxt, &B, &C, &D); }
db_name(B) NK_DOT table_name(C) correlation_or_recognition_opt(D). { PARSER_TRACE; A = createRealTableNode(pCxt, &B, &C, &D); } table_primary(A) ::= subquery(B) alias_opt(C). { PARSER_TRACE; A = createTempTableNode(pCxt, B, &C); }
table_primary(A) ::= subquery(B) correlation_or_recognition_opt(C). { PARSER_TRACE; A = createTempTableNode(pCxt, B, &C); }
table_primary ::= parenthesized_joined_table. table_primary ::= parenthesized_joined_table.
%type correlation_or_recognition_opt { SToken } %type alias_opt { SToken }
%destructor correlation_or_recognition_opt { PARSER_DESTRUCTOR_TRACE; } %destructor alias_opt { PARSER_DESTRUCTOR_TRACE; }
correlation_or_recognition_opt(A) ::= . { PARSER_TRACE; A = nil_token; } alias_opt(A) ::= . { PARSER_TRACE; A = nil_token; }
correlation_or_recognition_opt(A) ::= table_alias(B). { PARSER_TRACE; A = B; } alias_opt(A) ::= table_alias(B). { PARSER_TRACE; A = B; }
correlation_or_recognition_opt(A) ::= AS table_alias(B). { PARSER_TRACE; A = B; } alias_opt(A) ::= AS table_alias(B). { PARSER_TRACE; A = B; }
parenthesized_joined_table(A) ::= NK_LP joined_table(B) NK_RP. { PARSER_TRACE; A = B; } parenthesized_joined_table(A) ::= NK_LP joined_table(B) NK_RP. { PARSER_TRACE; A = B; }
parenthesized_joined_table(A) ::= NK_LP parenthesized_joined_table(B) NK_RP. { PARSER_TRACE; A = B; } parenthesized_joined_table(A) ::= NK_LP parenthesized_joined_table(B) NK_RP. { PARSER_TRACE; A = B; }
/*7.10*********************************************** joined_table ************************************************************/ /************************************************ joined_table ********************************************************/
joined_table(A) ::= joined_table(A) ::=
table_reference(B) join_type(C) JOIN table_reference(D) ON search_condition(E). { PARSER_TRACE; A = createJoinTableNode(pCxt, C, B, D, E); } table_reference(B) join_type(C) JOIN table_reference(D) ON search_condition(E). { PARSER_TRACE; A = createJoinTableNode(pCxt, C, B, D, E); }
@ -159,7 +206,7 @@ joined_table(A) ::=
%destructor join_type { PARSER_DESTRUCTOR_TRACE; } %destructor join_type { PARSER_DESTRUCTOR_TRACE; }
join_type(A) ::= INNER. { PARSER_TRACE; A = JOIN_TYPE_INNER; } join_type(A) ::= INNER. { PARSER_TRACE; A = JOIN_TYPE_INNER; }
/*7.15*********************************************** query_specification *************************************************/ /************************************************ query_specification *************************************************/
query_specification(A) ::= query_specification(A) ::=
SELECT set_quantifier_opt(B) select_list(C) from_clause(D) where_clause_opt(E) SELECT set_quantifier_opt(B) select_list(C) from_clause(D) where_clause_opt(E)
partition_by_clause_opt(F) twindow_clause_opt(G) partition_by_clause_opt(F) twindow_clause_opt(G)
@ -189,12 +236,53 @@ select_list(A) ::= select_sublist(B).
select_sublist(A) ::= select_item(B). { PARSER_TRACE; A = createNodeList(pCxt, B); } select_sublist(A) ::= select_item(B). { PARSER_TRACE; A = createNodeList(pCxt, B); }
select_sublist(A) ::= select_sublist(B) NK_COMMA select_item(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); } select_sublist(A) ::= select_sublist(B) NK_COMMA select_item(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
select_item(A) ::= value_expression(B). { PARSER_TRACE; A = B; } select_item(A) ::= expression(B). { PARSER_TRACE; A = B; }
select_item(A) ::= value_expression(B) NK_ID(C). { PARSER_TRACE; A = setProjectionAlias(pCxt, B, &C); } select_item(A) ::= expression(B) column_alias(C). { PARSER_TRACE; A = setProjectionAlias(pCxt, B, &C); }
select_item(A) ::= value_expression(B) AS NK_ID(C). { PARSER_TRACE; A = setProjectionAlias(pCxt, B, &C); } select_item(A) ::= expression(B) AS column_alias(C). { PARSER_TRACE; A = setProjectionAlias(pCxt, B, &C); }
select_item(A) ::= table_name(B) NK_DOT NK_STAR(C). { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); } select_item(A) ::= table_name(B) NK_DOT NK_STAR(C). { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); }
/*7.16*********************************************** query_expression ****************************************************/ where_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; }
where_clause_opt(A) ::= WHERE search_condition(B). { PARSER_TRACE; A = B; }
%type partition_by_clause_opt { SNodeList* }
%destructor partition_by_clause_opt { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); }
partition_by_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; }
partition_by_clause_opt(A) ::= PARTITION BY expression_list(B). { PARSER_TRACE; A = B; }
twindow_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; }
twindow_clause_opt(A) ::=
SESSION NK_LP column_reference(B) NK_COMMA NK_INTEGER(C) NK_RP. { PARSER_TRACE; A = createSessionWindowNode(pCxt, B, &C); }
twindow_clause_opt(A) ::= STATE_WINDOW NK_LP column_reference(B) NK_RP. { PARSER_TRACE; A = createStateWindowNode(pCxt, B); }
twindow_clause_opt(A) ::=
INTERVAL NK_LP duration_literal(B) NK_RP sliding_opt(C) fill_opt(D). { PARSER_TRACE; A = createIntervalWindowNode(pCxt, B, NULL, C, D); }
twindow_clause_opt(A) ::=
INTERVAL NK_LP duration_literal(B) NK_COMMA duration_literal(C) NK_RP
sliding_opt(D) fill_opt(E). { PARSER_TRACE; A = createIntervalWindowNode(pCxt, B, C, D, E); }
sliding_opt(A) ::= . { PARSER_TRACE; A = NULL; }
sliding_opt(A) ::= SLIDING NK_LP duration_literal(B) NK_RP. { PARSER_TRACE; A = B; }
fill_opt(A) ::= . { PARSER_TRACE; A = NULL; }
fill_opt(A) ::= FILL NK_LP fill_mode(B) NK_RP. { PARSER_TRACE; A = createFillNode(pCxt, B, NULL); }
fill_opt(A) ::= FILL NK_LP VALUE NK_COMMA literal_list(B) NK_RP. { PARSER_TRACE; A = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, B)); }
%type fill_mode { EFillMode }
%destructor fill_mode { PARSER_DESTRUCTOR_TRACE; }
fill_mode(A) ::= NONE. { PARSER_TRACE; A = FILL_MODE_NONE; }
fill_mode(A) ::= PREV. { PARSER_TRACE; A = FILL_MODE_PREV; }
fill_mode(A) ::= NULL. { PARSER_TRACE; A = FILL_MODE_NULL; }
fill_mode(A) ::= LINEAR. { PARSER_TRACE; A = FILL_MODE_LINEAR; }
fill_mode(A) ::= NEXT. { PARSER_TRACE; A = FILL_MODE_NEXT; }
%type group_by_clause_opt { SNodeList* }
%destructor group_by_clause_opt { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); }
group_by_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; }
group_by_clause_opt(A) ::= GROUP BY expression_list(B). { PARSER_TRACE; A = B; }
having_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; }
having_clause_opt(A) ::= HAVING search_condition(B). { PARSER_TRACE; A = B; }
/************************************************ query_expression ****************************************************/
query_expression(A) ::= query_expression(A) ::=
query_expression_body(B) query_expression_body(B)
order_by_clause_opt(C) slimit_clause_opt(D) limit_clause_opt(E). { order_by_clause_opt(C) slimit_clause_opt(D) limit_clause_opt(E). {
@ -219,25 +307,22 @@ order_by_clause_opt(A) ::= .
order_by_clause_opt(A) ::= ORDER BY sort_specification_list(B). { PARSER_TRACE; A = B; } order_by_clause_opt(A) ::= ORDER BY sort_specification_list(B). { PARSER_TRACE; A = B; }
slimit_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; } slimit_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; }
slimit_clause_opt(A) ::= SLIMIT signed_integer(B). { PARSER_TRACE; A = createLimitNode(pCxt, B, 0); } slimit_clause_opt(A) ::= SLIMIT NK_INTEGER(B). { PARSER_TRACE; A = createLimitNode(pCxt, &B, NULL); }
slimit_clause_opt(A) ::= SLIMIT signed_integer(B) SOFFSET signed_integer(C). { PARSER_TRACE; A = createLimitNode(pCxt, B, C); } slimit_clause_opt(A) ::= SLIMIT NK_INTEGER(B) SOFFSET NK_INTEGER(C). { PARSER_TRACE; A = createLimitNode(pCxt, &B, &C); }
slimit_clause_opt(A) ::= SLIMIT signed_integer(C) NK_COMMA signed_integer(B). { PARSER_TRACE; A = createLimitNode(pCxt, B, C); } slimit_clause_opt(A) ::= SLIMIT NK_INTEGER(C) NK_COMMA NK_INTEGER(B). { PARSER_TRACE; A = createLimitNode(pCxt, &B, &C); }
limit_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; } limit_clause_opt(A) ::= . { PARSER_TRACE; A = NULL; }
limit_clause_opt(A) ::= LIMIT signed_integer(B). { PARSER_TRACE; A = createLimitNode(pCxt, B, 0); } limit_clause_opt(A) ::= LIMIT NK_INTEGER(B). { PARSER_TRACE; A = createLimitNode(pCxt, &B, NULL); }
limit_clause_opt(A) ::= LIMIT signed_integer(B) OFFSET signed_integer(C). { PARSER_TRACE; A = createLimitNode(pCxt, B, C); } limit_clause_opt(A) ::= LIMIT NK_INTEGER(B) OFFSET NK_INTEGER(C). { PARSER_TRACE; A = createLimitNode(pCxt, &B, &C); }
limit_clause_opt(A) ::= LIMIT signed_integer(C) NK_COMMA signed_integer(B). { PARSER_TRACE; A = createLimitNode(pCxt, B, C); } limit_clause_opt(A) ::= LIMIT NK_INTEGER(C) NK_COMMA NK_INTEGER(B). { PARSER_TRACE; A = createLimitNode(pCxt, &B, &C); }
/*7.18*********************************************** subquery ************************************************************/ /************************************************ subquery ************************************************************/
subquery(A) ::= NK_LR query_expression(B) NK_RP. { PARSER_TRACE; A = B; } subquery(A) ::= NK_LR query_expression(B) NK_RP. { PARSER_TRACE; A = B; }
/*8.1*********************************************** predicate ************************************************************/ /************************************************ search_condition ****************************************************/
predicate ::= .
/*8.21 todo *********************************************** search_condition ************************************************************/
search_condition(A) ::= boolean_value_expression(B). { PARSER_TRACE; A = B; } search_condition(A) ::= boolean_value_expression(B). { PARSER_TRACE; A = B; }
/*10.10*********************************************** sort_specification_list ************************************************************/ /************************************************ sort_specification_list *********************************************/
%type sort_specification_list { SNodeList* } %type sort_specification_list { SNodeList* }
%destructor sort_specification_list { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); } %destructor sort_specification_list { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); }
sort_specification_list(A) ::= sort_specification(B). { PARSER_TRACE; A = createNodeList(pCxt, B); } sort_specification_list(A) ::= sort_specification(B). { PARSER_TRACE; A = createNodeList(pCxt, B); }
@ -245,7 +330,7 @@ sort_specification_list(A) ::=
sort_specification_list(B) NK_COMMA sort_specification(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); } sort_specification_list(B) NK_COMMA sort_specification(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
sort_specification(A) ::= sort_specification(A) ::=
value_expression(B) ordering_specification_opt(C) null_ordering_opt(D). { PARSER_TRACE; A = createOrderByExprNode(pCxt, B, C, D); } expression(B) ordering_specification_opt(C) null_ordering_opt(D). { PARSER_TRACE; A = createOrderByExprNode(pCxt, B, C, D); }
%type ordering_specification_opt EOrder %type ordering_specification_opt EOrder
%destructor ordering_specification_opt { PARSER_DESTRUCTOR_TRACE; } %destructor ordering_specification_opt { PARSER_DESTRUCTOR_TRACE; }
@ -258,39 +343,3 @@ ordering_specification_opt(A) ::= DESC.
null_ordering_opt(A) ::= . { PARSER_TRACE; A = NULL_ORDER_DEFAULT; } null_ordering_opt(A) ::= . { PARSER_TRACE; A = NULL_ORDER_DEFAULT; }
null_ordering_opt(A) ::= NULLS FIRST. { PARSER_TRACE; A = NULL_ORDER_FIRST; } null_ordering_opt(A) ::= NULLS FIRST. { PARSER_TRACE; A = NULL_ORDER_FIRST; }
null_ordering_opt(A) ::= NULLS LAST. { PARSER_TRACE; A = NULL_ORDER_LAST; } null_ordering_opt(A) ::= NULLS LAST. { PARSER_TRACE; A = NULL_ORDER_LAST; }
/************************************************ todo ************************************************************/
where_clause_opt ::= .
%type partition_by_clause_opt { SNodeList* }
%destructor partition_by_clause_opt { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); }
partition_by_clause_opt ::=.
twindow_clause_opt ::= .
%type group_by_clause_opt { SNodeList* }
%destructor group_by_clause_opt { PARSER_DESTRUCTOR_TRACE; nodesDestroyList($$); }
group_by_clause_opt ::= .
having_clause_opt ::= .
//////////////////////// value_function /////////////////////////////////
value_function ::= NK_ID NK_LP value_expression NK_RP.
value_function ::= NK_ID NK_LP value_expression NK_COMMA value_expression NK_RP.
//////////////////////// value_expression /////////////////////////////////
value_expression ::= common_value_expression.
common_value_expression ::= numeric_value_expression.
numeric_value_expression ::= numeric_primary.
numeric_value_expression ::= NK_PLUS numeric_primary.
numeric_value_expression ::= NK_MINUS numeric_primary.
numeric_value_expression ::= numeric_value_expression NK_PLUS numeric_value_expression.
numeric_value_expression ::= numeric_value_expression NK_MINUS numeric_value_expression.
numeric_value_expression ::= numeric_value_expression NK_STAR numeric_value_expression.
numeric_value_expression ::= numeric_value_expression NK_SLASH numeric_value_expression.
numeric_primary ::= value_expression_primary.
numeric_primary ::= value_function.

41
source/libs/parser/src/astCreateContext.c
View File

@ -16,53 +16,14 @@
#include "ttoken.h" #include "ttoken.h"
#include "astCreateContext.h" #include "astCreateContext.h"
typedef struct SResourceEntry {
EResourceType type;
void* res;
} SResourceEntry;
int32_t createAstCreateContext(SParseContext* pQueryCxt, SAstCreateContext* pCxt) { int32_t createAstCreateContext(SParseContext* pQueryCxt, SAstCreateContext* pCxt) {
pCxt->pQueryCxt = pQueryCxt; pCxt->pQueryCxt = pQueryCxt;
pCxt->notSupport = false; pCxt->notSupport = false;
pCxt->valid = true; pCxt->valid = true;
pCxt->pRootNode = NULL; pCxt->pRootNode = NULL;
pCxt->pResourceHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
if (NULL == pCxt->pResourceHash) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t destroyAstCreateContext(SAstCreateContext* pCxt) { int32_t destroyAstCreateContext(SAstCreateContext* pCxt) {
SResourceEntry* item = taosHashIterate(pCxt->pResourceHash, NULL); return TSDB_CODE_SUCCESS;
while (item) {
switch (item->type) {
case AST_CXT_RESOURCE_NODE:
nodesDestroyNode(item->res);
break;
case AST_CXT_RESOURCE_NODE_LIST:
nodesDestroyList(item->res);
break;
default:
tfree(item->res);
}
item = taosHashIterate(pCxt->pResourceHash, item);
}
}
void* acquireRaii(SAstCreateContext* pCxt, EResourceType type, void* p) {
if (NULL == p) {
return NULL;
}
SResourceEntry entry = { .type = type, .res = p };
taosHashPut(pCxt->pResourceHash, &p, POINTER_BYTES, &entry, sizeof(SResourceEntry));
return p;
}
void* releaseRaii(SAstCreateContext* pCxt, void* p) {
if (NULL == p) {
return NULL;
}
taosHashRemove(pCxt->pResourceHash, &p, POINTER_BYTES);
return p;
} }

146
source/libs/parser/src/astCreateFuncs.c
View File

@ -53,11 +53,11 @@ static bool checkColumnName(SAstCreateContext* pCxt, const SToken* pColumnName)
SNodeList* createNodeList(SAstCreateContext* pCxt, SNode* pNode) { SNodeList* createNodeList(SAstCreateContext* pCxt, SNode* pNode) {
SNodeList* list = nodesMakeList(); SNodeList* list = nodesMakeList();
CHECK_OUT_OF_MEM(list); CHECK_OUT_OF_MEM(list);
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE_LIST, nodesListAppend(list, releaseRaii(pCxt, pNode))); return nodesListAppend(list, pNode);
} }
SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode) { SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode) {
return nodesListAppend(pList, releaseRaii(pCxt, pNode)); return nodesListAppend(pList, pNode);
} }
SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName) { SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName) {
@ -70,14 +70,21 @@ SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const
strncpy(col->tableName, pTableName->z, pTableName->n); strncpy(col->tableName, pTableName->z, pTableName->n);
} }
strncpy(col->colName, pColumnName->z, pColumnName->n); strncpy(col->colName, pColumnName->z, pColumnName->n);
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, col); return (SNode*)col;
} }
SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral) { SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral) {
SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
CHECK_OUT_OF_MEM(val); CHECK_OUT_OF_MEM(val);
// strncpy(col->colName, pColumnName->z, pColumnName->n); // todo
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, val); return (SNode*)val;
}
SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral) {
SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE);
CHECK_OUT_OF_MEM(val);
// todo
return (SNode*)val;
} }
SNode* addMinusSign(SAstCreateContext* pCxt, SNode* pNode) { SNode* addMinusSign(SAstCreateContext* pCxt, SNode* pNode) {
@ -89,9 +96,51 @@ SNode* createLogicConditionNode(SAstCreateContext* pCxt, ELogicConditionType typ
CHECK_OUT_OF_MEM(cond); CHECK_OUT_OF_MEM(cond);
cond->condType = type; cond->condType = type;
cond->pParameterList = nodesMakeList(); cond->pParameterList = nodesMakeList();
nodesListAppend(cond->pParameterList, releaseRaii(pCxt, pParam1)); nodesListAppend(cond->pParameterList, pParam1);
nodesListAppend(cond->pParameterList, releaseRaii(pCxt, pParam2)); nodesListAppend(cond->pParameterList, pParam2);
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, cond); return (SNode*)cond;
}
SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pLeft, SNode* pRight) {
SOperatorNode* op = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
CHECK_OUT_OF_MEM(op);
op->opType = type;
op->pLeft = pLeft;
op->pRight = pRight;
return (SNode*)op;
}
SNode* createBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight) {
return createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND,
createOperatorNode(pCxt, OP_TYPE_GREATER_EQUAL, pExpr, pLeft), createOperatorNode(pCxt, OP_TYPE_LOWER_EQUAL, pExpr, pRight));
}
SNode* createNotBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight) {
return createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR,
createOperatorNode(pCxt, OP_TYPE_LOWER_THAN, pExpr, pLeft), createOperatorNode(pCxt, OP_TYPE_GREATER_THAN, pExpr, pRight));
}
SNode* createIsNullCondNode(SAstCreateContext* pCxt, SNode* pExpr, bool isNull) {
SIsNullCondNode* cond = (SIsNullCondNode*)nodesMakeNode(QUERY_NODE_IS_NULL_CONDITION);
CHECK_OUT_OF_MEM(cond);
cond->pExpr = pExpr;
cond->isNull = isNull;
return (SNode*)cond;
}
SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNodeList* pParameterList) {
SFunctionNode* func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
CHECK_OUT_OF_MEM(func);
strncpy(func->functionName, pFuncName->z, pFuncName->n);
func->pParameterList = pParameterList;
return (SNode*)func;
}
SNode* createNodeListNode(SAstCreateContext* pCxt, SNodeList* pList) {
SNodeListNode* list = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
CHECK_OUT_OF_MEM(list);
list->pNodeList = pList;
return (SNode*)list;
} }
SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName, const SToken* pTableAlias) { SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName, const SToken* pTableAlias) {
@ -104,41 +153,74 @@ SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const
strncpy(realTable->dbName, pDbName->z, pDbName->n); strncpy(realTable->dbName, pDbName->z, pDbName->n);
} }
strncpy(realTable->table.tableName, pTableName->z, pTableName->n); strncpy(realTable->table.tableName, pTableName->z, pTableName->n);
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, realTable); return (SNode*)realTable;
} }
SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, const SToken* pTableAlias) { SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, const SToken* pTableAlias) {
STempTableNode* tempTable = (STempTableNode*)nodesMakeNode(QUERY_NODE_TEMP_TABLE); STempTableNode* tempTable = (STempTableNode*)nodesMakeNode(QUERY_NODE_TEMP_TABLE);
CHECK_OUT_OF_MEM(tempTable); CHECK_OUT_OF_MEM(tempTable);
tempTable->pSubquery = pSubquery; tempTable->pSubquery = pSubquery;
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, tempTable); return (SNode*)tempTable;
} }
SNode* createJoinTableNode(SAstCreateContext* pCxt, EJoinType type, SNode* pLeft, SNode* pRight, SNode* pJoinCond) { SNode* createJoinTableNode(SAstCreateContext* pCxt, EJoinType type, SNode* pLeft, SNode* pRight, SNode* pJoinCond) {
SJoinTableNode* joinTable = (SJoinTableNode*)nodesMakeNode(QUERY_NODE_JOIN_TABLE); SJoinTableNode* joinTable = (SJoinTableNode*)nodesMakeNode(QUERY_NODE_JOIN_TABLE);
CHECK_OUT_OF_MEM(joinTable); CHECK_OUT_OF_MEM(joinTable);
joinTable->joinType = type; joinTable->joinType = type;
joinTable->pLeft = releaseRaii(pCxt, pLeft); joinTable->pLeft = pLeft;
joinTable->pRight = releaseRaii(pCxt, pRight); joinTable->pRight = pRight;
joinTable->pOnCond = pJoinCond; joinTable->pOnCond = pJoinCond;
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, joinTable); return (SNode*)joinTable;
} }
SNode* createLimitNode(SAstCreateContext* pCxt, SNode* pLimit, SNode* pOffset) { SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const SToken* pOffset) {
SLimitNode* limitNode = (SLimitNode*)nodesMakeNode(QUERY_NODE_LIMIT); SLimitNode* limitNode = (SLimitNode*)nodesMakeNode(QUERY_NODE_LIMIT);
CHECK_OUT_OF_MEM(limitNode); CHECK_OUT_OF_MEM(limitNode);
// limitNode->limit = limit; // limitNode->limit = limit;
// limitNode->offset = offset; // limitNode->offset = offset;
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, limitNode); return (SNode*)limitNode;
} }
SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder) { SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder) {
SOrderByExprNode* orderByExpr = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); SOrderByExprNode* orderByExpr = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR);
CHECK_OUT_OF_MEM(orderByExpr); CHECK_OUT_OF_MEM(orderByExpr);
orderByExpr->pExpr = releaseRaii(pCxt, pExpr); orderByExpr->pExpr = pExpr;
orderByExpr->order = order; orderByExpr->order = order;
orderByExpr->nullOrder = nullOrder; orderByExpr->nullOrder = nullOrder;
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, orderByExpr); return (SNode*)orderByExpr;
}
SNode* createSessionWindowNode(SAstCreateContext* pCxt, SNode* pCol, const SToken* pVal) {
SSessionWindowNode* session = (SSessionWindowNode*)nodesMakeNode(QUERY_NODE_SESSION_WINDOW);
CHECK_OUT_OF_MEM(session);
session->pCol = pCol;
// session->gap = getInteger(pVal);
return (SNode*)session;
}
SNode* createStateWindowNode(SAstCreateContext* pCxt, SNode* pCol) {
SStateWindowNode* state = (SStateWindowNode*)nodesMakeNode(QUERY_NODE_STATE_WINDOW);
CHECK_OUT_OF_MEM(state);
state->pCol = pCol;
return (SNode*)state;
}
SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode* pOffset, SNode* pSliding, SNode* pFill) {
SIntervalWindowNode* interval = (SIntervalWindowNode*)nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW);
CHECK_OUT_OF_MEM(interval);
interval->pInterval = pInterval;
interval->pOffset = pOffset;
interval->pSliding = pSliding;
interval->pFill = pFill;
return (SNode*)interval;
}
SNode* createFillNode(SAstCreateContext* pCxt, EFillMode mode, SNode* pValues) {
SFillNode* fill = (SFillNode*)nodesMakeNode(QUERY_NODE_FILL);
CHECK_OUT_OF_MEM(fill);
fill->mode = mode;
fill->pValues = pValues;
return (SNode*)fill;
} }
SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias) { SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias) {
@ -148,56 +230,56 @@ SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* p
SNode* addWhereClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWhere) { SNode* addWhereClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWhere) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pWhere = releaseRaii(pCxt, pWhere); ((SSelectStmt*)pStmt)->pWhere = pWhere;
} }
return pStmt; return pStmt;
} }
SNode* addPartitionByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pPartitionByList) { SNode* addPartitionByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pPartitionByList) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pPartitionByList = releaseRaii(pCxt, pPartitionByList); ((SSelectStmt*)pStmt)->pPartitionByList = pPartitionByList;
} }
return pStmt; return pStmt;
} }
SNode* addWindowClauseClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWindow) { SNode* addWindowClauseClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWindow) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pWindow = releaseRaii(pCxt, pWindow); ((SSelectStmt*)pStmt)->pWindow = pWindow;
} }
return pStmt; return pStmt;
} }
SNode* addGroupByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pGroupByList) { SNode* addGroupByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pGroupByList) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pGroupByList = releaseRaii(pCxt, pGroupByList); ((SSelectStmt*)pStmt)->pGroupByList = pGroupByList;
} }
return pStmt; return pStmt;
} }
SNode* addHavingClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pHaving) { SNode* addHavingClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pHaving) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pHaving = releaseRaii(pCxt, pHaving); ((SSelectStmt*)pStmt)->pHaving = pHaving;
} }
return pStmt; return pStmt;
} }
SNode* addOrderByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrderByList) { SNode* addOrderByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrderByList) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pOrderByList = releaseRaii(pCxt, pOrderByList); ((SSelectStmt*)pStmt)->pOrderByList = pOrderByList;
} }
return pStmt; return pStmt;
} }
SNode* addSlimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit) { SNode* addSlimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pSlimit = releaseRaii(pCxt, pSlimit); ((SSelectStmt*)pStmt)->pSlimit = pSlimit;
} }
return pStmt; return pStmt;
} }
SNode* addLimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit) { SNode* addLimitClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit) {
if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) { if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
((SSelectStmt*)pStmt)->pLimit = releaseRaii(pCxt, pLimit); ((SSelectStmt*)pStmt)->pLimit = pLimit;
} }
return pStmt; return pStmt;
} }
@ -209,23 +291,23 @@ SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pPr
if (NULL == pProjectionList) { if (NULL == pProjectionList) {
select->isStar = true; select->isStar = true;
} }
select->pProjectionList = releaseRaii(pCxt, pProjectionList); select->pProjectionList = pProjectionList;
select->pFromTable = releaseRaii(pCxt, pTable); select->pFromTable = pTable;
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, select); return (SNode*)select;
} }
SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight) { SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight) {
SSetOperator* setOp = (SSetOperator*)nodesMakeNode(QUERY_NODE_SET_OPERATOR); SSetOperator* setOp = (SSetOperator*)nodesMakeNode(QUERY_NODE_SET_OPERATOR);
CHECK_OUT_OF_MEM(setOp); CHECK_OUT_OF_MEM(setOp);
setOp->opType = type; setOp->opType = type;
setOp->pLeft = releaseRaii(pCxt, pLeft); setOp->pLeft = pLeft;
setOp->pRight = releaseRaii(pCxt, pRight); setOp->pRight = pRight;
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, setOp); return (SNode*)setOp;
} }
SNode* createShowStmt(SAstCreateContext* pCxt, EShowStmtType type) { SNode* createShowStmt(SAstCreateContext* pCxt, EShowStmtType type) {
SShowStmt* show = (SShowStmt*)nodesMakeNode(QUERY_NODE_SHOW_STMT); SShowStmt* show = (SShowStmt*)nodesMakeNode(QUERY_NODE_SHOW_STMT);
CHECK_OUT_OF_MEM(show); CHECK_OUT_OF_MEM(show);
show->showType = type; show->showType = type;
return acquireRaii(pCxt, AST_CXT_RESOURCE_NODE, show); return (SNode*)show;
} }

1757
source/libs/parser/src/new_sql.c
View File

File diff suppressed because it is too large Load Diff

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

@ -86,15 +86,15 @@ int32_t doParse(SParseContext* pParseCxt, SQuery* pQuery) {
int32_t i = 0; int32_t i = 0;
while (1) { while (1) {
SToken t0 = {0}; SToken t0 = {0};
printf("===========================\n"); // printf("===========================\n");
if (cxt.pQueryCxt->pSql[i] == 0) { if (cxt.pQueryCxt->pSql[i] == 0) {
NewParse(pParser, 0, t0, &cxt); NewParse(pParser, 0, t0, &cxt);
goto abort_parse; goto abort_parse;
} }
printf("input: [%s]\n", cxt.pQueryCxt->pSql + i); // printf("input: [%s]\n", cxt.pQueryCxt->pSql + i);
t0.n = getToken((char *)&cxt.pQueryCxt->pSql[i], &t0.type); t0.n = getToken((char *)&cxt.pQueryCxt->pSql[i], &t0.type);
t0.z = (char *)(cxt.pQueryCxt->pSql + i); t0.z = (char *)(cxt.pQueryCxt->pSql + i);
printf("token : %d %d [%s]\n", t0.type, t0.n, t0.z); // printf("token : %d %d [%s]\n", t0.type, t0.n, t0.z);
i += t0.n; i += t0.n;
switch (t0.type) { switch (t0.type) {
@ -131,7 +131,7 @@ int32_t doParse(SParseContext* pParseCxt, SQuery* pQuery) {
} }
abort_parse: abort_parse:
printf("doParse completed.\n"); // printf("doParse completed.\n");
NewParseFree(pParser, free); NewParseFree(pParser, free);
destroyAstCreateContext(&cxt); destroyAstCreateContext(&cxt);
pQuery->pRoot = cxt.pRootNode; pQuery->pRoot = cxt.pRootNode;

28
source/libs/parser/test/newParserTest.cpp
View File

@ -41,19 +41,10 @@ protected:
bool run(int32_t expectCode = TSDB_CODE_SUCCESS) { bool run(int32_t expectCode = TSDB_CODE_SUCCESS) {
int32_t code = doParse(&cxt_, &query_); int32_t code = doParse(&cxt_, &query_);
if (code != TSDB_CODE_SUCCESS) { if (code != TSDB_CODE_SUCCESS) {
cout << "code:" << tstrerror(code) << ", msg:" << errMagBuf_ << endl; cout << "sql:[" << cxt_.pSql << "] code:" << tstrerror(code) << ", msg:" << errMagBuf_ << endl;
return (code == expectCode); return (code == expectCode);
} }
cout << nodeType(query_.pRoot) << endl;
if (NULL != query_.pRoot && QUERY_NODE_SELECT_STMT == nodeType(query_.pRoot)) { if (NULL != query_.pRoot && QUERY_NODE_SELECT_STMT == nodeType(query_.pRoot)) {
// SNode* pWhereCond;
// SNodeList* pPartitionByList; // SNode
// SNode* pWindowClause;
// SNodeList* pGroupByList; // SGroupingSetNode
// SNodeList* pOrderByList; // SOrderByExprNode
// SLimitNode limit;
// SLimitNode slimit;
SSelectStmt* select = (SSelectStmt*)query_.pRoot; SSelectStmt* select = (SSelectStmt*)query_.pRoot;
string sql("SELECT "); string sql("SELECT ");
if (select->isDistinct) { if (select->isDistinct) {
@ -68,14 +59,6 @@ protected:
tableToSql(select->pFromTable, sql); tableToSql(select->pFromTable, sql);
cout << sql << endl; cout << sql << endl;
} }
// char* pStr = NULL;
// int32_t len = 0;
// code = nodesNodeToString(query_.pRoot, &pStr, &len);
// if (code != TSDB_CODE_SUCCESS) {
// cout << "code:" << tstrerror(code) << ", msg:" << errMagBuf_ << endl;
// return code;
// }
// cout << "node tree:\n" << pStr << endl;
return (code == expectCode); return (code == expectCode);
} }
@ -85,7 +68,6 @@ private:
void tableToSql(const SNode* node, string& sql) { void tableToSql(const SNode* node, string& sql) {
const STableNode* table = (const STableNode*)node; const STableNode* table = (const STableNode*)node;
cout << "node : " << nodeType(node) << endl;
switch (nodeType(node)) { switch (nodeType(node)) {
case QUERY_NODE_REAL_TABLE: { case QUERY_NODE_REAL_TABLE: {
SRealTableNode* realTable = (SRealTableNode*)table; SRealTableNode* realTable = (SRealTableNode*)table;
@ -108,12 +90,14 @@ private:
if (!firstNode) { if (!firstNode) {
sql.append(", "); sql.append(", ");
} }
firstNode = false;
switch (nodeType(node)) { switch (nodeType(node)) {
case QUERY_NODE_COLUMN: case QUERY_NODE_COLUMN:
sql.append(((SColumnNode*)node)->colName); sql.append(((SColumnNode*)node)->colName);
break; break;
} }
} }
sql.append(" ");
} }
void reset() { void reset() {
@ -140,6 +124,12 @@ TEST_F(NewParserTest, selectStar) {
bind("SELECT * FROM test.t1"); bind("SELECT * FROM test.t1");
ASSERT_TRUE(run()); ASSERT_TRUE(run());
bind("SELECT ts FROM t1");
ASSERT_TRUE(run());
bind("SELECT ts, tag1, c1 FROM t1");
ASSERT_TRUE(run());
} }
TEST_F(NewParserTest, syntaxError) { TEST_F(NewParserTest, syntaxError) {

2
source/nodes/src/nodesEqualFuncs.c
View File

@ -91,7 +91,7 @@ static bool logicConditionNodeEqual(const SLogicConditionNode* a, const SLogicCo
static bool isNullConditionNodeEqual(const SIsNullCondNode* a, const SIsNullCondNode* b) { static bool isNullConditionNodeEqual(const SIsNullCondNode* a, const SIsNullCondNode* b) {
COMPARE_NODE_FIELD(pExpr); COMPARE_NODE_FIELD(pExpr);
COMPARE_SCALAR_FIELD(isNot); COMPARE_SCALAR_FIELD(isNull);
return true; return true;
} }

7
source/nodes/src/nodesUtilFuncs.c
View File

@ -92,7 +92,12 @@ SNodeList* nodesListAppend(SNodeList* pList, SNode* pNode) {
return pList; return pList;
} }
p->pNode = pNode; p->pNode = pNode;
pList->pTail->pNext = p; if (NULL == pList->pHead) {
pList->pHead = p;
}
if (NULL != pList->pTail) {
pList->pTail->pNext = p;
}
pList->pTail = p; pList->pTail = p;
return pList; return pList;
} }