package sqlparser

import "bytes"

func SetParseTree(yylex interface{}, stmt Statement) {

yylex.(*Tokenizer).ParseTree = stmt

}

func SetAllowComments(yylex interface{}, allow bool) {

yylex.(*Tokenizer).AllowComments = allow

}

func ForceEOF(yylex interface{}) {

yylex.(*Tokenizer).ForceEOF = true

}

var (

SHARE = []byte("share")

MODE = []byte("mode")

IF_BYTES = []byte("if")

VALUES_BYTES = []byte("values")

)

%}

%union {

empty struct{}

statement Statement

selStmt SelectStatement

byt byte

bytes []byte

bytes2 [][]byte

str string

selectExprs SelectExprs

selectExpr SelectExpr

columns Columns

colName *ColName

tableExprs TableExprs

tableExpr TableExpr

smTableExpr SimpleTableExpr

tableName *TableName

indexHints *IndexHints

expr Expr

boolExpr BoolExpr

valExpr ValExpr

colTuple ColTuple

valExprs ValExprs

values Values

rowTuple RowTuple

subquery *Subquery

caseExpr *CaseExpr

whens []*When

when *When

orderBy OrderBy

order *Order

limit *Limit

insRows InsertRows

updateExprs UpdateExprs

updateExpr *UpdateExpr

createTableStmt CreateTable

columnDefinition *ColumnDefinition

columnDefinitions ColumnDefinitions

columnAtts ColumnAtts

}

%token LEX_ERROR

%token <empty> SELECT INSERT UPDATE DELETE FROM WHERE GROUP HAVING ORDER BY LIMIT FOR

%token <empty> ALL DISTINCT AS EXISTS IN IS LIKE BETWEEN NULL ASC DESC VALUES INTO DUPLICATE KEY DEFAULT SET LOCK

%token <bytes> ID STRING NUMBER VALUE_ARG LIST_ARG COMMENT

%token <empty> LE GE NE NULL_SAFE_EQUAL

%token <empty> '(' '=' '<' '>' '~'

%token <empty> PRIMARY

%token <empty> UNIQUE

%left <empty> UNION MINUS EXCEPT INTERSECT

%left <empty> ','

%left <empty> JOIN STRAIGHT_JOIN LEFT RIGHT INNER OUTER CROSS NATURAL USE FORCE

%left <empty> ON

%left <empty> OR

%left <empty> AND

%right <empty> NOT

%left <empty> '&' '|' '^'

%left <empty> '+' '-'

%left <empty> '*' '/' '%'

%nonassoc <empty> '.'

%left <empty> UNARY

%right <empty> CASE WHEN THEN ELSE

%left <empty> END

// DDL Tokens

%token <empty> CREATE ALTER DROP RENAME ANALYZE

%token <empty> TABLE INDEX VIEW TO IGNORE IF USING

%token <empty> SHOW DESCRIBE EXPLAIN

%start any_command

%type <statement> command

%type <selStmt> select_statement

%type <statement> insert_statement update_statement delete_statement set_statement

%type <statement> create_statement alter_statement rename_statement drop_statement

%type <statement> analyze_statement other_statement

%type <bytes2> comment_opt comment_list

%type <str> union_op

%type <str> distinct_opt

%type <selectExprs> select_expression_list

%type <selectExpr> select_expression

%type <bytes> as_lower_opt as_opt

%type <expr> expression

%type <tableExprs> table_expression_list

%type <tableExpr> table_expression

%type <str> join_type

%type <smTableExpr> simple_table_expression

%type <tableName> dml_table_expression

%type <indexHints> index_hint_list

%type <bytes2> index_list

%type <boolExpr> where_expression_opt

%type <boolExpr> boolean_expression condition

%type <str> compare

%type <insRows> row_list

%type <valExpr> value value_expression

%type <colTuple> col_tuple

%type <valExprs> value_expression_list

%type <values> tuple_list

%type <rowTuple> row_tuple

%type <bytes> keyword_as_func

%type <subquery> subquery

%type <byt> unary_operator

%type <colName> column_name

%type <caseExpr> case_expression

%type <whens> when_expression_list

%type <when> when_expression

%type <valExpr> value_expression_opt else_expression_opt

%type <valExprs> group_by_opt

%type <boolExpr> having_opt

%type <orderBy> order_by_opt order_list

%type <order> order

%type <str> asc_desc_opt

%type <limit> limit_opt

%type <str> lock_opt

%type <columns> column_list_opt column_list

%type <updateExprs> on_dup_opt

%type <updateExprs> update_list

%type <updateExpr> update_expression

%type <empty> exists_opt not_exists_opt ignore_opt non_rename_operation to_opt constraint_opt using_opt

%type <bytes> sql_id

%type <empty> force_eof

%token <empty> BIT TINYINT SMALLINT MEDIUMINT INT INTEGER BIGINT REAL DOUBLE FLOAT UNSIGNED ZEROFILL DECIMAL NUMERIC DATE TIME TIMESTAMP DATETIME YEAR

%token <empty> TEXT CHAR VARCHAR

%token <empty> NULLX AUTO_INCREMENT BOOL APPROXNUM INTNUM

%type <str> data_type

%type <columnDefinition> column_definition

%type <columnDefinitions> column_definition_list

%type <statement> create_table_statement

%type <str> length_opt char_type numeric_type unsigned_opt zero_fill_opt key_att int_type decimal_type precision_opt time_type

%type <columnAtts> column_atts

any_command:

command

{

SetParseTree(yylex, $1)

}

command:

select_statement

{

$$ = $1

}

| insert_statement

| update_statement

| delete_statement

| set_statement

| create_statement

| alter_statement

| rename_statement

| drop_statement

| analyze_statement

| other_statement

select_statement:

SELECT comment_opt distinct_opt select_expression_list FROM table_expression_list where_expression_opt group_by_opt having_opt order_by_opt limit_opt lock_opt

{

$$ = &Select{Comments: Comments($2), Distinct: $3, SelectExprs: $4, From: $6, Where: NewWhere(AST_WHERE, $7), GroupBy: GroupBy($8), Having: NewWhere(AST_HAVING, $9), OrderBy: $10, Limit: $11, Lock: $12}

}

| select_statement union_op select_statement %prec UNION

{

$$ = &Union{Type: $2, Left: $1, Right: $3}

}

insert_statement:

INSERT comment_opt INTO dml_table_expression column_list_opt row_list on_dup_opt

{

$$ = &Insert{Comments: Comments($2), Table: $4, Columns: $5, Rows: $6, OnDup: OnDup($7)}

}

| INSERT comment_opt INTO dml_table_expression SET update_list on_dup_opt

{

cols := make(Columns, 0, len($6))

vals := make(ValTuple, 0, len($6))

for _, col := range $6 {

cols = append(cols, &NonStarExpr{Expr: col.Name})

vals = append(vals, col.Expr)

}

$$ = &Insert{Comments: Comments($2), Table: $4, Columns: cols, Rows: Values{vals}, OnDup: OnDup($7)}

}

update_statement:

UPDATE comment_opt dml_table_expression SET update_list where_expression_opt order_by_opt limit_opt

{

$$ = &Update{Comments: Comments($2), Table: $3, Exprs: $5, Where: NewWhere(AST_WHERE, $6), OrderBy: $7, Limit: $8}

}

delete_statement:

DELETE comment_opt FROM dml_table_expression where_expression_opt order_by_opt limit_opt

{

$$ = &Delete{Comments: Comments($2), Table: $4, Where: NewWhere(AST_WHERE, $5), OrderBy: $6, Limit: $7}

}

set_statement:

SET comment_opt update_list

{

$$ = &Set{Comments: Comments($2), Exprs: $3}

}

zero_fill_opt:

{

$$ = ""

}

| ZEROFILL

{

$$ = AST_ZEROFILL

}

data_type:

numeric_type unsigned_opt zero_fill_opt

{

$$ = $1

if $2 != "" {

$$ += " " + $2

}

if $3 != "" {

$$ += " " + $3

}

}

| char_type

| time_type

time_type:

DATE

{

$$ = AST_DATE

}

| TIME

{

$$ = AST_TIME

}

| TIMESTAMP

{

$$ = AST_TIMESTAMP

}

| DATETIME

{

$$ = AST_DATETIME

}

| YEAR

{

$$ = AST_YEAR

}

char_type:

CHAR length_opt

{

if $2 == "" {

$$ = AST_CHAR

} else {

$$ = AST_CHAR + $2

}

}

| VARCHAR length_opt

{

if $2 == "" {

$$ = AST_VARCHAR

} else {

$$ = AST_VARCHAR + $2

}

}

| TEXT

{

$$ = AST_TEXT

}

numeric_type:

int_type length_opt

{

$$ = $1 + $2

}

| decimal_type

{

$$ = $1

}

int_type:

BIT

{

$$ = AST_BIT

}

| TINYINT

{

$$ = AST_TINYINT

}

| SMALLINT

{

$$ = AST_SMALLINT

}

| MEDIUMINT

{

$$ = AST_MEDIUMINT

}

| INT

{

$$ = AST_INT

}

| INTEGER

{

$$ = AST_INTEGER

}

| BIGINT

{

$$ = AST_BIGINT

}

decimal_type:

REAL precision_opt

{

$$ = AST_REAL + $2

}

| DOUBLE precision_opt

{

$$ = AST_DOUBLE + $2

}

| FLOAT precision_opt

{

$$ = AST_FLOAT + $2

}

| DECIMAL precision_opt

{

$$ = AST_DECIMAL + $2

}

| DECIMAL length_opt

{

$$ = AST_DECIMAL + $2

}

| NUMERIC precision_opt

{

$$ = AST_NUMERIC + $2

}

| NUMERIC length_opt

{

$$ = AST_NUMERIC + $2

}

precision_opt:

{

$$ = ""

}

| '(' NUMBER ',' NUMBER ')'

{

$$ = "(" + string($2) + ", " + string($4) + ")"

}

length_opt:

{

$$ = ""

}

| '(' NUMBER ')'

{

$$ = "(" + string($2) + ")"

}

unsigned_opt:

{

$$ = ""

}

| UNSIGNED

{

$$ = AST_UNSIGNED

}

column_atts:

{

$$ = ColumnAtts{}

}

| column_atts NOT NULL

{

$$ = append($$, AST_NOT_NULL)

}

| column_atts NULL

| column_atts DEFAULT STRING

{

node := StrVal($3)

$$ = append($$, "default " + String(node))

}

| column_atts DEFAULT NUMBER

{

node := NumVal($3)

$$ = append($$, "default " + String(node))

}

| column_atts AUTO_INCREMENT

{

$$ = append($$, AST_AUTO_INCREMENT)

}

| column_atts key_att

{

$$ = append($$, $2)

}

key_att:

primary_key

{

$$ = AST_PRIMARY_KEY

}

| unique_key

{

$$ = AST_UNIQUE_KEY

}

primary_key:

PRIMARY KEY

| KEY

unique_key:

UNIQUE

| UNIQUE KEY

column_definition:

ID data_type column_atts

{

$$ = &ColumnDefinition{ColName: string($1), ColType: $2, ColumnAtts: $3 }

}

column_definition_list:

column_definition

{

$$ = ColumnDefinitions{$1}

}

| column_definition_list ',' column_definition

{

$$ = append($$, $3)

}

create_table_statement:

CREATE TABLE not_exists_opt ID '(' column_definition_list ')'

{

$$ = &CreateTable{Name: $4, ColumnDefinitions: $6}

}

create_statement:

create_table_statement

{

$$ = $1

}

| CREATE constraint_opt INDEX sql_id using_opt ON ID force_eof

{

// Change this to an alter statement

$$ = &DDL{Action: AST_ALTER, Table: $7, NewName: $7}

}

| CREATE VIEW sql_id force_eof

{

$$ = &DDL{Action: AST_CREATE, NewName: $3}

}

alter_statement:

ALTER ignore_opt TABLE ID non_rename_operation force_eof

{

$$ = &DDL{Action: AST_ALTER, Table: $4, NewName: $4}

}

| ALTER ignore_opt TABLE ID RENAME to_opt ID

{

// Change this to a rename statement

$$ = &DDL{Action: AST_RENAME, Table: $4, NewName: $7}

}

| ALTER VIEW sql_id force_eof

{

$$ = &DDL{Action: AST_ALTER, Table: $3, NewName: $3}

}

rename_statement:

RENAME TABLE ID TO ID

{

$$ = &DDL{Action: AST_RENAME, Table: $3, NewName: $5}

}

drop_statement:

DROP TABLE exists_opt ID

{

$$ = &DDL{Action: AST_DROP, Table: $4}

}

| DROP INDEX sql_id ON ID

{

// Change this to an alter statement

$$ = &DDL{Action: AST_ALTER, Table: $5, NewName: $5}

}

| DROP VIEW exists_opt sql_id force_eof

{

$$ = &DDL{Action: AST_DROP, Table: $4}

}

analyze_statement:

ANALYZE TABLE ID

