package sqlparser

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

yylex.(*Tokenizer).ParseTree = stmt

}

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

yylex.(*Tokenizer).AllowComments = allow

}

func setDDL(yylex interface{}, ddl *DDL) {

yylex.(*Tokenizer).partialDDL = ddl

}

func incNesting(yylex interface{}) bool {

yylex.(*Tokenizer).nesting++

if yylex.(*Tokenizer).nesting == 200 {

return true

}

return false

}

func decNesting(yylex interface{}) {

yylex.(*Tokenizer).nesting--

}

func forceEOF(yylex interface{}) {

yylex.(*Tokenizer).ForceEOF = true

}

%union {

empty struct{}

statement Statement

selStmt SelectStatement

ddl *DDL

ins *Insert

byt byte

bytes []byte

bytes2 [][]byte

str string

strs []string

selectExprs SelectExprs

selectExpr SelectExpr

columns Columns

colName *ColName

tableExprs TableExprs

tableExpr TableExpr

joinCondition JoinCondition

tableName TableName

tableNames TableNames

indexHints *IndexHints

expr Expr

exprs Exprs

boolVal BoolVal

colTuple ColTuple

values Values

valTuple ValTuple

subquery *Subquery

whens []*When

when *When

orderBy OrderBy

order *Order

limit *Limit

updateExprs UpdateExprs

updateExpr *UpdateExpr

colIdent ColIdent

colIdents []ColIdent

tableIdent TableIdent

convertType *ConvertType

aliasedTableName *AliasedTableExpr

TableSpec *TableSpec

columnType ColumnType

colKeyOpt ColumnKeyOption

optVal *SQLVal

LengthScaleOption LengthScaleOption

columnDefinition *ColumnDefinition

indexDefinition *IndexDefinition

indexInfo *IndexInfo

indexColumn *IndexColumn

indexColumns []*IndexColumn

partDefs []*PartitionDefinition

partDef *PartitionDefinition

partSpec *PartitionSpec

}

%token LEX_ERROR

%left <bytes> UNION

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

%token <bytes> ALL DISTINCT AS EXISTS ASC DESC INTO DUPLICATE KEY DEFAULT SET LOCK

%token <bytes> VALUES LAST_INSERT_ID

%token <bytes> NEXT VALUE SHARE MODE

%token <bytes> SQL_NO_CACHE SQL_CACHE

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

%left <bytes> ON USING

%token <empty> '(' ',' ')'

%token <bytes> ID HEX STRING INTEGRAL FLOAT HEXNUM VALUE_ARG LIST_ARG COMMENT COMMENT_KEYWORD BIT_LITERAL

%token <bytes> NULL TRUE FALSE

// Precedence dictated by mysql. But the vitess grammar is simplified.

// Some of these operators don't conflict in our situation. Nevertheless,

// it's better to have these listed in the correct order. Also, we don't

// support all operators yet.

%left <bytes> OR

%left <bytes> AND

%right <bytes> NOT '!'

%left <bytes> BETWEEN CASE WHEN THEN ELSE END

%left <bytes> '=' '<' '>' LE GE NE NULL_SAFE_EQUAL IS LIKE REGEXP IN

%left <bytes> '|'

%left <bytes> '&'

%left <bytes> SHIFT_LEFT SHIFT_RIGHT

%left <bytes> '+' '-'

%left <bytes> '*' '/' DIV '%' MOD

%left <bytes> '^'

%right <bytes> '~' UNARY

%left <bytes> COLLATE

%right <bytes> BINARY UNDERSCORE_BINARY

%right <bytes> INTERVAL

%nonassoc <bytes> '.'

// There is no need to define precedence for the JSON

// operators because the syntax is restricted enough that

// they don't cause conflicts.

%token <empty> JSON_EXTRACT_OP JSON_UNQUOTE_EXTRACT_OP

// DDL Tokens

%token <bytes> CREATE ALTER DROP RENAME ANALYZE

%token <bytes> TABLE INDEX VIEW TO IGNORE IF UNIQUE PRIMARY

