/*

Copyright 2017 Google Inc.

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

*/

%{

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--

}

// forceEOF forces the lexer to end prematurely. Not all SQL statements

// are supported by the Parser, thus calling forceEOF will make the lexer

// return EOF early.

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

partitions Partitions

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

setExprs SetExprs

updateExpr *UpdateExpr

setExpr *SetExpr

colIdent ColIdent

tableIdent TableIdent

convertType *ConvertType

aliasedTableName *AliasedTableExpr

TableSpec *TableSpec

columnOption columnOption

columnOptions []columnOption

TableOption TableOption

columnType ColumnType

colKeyOpt ColumnKeyOption

optVal *SQLVal

LengthScaleOption LengthScaleOption

columnDefinition *ColumnDefinition

indexDefinition *IndexDefinition

indexInfo *IndexInfo

indexColumn *IndexColumn

indexColumns []*IndexColumn

partDefs []*PartitionDefinition

partDef *PartitionDefinition

partSpec *PartitionSpec

vindexParam VindexParam

vindexParams []VindexParam

ForeignOptionList []ForeignOption

ForeignOption ForeignOption

}

%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 KEYS

%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> 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

%right <bytes> BINARY UNDERSCORE_BINARY

%left <bytes> COLLATE

%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 ADD

%token <bytes> TABLE INDEX VIEW TO IGNORE IF UNIQUE PRIMARY COLUMN CONSTRAINT SPATIAL FULLTEXT FOREIGN REFERENCES CASCADE RESTRICT NO ACTION

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

%token <bytes> MAXVALUE PARTITION REORGANIZE LESS THAN PROCEDURE TRIGGER

%token <bytes> VINDEX VINDEXES

%token <bytes> ENGINE STATUS VARIABLES

// Transaction Tokens

%token <bytes> BEGIN START TRANSACTION COMMIT ROLLBACK

// 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 VITESS_TABLETS VSCHEMA_TABLES

// SET tokens

%token <bytes> NAMES CHARSET GLOBAL SESSION

// Functions

%token <bytes> CURRENT_TIMESTAMP DATABASE CURRENT_DATE NOW

%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 ID

%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 <statement> begin_statement commit_statement rollback_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 <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 column_list

%type <partitions> opt_partition_clause partition_list

%type <updateExprs> on_dup_opt

%type <updateExprs> update_list

%type <setExprs> set_list

%type <bytes> charset_or_character_set

%type <updateExpr> update_expression

%type <setExpr> set_expression

%type <bytes> for_from

%type <str> ignore_opt default_opt

%type <byt> exists_opt

%type <empty> not_exists_opt non_add_drop_or_rename_operation to_opt index_opt constraint_opt

%type <bytes> reserved_keyword non_reserved_keyword

%type <colIdent> sql_id reserved_sql_id col_alias as_ci_opt using_opt

%type <expr> 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 <str> set_session_or_global show_session_or_global

%type <convertType> convert_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 current_timestamp_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 <columnOption> table_column_option

%type <columnOptions> table_column_opt_list

%type <str> table_opt_value

%type <TableOption> table_option table_option_list

%type <indexInfo> index_info constraint_index_info

%type <ForeignOption> foreign_option_list foreign_option

%type <indexColumn> index_column

%type <indexColumns> index_column_list

%type <partDefs> partition_definitions

%type <partDef> partition_definition

%type <partSpec> partition_operation

%type <vindexParam> vindex_param

%type <vindexParams> vindex_param_list vindex_params_opt

%type <colIdent> vindex_type vindex_type_opt

%type <bytes> alter_object_type

%type <bytes> any_string foreign_action

%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

| begin_statement

| commit_statement

| rollback_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 is an unparenthesized SELECT with no order by clause or beyond.

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 opt_partition_clause insert_data on_dup_opt

{

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

ins := $6

ins.Action = $1

ins.Comments = $2

ins.Ignore = $3

ins.Table = $4

ins.Partitions = $5

ins.OnDup = OnDup($7)

$$ = ins

}

| insert_or_replace comment_opt ignore_opt into_table_name opt_partition_clause SET update_list on_dup_opt

{

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

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

for _, updateList := range $7 {

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

vals = append(vals, updateList.Expr)

}

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

}

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 opt_partition_clause where_expression_opt order_by_opt limit_opt

{

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

}

| 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)

}

opt_partition_clause:

{

$$ = nil

}

| PARTITION openb partition_list closeb

{

$$ = $3

}

set_statement:

SET comment_opt set_list

{

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

}

| SET comment_opt set_session_or_global set_list

{

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

}

set_session_or_global:

SESSION

{

$$ = SessionStr

}

| GLOBAL

{

$$ = GlobalStr

}

create_statement:

create_table_prefix table_spec

{

$1.TableSpec = $2

$$ = $1

}

| create_table_prefix '(' LIKE table_name ')'

{

$$ = $1

$1.Table = $4

$1.LikeTable = $4

}

| CREATE DATABASE not_exists_opt ID table_option_list