{

$$ = &DDL{Action: AST_ALTER, Table: $3, NewName: $3}

}

other_statement:

SHOW force_eof

{

$$ = &Other{}

}

| DESCRIBE force_eof

{

$$ = &Other{}

}

| EXPLAIN force_eof

{

$$ = &Other{}

}

comment_opt:

{

SetAllowComments(yylex, true)

}

comment_list

{

$$ = $2

SetAllowComments(yylex, false)

}

comment_list:

{

$$ = nil

}

| comment_list COMMENT

{

$$ = append($1, $2)

}

union_op:

UNION

{

$$ = AST_UNION

}

| UNION ALL

{

$$ = AST_UNION_ALL

}

| MINUS

{

$$ = AST_SET_MINUS

}

| EXCEPT

{

$$ = AST_EXCEPT

}

| INTERSECT

{

$$ = AST_INTERSECT

}

distinct_opt:

{

$$ = ""

}

| DISTINCT

{

$$ = AST_DISTINCT

}

select_expression_list:

select_expression

{

$$ = SelectExprs{$1}

}

| select_expression_list ',' select_expression

{

$$ = append($$, $3)

}

select_expression:

'*'

{

$$ = &StarExpr{}

}

| expression as_lower_opt

{

$$ = &NonStarExpr{Expr: $1, As: $2}

}

| ID '.' '*'

{

$$ = &StarExpr{TableName: $1}

}

expression:

boolean_expression

{

$$ = $1

}

| value_expression

{

$$ = $1

}

as_lower_opt:

{

$$ = nil

}

| sql_id

{

$$ = $1

}

| AS sql_id

{

$$ = $2

}

table_expression_list:

table_expression

{

$$ = TableExprs{$1}

}

| table_expression_list ',' table_expression

{

$$ = append($$, $3)

}

table_expression:

simple_table_expression as_opt index_hint_list

{

$$ = &AliasedTableExpr{Expr:$1, As: $2, Hints: $3}

}

| '(' table_expression ')'

{

$$ = &ParenTableExpr{Expr: $2}

}

| table_expression join_type table_expression %prec JOIN

{

$$ = &JoinTableExpr{LeftExpr: $1, Join: $2, RightExpr: $3}

}

| table_expression join_type table_expression ON boolean_expression %prec JOIN

{

$$ = &JoinTableExpr{LeftExpr: $1, Join: $2, RightExpr: $3, On: $5}

}

as_opt:

{

$$ = nil

}

| ID

{

$$ = $1

}

| AS ID

{

$$ = $2

}

join_type:

JOIN

{

$$ = AST_JOIN

}

| STRAIGHT_JOIN

{

$$ = AST_STRAIGHT_JOIN

}

| LEFT JOIN

{

$$ = AST_LEFT_JOIN

}

| LEFT OUTER JOIN

{

$$ = AST_LEFT_JOIN

}

| RIGHT JOIN

{

$$ = AST_RIGHT_JOIN

}

| RIGHT OUTER JOIN

{

$$ = AST_RIGHT_JOIN

}

| INNER JOIN

{

$$ = AST_JOIN

}

| CROSS JOIN

{

$$ = AST_CROSS_JOIN

}

| NATURAL JOIN

{

$$ = AST_NATURAL_JOIN

}

simple_table_expression:

{

$$ = &TableName{Name: $1}

}

| ID '.' ID

{

$$ = &TableName{Qualifier: $1, Name: $3}

}

| subquery

{

$$ = $1

}

dml_table_expression:

{

$$ = &TableName{Name: $1}

}

| ID '.' ID

{

$$ = &TableName{Qualifier: $1, Name: $3}

}

index_hint_list:

{

$$ = nil

}

| USE INDEX '(' index_list ')'

{

$$ = &IndexHints{Type: AST_USE, Indexes: $4}

}

| IGNORE INDEX '(' index_list ')'

{

$$ = &IndexHints{Type: AST_IGNORE, Indexes: $4}

}

| FORCE INDEX '(' index_list ')'

{

$$ = &IndexHints{Type: AST_FORCE, Indexes: $4}

}

index_list:

sql_id

{

$$ = [][]byte{$1}

}

| index_list ',' sql_id

{

$$ = append($1, $3)

}

where_expression_opt:

{

$$ = nil

}

| WHERE boolean_expression

{

$$ = $2

}

boolean_expression:

condition

| boolean_expression AND boolean_expression

{

$$ = &AndExpr{Left: $1, Right: $3}

}

| boolean_expression OR boolean_expression

{

$$ = &OrExpr{Left: $1, Right: $3}

}

| NOT boolean_expression

{

$$ = &NotExpr{Expr: $2}

}

| '(' boolean_expression ')'

{

$$ = &ParenBoolExpr{Expr: $2}

}

condition:

value_expression compare value_expression

{

$$ = &ComparisonExpr{Left: $1, Operator: $2, Right: $3}

}

| value_expression IN col_tuple

{

$$ = &ComparisonExpr{Left: $1, Operator: AST_IN, Right: $3}

}

| value_expression NOT IN col_tuple

{

$$ = &ComparisonExpr{Left: $1, Operator: AST_NOT_IN, Right: $4}

}

| value_expression LIKE value_expression

{

$$ = &ComparisonExpr{Left: $1, Operator: AST_LIKE, Right: $3}

}

| value_expression NOT LIKE value_expression

{

$$ = &ComparisonExpr{Left: $1, Operator: AST_NOT_LIKE, Right: $4}

}

| value_expression BETWEEN value_expression AND value_expression

{

$$ = &RangeCond{Left: $1, Operator: AST_BETWEEN, From: $3, To: $5}

}

| value_expression NOT BETWEEN value_expression AND value_expression

{

$$ = &RangeCond{Left: $1, Operator: AST_NOT_BETWEEN, From: $4, To: $6}

}

| value_expression IS NULL

{

$$ = &NullCheck{Operator: AST_IS_NULL, Expr: $1}

}

| value_expression IS NOT NULL

{

$$ = &NullCheck{Operator: AST_IS_NOT_NULL, Expr: $1}

}

| EXISTS subquery

{

$$ = &ExistsExpr{Subquery: $2}

}

compare:

'='

{

$$ = AST_EQ

}

| '<'

{

$$ = AST_LT

}

| '>'

{

$$ = AST_GT

}

| LE

{

$$ = AST_LE

}

| GE

{

$$ = AST_GE

}

| NE

{

$$ = AST_NE

}

| NULL_SAFE_EQUAL

{

$$ = AST_NSE

}

col_tuple:

'(' value_expression_list ')'

{

$$ = ValTuple($2)

}

| subquery

{

$$ = $1

}

| LIST_ARG

{

$$ = ListArg($1)

}

subquery:

'(' select_statement ')'

{

$$ = &Subquery{$2}

}

value_expression_list:

value_expression

{

$$ = ValExprs{$1}

}

| value_expression_list ',' value_expression

{

$$ = append($1, $3)

}

value_expression:

value

{

$$ = $1

}

| column_name

{

$$ = $1

}

| row_tuple

{

$$ = $1

}

| value_expression '&' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_BITAND, Right: $3}

}

| value_expression '|' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_BITOR, Right: $3}

}

| value_expression '^' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_BITXOR, Right: $3}

}

| value_expression '+' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_PLUS, Right: $3}

}

| value_expression '-' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_MINUS, Right: $3}

}

| value_expression '*' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_MULT, Right: $3}

}

| value_expression '/' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_DIV, Right: $3}

}

| value_expression '%' value_expression

{

$$ = &BinaryExpr{Left: $1, Operator: AST_MOD, Right: $3}

}

| unary_operator value_expression %prec UNARY

{

if num, ok := $2.(NumVal); ok {

switch $1 {

case '-':

$$ = append(NumVal("-"), num...)

case '+':

$$ = num

default:

$$ = &UnaryExpr{Operator: $1, Expr: $2}

}

} else {

$$ = &UnaryExpr{Operator: $1, Expr: $2}

}

}

| sql_id '(' ')'

{

$$ = &FuncExpr{Name: $1}

}

| sql_id '(' select_expression_list ')'

{

$$ = &FuncExpr{Name: $1, Exprs: $3}

}

| sql_id '(' DISTINCT select_expression_list ')'

{

$$ = &FuncExpr{Name: $1, Distinct: true, Exprs: $4}

}

| keyword_as_func '(' select_expression_list ')'

{

$$ = &FuncExpr{Name: $1, Exprs: $3}

}

| case_expression

{

$$ = $1

}

keyword_as_func:

IF

{

$$ = IF_BYTES

}

| VALUES

{

$$ = VALUES_BYTES

}

unary_operator:

'+'

{

$$ = AST_UPLUS

}