%token <bytes> SHOW DESCRIBE EXPLAIN DATE ESCAPE REPAIR OPTIMIZE TRUNCATE

%token <bytes> MAXVALUE PARTITION REORGANIZE LESS THAN

// Type Tokens

%token <bytes> BIT TINYINT SMALLINT MEDIUMINT INT INTEGER BIGINT INTNUM

%token <bytes> REAL DOUBLE FLOAT_TYPE DECIMAL NUMERIC

%token <bytes> TIME TIMESTAMP DATETIME YEAR

%token <bytes> CHAR VARCHAR BOOL CHARACTER VARBINARY NCHAR

%token <bytes> TEXT TINYTEXT MEDIUMTEXT LONGTEXT

%token <bytes> BLOB TINYBLOB MEDIUMBLOB LONGBLOB JSON ENUM

// Type Modifiers

%token <bytes> NULLX AUTO_INCREMENT APPROXNUM SIGNED UNSIGNED ZEROFILL

// Supported SHOW tokens

%token <bytes> DATABASES TABLES VITESS_KEYSPACES VITESS_SHARDS VSCHEMA_TABLES

// SET tokens

%token <bytes> NAMES CHARSET

// Functions

%token <bytes> CURRENT_TIMESTAMP DATABASE CURRENT_DATE

%token <bytes> CURRENT_TIME LOCALTIME LOCALTIMESTAMP

%token <bytes> UTC_DATE UTC_TIME UTC_TIMESTAMP

%token <bytes> REPLACE

%token <bytes> CONVERT CAST

%token <bytes> GROUP_CONCAT SEPARATOR

// Match

%token <bytes> MATCH AGAINST BOOLEAN LANGUAGE WITH QUERY EXPANSION

// MySQL reserved words that are unused by this grammar will map to this token.

%token <bytes> UNUSED

%type <statement> command

%type <selStmt> select_statement base_select union_lhs union_rhs

%type <statement> insert_statement update_statement delete_statement set_statement

%type <statement> create_statement alter_statement rename_statement drop_statement truncate_statement

%type <ddl> create_table_prefix

%type <statement> analyze_statement show_statement use_statement other_statement

%type <bytes2> comment_opt comment_list

%type <str> union_op insert_or_replace

%type <str> distinct_opt straight_join_opt cache_opt match_option separator_opt

%type <expr> like_escape_opt

%type <selectExprs> select_expression_list select_expression_list_opt

%type <selectExpr> select_expression

%type <expr> expression

%type <tableExprs> from_opt table_references

%type <tableExpr> table_reference table_factor join_table

%type <joinCondition> join_condition join_condition_opt on_expression_opt

%type <tableNames> table_name_list

%type <str> inner_join outer_join straight_join natural_join

%type <tableName> table_name into_table_name

%type <aliasedTableName> aliased_table_name

%type <indexHints> index_hint_list

%type <colIdents> index_list

%type <expr> where_expression_opt

%type <expr> condition

%type <boolVal> boolean_value

%type <str> compare

%type <ins> insert_data

%type <expr> value value_expression num_val

%type <expr> function_call_keyword function_call_nonkeyword function_call_generic function_call_conflict

%type <str> is_suffix

%type <colTuple> col_tuple

%type <exprs> expression_list

%type <values> tuple_list

%type <valTuple> row_tuple tuple_or_empty

%type <expr> tuple_expression

%type <subquery> subquery

%type <colName> column_name

%type <whens> when_expression_list

%type <when> when_expression

%type <expr> expression_opt else_expression_opt

%type <exprs> group_by_opt

%type <expr> 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> ins_column_list using_column_list

%type <updateExprs> on_dup_opt

%type <updateExprs> update_list

%type <bytes> charset_or_character_set

%type <updateExpr> update_expression

%type <bytes> for_from

%type <str> ignore_opt default_opt

%type <byt> exists_opt

%type <empty> not_exists_opt non_rename_operation to_opt index_opt constraint_opt using_opt

%type <bytes> reserved_keyword non_reserved_keyword

%type <colIdent> sql_id reserved_sql_id col_alias as_ci_opt charset_value

%type <tableIdent> table_id reserved_table_id table_alias as_opt_id

%type <empty> as_opt

%type <empty> force_eof ddl_force_eof

%type <str> charset

%type <convertType> convert_type

%type <str> show_statement_type

%type <columnType> column_type

%type <columnType> int_type decimal_type numeric_type time_type char_type

%type <optVal> length_opt column_default_opt column_comment_opt on_update_opt

%type <str> charset_opt collate_opt

%type <boolVal> unsigned_opt zero_fill_opt

%type <LengthScaleOption> float_length_opt decimal_length_opt

%type <boolVal> null_opt auto_increment_opt

%type <colKeyOpt> column_key_opt

%type <strs> enum_values

%type <columnDefinition> column_definition

%type <indexDefinition> index_definition

%type <str> index_or_key

%type <TableSpec> table_spec table_column_list

%type <str> table_option_list table_option table_opt_value

%type <indexInfo> index_info

%type <indexColumn> index_column

%type <indexColumns> index_column_list

%type <partDefs> partition_definitions

%type <partDef> partition_definition

%type <partSpec> partition_operation

%start any_command

any_command:

command semicolon_opt

{

setParseTree(yylex, $1)

}

semicolon_opt:

/*empty*/ {}

| ';' {}

command:

select_statement

{

$$ = $1

}

| insert_statement

| update_statement

| delete_statement

| set_statement

| create_statement

| alter_statement

| rename_statement

| drop_statement

| truncate_statement

| analyze_statement

| show_statement

| use_statement

| other_statement

select_statement:

base_select order_by_opt limit_opt lock_opt

{

sel := $1.(*Select)

sel.OrderBy = $2

sel.Limit = $3

sel.Lock = $4

$$ = sel

}

| union_lhs union_op union_rhs order_by_opt limit_opt lock_opt

{

$$ = &Union{Type: $2, Left: $1, Right: $3, OrderBy: $4, Limit: $5, Lock: $6}

}

| SELECT comment_opt cache_opt NEXT num_val for_from table_name

{

$$ = &Select{Comments: Comments($2), Cache: $3, SelectExprs: SelectExprs{Nextval{Expr: $5}}, From: TableExprs{&AliasedTableExpr{Expr: $7}}}

}

base_select:

SELECT comment_opt cache_opt distinct_opt straight_join_opt select_expression_list from_opt where_expression_opt group_by_opt having_opt

{

$$ = &Select{Comments: Comments($2), Cache: $3, Distinct: $4, Hints: $5, SelectExprs: $6, From: $7, Where: NewWhere(WhereStr, $8), GroupBy: GroupBy($9), Having: NewWhere(HavingStr, $10)}

}

union_lhs:

select_statement

{

$$ = $1

}

| openb select_statement closeb

{

$$ = &ParenSelect{Select: $2}

}

union_rhs:

base_select

{

$$ = $1

}

| openb select_statement closeb

{

$$ = &ParenSelect{Select: $2}

}

insert_statement:

insert_or_replace comment_opt ignore_opt into_table_name insert_data on_dup_opt

{

// insert_data returns a *Insert pre-filled with Columns & Values

ins := $5

ins.Action = $1

ins.Comments = $2

ins.Ignore = $3

ins.Table = $4

ins.OnDup = OnDup($6)

$$ = ins

}

| insert_or_replace comment_opt ignore_opt into_table_name SET update_list on_dup_opt

{

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

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

for _, updateList := range $6 {

cols = append(cols, updateList.Name.Name)

vals = append(vals, updateList.Expr)

}

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

}

insert_or_replace:

INSERT

{

$$ = InsertStr

}

| REPLACE

{

$$ = ReplaceStr

}

update_statement:

UPDATE comment_opt table_references SET update_list where_expression_opt order_by_opt limit_opt

{

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

}

delete_statement:

DELETE comment_opt FROM table_name where_expression_opt order_by_opt limit_opt

{

$$ = &Delete{Comments: Comments($2), TableExprs: TableExprs{&AliasedTableExpr{Expr:$4}}, Where: NewWhere(WhereStr, $5), OrderBy: $6, Limit: $7}

}

| DELETE comment_opt table_name_list from_or_using table_references where_expression_opt

{

$$ = &Delete{Comments: Comments($2), Targets: $3, TableExprs: $5, Where: NewWhere(WhereStr, $6)}

}

from_or_using:

FROM {}

| USING {}

table_name_list:

table_name

{

$$ = TableNames{$1}

}

| table_name_list ',' table_name

{

$$ = append($$, $3)

}

set_statement:

SET comment_opt charset_or_character_set charset_value force_eof

{

$$ = &Set{Comments: Comments($2), Charset: $4}

}

| SET comment_opt update_list

{

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

}

charset_or_character_set:

CHARSET

| CHARACTER SET

| NAMES

charset_value:

reserved_sql_id

{

$$ = $1

}

| STRING

{

$$ = NewColIdent(string($1))

}

create_statement:

create_table_prefix table_spec

{

$1.TableSpec = $2

$$ = $1

}

| CREATE constraint_opt INDEX ID using_opt ON table_name ddl_force_eof

{

// Change this to an alter statement

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

}

| CREATE VIEW table_name ddl_force_eof

{

$$ = &DDL{Action: CreateStr, NewName: $3.ToViewName()}

}

| CREATE OR REPLACE VIEW table_name ddl_force_eof

{

$$ = &DDL{Action: CreateStr, NewName: $5.ToViewName()}

}

create_table_prefix:

CREATE TABLE not_exists_opt table_name

{

$$ = &DDL{Action: CreateStr, NewName: $4}

setDDL(yylex, $$)

}

table_spec:

'(' table_column_list ')' table_option_list

{

$$ = $2

$$.Options = $4

}

table_column_list:

column_definition

{

$$ = &TableSpec{}

$$.AddColumn($1)

}

| table_column_list ',' column_definition

{

$$.AddColumn($3)

}

| table_column_list ',' index_definition

{

$$.AddIndex($3)

}

column_definition:

ID column_type null_opt column_default_opt on_update_opt auto_increment_opt column_key_opt column_comment_opt

{

$2.NotNull = $3

$2.Default = $4

$2.OnUpdate = $5

$2.Autoincrement = $6

$2.KeyOpt = $7

$2.Comment = $8

$$ = &ColumnDefinition{Name: NewColIdent(string($1)), Type: $2}

}

column_type:

numeric_type unsigned_opt zero_fill_opt

{

$$ = $1

$$.Unsigned = $2

$$.Zerofill = $3

}

| char_type

| time_type

numeric_type:

int_type length_opt

{

$$ = $1

$$.Length = $2

}

| decimal_type

{

$$ = $1

}

int_type:

BIT

{

$$ = ColumnType{Type: string($1)}

}

| TINYINT

{

$$ = ColumnType{Type: string($1)}

}

| SMALLINT

{

$$ = ColumnType{Type: string($1)}

}

| MEDIUMINT

{

$$ = ColumnType{Type: string($1)}

}

| INT

{

$$ = ColumnType{Type: string($1)}

}

| INTEGER

{

$$ = ColumnType{Type: string($1)}

}

| BIGINT

{

$$ = ColumnType{Type: string($1)}

}

decimal_type:

REAL float_length_opt

{

$$ = ColumnType{Type: string($1)}

$$.Length = $2.Length

$$.Scale = $2.Scale

}

| DOUBLE float_length_opt

{

$$ = ColumnType{Type: string($1)}

$$.Length = $2.Length

$$.Scale = $2.Scale

}

| FLOAT_TYPE float_length_opt

{

$$ = ColumnType{Type: string($1)}

$$.Length = $2.Length

$$.Scale = $2.Scale

}

| DECIMAL decimal_length_opt

{

$$ = ColumnType{Type: string($1)}

$$.Length = $2.Length

$$.Scale = $2.Scale

}

| NUMERIC decimal_length_opt

{

$$ = ColumnType{Type: string($1)}

$$.Length = $2.Length

$$.Scale = $2.Scale

}

time_type:

DATE

{

$$ = ColumnType{Type: string($1)}

}

| TIME length_opt

{

$$ = ColumnType{Type: string($1), Length: $2}

}

| TIMESTAMP length_opt

{

$$ = ColumnType{Type: string($1), Length: $2}

}

| DATETIME length_opt

{

$$ = ColumnType{Type: string($1), Length: $2}

}

| YEAR

{

$$ = ColumnType{Type: string($1)}

}

char_type:

CHAR length_opt charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), Length: $2, Charset: $3, Collate: $4}

}

| VARCHAR length_opt charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), Length: $2, Charset: $3, Collate: $4}

}

| BINARY length_opt

{

$$ = ColumnType{Type: string($1), Length: $2}

}

| VARBINARY length_opt

{

$$ = ColumnType{Type: string($1), Length: $2}

}

| TEXT charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), Charset: $2, Collate: $3}

}

| TINYTEXT charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), Charset: $2, Collate: $3}

}

| MEDIUMTEXT charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), Charset: $2, Collate: $3}

}

| LONGTEXT charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), Charset: $2, Collate: $3}

}

| BLOB

{

$$ = ColumnType{Type: string($1)}

}

| TINYBLOB

{

$$ = ColumnType{Type: string($1)}

}

| MEDIUMBLOB

{

$$ = ColumnType{Type: string($1)}

}

| LONGBLOB

{

$$ = ColumnType{Type: string($1)}

}

| JSON

{

$$ = ColumnType{Type: string($1)}

}

| ENUM '(' enum_values ')'

{

$$ = ColumnType{Type: string($1), EnumValues: $3}

}

enum_values:

STRING

{

$$ = make([]string, 0, 4)

$$ = append($$, "'" + string($1) + "'")

}

| enum_values ',' STRING

{

$$ = append($1, "'" + string($3) + "'")

}

length_opt:

{

$$ = nil

}

| '(' INTEGRAL ')'

{

$$ = NewIntVal($2)

}

float_length_opt:

{

$$ = LengthScaleOption{}

}

| '(' INTEGRAL ',' INTEGRAL ')'

{

$$ = LengthScaleOption{

Length: NewIntVal($2),

Scale: NewIntVal($4),

}

}

decimal_length_opt:

{

$$ = LengthScaleOption{}

}

| '(' INTEGRAL ')'

{

$$ = LengthScaleOption{

Length: NewIntVal($2),

}

}

| '(' INTEGRAL ',' INTEGRAL ')'

{

$$ = LengthScaleOption{

Length: NewIntVal($2),

Scale: NewIntVal($4),

}

}

unsigned_opt:

{

$$ = BoolVal(false)

}

| UNSIGNED

{

$$ = BoolVal(true)

}

zero_fill_opt:

{

$$ = BoolVal(false)

}

| ZEROFILL

{

$$ = BoolVal(true)

}

null_opt:

{

$$ = BoolVal(false)

}

| NULL

{

$$ = BoolVal(false)

}

| NOT NULL

{

$$ = BoolVal(true)

}

column_default_opt:

{

$$ = nil

}

| DEFAULT STRING

{

$$ = NewStrVal($2)

}

| DEFAULT INTEGRAL

{

$$ = NewIntVal($2)

}

| DEFAULT FLOAT

{

$$ = NewFloatVal($2)

}

| DEFAULT NULL

{

$$ = NewValArg($2)

}

| DEFAULT CURRENT_TIMESTAMP

{

$$ = NewValArg($2)

}

on_update_opt:

{

$$ = nil

}

| ON UPDATE CURRENT_TIMESTAMP

{

$$ = NewValArg($3)

}

auto_increment_opt:

{

$$ = BoolVal(false)

}

| AUTO_INCREMENT

{

$$ = BoolVal(true)

}

charset_opt:

{

$$ = ""

}

| CHARACTER SET ID

{

$$ = string($3)

}

| CHARACTER SET BINARY

{

$$ = string($3)

}

collate_opt:

{

$$ = ""

}

| COLLATE ID

{

$$ = string($2)

}

column_key_opt:

{

$$ = colKeyNone

}

| PRIMARY KEY

{

$$ = colKeyPrimary

}

| KEY

{

$$ = colKey

}

| UNIQUE KEY

{

$$ = colKeyUniqueKey

}

| UNIQUE

{

$$ = colKeyUnique

}

column_comment_opt:

{

$$ = nil

}

| COMMENT_KEYWORD STRING

{

$$ = NewStrVal($2)

}

index_definition:

index_info '(' index_column_list ')'

{

$$ = &IndexDefinition{Info: $1, Columns: $3}

}

index_info:

PRIMARY KEY

{

$$ = &IndexInfo{Type: string($1) + " " + string($2), Name: NewColIdent("PRIMARY"), Primary: true, Unique: true}

}

| UNIQUE index_or_key ID

{

$$ = &IndexInfo{Type: string($1) + " " + string($2), Name: NewColIdent(string($3)), Unique: true}

}

| UNIQUE ID

{

$$ = &IndexInfo{Type: string($1), Name: NewColIdent(string($2)), Unique: true}

}

| index_or_key ID

{

$$ = &IndexInfo{Type: string($1), Name: NewColIdent(string($2)), Unique: false}

}

index_or_key:

INDEX

{

$$ = string($1)

}

| KEY

{

$$ = string($1)

}

index_column_list:

index_column

{

$$ = []*IndexColumn{$1}

}

| index_column_list ',' index_column

{

$$ = append($$, $3)

}

index_column:

sql_id length_opt

{

$$ = &IndexColumn{Column: $1, Length: $2}

}

table_option_list:

{

$$ = ""

}

| table_option

{

$$ = " " + string($1)

}

| table_option_list ',' table_option

{

$$ = string($1) + ", " + string($3)

}

table_option:

table_opt_value

{

$$ = $1

}

| table_option table_opt_value

{

$$ = $1 + " " + $2

}

| table_option '=' table_opt_value

{

$$ = $1 + "=" + $3

}

table_opt_value:

reserved_sql_id

{

$$ = $1.String()

}

| STRING

{

$$ = "'" + string($1) + "'"

}

| INTEGRAL

{

$$ = string($1)

}

alter_statement:

ALTER ignore_opt TABLE table_name non_rename_operation force_eof

{

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

}

| ALTER ignore_opt TABLE table_name RENAME to_opt table_name

{

// Change this to a rename statement

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

}

| ALTER ignore_opt TABLE table_name RENAME index_opt force_eof

{

// Rename an index can just be an alter

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

}

| ALTER VIEW table_name ddl_force_eof

{

$$ = &DDL{Action: AlterStr, Table: $3.ToViewName(), NewName: $3.ToViewName()}

}

| ALTER ignore_opt TABLE table_name partition_operation

{

$$ = &DDL{Action: AlterStr, Table: $4, PartitionSpec: $5}

}

partition_operation:

REORGANIZE PARTITION sql_id INTO openb partition_definitions closeb

{

$$ = &PartitionSpec{Action: ReorganizeStr, Name: $3, Definitions: $6}

}

partition_definitions:

partition_definition

{

$$ = []*PartitionDefinition{$1}

}

| partition_definitions ',' partition_definition

{

$$ = append($1, $3)

}

partition_definition:

PARTITION sql_id VALUES LESS THAN openb value_expression closeb

{

$$ = &PartitionDefinition{Name: $2, Limit: $7}

}

| PARTITION sql_id VALUES LESS THAN openb MAXVALUE closeb

{

$$ = &PartitionDefinition{Name: $2, Maxvalue: true}

}

rename_statement:

RENAME TABLE table_name TO table_name

{

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

}

drop_statement:

DROP TABLE exists_opt table_name

{

var exists bool

if $3 != 0 {

exists = true

}

$$ = &DDL{Action: DropStr, Table: $4, IfExists: exists}

}

| DROP INDEX ID ON table_name ddl_force_eof

{

// Change this to an alter statement

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

}

| DROP VIEW exists_opt table_name ddl_force_eof

{