{

$$ = &DDL{Action: CreateDatabaseStr, Table: TableName{Qualifier:TableIdent{string($4)}}, TableSpec:&TableSpec{Option:$5}}

}

| 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 VINDEX sql_id vindex_type_opt vindex_params_opt

{

$$ = &DDL{Action: CreateVindexStr, VindexSpec: &VindexSpec{

Name: $3,

Type: $4,

Params: $5,

}}

}

vindex_type_opt:

{

$$ = NewColIdent("")

}

| USING vindex_type

{

$$ = $2

}

vindex_type:

ID

{

$$ = NewColIdent(string($1))

}

vindex_params_opt:

{

var v []VindexParam

$$ = v

}

| WITH vindex_param_list

{

$$ = $2

}

vindex_param_list:

vindex_param

{

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

$$ = append($$, $1)

}

| vindex_param_list ',' vindex_param

{

$$ = append($$, $3)

}

vindex_param:

reserved_sql_id '=' table_opt_value

{

$$ = VindexParam{Key: $1, Val: $3}

}

create_table_prefix:

CREATE TABLE not_exists_opt table_name

{

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

setDDL(yylex, $$)

}

| CREATE TABLE not_exists_opt table_name LIKE table_name

{

$$ = &DDL{Action: CreateTableStr, NewName: $4, Table: $6, LikeTable:$6}

setDDL(yylex, $$)

}

table_spec:

'(' table_column_list ')' table_option_list

{

$$ = $2

$$.Option = $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:

column_name column_type table_column_opt_list

{

$$ = &ColumnDefinition{Name: $1.Name, Type: $2, options:$3}

$$.mergeOptions()

}

table_column_opt_list:

{

$$ = []columnOption{}

}

| table_column_opt_list table_column_option

{

$$ = append($1, $2)

}

table_column_option:

null_opt

{

$$ = columnOption{key:"null_opt", value:$1}

}

| column_default_opt

{

$$ = columnOption{key:"column_default_opt", value:$1}

}

| on_update_opt

{

$$ = columnOption{key:"on_update_opt", value:$1}

}

| auto_increment_opt

{

$$ = columnOption{key:"auto_increment_opt", value:$1}

}

| column_key_opt

{

$$ = columnOption{key:"column_key_opt", value:$1}

}

| column_comment_opt

{

$$ = columnOption{key:"column_comment_opt", value:$1}

}

|charset_opt

{

$$ = columnOption{key:"charset_opt", value:$1}

}

|collate_opt

{

$$ = columnOption{key:"collate_opt", value:$1}

}

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)}

}

| BOOLEAN

{

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

}

decimal_type:

REAL float_length_opt

{

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

$$.Length = $2.Length

$$.Scale = $2.Scale

}

| DOUBLE UNUSED float_length_opt

{

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

$$.Length = $3.Length

$$.Scale = $3.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 ')' charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), EnumValues: $3, Charset: $5, Collate: $6}

}

// need set_values / SetValues ?

| SET '(' enum_values ')' charset_opt collate_opt

{

$$ = ColumnType{Type: string($1), EnumValues: $3, Charset: $5, Collate: $6}

}

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 returns false to mean NULL (i.e. the default) and true for NOT NULL

null_opt:

NULL

{

$$ = BoolVal(false)

}

| NOT NULL

{

$$ = BoolVal(true)

}

column_default_opt:

DEFAULT STRING

{

$$ = NewStrVal($2)

}

| DEFAULT INTEGRAL

{

$$ = NewIntVal($2)

}

| DEFAULT FLOAT

{

$$ = NewFloatVal($2)

}

| DEFAULT NULL

{

$$ = NewValArg($2)

}

| DEFAULT current_timestamp_opt

{

$$ = $2

}

| DEFAULT NOW

{

$$ = NewValArg($2)

}

| DEFAULT NOW '(' ')'

{

$$ = NewValArg($2)

}

| DEFAULT BIT_LITERAL

{

$$ = NewBitVal($2)

}

current_timestamp_opt:

CURRENT_TIMESTAMP

{

$$ = NewValArg($1)

}

| CURRENT_TIMESTAMP '(' INTEGRAL ')'

{

$$ = NewValArg($1)

}

| CURRENT_TIMESTAMP '(' ')'

{

$$ = NewValArg($1)

}

on_update_opt:

ON UPDATE current_timestamp_opt

{

$$ = $3

}

auto_increment_opt:

AUTO_INCREMENT

{

$$ = BoolVal(true)

}

charset_opt:

{

$$ = ""

}

| CHARSET ID

{

$$ = string($2)

}

| CHARSET '=' ID

{

$$ = string($3)

}

| CHARSET STRING

{

$$ = string($2)

}

| CHARSET '=' STRING

{

$$ = string($3)

}

| CHARACTER SET ID

{

$$ = string($3)

}

| CHARACTER SET '=' ID

{

$$ = string($4)

}

| CHARACTER SET STRING

{

$$ = string($3)

}

| CHARACTER SET '=' STRING

{

$$ = string($4)

}

| CHARACTER SET BINARY

{

$$ = string($3)

}

collate_opt: