github.com/matrixorigin/matrixone@v0.7.0/pkg/sql/parsers/dialect/mysql/mysql_sql.y

// Copyright 2021 Matrix Origin
//
// 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 mysql

import (
    "fmt"
    "strings"
    "go/constant"

    "github.com/matrixorigin/matrixone/pkg/sql/parsers/tree"
    "github.com/matrixorigin/matrixone/pkg/sql/parsers/util"
    "github.com/matrixorigin/matrixone/pkg/defines"
)
%}

%struct {
    id  int
    str string
    item interface{}
}

%union {
    statement tree.Statement
    statements []tree.Statement

    tableDef tree.TableDef
    tableDefs tree.TableDefs
    tableName *tree.TableName
    tableNames tree.TableNames
    columnTableDef *tree.ColumnTableDef
    tableOption tree.TableOption
    tableOptions []tree.TableOption
    tableExprs tree.TableExprs
    tableExpr tree.TableExpr
    rowFormatType tree.RowFormatType
    matchType tree.MatchType
    attributeReference *tree.AttributeReference
    loadParam *tree.ExternParam
    tailParam *tree.TailParameter

    functionName *tree.FunctionName
    funcArg tree.FunctionArg
    funcArgs tree.FunctionArgs
    funcArgDecl *tree.FunctionArgDecl
    funcReturn *tree.ReturnType

    from *tree.From
    where *tree.Where
    groupBy tree.GroupBy
    aliasedTableExpr *tree.AliasedTableExpr
    direction tree.Direction
    nullsPosition tree.NullsPosition
    orderBy tree.OrderBy
    order *tree.Order
    limit *tree.Limit
    unionTypeRecord *tree.UnionTypeRecord
    parenTableExpr *tree.ParenTableExpr
    identifierList tree.IdentifierList
    joinCond tree.JoinCond

    columnType *tree.T
    unresolvedName *tree.UnresolvedName
    lengthScaleOpt tree.LengthScaleOpt
    tuple *tree.Tuple
    funcType tree.FuncType

    columnAttribute tree.ColumnAttribute
    columnAttributes []tree.ColumnAttribute
    attributeNull tree.AttributeNull
    expr tree.Expr
    exprs tree.Exprs
    rowsExprs []tree.Exprs
    comparisonOp tree.ComparisonOp
    referenceOptionType tree.ReferenceOptionType
    referenceOnRecord *tree.ReferenceOnRecord

    select *tree.Select
    selectStatement tree.SelectStatement
    selectExprs tree.SelectExprs
    selectExpr tree.SelectExpr

    insert *tree.Insert
    replace *tree.Replace
    createOption tree.CreateOption
    createOptions []tree.CreateOption
    indexType tree.IndexType
    indexCategory tree.IndexCategory
    keyParts []*tree.KeyPart
    keyPart *tree.KeyPart
    indexOption *tree.IndexOption
    comparisionExpr *tree.ComparisonExpr

    userMiscOption tree.UserMiscOption
    userMiscOptions []tree.UserMiscOption
    updateExpr *tree.UpdateExpr
    updateExprs tree.UpdateExprs
    completionType tree.CompletionType
    varAssignmentExpr *tree.VarAssignmentExpr
    varAssignmentExprs []*tree.VarAssignmentExpr
    setRole *tree.SetRole
    setDefaultRole *tree.SetDefaultRole
    privilege *tree.Privilege
    privileges []*tree.Privilege
    objectType tree.ObjectType
    privilegeType tree.PrivilegeType
    privilegeLevel *tree.PrivilegeLevel
    unresolveNames []*tree.UnresolvedName

    partitionOption *tree.PartitionOption
    clusterByOption *tree.ClusterByOption
    partitionBy *tree.PartitionBy
    windowSpec *tree.WindowSpec
    windowFrame *tree.WindowFrame
    windowFrameBound tree.WindowFrameBound
    windowFrameUnit tree.WindowFrameUnits
    partition *tree.Partition
    partitions []*tree.Partition
    values tree.Values
    numVal *tree.NumVal
    subPartition *tree.SubPartition
    subPartitions []*tree.SubPartition

    subquery *tree.Subquery
    funcExpr *tree.FuncExpr

    roles []*tree.Role
    role *tree.Role
    usernameRecord *tree.UsernameRecord
    authRecord *tree.AuthRecord
    user *tree.User
    users []*tree.User
    tlsOptions []tree.TlsOption
    tlsOption tree.TlsOption
    resourceOption tree.ResourceOption
    resourceOptions []tree.ResourceOption
    unresolvedObjectName *tree.UnresolvedObjectName
    lengthOpt int32
    unsignedOpt bool
    zeroFillOpt bool
    ifNotExists bool
    defaultOptional bool
    fullOpt bool
    boolVal bool
    int64Val int64
    strs []string

    duplicateKey tree.DuplicateKey
    fields *tree.Fields
    fieldsList []*tree.Fields
    lines *tree.Lines
    varExpr *tree.VarExpr
    varExprs []*tree.VarExpr
    loadColumn tree.LoadColumn
    loadColumns []tree.LoadColumn
    assignments []*tree.Assignment
    assignment *tree.Assignment
    properties []tree.Property
    property tree.Property
    exportParm *tree.ExportParam

    epxlainOptions []tree.OptionElem
    epxlainOption tree.OptionElem
    whenClause *tree.When
    whenClauseList []*tree.When
    withClause *tree.With
    cte *tree.CTE
    cteList []*tree.CTE

    accountAuthOption tree.AccountAuthOption
    alterAccountAuthOption tree.AlterAccountAuthOption
    accountIdentified tree.AccountIdentified
    accountStatus tree.AccountStatus
    accountComment tree.AccountComment
    accountCommentOrAttribute tree.AccountCommentOrAttribute
    userIdentified *tree.AccountIdentified
    accountRole *tree.Role
    showType tree.ShowType
    joinTableExpr *tree.JoinTableExpr

    indexHintType tree.IndexHintType
    indexHintScope tree.IndexHintScope
    indexHint *tree.IndexHint
    indexHintList []*tree.IndexHint

    killOption tree.KillOption
    statementOption tree.StatementOption

    tableLock tree.TableLock
    tableLocks []tree.TableLock
    tableLockType tree.TableLockType
}

%token LEX_ERROR
%nonassoc EMPTY
%left <str> UNION EXCEPT INTERSECT MINUS
%token <str> SELECT STREAM INSERT UPDATE DELETE FROM WHERE GROUP HAVING ORDER BY LIMIT OFFSET FOR CONNECT MANAGE GRANTS OWNERSHIP REFERENCE
%nonassoc LOWER_THAN_SET
%nonassoc <str> SET
%token <str> ALL DISTINCT DISTINCTROW AS EXISTS ASC DESC INTO DUPLICATE DEFAULT LOCK KEYS NULLS FIRST LAST
%token <str> VALUES
%token <str> NEXT VALUE SHARE MODE
%token <str> SQL_NO_CACHE SQL_CACHE
%left <str> JOIN STRAIGHT_JOIN LEFT RIGHT INNER OUTER CROSS NATURAL USE FORCE
%nonassoc LOWER_THAN_ON
%nonassoc <str> ON USING
%left <str> SUBQUERY_AS_EXPR
%right <str> '('
%left <str> ')'
%nonassoc LOWER_THAN_STRING
%nonassoc <str> ID AT_ID AT_AT_ID STRING VALUE_ARG LIST_ARG COMMENT COMMENT_KEYWORD
%token <item> INTEGRAL HEX BIT_LITERAL FLOAT
%token <str>  HEXNUM
%token <str> NULL TRUE FALSE
%nonassoc LOWER_THAN_CHARSET
%nonassoc <str> CHARSET
%right <str> UNIQUE KEY
%left <str> OR PIPE_CONCAT
%left <str> XOR
%left <str> AND
%right <str> NOT '!'
%left <str> BETWEEN CASE WHEN THEN ELSE END
%nonassoc LOWER_THAN_EQ
%left <str> '=' '<' '>' LE GE NE NULL_SAFE_EQUAL IS LIKE REGEXP IN ASSIGNMENT ILIKE
%left <str> '|'
%left <str> '&'
%left <str> SHIFT_LEFT SHIFT_RIGHT
%left <str> '+' '-'
%left <str> '*' '/' DIV '%' MOD
%left <str> '^'
%right <str> '~' UNARY
%left <str> COLLATE
%right <str> BINARY UNDERSCORE_BINARY
%right <str> INTERVAL
%nonassoc <str> '.' ','

// Transaction
%token <str> BEGIN START TRANSACTION COMMIT ROLLBACK WORK CONSISTENT SNAPSHOT
%token <str> CHAIN NO RELEASE PRIORITY QUICK

// Type
%token <str> BIT TINYINT SMALLINT MEDIUMINT INT INTEGER BIGINT INTNUM
%token <str> REAL DOUBLE FLOAT_TYPE DECIMAL NUMERIC DECIMAL_VALUE
%token <str> TIME TIMESTAMP DATETIME YEAR
%token <str> CHAR VARCHAR BOOL CHARACTER VARBINARY NCHAR
%token <str> TEXT TINYTEXT MEDIUMTEXT LONGTEXT
%token <str> BLOB TINYBLOB MEDIUMBLOB LONGBLOB JSON ENUM UUID
%token <str> GEOMETRY POINT LINESTRING POLYGON GEOMETRYCOLLECTION MULTIPOINT MULTILINESTRING MULTIPOLYGON
%token <str> INT1 INT2 INT3 INT4 INT8 S3OPTION

// Select option
%token <str> SQL_SMALL_RESULT SQL_BIG_RESULT SQL_BUFFER_RESULT
%token <str> LOW_PRIORITY HIGH_PRIORITY DELAYED

// Create Table
%token <str> CREATE ALTER DROP RENAME ANALYZE ADD RETURNS
%token <str> SCHEMA TABLE INDEX VIEW TO IGNORE IF PRIMARY COLUMN CONSTRAINT SPATIAL FULLTEXT FOREIGN KEY_BLOCK_SIZE
%token <str> SHOW DESCRIBE EXPLAIN DATE ESCAPE REPAIR OPTIMIZE TRUNCATE
%token <str> MAXVALUE PARTITION REORGANIZE LESS THAN PROCEDURE TRIGGER
%token <str> STATUS VARIABLES ROLE PROXY AVG_ROW_LENGTH STORAGE DISK MEMORY
%token <str> CHECKSUM COMPRESSION DATA DIRECTORY DELAY_KEY_WRITE ENCRYPTION ENGINE
%token <str> MAX_ROWS MIN_ROWS PACK_KEYS ROW_FORMAT STATS_AUTO_RECALC STATS_PERSISTENT STATS_SAMPLE_PAGES
%token <str> DYNAMIC COMPRESSED REDUNDANT COMPACT FIXED COLUMN_FORMAT AUTO_RANDOM
%token <str> RESTRICT CASCADE ACTION PARTIAL SIMPLE CHECK ENFORCED
%token <str> RANGE LIST ALGORITHM LINEAR PARTITIONS SUBPARTITION SUBPARTITIONS CLUSTER
%token <str> TYPE ANY SOME EXTERNAL LOCALFILE URL
%token <str> PREPARE DEALLOCATE RESET
%token <str> EXTENSION

// MO table option
%token <str> PROPERTIES

// Index
%token <str> PARSER VISIBLE INVISIBLE BTREE HASH RTREE BSI
%token <str> ZONEMAP LEADING BOTH TRAILING UNKNOWN

// Alter
%token <str> EXPIRE ACCOUNT ACCOUNTS UNLOCK DAY NEVER PUMP MYSQL_COMPATBILITY_MODE

// Time
%token <str> SECOND ASCII COALESCE COLLATION HOUR MICROSECOND MINUTE MONTH QUARTER REPEAT
%token <str> REVERSE ROW_COUNT WEEK

// Revoke
%token <str> REVOKE FUNCTION PRIVILEGES TABLESPACE EXECUTE SUPER GRANT OPTION REFERENCES REPLICATION
%token <str> SLAVE CLIENT USAGE RELOAD FILE TEMPORARY ROUTINE EVENT SHUTDOWN

// Type Modifiers
%token <str> NULLX AUTO_INCREMENT APPROXNUM SIGNED UNSIGNED ZEROFILL ENGINES LOW_CARDINALITY

// Account
%token <str> ADMIN_NAME RANDOM SUSPEND ATTRIBUTE HISTORY REUSE CURRENT OPTIONAL FAILED_LOGIN_ATTEMPTS PASSWORD_LOCK_TIME UNBOUNDED SECONDARY

// User
%token <str> USER IDENTIFIED CIPHER ISSUER X509 SUBJECT SAN REQUIRE SSL NONE PASSWORD
%token <str> MAX_QUERIES_PER_HOUR MAX_UPDATES_PER_HOUR MAX_CONNECTIONS_PER_HOUR MAX_USER_CONNECTIONS

// Explain
%token <str> FORMAT VERBOSE CONNECTION TRIGGERS PROFILES

// Load
%token <str> LOAD INFILE TERMINATED OPTIONALLY ENCLOSED ESCAPED STARTING LINES ROWS IMPORT

// MODump
%token <str> MODUMP

// Window function
%token <str> OVER PRECEDING FOLLOWING GROUPS

// Supported SHOW tokens
%token <str> DATABASES TABLES EXTENDED FULL PROCESSLIST FIELDS COLUMNS OPEN ERRORS WARNINGS INDEXES SCHEMAS NODE LOCKS
%token <str> TABLE_NUMBER COLUMN_NUMBER TABLE_VALUES

// SET tokens
%token <str> NAMES GLOBAL SESSION ISOLATION LEVEL READ WRITE ONLY REPEATABLE COMMITTED UNCOMMITTED SERIALIZABLE
%token <str> LOCAL EVENTS PLUGINS

// Functions
%token <str> CURRENT_TIMESTAMP DATABASE
%token <str> CURRENT_TIME LOCALTIME LOCALTIMESTAMP
%token <str> UTC_DATE UTC_TIME UTC_TIMESTAMP
%token <str> REPLACE CONVERT
%token <str> SEPARATOR TIMESTAMPDIFF
%token <str> CURRENT_DATE CURRENT_USER CURRENT_ROLE

// Time unit
%token <str> SECOND_MICROSECOND MINUTE_MICROSECOND MINUTE_SECOND HOUR_MICROSECOND
%token <str> HOUR_SECOND HOUR_MINUTE DAY_MICROSECOND DAY_SECOND DAY_MINUTE DAY_HOUR YEAR_MONTH
%token <str> SQL_TSI_HOUR SQL_TSI_DAY SQL_TSI_WEEK SQL_TSI_MONTH SQL_TSI_QUARTER SQL_TSI_YEAR
%token <str> SQL_TSI_SECOND SQL_TSI_MINUTE

// With
%token <str> RECURSIVE CONFIG DRAINER

// Match
%token <str> MATCH AGAINST BOOLEAN LANGUAGE WITH QUERY EXPANSION

// Built-in function
%token <str> ADDDATE BIT_AND BIT_OR BIT_XOR CAST COUNT APPROX_COUNT_DISTINCT
%token <str> APPROX_PERCENTILE CURDATE CURTIME DATE_ADD DATE_SUB EXTRACT
%token <str> GROUP_CONCAT MAX MID MIN NOW POSITION SESSION_USER STD STDDEV MEDIAN
%token <str> STDDEV_POP STDDEV_SAMP SUBDATE SUBSTR SUBSTRING SUM SYSDATE
%token <str> SYSTEM_USER TRANSLATE TRIM VARIANCE VAR_POP VAR_SAMP AVG

//JSON function
%token <str> ARROW

// Insert
%token <str> ROW OUTFILE HEADER MAX_FILE_SIZE FORCE_QUOTE PARALLEL

%token <str> UNUSED BINDINGS

// Do
%token <str> DO

// Declare
%token <str> DECLARE

%type <statement> stmt
%type <statements> stmt_list
%type <statement> create_stmt insert_stmt delete_stmt drop_stmt alter_stmt truncate_table_stmt
%type <statement> delete_without_using_stmt delete_with_using_stmt
%type <statement> drop_ddl_stmt drop_database_stmt drop_table_stmt drop_index_stmt drop_prepare_stmt drop_view_stmt drop_function_stmt
%type <statement> drop_account_stmt drop_role_stmt drop_user_stmt
%type <statement> create_account_stmt create_user_stmt create_role_stmt
%type <statement> create_ddl_stmt create_table_stmt create_database_stmt create_index_stmt create_view_stmt create_function_stmt create_extension_stmt
%type <statement> show_stmt show_create_stmt show_columns_stmt show_databases_stmt show_target_filter_stmt show_table_status_stmt show_grants_stmt show_collation_stmt show_accounts_stmt
%type <statement> show_tables_stmt show_process_stmt show_errors_stmt show_warnings_stmt show_target
%type <statement> show_function_status_stmt show_node_list_stmt show_locks_stmt
%type <statement> show_table_num_stmt show_column_num_stmt show_table_values_stmt
%type <statement> show_variables_stmt show_status_stmt show_index_stmt
%type <statement> alter_account_stmt alter_user_stmt alter_view_stmt update_stmt use_stmt update_no_with_stmt alter_database_config_stmt
%type <statement> transaction_stmt begin_stmt commit_stmt rollback_stmt
%type <statement> explain_stmt explainable_stmt
%type <statement> set_stmt set_variable_stmt set_password_stmt set_role_stmt set_default_role_stmt
%type <statement> lock_stmt lock_table_stmt unlock_table_stmt
%type <statement> revoke_stmt grant_stmt
%type <statement> load_data_stmt import_data_stmt
%type <statement> analyze_stmt
%type <statement> prepare_stmt prepareable_stmt deallocate_stmt execute_stmt reset_stmt
%type <statement> replace_stmt
%type <statement> do_stmt
%type <statement> declare_stmt
%type <statement> values_stmt
%type <statement> mo_dump_stmt
%type <statement> load_extension_stmt
%type <statement> kill_stmt
%type <rowsExprs> row_constructor_list
%type <exprs>  row_constructor
%type <exportParm> export_data_param_opt
%type <loadParam> load_param_opt load_param_opt_2
%type <tailParam> tail_param_opt

%type <select> select_stmt select_no_parens
%type <selectStatement> simple_select select_with_parens simple_select_clause
%type <selectExprs> select_expression_list
%type <selectExpr> select_expression
%type <tableExprs> table_name_wild_list
%type <joinTableExpr>  table_references join_table
%type <tableExpr> into_table_name table_function table_factor table_reference escaped_table_reference
%type <direction> asc_desc_opt
%type <nullsPosition> nulls_first_last_opt
%type <order> order
%type <orderBy> order_list order_by_clause order_by_opt
%type <limit> limit_opt limit_clause
%type <str> insert_column
%type <identifierList> column_list column_list_opt partition_clause_opt partition_id_list insert_column_list accounts_opt accounts_list
%type <joinCond> join_condition join_condition_opt on_expression_opt

%type <functionName> func_name
%type <funcArgs> func_args_list_opt func_args_list
%type <funcArg> func_arg
%type <funcArgDecl> func_arg_decl
%type <funcReturn> func_return
%type <str> func_lang extension_lang extension_name

%type <tableDefs> table_elem_list_opt table_elem_list
%type <tableDef> table_elem constaint_def constraint_elem
%type <tableName> table_name table_name_opt_wild
%type <tableNames> table_name_list
%type <columnTableDef> column_def
%type <columnType> mo_cast_type mysql_cast_type
%type <columnType> column_type char_type spatial_type time_type numeric_type decimal_type int_type
%type <str> integer_opt
%type <columnAttribute> column_attribute_elem keys
%type <columnAttributes> column_attribute_list column_attribute_list_opt
%type <tableOptions> table_option_list_opt table_option_list
%type <str> charset_name storage_opt collate_name column_format storage_media
%type <rowFormatType> row_format_options
%type <int64Val> field_length_opt max_file_size_opt
%type <matchType> match match_opt
%type <referenceOptionType> ref_opt on_delete on_update
%type <referenceOnRecord> on_delete_update_opt
%type <attributeReference> references_def

%type <tableOption> table_option
%type <from> from_clause from_opt
%type <where> where_expression_opt having_opt
%type <groupBy> group_by_opt
%type <aliasedTableExpr> aliased_table_name
%type <unionTypeRecord> union_op
%type <parenTableExpr> table_subquery
%type <str> inner_join straight_join outer_join natural_join
%type <funcType> func_type_opt
%type <funcExpr> function_call_generic
%type <funcExpr> function_call_keyword
%type <funcExpr> function_call_nonkeyword
%type <funcExpr> function_call_aggregate

%type <unresolvedName> column_name column_name_unresolved
%type <strs> enum_values force_quote_opt force_quote_list infile_or_s3_param infile_or_s3_params
%type <str> sql_id charset_keyword db_name db_name_opt
%type <str> not_keyword func_not_keyword
%type <str> reserved_keyword non_reserved_keyword
%type <str> equal_opt reserved_sql_id reserved_table_id
%type <str> as_name_opt as_opt_id table_id id_or_var name_string ident
%type <str> database_id table_alias explain_sym prepare_sym deallocate_sym stmt_name reset_sym
%type <unresolvedObjectName> unresolved_object_name table_column_name
%type <unresolvedObjectName> table_name_unresolved
%type <comparisionExpr> like_opt
%type <fullOpt> full_opt
%type <str> database_name_opt auth_string constraint_keyword_opt constraint_keyword
%type <userMiscOption> pwd_or_lck pwd_or_lck_opt
//%type <userMiscOptions> pwd_or_lck_list

%type <expr> literal
%type <expr> predicate
%type <expr> bit_expr interval_expr
%type <expr> simple_expr else_opt
%type <expr> expression like_escape_opt boolean_primary col_tuple expression_opt
%type <exprs> expression_list_opt
%type <exprs> expression_list row_value window_partition_by window_partition_by_opt
%type <expr> datetime_precision_opt datetime_precision
%type <tuple> tuple_expression
%type <comparisonOp> comparison_operator and_or_some
%type <createOption> create_option
%type <createOptions> create_option_list_opt create_option_list
%type <ifNotExists> not_exists_opt
%type <defaultOptional> default_opt
%type <str> database_or_schema
%type <indexType> using_opt
%type <indexCategory> index_prefix
%type <keyParts> index_column_list index_column_list_opt
%type <keyPart> index_column
%type <indexOption> index_option_list index_option
%type <roles> role_spec_list using_roles_opt
%type <role> role_spec
%type <str> role_name
%type <usernameRecord> user_name
%type <user> user_spec drop_user_spec user_spec_with_identified
%type <users> user_spec_list drop_user_spec_list user_spec_list_of_create_user
//%type <tlsOptions> require_clause_opt require_clause require_list
//%type <tlsOption> require_elem
//%type <resourceOptions> conn_option_list conn_options
//%type <resourceOption> conn_option
%type <updateExpr> update_value
%type <updateExprs> update_list on_duplicate_key_update_opt
%type <completionType> completion_type
%type <str> password_opt
%type <boolVal> grant_option_opt enforce enforce_opt

%type <varAssignmentExpr> var_assignment
%type <varAssignmentExprs> var_assignment_list
%type <str> var_name equal_or_assignment
%type <strs> var_name_list
%type <expr> set_expr
//%type <setRole> set_role_opt
%type <setDefaultRole> set_default_role_opt
%type <privilege> priv_elem
%type <privileges> priv_list
%type <objectType> object_type
%type <privilegeType> priv_type
%type <privilegeLevel> priv_level
%type <unresolveNames> column_name_list
%type <partitionOption> partition_by_opt
%type <clusterByOption> cluster_by_opt
%type <partitionBy> partition_method sub_partition_method sub_partition_opt
%type <windowSpec> window_spec_opt
%type <windowFrame> window_frame window_frame_opt
%type <windowFrameBound> window_frame_bound
%type <windowFrameUnit> window_frame_unit
%type <str> fields_or_columns
%type <int64Val> algorithm_opt partition_num_opt sub_partition_num_opt
%type <boolVal> linear_opt
%type <partition> partition
%type <partitions> partition_list_opt partition_list
%type <values> values_opt
%type <tableOptions> partition_option_list
%type <subPartition> sub_partition
%type <subPartitions> sub_partition_list sub_partition_list_opt
%type <subquery> subquery

%type <lengthOpt> length_opt length_option_opt length timestamp_option_opt
%type <lengthScaleOpt> float_length_opt decimal_length_opt
%type <unsignedOpt> unsigned_opt header_opt parallel_opt
%type <zeroFillOpt> zero_fill_opt
%type <boolVal> global_scope exists_opt distinct_opt temporary_opt
%type <item> pwd_expire clear_pwd_opt
%type <str> name_confict distinct_keyword separator_opt
%type <insert> insert_data
%type <replace> replace_data
%type <rowsExprs> values_list
%type <str> name_datetime_precision braces_opt name_braces
%type <str> std_dev_pop extended_opt
%type <expr> expr_or_default
%type <exprs> data_values data_opt row_value

%type <boolVal> local_opt
%type <duplicateKey> duplicate_opt
%type <fields> load_fields field_item export_fields
%type <fieldsList> field_item_list
%type <str> field_terminator starting_opt lines_terminated_opt starting lines_terminated
%type <lines> load_lines export_lines_opt
%type <int64Val> ignore_lines
%type <varExpr> user_variable variable system_variable
%type <varExprs> variable_list
%type <loadColumn> columns_or_variable
%type <loadColumns> columns_or_variable_list columns_or_variable_list_opt
%type <unresolvedName> normal_ident
%type <updateExpr> load_set_item
%type <updateExprs> load_set_list load_set_spec_opt
%type <strs> index_name_and_type_opt index_name_list
%type <str> index_name index_type key_or_index_opt key_or_index
// type <str> mo_keywords
%type <properties> properties_list
%type <property> property_elem
%type <assignments> set_value_list
%type <assignment> set_value
%type <str> row_opt substr_option
%type <str> time_unit time_stamp_unit
%type <whenClause> when_clause
%type <whenClauseList> when_clause_list
%type <withClause> with_clause
%type <cte> common_table_expr
%type <cteList> cte_list

%type <epxlainOptions> utility_option_list
%type <epxlainOption> utility_option_elem
%type <str> utility_option_name utility_option_arg
%type <str> explain_option_key select_option_opt
%type <str> explain_foramt_value trim_direction
%type <str> priority_opt priority quick_opt ignore_opt wild_opt

%type <str> account_name account_admin_name account_role_name
%type <accountAuthOption> account_auth_option
%type <alterAccountAuthOption> alter_account_auth_option
%type <accountIdentified> account_identified
%type <accountStatus> account_status_option
%type <accountComment> account_comment_opt
%type <accountCommentOrAttribute> user_comment_or_attribute_opt
%type <userIdentified> user_identified user_identified_opt
%type <accountRole> default_role_opt

%type <indexHintType> index_hint_type
%type <indexHintScope> index_hint_scope
%type <indexHint> index_hint
%type <indexHintList> index_hint_list index_hint_list_opt

%token <str> KILL
%type <killOption> kill_opt
%type <statementOption> statement_id_opt
%token <str> QUERY_RESULT
%start start_command

%type<tableLock> table_lock_elem
%type<tableLocks> table_lock_list
%type<tableLockType> table_lock_type

%%

start_command:
    stmt_list

stmt_list:
    stmt
    {
        if $1 != nil {
            yylex.(*Lexer).AppendStmt($1)
        }
    }
|   stmt_list ';' stmt
    {
        if $3 != nil {
            yylex.(*Lexer).AppendStmt($3)
        }
    }

stmt:
    create_stmt
|   mo_dump_stmt
|   insert_stmt
|   replace_stmt
|   delete_stmt
|   drop_stmt
|   truncate_table_stmt
|   explain_stmt
|   prepare_stmt
|   deallocate_stmt
|   reset_stmt
|   execute_stmt
|   show_stmt
|   alter_stmt
|   analyze_stmt
|   update_stmt
|   use_stmt
|   transaction_stmt
|   set_stmt
|   lock_stmt
|   revoke_stmt
|   grant_stmt
|   load_data_stmt
|   import_data_stmt
|   load_extension_stmt
|   do_stmt
|   declare_stmt
|   values_stmt
|   select_stmt
    {
        $$ = $1
    }
|   kill_stmt
|   /* EMPTY */
    {
        $$ = tree.Statement(nil)
    }

kill_stmt:
    KILL kill_opt INTEGRAL statement_id_opt
    {
        var connectionId uint64
        switch v := $3.(type) {
        case uint64:
	    connectionId = v
        case int64:
	    connectionId = uint64(v)
        default:
	    yylex.Error("parse integral fail")
	    return 1
        }

	$$ = &tree.Kill{
            Option: $2,
            ConnectionId: connectionId,
            StmtOption:  $4,
	}
    }

kill_opt:
{
    $$ = tree.KillOption{
        Exist: false,
    }
}
| CONNECTION
{
    $$ = tree.KillOption{
	Exist: true,
	Typ: tree.KillTypeConnection,
    }
}
| QUERY
{
    $$ = tree.KillOption{
	Exist: true,
	Typ: tree.KillTypeQuery,
    }
}

statement_id_opt:
{
    $$ = tree.StatementOption{
        Exist: false,
    }
}
| STRING
{
    $$ = tree.StatementOption{
        Exist: true,
        StatementId: $1,
    }
}

mo_dump_stmt:
    MODUMP DATABASE database_id INTO STRING max_file_size_opt
    {
	$$ = &tree.MoDump{
	    DumpDatabase: true,
	    Database: tree.Identifier($3),
	    OutFile: $5,
	    MaxFileSize: int64($6),
	}
    }
|   MODUMP DATABASE database_id TABLES table_name_list INTO STRING max_file_size_opt
    {
	$$ = &tree.MoDump{
	    DumpDatabase: true,
	    Database: tree.Identifier($3),
	    Tables: $5,
	    OutFile: $7,
	    MaxFileSize: int64($8),
	}
    }
|   MODUMP QUERY_RESULT STRING INTO STRING export_fields export_lines_opt header_opt max_file_size_opt force_quote_opt
    {
        ep := &tree.ExportParam{
		Outfile:    true,
		QueryId:    $3,
		FilePath :  $5,
		Fields:     $6,
		Lines:      $7,
		Header:     $8,
		MaxFileSize:uint64($9)*1024,
		ForceQuote: $10,
	}
        $$ = &tree.MoDump{
            DumpDatabase: false,
            ExportParams: ep,
        }
    }



import_data_stmt:
    IMPORT DATA local_opt load_param_opt duplicate_opt INTO TABLE table_name tail_param_opt
    {
        $$ = &tree.Import{
            Local: $3,
            Param: $4,
            DuplicateHandling: $5,
            Table: $8,
        }
        $$.(*tree.Import).Param.Tail = $9
    }

load_data_stmt:
    LOAD DATA local_opt load_param_opt duplicate_opt INTO TABLE table_name accounts_opt tail_param_opt parallel_opt
    {
        $$ = &tree.Load{
            Local: $3,
            Param: $4,
            DuplicateHandling: $5,
            Table: $8,
            Accounts: $9,
        }
        $$.(*tree.Load).Param.Tail = $10
        $$.(*tree.Load).Param.Parallel = $11
    }

load_extension_stmt:
    LOAD extension_name
    {
        $$ = &tree.LoadExtension{
            Name: tree.Identifier($2),
        }
    }

load_set_spec_opt:
    {
        $$ = nil
    }
|   SET load_set_list
    {
        $$ = $2
    }

load_set_list:
    load_set_item
    {
        $$ = tree.UpdateExprs{$1}
    }
|   load_set_list ',' load_set_item
    {
        $$ = append($1, $3)
    }

load_set_item:
    normal_ident '=' DEFAULT
    {
        $$ = &tree.UpdateExpr{
            Names: []*tree.UnresolvedName{$1},
            Expr: &tree.DefaultVal{},
        }
    }
|   normal_ident '=' expression
    {
        $$ = &tree.UpdateExpr{
            Names: []*tree.UnresolvedName{$1},
            Expr: $3,
        }
    }

parallel_opt:
    {
        $$ = false
    }
|   PARALLEL STRING
    {
        str := strings.ToLower($2)
        if str == "true" {
            $$ = true
        } else if str == "false" {
            $$ = false
        } else {
            yylex.Error("error parallel flag")
            return 1
        }
    }

normal_ident:
    ident
    {
        $$ = tree.SetUnresolvedName($1)
    }
|   ident '.' ident
    {
        $$ = tree.SetUnresolvedName($1, $3)
    }
|   ident '.' ident '.' ident
    {
        $$ = tree.SetUnresolvedName($1, $3, $5)
    }

columns_or_variable_list_opt:
    {
        $$ = nil
    }
|   '(' ')'
    {
        $$ = nil
    }
|   '(' columns_or_variable_list ')'
    {
        $$ = $2
    }

columns_or_variable_list:
    columns_or_variable
    {
        switch $1.(type) {
        case *tree.UnresolvedName:
            $$ = []tree.LoadColumn{$1.(*tree.UnresolvedName)}
        case *tree.VarExpr:
            $$ = []tree.LoadColumn{$1.(*tree.VarExpr)}
        }
    }
|   columns_or_variable_list ',' columns_or_variable
    {
        switch $3.(type) {
        case *tree.UnresolvedName:
            $$ = append($1, $3.(*tree.UnresolvedName))
        case *tree.VarExpr:
            $$ = append($1, $3.(*tree.VarExpr))
        }
    }

columns_or_variable:
    column_name_unresolved
    {
        $$ = $1
    }
|   user_variable
    {
        $$ = $1
    }

variable_list:
    variable
    {
        $$ = []*tree.VarExpr{$1}
    }
|   variable_list ',' variable
    {
        $$ = append($1, $3)
    }

variable:
    system_variable
    {
        $$ = $1
    }
|   user_variable
    {
        $$ = $1
    }

system_variable:
    AT_AT_ID
    {
        vs := strings.Split($1, ".")
        var isGlobal bool
        if strings.ToLower(vs[0]) == "global" {
            isGlobal = true
        }
        var r string
        if len(vs) == 2 {
           r = vs[1]
        } else if len(vs) == 1 {
           r = vs[0]
        } else {
            yylex.Error("variable syntax error")
            return 1
        }
        $$ = &tree.VarExpr{
            Name: r,
            System: true,
            Global: isGlobal,
        }
    }

user_variable:
    AT_ID
    {
//        vs := strings.Split($1, ".")
//        var r string
//        if len(vs) == 2 {
//           r = vs[1]
//        } else if len(vs) == 1 {
//           r = vs[0]
//        } else {
//            yylex.Error("variable syntax error")
//            return 1
//        }
        $$ = &tree.VarExpr{
            Name: $1,
            System: false,
            Global: false,
        }
    }

ignore_lines:
    {
        $$ = 0
    }
|   IGNORE INTEGRAL LINES
    {
        $$ = $2.(int64)
    }
|   IGNORE INTEGRAL ROWS
    {
        $$ = $2.(int64)
    }

load_lines:
    {
        $$ = nil
    }
|   LINES starting lines_terminated_opt
    {
        $$ = &tree.Lines{
            StartingBy: $2,
            TerminatedBy: $3,
        }
    }
|   LINES lines_terminated starting_opt
    {
        $$ = &tree.Lines{
            StartingBy: $3,
            TerminatedBy: $2,
        }
    }

starting_opt:
    {
        $$ = ""
    }
|   starting

starting:
    STARTING BY STRING
    {
        $$ = $3
    }

lines_terminated_opt:
    {
        $$ = "\n"
    }
|   lines_terminated

lines_terminated:
    TERMINATED BY STRING
    {
        $$ = $3
    }

load_fields:
    {
        $$ = nil
    }
|   fields_or_columns field_item_list
    {
        res := &tree.Fields{
            Terminated: "\t",
            EscapedBy:    0,
        }
        for _, f := range $2 {
            if f.Terminated != "" {
                res.Terminated = f.Terminated
            }
            if f.Optionally {
                res.Optionally = f.Optionally
            }
            if f.EnclosedBy != 0 {
                res.EnclosedBy = f.EnclosedBy
            }
            if f.EscapedBy != 0 {
                res.EscapedBy = f.EscapedBy
            }
        }
        $$ = res
    }

field_item_list:
    field_item
    {
        $$ = []*tree.Fields{$1}
    }
|   field_item_list field_item
    {
        $$ = append($1, $2)
    }

field_item:
    TERMINATED BY field_terminator
    {
        $$ = &tree.Fields{
            Terminated: $3,
        }
    }
|   OPTIONALLY ENCLOSED BY field_terminator
    {
        str := $4
        if str != "\\" && len(str) > 1 {
            yylex.Error("error field terminator")
            return 1
        }
        var b byte
        if len(str) != 0 {
            b = byte(str[0])
        } else {
            b = 0
        }
        $$ = &tree.Fields{
            Optionally: true,
            EnclosedBy: b,
        }
    }
|   ENCLOSED BY field_terminator
    {
        str := $3
        if str != "\\" && len(str) > 1 {
            yylex.Error("error field terminator")
            return 1
        }
        var b byte
        if len(str) != 0 {
           b = byte(str[0])
        } else {
           b = 0
        }
        $$ = &tree.Fields{
            EnclosedBy: b,
        }
    }
|   ESCAPED BY field_terminator
    {
        str := $3
        if str != "\\" && len(str) > 1 {
            yylex.Error("error field terminator")
            return 1
        }
        var b byte
        if len(str) != 0 {
           b = byte(str[0])
        } else {
           b = 0
        }
        $$ = &tree.Fields{
            EscapedBy: b,
        }
    }

field_terminator:
    STRING
// |   HEXNUM
// |   BIT_LITERAL

duplicate_opt:
    {
        $$ = &tree.DuplicateKeyError{}
    }
|   IGNORE
    {
        $$ = &tree.DuplicateKeyIgnore{}
    }
|   REPLACE
    {
        $$ = &tree.DuplicateKeyReplace{}
    }

local_opt:
    {
        $$ = false
    }
|   LOCAL
    {
        $$ = true
    }

grant_stmt:
    GRANT priv_list ON object_type priv_level TO role_spec_list grant_option_opt
    {
        $$ = &tree.Grant{
            Typ: tree.GrantTypePrivilege,
            GrantPrivilege: tree.GrantPrivilege{
                Privileges: $2,
                ObjType: $4,
                Level: $5,
                Roles: $7,
                GrantOption: $8,
            },
        }
    }
|   GRANT role_spec_list TO drop_user_spec_list grant_option_opt
    {
        $$ = &tree.Grant{
            Typ: tree.GrantTypeRole,
            GrantRole:tree.GrantRole{
                Roles: $2,
                Users: $4,
                GrantOption: $5,
            },
        }
    }
|   GRANT PROXY ON user_spec TO user_spec_list grant_option_opt
    {
        $$ =  &tree.Grant{
            Typ: tree.GrantTypeProxy,
            GrantProxy:tree.GrantProxy{
                ProxyUser: $4,
                Users: $6,
                GrantOption: $7,
            },
        }

    }

grant_option_opt:
    {
        $$ = false
    }
|   WITH GRANT OPTION
    {
        $$ = true
    }
// |    WITH MAX_QUERIES_PER_HOUR INTEGRAL
// |    WITH MAX_UPDATES_PER_HOUR INTEGRAL
// |    WITH MAX_CONNECTIONS_PER_HOUR INTEGRAL
// |    WITH MAX_USER_CONNECTIONS INTEGRAL

revoke_stmt:
    REVOKE exists_opt  priv_list ON object_type priv_level FROM role_spec_list
    {
        $$ = &tree.Revoke{
            Typ: tree.RevokeTypePrivilege,
            RevokePrivilege: tree.RevokePrivilege{
                IfExists: $2,
                Privileges: $3,
                ObjType: $5,
                Level: $6,
                Roles: $8,
            },
        }
    }
|   REVOKE exists_opt role_spec_list FROM user_spec_list
    {
        $$ = &tree.Revoke{
            Typ: tree.RevokeTypeRole,
            RevokeRole: tree.RevokeRole{
                IfExists: $2,
                Roles: $3,
                Users: $5,
            },
        }
    }

priv_level:
    '*'
    {
        $$ = &tree.PrivilegeLevel{
            Level: tree.PRIVILEGE_LEVEL_TYPE_STAR,
        }
    }
|   '*' '.' '*'
    {
        $$ = &tree.PrivilegeLevel{
            Level: tree.PRIVILEGE_LEVEL_TYPE_STAR_STAR,
        }
    }
|   ID '.' '*'
    {
        $$ = &tree.PrivilegeLevel{
            Level: tree.PRIVILEGE_LEVEL_TYPE_DATABASE_STAR,
            DbName: $1,
        }
    }
|   ID '.' ID
    {
        $$ = &tree.PrivilegeLevel{
            Level: tree.PRIVILEGE_LEVEL_TYPE_DATABASE_TABLE,
            DbName: $1,
            TabName: $3,
        }
    }
|   ID
    {
        $$ = &tree.PrivilegeLevel{
            Level: tree.PRIVILEGE_LEVEL_TYPE_TABLE,
            TabName: $1,
        }
    }

object_type:
    TABLE
    {
        $$ = tree.OBJECT_TYPE_TABLE
    }
|   DATABASE
    {
        $$ = tree.OBJECT_TYPE_DATABASE
    }
|   FUNCTION
    {
        $$ = tree.OBJECT_TYPE_FUNCTION
    }
|   PROCEDURE
    {
        $$ = tree.OBJECT_TYPE_PROCEDURE
    }
|   VIEW
    {
        $$ = tree.OBJECT_TYPE_VIEW
    }
|   ACCOUNT
    {
        $$ = tree.OBJECT_TYPE_ACCOUNT
    }


priv_list:
    priv_elem
    {
        $$ = []*tree.Privilege{$1}
    }
|   priv_list ',' priv_elem
    {
        $$ = append($1, $3)
    }

priv_elem:
    priv_type
    {
        $$ = &tree.Privilege{
            Type: $1,
            ColumnList: nil,
        }
    }
|   priv_type '(' column_name_list ')'
    {
        $$ = &tree.Privilege{
            Type: $1,
            ColumnList: $3,
        }
    }

column_name_list:
    column_name
    {
        $$ = []*tree.UnresolvedName{$1}
    }
|   column_name_list ',' column_name
    {
        $$ = append($1, $3)
    }

priv_type:
    ALL
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_ALL
    }
|    CREATE ACCOUNT
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_ACCOUNT
    }
|    DROP ACCOUNT
        {
            $$ = tree.PRIVILEGE_TYPE_STATIC_DROP_ACCOUNT
        }
|    ALTER ACCOUNT
        {
                $$ = tree.PRIVILEGE_TYPE_STATIC_ALTER_ACCOUNT
        }
|    ALL PRIVILEGES
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_ALL
    }
|    ALTER TABLE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_ALTER_TABLE
    }
|    ALTER VIEW
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_ALTER_VIEW
    }
|    CREATE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE
    }
|    CREATE USER
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_USER
    }
|    DROP USER
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_DROP_USER
    }
|    ALTER USER
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_ALTER_USER
    }
|    CREATE TABLESPACE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_TABLESPACE
    }
|    TRIGGER
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_TRIGGER
    }
|    DELETE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_DELETE
    }
|    DROP TABLE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_DROP_TABLE
    }
|    DROP VIEW
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_DROP_VIEW
    }
|    EXECUTE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_EXECUTE
    }
|    INDEX
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_INDEX
    }
|    INSERT
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_INSERT
    }
|    SELECT
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_SELECT
    }
|    SUPER
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_SUPER
    }
|    CREATE DATABASE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_DATABASE
    }
|    DROP DATABASE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_DROP_DATABASE
    }
|    SHOW DATABASES
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_SHOW_DATABASES
    }
|    CONNECT
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CONNECT
    }
|    MANAGE GRANTS
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_MANAGE_GRANTS
    }
|    OWNERSHIP
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_OWNERSHIP
    }
|    SHOW TABLES
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_SHOW_TABLES
    }
|    CREATE TABLE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_TABLE
    }
|    UPDATE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_UPDATE
    }
|    GRANT OPTION
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_GRANT_OPTION
    }
|    REFERENCES
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_REFERENCES
    }
|    REFERENCE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_REFERENCE
    }
|    REPLICATION SLAVE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_REPLICATION_SLAVE
    }
|    REPLICATION CLIENT
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_REPLICATION_CLIENT
    }
|    USAGE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_USAGE
    }
|    RELOAD
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_RELOAD
    }
|    FILE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_FILE
    }
|    CREATE TEMPORARY TABLES
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_TEMPORARY_TABLES
    }
|    LOCK TABLES
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_LOCK_TABLES
    }
|    CREATE VIEW
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_VIEW
    }
|    SHOW VIEW
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_SHOW_VIEW
    }
|    CREATE ROLE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_ROLE
    }
|    DROP ROLE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_DROP_ROLE
    }
|    ALTER ROLE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_ALTER_ROLE
    }
|      CREATE ROUTINE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_CREATE_ROUTINE
    }
|    ALTER ROUTINE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_ALTER_ROUTINE
    }
|    EVENT
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_EVENT
    }
|    SHUTDOWN
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_SHUTDOWN
    }
|    TRUNCATE
    {
        $$ = tree.PRIVILEGE_TYPE_STATIC_TRUNCATE
    }

set_stmt:
    set_variable_stmt
|   set_password_stmt
|   set_role_stmt
|   set_default_role_stmt

set_role_stmt:
    SET ROLE role_spec
    {
        $$ = &tree.SetRole{
            SecondaryRole: false,
            Role: $3,
        }
    }
|   SET SECONDARY ROLE ALL
    {
    $$ = &tree.SetRole{
            SecondaryRole: true,
            SecondaryRoleType: tree.SecondaryRoleTypeAll,
        }
    }
|   SET SECONDARY ROLE NONE
    {
    $$ = &tree.SetRole{
            SecondaryRole: true,
            SecondaryRoleType: tree.SecondaryRoleTypeNone,
        }
    }

set_default_role_stmt:
    SET DEFAULT ROLE set_default_role_opt TO user_spec_list
    {
        dr := $4
        dr.Users = $6
        $$ = dr
    }

//set_role_opt:
//    ALL EXCEPT role_spec_list
//    {
//        $$ = &tree.SetRole{Type: tree.SET_ROLE_TYPE_ALL_EXCEPT, Roles: $3}
//    }
//|   DEFAULT
//    {
//        $$ = &tree.SetRole{Type: tree.SET_ROLE_TYPE_DEFAULT, Roles: nil}
//    }
//|   NONE
//    {
//        $$ = &tree.SetRole{Type: tree.SET_ROLE_TYPE_NONE, Roles: nil}
//    }
//|   ALL
//    {
//        $$ = &tree.SetRole{Type: tree.SET_ROLE_TYPE_ALL, Roles: nil}
//    }
//|   role_spec_list
//    {
//        $$ = &tree.SetRole{Type: tree.SET_ROLE_TYPE_NORMAL, Roles: $1}
//    }

set_default_role_opt:
    NONE
    {
        $$ = &tree.SetDefaultRole{Type: tree.SET_DEFAULT_ROLE_TYPE_NONE, Roles: nil}
    }
|   ALL
    {
        $$ = &tree.SetDefaultRole{Type: tree.SET_DEFAULT_ROLE_TYPE_ALL, Roles: nil}
    }
|   role_spec_list
    {
        $$ = &tree.SetDefaultRole{Type: tree.SET_DEFAULT_ROLE_TYPE_NORMAL, Roles: $1}
    }

set_variable_stmt:
    SET var_assignment_list
    {
        $$ = &tree.SetVar{Assignments: $2}
    }

set_password_stmt:
    SET PASSWORD '=' password_opt
    {
        $$ = &tree.SetPassword{Password: $4}
    }
|   SET PASSWORD FOR user_spec '=' password_opt
    {
        $$ = &tree.SetPassword{User: $4, Password: $6}
    }

password_opt:
    STRING
|   PASSWORD '(' auth_string ')'
    {
        $$ = $3
    }

var_assignment_list:
    var_assignment
    {
        $$ = []*tree.VarAssignmentExpr{$1}
    }
|   var_assignment_list ',' var_assignment
    {
        $$ = append($1, $3)
    }

var_assignment:
    var_name equal_or_assignment set_expr
    {
        $$ = &tree.VarAssignmentExpr{
            System: true,
            Name: $1,
            Value: $3,
        }
    }
|   GLOBAL var_name equal_or_assignment set_expr
    {
        $$ = &tree.VarAssignmentExpr{
            System: true,
            Global: true,
            Name: $2,
            Value: $4,
        }
    }
|   SESSION var_name equal_or_assignment set_expr
    {
        $$ = &tree.VarAssignmentExpr{
            System: true,
            Name: $2,
            Value: $4,
        }
    }
|   LOCAL var_name equal_or_assignment set_expr
    {
        $$ = &tree.VarAssignmentExpr{
            System: true,
            Name: $2,
            Value: $4,
        }
    }
|   AT_ID equal_or_assignment set_expr
    {
        vs := strings.Split($1, ".")
        var isGlobal bool
        if strings.ToLower(vs[0]) == "global" {
            isGlobal = true
        }
        var r string
        if len(vs) == 2 {
            r = vs[1]
        } else if len(vs) == 1{
            r = vs[0]
        } else {
            yylex.Error("variable syntax error")
            return 1
        }
        $$ = &tree.VarAssignmentExpr{
            System: false,
            Global: isGlobal,
            Name: r,
            Value: $3,
        }
    }
|   AT_AT_ID equal_or_assignment set_expr
    {
        vs := strings.Split($1, ".")
        var isGlobal bool
        if strings.ToLower(vs[0]) == "global" {
            isGlobal = true
        }
        var r string
        if len(vs) == 2 {
            r = vs[1]
        } else if len(vs) == 1{
            r = vs[0]
        } else {
            yylex.Error("variable syntax error")
            return 1
        }
        $$ = &tree.VarAssignmentExpr{
            System: true,
            Global: isGlobal,
            Name: r,
            Value: $3,
        }
    }
|   NAMES charset_name
    {
        $$ = &tree.VarAssignmentExpr{
            Name: $1,
            Value: tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_char),
        }
    }
|   NAMES charset_name COLLATE DEFAULT
    {
        $$ = &tree.VarAssignmentExpr{
            Name: $1,
            Value: tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_char),
        }
    }
|   NAMES charset_name COLLATE name_string
    {
        $$ = &tree.VarAssignmentExpr{
            Name: $1,
            Value: tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_char),
            Reserved: tree.NewNumValWithType(constant.MakeString($4), $4, false, tree.P_char),
        }
    }
|   NAMES DEFAULT
    {
        $$ = &tree.VarAssignmentExpr{
            Name: $1,
            Value: &tree.DefaultVal{},
        }
    }
|   charset_keyword charset_name
    {
        $$ = &tree.VarAssignmentExpr{
            Name: $1,
            Value: tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_char),
        }
    }
|   charset_keyword DEFAULT
    {
        $$ = &tree.VarAssignmentExpr{
            Name: $1,
            Value: &tree.DefaultVal{},
        }
    }

set_expr:
    ON
    {
        $$ = tree.NewNumValWithType(constant.MakeString($1), $1, false, tree.P_char)
    }
|   BINARY
    {
        $$ = tree.NewNumValWithType(constant.MakeString($1), $1, false, tree.P_char)
    }
|   expr_or_default
    {
        $$ = $1
    }

equal_or_assignment:
    '='
    {
        $$ = string($1)
    }
|   ASSIGNMENT
    {
        $$ = $1
    }

var_name:
    ident
|   ident '.' ident
    {
        $$ = $1 + "." + $3
    }

var_name_list:
    var_name
    {
        $$ = []string{$1}
    }
|   var_name_list ',' var_name
    {
        $$ = append($1, $3)
    }

transaction_stmt:
    begin_stmt
|   commit_stmt
|   rollback_stmt

rollback_stmt:
    ROLLBACK completion_type
    {
        $$ = &tree.RollbackTransaction{Type: $2}
    }

commit_stmt:
    COMMIT completion_type
    {
        $$ = &tree.CommitTransaction{Type: $2}
    }

completion_type:
    {
        $$ = tree.COMPLETION_TYPE_NO_CHAIN
    }
|    WORK
    {
        $$ = tree.COMPLETION_TYPE_NO_CHAIN
    }
|   AND CHAIN NO RELEASE
    {
        $$ = tree.COMPLETION_TYPE_CHAIN
    }
|   AND CHAIN
    {
        $$ = tree.COMPLETION_TYPE_CHAIN
    }
|   AND NO CHAIN RELEASE
    {
        $$ = tree.COMPLETION_TYPE_RELEASE
    }
|   RELEASE
    {
        $$ = tree.COMPLETION_TYPE_RELEASE
    }
|   AND NO CHAIN NO RELEASE
    {
        $$ = tree.COMPLETION_TYPE_NO_CHAIN
    }
|   AND NO CHAIN
    {
        $$ = tree.COMPLETION_TYPE_NO_CHAIN
    }
|   NO RELEASE
    {
        $$ = tree.COMPLETION_TYPE_NO_CHAIN
    }

begin_stmt:
    BEGIN
    {
        $$ = &tree.BeginTransaction{}
    }
|   BEGIN WORK
    {
        $$ = &tree.BeginTransaction{}
    }
|   START TRANSACTION
    {
        $$ = &tree.BeginTransaction{}
    }
|   START TRANSACTION READ WRITE
    {
        m := tree.MakeTransactionModes(tree.READ_WRITE_MODE_READ_WRITE)
        $$ = &tree.BeginTransaction{Modes: m}
    }
|   START TRANSACTION READ ONLY
    {
        m := tree.MakeTransactionModes(tree.READ_WRITE_MODE_READ_ONLY)
        $$ = &tree.BeginTransaction{Modes: m}
    }
|   START TRANSACTION WITH CONSISTENT SNAPSHOT
    {
        $$ = &tree.BeginTransaction{}
    }

use_stmt:
    USE ident
    {
        $$ = &tree.Use{
            SecondaryRole: false,
            Name: $2,
        }
    }
|   USE
    {
        $$ = &tree.Use{
            SecondaryRole: false,
        }
    }
|   USE ROLE role_spec
    {
    $$ = &tree.Use{
        SecondaryRole: false,
        Role: $3,
    }
    }
|   USE SECONDARY ROLE ALL
    {
    $$ = &tree.Use{
        SecondaryRole: true,
        SecondaryRoleType: tree.SecondaryRoleTypeAll,
    }
    }
|   USE SECONDARY ROLE NONE
    {
    $$ = &tree.Use{
        SecondaryRole: true,
        SecondaryRoleType: tree.SecondaryRoleTypeNone,
    }
    }

update_stmt:
    update_no_with_stmt
|    with_clause update_no_with_stmt
    {
        $2.(*tree.Update).With = $1
        $$ = $2
    }

update_no_with_stmt:
    UPDATE priority_opt ignore_opt table_reference SET update_list where_expression_opt order_by_opt limit_opt
    {
        // Single-table syntax
        $$ = &tree.Update{
            Tables: tree.TableExprs{$4},
            Exprs: $6,
            Where: $7,
            OrderBy: $8,
            Limit: $9,
        }
    }
|    UPDATE priority_opt ignore_opt table_references SET update_list where_expression_opt
    {
        // Multiple-table syntax
        $$ = &tree.Update{
            Tables: tree.TableExprs{$4},
            Exprs: $6,
            Where: $7,
        }
    }

update_list:
    update_value
    {
        $$ = tree.UpdateExprs{$1}
    }
|   update_list ',' update_value
    {
        $$ = append($1, $3)
    }

update_value:
    column_name '=' expr_or_default
    {
        $$ = &tree.UpdateExpr{Names: []*tree.UnresolvedName{$1}, Expr: $3}
    }

lock_stmt:
    lock_table_stmt
|   unlock_table_stmt

lock_table_stmt:
    LOCK TABLES table_lock_list
    {
        $$ = &tree.LockTableStmt{TableLocks:$3}
    }

table_lock_list:
    table_lock_elem
    {
       $$ = []tree.TableLock{$1}
    }
|   table_lock_list ',' table_lock_elem
    {
       $$ = append($1, $3);
    }

table_lock_elem:
    table_name table_lock_type
    {
        $$ = tree.TableLock{$1, $2}
    }

table_lock_type:  
    READ
    {
        $$ = tree.TableLockRead
    }
|   READ LOCAL
    {
        $$ = tree.TableLockReadLocal
    }
|   WRITE
    {
        $$ = tree.TableLockWrite
    }
|   LOW_PRIORITY WRITE
    {
        $$ = tree.TableLockLowPriorityWrite
    }

unlock_table_stmt:
    UNLOCK TABLES
    {
       $$ = &tree.UnLockTableStmt{}
    }

prepareable_stmt:
    create_stmt
|   insert_stmt
|   delete_stmt
|   drop_stmt
|   show_stmt
|   update_stmt
|   select_stmt
    {
        $$ = $1
    }

prepare_stmt:
    prepare_sym stmt_name FROM prepareable_stmt
    {
        $$ = tree.NewPrepareStmt(tree.Identifier($2), $4)
    }
|   prepare_sym stmt_name FROM STRING
    {
        $$ = tree.NewPrepareString(tree.Identifier($2), $4)
    }

execute_stmt:
    execute_sym stmt_name
    {
        $$ = tree.NewExecute(tree.Identifier($2))
    }
|   execute_sym stmt_name USING variable_list
    {
        $$ = tree.NewExecuteWithVariables(tree.Identifier($2), $4)
    }

deallocate_stmt:
    deallocate_sym PREPARE stmt_name
    {
        $$ = tree.NewDeallocate(tree.Identifier($3), false)
    }

reset_stmt:
    reset_sym PREPARE stmt_name
    {
        $$ = tree.NewReset(tree.Identifier($3))
    }

explainable_stmt:
    delete_stmt
|   insert_stmt
|   replace_stmt
|   update_stmt
|   select_stmt
    {
        $$ = $1
    }

explain_stmt:
    explain_sym unresolved_object_name
    {
        $$ = &tree.ShowColumns{Table: $2}
    }
|   explain_sym unresolved_object_name column_name
    {
        $$ = &tree.ShowColumns{Table: $2, ColName: $3}
    }
|   explain_sym FOR CONNECTION INTEGRAL
    {
        $$ = tree.NewExplainFor("", uint64($4.(int64)))
    }
|   explain_sym FORMAT '=' STRING FOR CONNECTION INTEGRAL
    {
        $$ = tree.NewExplainFor($4, uint64($7.(int64)))
    }
|   explain_sym explainable_stmt
    {
        $$ = tree.NewExplainStmt($2, "text")
    }
|   explain_sym VERBOSE explainable_stmt
    {
        explainStmt := tree.NewExplainStmt($3, "text")
        optionElem := tree.MakeOptionElem("verbose", "NULL")
        options := tree.MakeOptions(optionElem)
        explainStmt.Options = options
        $$ = explainStmt
    }
|   explain_sym ANALYZE explainable_stmt
    {
            explainStmt := tree.NewExplainAnalyze($3, "text")
            optionElem := tree.MakeOptionElem("analyze", "NULL")
        options := tree.MakeOptions(optionElem)
    explainStmt.Options = options
    $$ = explainStmt
    }
|   explain_sym ANALYZE VERBOSE explainable_stmt
    {
        explainStmt := tree.NewExplainAnalyze($4, "text")
        optionElem1 := tree.MakeOptionElem("analyze", "NULL")
        optionElem2 := tree.MakeOptionElem("verbose", "NULL")
        options := tree.MakeOptions(optionElem1)
        options = append(options, optionElem2)
        explainStmt.Options = options
        $$ = explainStmt
    }
|   explain_sym '(' utility_option_list ')' explainable_stmt
    {
        if tree.IsContainAnalyze($3) {
             explainStmt := tree.NewExplainAnalyze($5, "text")
         explainStmt.Options = $3
         $$ = explainStmt
        } else {
             explainStmt := tree.NewExplainStmt($5, "text")
             explainStmt.Options = $3
         $$ = explainStmt
        }
    }

explain_option_key:
    ANALYZE
|   VERBOSE
|   FORMAT

explain_foramt_value:
    JSON
|   TEXT


prepare_sym:
    PREPARE

deallocate_sym:
    DEALLOCATE

execute_sym:
    EXECUTE

reset_sym:
    RESET

explain_sym:
    EXPLAIN
|   DESCRIBE
|   DESC

utility_option_list:
    utility_option_elem
    {
        $$ = tree.MakeOptions($1)
    }
|     utility_option_list ',' utility_option_elem
    {
        $$ = append($1, $3);
    }

utility_option_elem:
    utility_option_name utility_option_arg
    {
        $$ = tree.MakeOptionElem($1, $2)
    }

utility_option_name:
    explain_option_key
    {
         $$ = $1
    }

utility_option_arg:
    TRUE                    { $$ = "true" }
|   FALSE                        { $$ = "false" }
|   explain_foramt_value                    { $$ = $1 }


analyze_stmt:
    ANALYZE TABLE table_name '(' column_list ')'
    {
        $$ = tree.NewAnalyzeStmt($3, $5)
    }

alter_stmt:
    alter_user_stmt
|   alter_account_stmt
|   alter_database_config_stmt
|   alter_view_stmt
// |    alter_ddl_stmt

alter_view_stmt:
    ALTER VIEW exists_opt table_name column_list_opt AS select_stmt
    {
        $$ = &tree.AlterView{
            Name: $4,
            ColNames: $5,
            AsSource: $7,
            IfExists: $3,
        }
    }

alter_account_stmt:
    ALTER ACCOUNT exists_opt account_name alter_account_auth_option account_status_option account_comment_opt
    {
        $$ = &tree.AlterAccount{
            IfExists:$3,
            Name:$4,
            AuthOption:$5,
            StatusOption:$6,
            Comment:$7,
        }
    }

alter_database_config_stmt:
     ALTER DATABASE db_name SET MYSQL_COMPATBILITY_MODE '=' STRING
     {
        $$ = &tree.AlterDataBaseConfig{
            DbName:$3,
            UpdateConfig: $7,
            IsAccountLevel: false,
        }
     }
|    ALTER ACCOUNT CONFIG account_name SET MYSQL_COMPATBILITY_MODE '=' STRING
     {
        $$ = &tree.AlterDataBaseConfig{
            AccountName:$4,
            UpdateConfig: $8,
            IsAccountLevel: true,
        }
     }
    
alter_account_auth_option:
{
    $$ = tree.AlterAccountAuthOption{
       Exist: false,
    }
}
| ADMIN_NAME equal_opt account_admin_name account_identified
{
    $$ = tree.AlterAccountAuthOption{
        Exist: true,
        Equal:$2,
        AdminName:$3,
        IdentifiedType:$4,
    }
}

alter_user_stmt:
    ALTER USER exists_opt user_spec_list_of_create_user default_role_opt pwd_or_lck_opt user_comment_or_attribute_opt
    {
        $$ = &tree.AlterUser{
            IfExists: $3,
            Users: $4,
            Role: $5,
            MiscOpt: $6,
            CommentOrAttribute: $7,
        }
    }

default_role_opt:
    {
        $$ = nil
    }
|   DEFAULT ROLE account_role_name
    {
        $$ = &tree.Role{UserName:$3}
    }

exists_opt:
    {
        $$ = false
    }
|   IF EXISTS
    {
        $$ = true
    }

pwd_or_lck_opt:
    {
        $$ = nil
    }
|   pwd_or_lck
    {
        $$ = $1
    }

//pwd_or_lck_list:
//    pwd_or_lck
//    {
//        $$ = []tree.UserMiscOption{$1}
//    }
//|   pwd_or_lck_list pwd_or_lck
//    {
//        $$ = append($1, $2)
//    }

pwd_or_lck:
    UNLOCK
    {
        $$ = &tree.UserMiscOptionAccountUnlock{}
    }
|   LOCK
    {
        $$ = &tree.UserMiscOptionAccountLock{}
    }
|   pwd_expire
    {
        $$ = &tree.UserMiscOptionPasswordExpireNone{}
    }
|   pwd_expire INTERVAL INTEGRAL DAY
    {
        $$ = &tree.UserMiscOptionPasswordExpireInterval{Value: $3.(int64)}
    }
|   pwd_expire NEVER
    {
        $$ = &tree.UserMiscOptionPasswordExpireNever{}
    }
|   pwd_expire DEFAULT
    {
        $$ = &tree.UserMiscOptionPasswordExpireDefault{}
    }
|   PASSWORD HISTORY DEFAULT
    {
        $$ = &tree.UserMiscOptionPasswordHistoryDefault{}
    }
|   PASSWORD HISTORY INTEGRAL
    {
        $$ = &tree.UserMiscOptionPasswordHistoryCount{Value: $3.(int64)}
    }
|   PASSWORD REUSE INTERVAL DEFAULT
    {
        $$ = &tree.UserMiscOptionPasswordReuseIntervalDefault{}
    }
|   PASSWORD REUSE INTERVAL INTEGRAL DAY
    {
        $$ = &tree.UserMiscOptionPasswordReuseIntervalCount{Value: $4.(int64)}
    }
|   PASSWORD REQUIRE CURRENT
    {
        $$ = &tree.UserMiscOptionPasswordRequireCurrentNone{}
    }
|   PASSWORD REQUIRE CURRENT DEFAULT
    {
        $$ = &tree.UserMiscOptionPasswordRequireCurrentDefault{}
    }
|   PASSWORD REQUIRE CURRENT OPTIONAL
    {
        $$ = &tree.UserMiscOptionPasswordRequireCurrentOptional{}
    }
|   FAILED_LOGIN_ATTEMPTS INTEGRAL
    {
        $$ = &tree.UserMiscOptionFailedLoginAttempts{Value: $2.(int64)}
    }
|   PASSWORD_LOCK_TIME INTEGRAL
    {
        $$ = &tree.UserMiscOptionPasswordLockTimeCount{Value: $2.(int64)}
    }
|   PASSWORD_LOCK_TIME UNBOUNDED
    {
        $$ = &tree.UserMiscOptionPasswordLockTimeUnbounded{}
    }

pwd_expire:
    PASSWORD EXPIRE clear_pwd_opt
    {
        $$ = nil
    }

clear_pwd_opt:
    {
        $$ = nil
    }

auth_string:
    STRING

show_stmt:
    show_create_stmt
|   show_columns_stmt
|   show_databases_stmt
|   show_tables_stmt
|   show_process_stmt
|   show_errors_stmt
|   show_warnings_stmt
|   show_variables_stmt
|   show_status_stmt
|   show_index_stmt
|   show_target_filter_stmt
|   show_table_status_stmt
|   show_grants_stmt
|   show_collation_stmt
|   show_function_status_stmt
|   show_node_list_stmt
|   show_locks_stmt
|   show_table_num_stmt
|   show_column_num_stmt
|   show_table_values_stmt
|   show_accounts_stmt

show_collation_stmt:
    SHOW COLLATION like_opt where_expression_opt
    {
        $$ = &tree.ShowCollation{}
    }
show_grants_stmt:
    SHOW GRANTS
    {
        $$ = &tree.ShowGrants{ShowGrantType: tree.GrantForUser}
    }
|    SHOW GRANTS FOR user_name using_roles_opt
    {
        $$ = &tree.ShowGrants{Username: $4.Username, Hostname: $4.Hostname, Roles: $5, ShowGrantType: tree.GrantForUser}
    }
|    SHOW GRANTS FOR ROLE role_name
    {
        s := &tree.ShowGrants{}
        roles := []*tree.Role{tree.NewRole($5)}
        s.Roles = roles
        s.ShowGrantType = tree.GrantForRole
        $$ = s
    }

using_roles_opt:
    {
        $$ = nil
    }
|    USING role_spec_list
    {
        $$ = $2
    }

show_table_status_stmt:
    SHOW TABLE STATUS from_or_in_opt db_name_opt like_opt where_expression_opt
    {
        $$ = &tree.ShowTableStatus{DbName: $5, Like: $6, Where: $7}
    }

from_or_in_opt:
    {}
|    from_or_in

db_name_opt:
    {}
|    db_name

show_function_status_stmt:
    SHOW FUNCTION STATUS like_opt where_expression_opt
    {
       $$ = &tree.ShowFunctionStatus{
            Like: $4,
            Where: $5,
        }
    }

show_node_list_stmt:
    SHOW NODE LIST
    {
       $$ = &tree.ShowNodeList{}
    }

show_locks_stmt:
    SHOW LOCKS
    {
       $$ = &tree.ShowLocks{}
    }

show_table_num_stmt:
    SHOW TABLE_NUMBER from_or_in_opt db_name_opt
    {
      $$ = &tree.ShowTableNumber{DbName: $4}
    }

show_column_num_stmt:
    SHOW COLUMN_NUMBER table_column_name database_name_opt
    {
       $$ = &tree.ShowColumnNumber{Table: $3, DbName: $4}
    }

show_table_values_stmt:
   SHOW TABLE_VALUES table_column_name database_name_opt
    {
       $$ = &tree.ShowTableValues{Table: $3, DbName: $4}
    }

show_target_filter_stmt:
    SHOW show_target like_opt where_expression_opt
    {
        s := $2.(*tree.ShowTarget)
        s.Like = $3
        s.Where = $4
        $$ = s
    }

show_target:
    CONFIG
    {
        $$ = &tree.ShowTarget{Type: tree.ShowConfig}
    }
|    charset_keyword
    {
        $$ = &tree.ShowTarget{Type: tree.ShowCharset}
    }
|    ENGINES
    {
        $$ = &tree.ShowTarget{Type: tree.ShowEngines}
    }
|    TRIGGERS from_or_in_opt db_name_opt
    {
        $$ = &tree.ShowTarget{DbName: $3, Type: tree.ShowTriggers}
    }
|    PROCEDURE STATUS
    {
        $$ = &tree.ShowTarget{Type: tree.ShowProcedureStatus}
    }
|    EVENTS from_or_in_opt db_name_opt
    {
        $$ = &tree.ShowTarget{DbName: $3, Type: tree.ShowEvents}
    }
|    PLUGINS
    {
        $$ = &tree.ShowTarget{Type: tree.ShowPlugins}
    }
|    PRIVILEGES
    {
        $$ = &tree.ShowTarget{Type: tree.ShowPrivileges}
    }
|    PROFILES
    {
        $$ = &tree.ShowTarget{Type: tree.ShowProfiles}
    }

show_index_stmt:
    SHOW extended_opt index_kwd from_or_in table_name where_expression_opt
    {
        $$ = &tree.ShowIndex{
            TableName: *$5,
            Where: $6,
        }
    }
|	SHOW extended_opt index_kwd from_or_in ident from_or_in ident where_expression_opt
     {
     	 prefix := tree.ObjectNamePrefix{SchemaName: tree.Identifier($7), ExplicitSchema: true}
         tbl := tree.NewTableName(tree.Identifier($5), prefix)
         $$ = &tree.ShowIndex{
             TableName: *tbl,
             Where: $8,
         }
     }

extended_opt:
    {}
|    EXTENDED
    {}

index_kwd:
    INDEX
|   INDEXES
|   KEYS

show_variables_stmt:
    SHOW global_scope VARIABLES like_opt where_expression_opt
    {
        $$ = &tree.ShowVariables{
            Global: $2,
            Like: $4,
            Where: $5,
        }
    }

show_status_stmt:
    SHOW global_scope STATUS like_opt where_expression_opt
    {
        $$ = &tree.ShowStatus{
            Global: $2,
            Like: $4,
            Where: $5,
        }
    }

global_scope:
    {
        $$ = false
    }
|   GLOBAL
    {
        $$ = true
    }
|   SESSION
    {
        $$ = false
    }

show_warnings_stmt:
    SHOW WARNINGS limit_opt
    {
        $$ = &tree.ShowWarnings{}
    }

show_errors_stmt:
    SHOW ERRORS limit_opt
    {
        $$ = &tree.ShowErrors{}
    }

show_process_stmt:
    SHOW full_opt PROCESSLIST
    {
        $$ = &tree.ShowProcessList{Full: $2}
    }

show_tables_stmt:
    SHOW full_opt TABLES database_name_opt like_opt where_expression_opt
    {
        $$ = &tree.ShowTables{
            Open: false,
            Full: $2,
            DBName: $4,
            Like: $5,
            Where: $6,
        }
    }
|   SHOW OPEN full_opt TABLES database_name_opt like_opt where_expression_opt
    {
        $$ = &tree.ShowTables{
            Open: true,
            Full: $3,
            DBName: $5,
            Like: $6,
            Where: $7,
        }
    }

show_databases_stmt:
    SHOW DATABASES like_opt where_expression_opt
    {
        $$ = &tree.ShowDatabases{Like: $3, Where: $4}
    }
|   SHOW SCHEMAS like_opt where_expression_opt
    {
        $$ = &tree.ShowDatabases{Like: $3, Where: $4}
    }

show_columns_stmt:
    SHOW full_opt fields_or_columns table_column_name database_name_opt like_opt where_expression_opt
    {
        $$ = &tree.ShowColumns{
            Ext: false,
            Full: $2,
            Table: $4,
            // colName: $3,
            DBName: $5,
            Like: $6,
            Where: $7,
        }
    }
|   SHOW EXTENDED full_opt fields_or_columns table_column_name database_name_opt like_opt where_expression_opt
    {
        $$ = &tree.ShowColumns{
            Ext: true,
            Full: $3,
            Table: $5,
            // colName: $3,
            DBName: $6,
            Like: $7,
            Where: $8,
        }
    }

show_accounts_stmt:
    SHOW ACCOUNTS like_opt
    {
        $$ = &tree.ShowAccounts{Like: $3}
    }

like_opt:
    {
        $$ = nil
    }
|   LIKE simple_expr
    {
        $$ = tree.NewComparisonExpr(tree.LIKE, nil, $2)
    }
|   ILIKE simple_expr
    {
        $$ = tree.NewComparisonExpr(tree.ILIKE, nil, $2)
    }

database_name_opt:
    {
        $$ = ""
    }
|   from_or_in database_id
    {
        $$ = $2
    }

table_column_name:
    from_or_in unresolved_object_name
    {
        $$ = $2
    }

from_or_in:
    FROM
|   IN

fields_or_columns:
    FIELDS
|   COLUMNS

full_opt:
    {
        $$ = false
    }
|   FULL
    {
        $$ = true
    }

show_create_stmt:
    SHOW CREATE TABLE table_name_unresolved
    {
        $$ = &tree.ShowCreateTable{Name: $4}
    }
|
    SHOW CREATE VIEW table_name_unresolved
    {
        $$ = &tree.ShowCreateView{Name: $4}
    }
|   SHOW CREATE DATABASE not_exists_opt db_name
    {
        $$ = &tree.ShowCreateDatabase{IfNotExists: $4, Name: $5}
    }

table_name_unresolved:
    ident
    {
        $$ = tree.SetUnresolvedObjectName(1, [3]string{$1})
    }
|   ident '.' ident
    {
        $$ = tree.SetUnresolvedObjectName(2, [3]string{$3, $1})
    }

db_name:
    ident

unresolved_object_name:
    ident
    {
        $$ = tree.SetUnresolvedObjectName(1, [3]string{$1})
    }
|   ident '.' ident
    {
        $$ = tree.SetUnresolvedObjectName(2, [3]string{$3, $1})
    }
|   ident '.' ident '.' ident
    {
        $$ = tree.SetUnresolvedObjectName(3, [3]string{$5, $3, $1})
    }

truncate_table_stmt:
    TRUNCATE table_name
    {
    	$$ = tree.NewTruncateTable($2)
    }
|   TRUNCATE TABLE table_name
    {
	$$ = tree.NewTruncateTable($3)
    }

drop_stmt:
    drop_ddl_stmt

drop_ddl_stmt:
    drop_database_stmt
|   drop_prepare_stmt
|   drop_table_stmt
|   drop_view_stmt
|   drop_index_stmt
|   drop_role_stmt
|   drop_user_stmt
|   drop_account_stmt
|   drop_function_stmt

drop_account_stmt:
    DROP ACCOUNT exists_opt account_name
    {
        $$ = &tree.DropAccount{
            IfExists: $3,
            Name: $4,
        }
    }

drop_user_stmt:
    DROP USER exists_opt drop_user_spec_list
    {
        $$ = &tree.DropUser{
            IfExists: $3,
            Users: $4,
        }
    }

drop_user_spec_list:
    drop_user_spec
    {
        $$ = []*tree.User{$1}
    }
|   drop_user_spec_list ',' drop_user_spec
    {
        $$ = append($1, $3)
    }

drop_user_spec:
    user_name
    {
        $$ = &tree.User{
            Username: $1.Username,
            Hostname: $1.Hostname,
        }
    }

drop_role_stmt:
    DROP ROLE exists_opt role_spec_list
    {
        $$ = &tree.DropRole{
            IfExists: $3,
            Roles: $4,
        }
    }

drop_index_stmt:
    DROP INDEX exists_opt ident ON table_name
    {
        $$ = &tree.DropIndex{
            Name: tree.Identifier($4),
            TableName: *$6,
            IfExists: $3,
        }
    }

drop_table_stmt:
    DROP TABLE exists_opt table_name_list
    {
        $$ = &tree.DropTable{IfExists: $3, Names: $4}
    }

drop_view_stmt:
    DROP VIEW exists_opt table_name_list
    {
        $$ = &tree.DropView{IfExists: $3, Names: $4}
    }

drop_database_stmt:
    DROP DATABASE exists_opt database_id
    {
        $$ = &tree.DropDatabase{Name: tree.Identifier($4), IfExists: $3}
    }

drop_prepare_stmt:
    DROP PREPARE stmt_name
    {
        $$ = tree.NewDeallocate(tree.Identifier($3), true)
    }

drop_function_stmt:
    DROP FUNCTION func_name '(' func_args_list_opt ')'
    {
        $$ = &tree.DropFunction{
            Name: $3,
            Args: $5,
        }
    }

delete_stmt:
    delete_without_using_stmt
|    delete_with_using_stmt
|    with_clause delete_with_using_stmt
    {
        $2.(*tree.Delete).With = $1
        $$ = $2
    }
|    with_clause delete_without_using_stmt
    {
        $2.(*tree.Delete).With = $1
        $$ = $2
    }

delete_without_using_stmt:
    DELETE priority_opt quick_opt ignore_opt FROM table_name partition_clause_opt as_opt_id where_expression_opt order_by_opt limit_opt
    {
        // Single-Table Syntax
        t := &tree.AliasedTableExpr {
            Expr: $6,
            As: tree.AliasClause{
                Alias: tree.Identifier($8),
            },
        }
        $$ = &tree.Delete{
            Tables: tree.TableExprs{t},
            Where: $9,
            OrderBy: $10,
            Limit: $11,
        }
    }
|    DELETE priority_opt quick_opt ignore_opt table_name_wild_list FROM table_references where_expression_opt
    {
        // Multiple-Table Syntax
        $$ = &tree.Delete{
            Tables: $5,
            Where: $8,
            TableRefs: tree.TableExprs{$7},
        }
    }



delete_with_using_stmt:
    DELETE priority_opt quick_opt ignore_opt FROM table_name_wild_list USING table_references where_expression_opt
    {
        // Multiple-Table Syntax
        $$ = &tree.Delete{
            Tables: $6,
            Where: $9,
            TableRefs: tree.TableExprs{$8},
        }
    }

table_name_wild_list:
    table_name_opt_wild
    {
        $$ = tree.TableExprs{$1}
    }
|    table_name_wild_list ',' table_name_opt_wild
    {
        $$ = append($1, $3)
    }

table_name_opt_wild:
    ident wild_opt
    {
        prefix := tree.ObjectNamePrefix{ExplicitSchema: false}
        $$ = tree.NewTableName(tree.Identifier($1), prefix)
    }
|    ident '.' ident wild_opt
    {
        prefix := tree.ObjectNamePrefix{SchemaName: tree.Identifier($1), ExplicitSchema: true}
        $$ = tree.NewTableName(tree.Identifier($3), prefix)
    }

wild_opt:
    %prec EMPTY
    {}
|    '.' '*'
    {}

priority_opt:
    {}
|    priority

priority:
    LOW_PRIORITY
|    HIGH_PRIORITY
|    DELAYED

quick_opt:
    {}
|    QUICK

ignore_opt:
    {}
|    IGNORE

replace_stmt:
    REPLACE into_table_name partition_clause_opt replace_data
    {
    	rep := $4
    	rep.Table = $2
    	rep.PartitionNames = $3
    	$$ = rep
    }

replace_data:
    VALUES values_list
    {
        vc := tree.NewValuesClause($2)
        $$ = &tree.Replace{
            Rows: tree.NewSelect(vc, nil, nil),
        }
    }
|   select_stmt
    {
        $$ = &tree.Replace{
            Rows: $1,
        }
    }
|   '(' insert_column_list ')' VALUES values_list
    {
        vc := tree.NewValuesClause($5)
        $$ = &tree.Replace{
            Columns: $2,
            Rows: tree.NewSelect(vc, nil, nil),
        }
    }
|   '(' ')' VALUES values_list
    {
        vc := tree.NewValuesClause($4)
        $$ = &tree.Replace{
            Rows: tree.NewSelect(vc, nil, nil),
        }
    }
|   '(' insert_column_list ')' select_stmt
    {
        $$ = &tree.Replace{
            Columns: $2,
            Rows: $4,
        }
    }
|	SET set_value_list
	{
		if $2 == nil {
			yylex.Error("the set list of replace can not be empty")
			return 1
		}
		var identList tree.IdentifierList
		var valueList tree.Exprs
		for _, a := range $2 {
			identList = append(identList, a.Column)
			valueList = append(valueList, a.Expr)
		}
		vc := tree.NewValuesClause([]tree.Exprs{valueList})
		$$ = &tree.Replace{
			Columns: identList,
			Rows: tree.NewSelect(vc, nil, nil),
		}
	}

insert_stmt:
    INSERT into_table_name partition_clause_opt insert_data on_duplicate_key_update_opt
    {
        ins := $4
        ins.Table = $2
        ins.PartitionNames = $3
        ins.OnDuplicateUpdate = $5
        $$ = ins
    }

accounts_opt:
    {
        $$ = nil
    }
|   ACCOUNTS '(' accounts_list ')'
    {
        $$ = $3
    }

accounts_list:
    account_name
    {
        $$ = tree.IdentifierList{tree.Identifier($1)}
    }
|   accounts_list ',' account_name
    {
        $$ = append($1, tree.Identifier($3))
    }

insert_data:
    accounts_opt VALUES values_list
    {
        vc := tree.NewValuesClause($3)
        $$ = &tree.Insert{
            Accounts: $1,
            Rows: tree.NewSelect(vc, nil, nil),
        }
    }
|   select_stmt
    {
        $$ = &tree.Insert{
            Rows: $1,
        }
    }
|   ACCOUNTS '(' accounts_list ')' select_stmt
   {
        $$ = &tree.Insert{
            Accounts: $3,
	    Rows: $5,
        }
    }
|   '(' insert_column_list ')' accounts_opt VALUES values_list
    {
        vc := tree.NewValuesClause($6)
        $$ = &tree.Insert{
            Columns: $2,
            Accounts: $4,
            Rows: tree.NewSelect(vc, nil, nil),
        }
    }
|   '(' ')' accounts_opt VALUES values_list
    {
        vc := tree.NewValuesClause($5)
        $$ = &tree.Insert{
            Accounts: $3,
            Rows: tree.NewSelect(vc, nil, nil),
        }
    }
|   '(' insert_column_list ')' accounts_opt select_stmt
    {
        $$ = &tree.Insert{
            Columns: $2,
            Accounts: $4,
            Rows: $5,
        }
    }
|   accounts_opt SET set_value_list
    {
        if $3 == nil {
            yylex.Error("the set list of insert can not be empty")
            return 1
        }
        var identList tree.IdentifierList
        var valueList tree.Exprs
        for _, a := range $3 {
            identList = append(identList, a.Column)
            valueList = append(valueList, a.Expr)
        }
        vc := tree.NewValuesClause([]tree.Exprs{valueList})
        $$ = &tree.Insert{
            Columns: identList,
            Accounts: $1,
            Rows: tree.NewSelect(vc, nil, nil),
        }
    }

on_duplicate_key_update_opt:
    {
		$$ = []*tree.UpdateExpr{}
    }
|   ON DUPLICATE KEY UPDATE update_list
    {
      	$$ = $5
    }

set_value_list:
    {
        $$ = nil
    }
|    set_value
    {
        $$ = []*tree.Assignment{$1}
    }
|    set_value_list ',' set_value
    {
        $$ = append($1, $3)
    }

set_value:
    insert_column '=' expr_or_default
    {
        $$ = &tree.Assignment{
            Column: tree.Identifier($1),
            Expr: $3,
        }
    }

insert_column_list:
    insert_column
    {
        $$ = tree.IdentifierList{tree.Identifier($1)}
    }
|   insert_column_list ',' insert_column
    {
        $$ = append($1, tree.Identifier($3))
    }

insert_column:
    ident
    {
        $$ = $1
    }
|   ident '.' ident
    {
        $$ = $3
    }

values_list:
    row_value
    {
        $$ = []tree.Exprs{$1}
    }
|   values_list ',' row_value
    {
        $$ = append($1, $3)
    }

row_value:
    row_opt '(' data_opt ')'
    {
        $$ = $3
    }

row_opt:
    {}
|    ROW

data_opt:
    {
        $$ = nil
    }
|   data_values

data_values:
    expr_or_default
    {
        $$ = tree.Exprs{$1}
    }
|   data_values ',' expr_or_default
    {
        $$ = append($1, $3)
    }

expr_or_default:
    expression
|   DEFAULT
    {
        $$ = &tree.DefaultVal{}
    }

partition_clause_opt:
    {
        $$ = nil
    }
|   PARTITION '(' partition_id_list ')'
    {
        $$ = $3
    }

partition_id_list:
    ident
    {
        $$ = tree.IdentifierList{tree.Identifier($1)}
    }
|   partition_id_list ',' ident
    {
        $$ = append($1 , tree.Identifier($3))
    }

into_table_name:
    INTO table_name
    {
        $$ = $2
    }
|   table_name
    {
        $$ = $1
    }

export_data_param_opt:
    {
        $$ = nil
    }
|   INTO OUTFILE STRING export_fields export_lines_opt header_opt max_file_size_opt force_quote_opt
    {
        $$ = &tree.ExportParam{
            Outfile:    true,
            FilePath :  $3,
            Fields:     $4,
            Lines:      $5,
            Header:     $6,
            MaxFileSize:uint64($7)*1024,
            ForceQuote: $8,
        }
    }

export_fields:
    {
        $$ = &tree.Fields{
            Terminated: ",",
            EnclosedBy: '"',
        }
    }
|   FIELDS TERMINATED BY STRING
    {
        $$ = &tree.Fields{
            Terminated: $4,
            EnclosedBy: '"',
        }
    }
|   FIELDS TERMINATED BY STRING ENCLOSED BY field_terminator
    {
        str := $7
        if str != "\\" && len(str) > 1 {
            yylex.Error("export1 error field terminator")
            return 1
        }
        var b byte
        if len(str) != 0 {
           b = byte(str[0])
        } else {
           b = 0
        }
        $$ = &tree.Fields{
            Terminated: $4,
            EnclosedBy: b,
        }
    }
|   FIELDS ENCLOSED BY field_terminator
    {
        str := $4
        if str != "\\" && len(str) > 1 {
            yylex.Error("export2 error field terminator")
            return 1
        }
        var b byte
        if len(str) != 0 {
           b = byte(str[0])
        } else {
           b = 0
        }
        $$ = &tree.Fields{
            Terminated: ",",
            EnclosedBy: b,
        }
    }

export_lines_opt:
    {
        $$ = &tree.Lines{
            TerminatedBy: "\n",
        }
    }
|   LINES lines_terminated_opt
    {
        $$ = &tree.Lines{
            TerminatedBy: $2,
        }
    }

header_opt:
    {
        $$ = true
    }
|   HEADER STRING
    {
        str := strings.ToLower($2)
        if str == "true" {
            $$ = true
        } else if str == "false" {
            $$ = false
        } else {
            yylex.Error("error header flag")
            return 1
        }
    }

max_file_size_opt:
    {
        $$ = 0
    }
|   MAX_FILE_SIZE INTEGRAL
    {
        $$ = $2.(int64)
    }

force_quote_opt:
    {
        $$ = []string{}
    }
|   FORCE_QUOTE '(' force_quote_list ')'
    {
        $$ = $3
    }


force_quote_list:
    ident
    {
        $$ = make([]string, 0, 4)
        $$ = append($$, $1)
    }
|   force_quote_list ',' ident
    {
        $$ = append($1, $3)
    }

select_stmt:
    select_no_parens
|   select_with_parens
    {
        $$ = &tree.Select{Select: $1}
    }

select_no_parens:
    simple_select order_by_opt limit_opt export_data_param_opt // select_lock_opt
    {
        $$ = &tree.Select{Select: $1, OrderBy: $2, Limit: $3, Ep: $4}
    }
|   select_with_parens order_by_clause export_data_param_opt
    {
        $$ = &tree.Select{Select: $1, OrderBy: $2, Ep: $3}
    }
|   select_with_parens order_by_opt limit_clause export_data_param_opt
    {
        $$ = &tree.Select{Select: $1, OrderBy: $2, Limit: $3, Ep: $4}
    }
|    with_clause simple_select order_by_opt limit_opt export_data_param_opt // select_lock_opt
    {
        $$ = &tree.Select{Select: $2, OrderBy: $3, Limit: $4, Ep: $5, With: $1}
    }
|   with_clause select_with_parens order_by_clause export_data_param_opt
    {
        $$ = &tree.Select{Select: $2, OrderBy: $3, Ep: $4, With: $1}
    }
|   with_clause select_with_parens order_by_opt limit_clause export_data_param_opt
    {
        $$ = &tree.Select{Select: $2, OrderBy: $3, Limit: $4, Ep: $5, With: $1}
    }

with_clause:
    WITH cte_list
    {
        $$ = &tree.With{
            IsRecursive: false,
            CTEs: $2,
        }
    }
|    WITH RECURSIVE cte_list
    {
        $$ = &tree.With{
            IsRecursive: true,
            CTEs: $3,
        }
    }

cte_list:
    common_table_expr
    {
        $$ = []*tree.CTE{$1}
    }
|    cte_list ',' common_table_expr
    {
        $$ = append($1, $3)
    }

common_table_expr:
    ident column_list_opt AS '(' stmt ')'
    {
        $$ = &tree.CTE{
            Name: &tree.AliasClause{Alias: tree.Identifier($1), Cols: $2},
            Stmt: $5,
        }
    }

column_list_opt:
    {
        $$ = nil
    }
|    '(' column_list ')'
    {
        $$ = $2
    }

limit_opt:
    {
        $$ = nil
    }
|   limit_clause
    {
        $$ = $1
    }

limit_clause:
    LIMIT expression
    {
        $$ = &tree.Limit{Count: $2}
    }
|   LIMIT expression ',' expression
    {
        $$ = &tree.Limit{Offset: $2, Count: $4}
    }
|   LIMIT expression OFFSET expression
    {
        $$ = &tree.Limit{Offset: $4, Count: $2}
    }

order_by_opt:
    {
        $$ = nil
    }
|   order_by_clause
    {
        $$ = $1
    }

order_by_clause:
    ORDER BY order_list
    {
        $$ = $3
    }

order_list:
    order
    {
        $$ = tree.OrderBy{$1}
    }
|   order_list ',' order
    {
        $$ = append($1, $3)
    }

order:
    expression asc_desc_opt nulls_first_last_opt
    {
        $$ = &tree.Order{Expr: $1, Direction: $2, NullsPosition: $3}
    }

asc_desc_opt:
    {
        $$ = tree.DefaultDirection
    }
|   ASC
    {
        $$ = tree.Ascending
    }
|   DESC
    {
        $$ = tree.Descending
    }

nulls_first_last_opt:
    {
        $$ = tree.DefaultNullsPosition
    }
|   NULLS FIRST
    {
        $$ = tree.NullsFirst
    }
|   NULLS LAST
    {
        $$ = tree.NullsLast
    }

select_with_parens:
    '(' select_no_parens ')'
    {
        $$ = &tree.ParenSelect{Select: $2}
    }
|   '(' select_with_parens ')'
    {
        $$ = &tree.ParenSelect{Select: &tree.Select{Select: $2}}
    }
|   '(' values_stmt ')'
    {
        valuesStmt := $2.(*tree.ValuesStatement);
        $$ = &tree.ParenSelect{Select: &tree.Select {
            Select: &tree.ValuesClause {
                Rows: valuesStmt.Rows,
                RowWord: true,
            },
            OrderBy: valuesStmt.OrderBy,
            Limit:   valuesStmt.Limit,
        }}
    }

simple_select:
    simple_select_clause
    {
        $$ = $1
    }
|   simple_select union_op simple_select_clause
    {
        $$ = &tree.UnionClause{
            Type: $2.Type,
            Left: $1,
            Right: $3,
            All: $2.All,
            Distinct: $2.Distinct,
        }
    }
|   select_with_parens union_op simple_select_clause
    {
        $$ = &tree.UnionClause{
            Type: $2.Type,
            Left: $1,
            Right: $3,
            All: $2.All,
            Distinct: $2.Distinct,
        }
    }
|   simple_select union_op select_with_parens
    {
        $$ = &tree.UnionClause{
            Type: $2.Type,
            Left: $1,
            Right: $3,
            All: $2.All,
            Distinct: $2.Distinct,
        }
    }
|   select_with_parens union_op select_with_parens
    {
        $$ = &tree.UnionClause{
            Type: $2.Type,
            Left: $1,
            Right: $3,
            All: $2.All,
            Distinct: $2.Distinct,
        }
    }

union_op:
    UNION
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.UNION,
            All: false,
            Distinct: false,
        }
    }
|   UNION ALL
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.UNION,
            All: true,
            Distinct: false,
        }
    }
|   UNION DISTINCT
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.UNION,
            All: false,
            Distinct: true,
        }
    }
|
    EXCEPT
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.EXCEPT,
            All: false,
            Distinct: false,
        }
    }
|   EXCEPT ALL
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.EXCEPT,
            All: true,
            Distinct: false,
        }
    }
|   EXCEPT DISTINCT
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.EXCEPT,
            All: false,
            Distinct: true,
        }
    }
|    INTERSECT
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.INTERSECT,
            All: false,
            Distinct: false,
        }
    }
|   INTERSECT ALL
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.INTERSECT,
            All: true,
            Distinct: false,
        }
    }
|   INTERSECT DISTINCT
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.INTERSECT,
            All: false,
            Distinct: true,
        }
    }
|    MINUS
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.UT_MINUS,
            All: false,
            Distinct: false,
        }
    }
|   MINUS ALL
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.UT_MINUS,
            All: true,
            Distinct: false,
        }
    }
|    MINUS DISTINCT
    {
        $$ = &tree.UnionTypeRecord{
            Type: tree.UT_MINUS,
            All: false,
            Distinct: true,
        }
    }

simple_select_clause:
    SELECT distinct_opt select_expression_list from_opt where_expression_opt group_by_opt having_opt
    {
        $$ = &tree.SelectClause{
            Distinct: $2,
            Exprs: $3,
            From: $4,
            Where: $5,
            GroupBy: $6,
            Having: $7,
        }
    }
|    SELECT select_option_opt select_expression_list from_opt where_expression_opt group_by_opt having_opt
    {
        $$ = &tree.SelectClause{
            Distinct: false,
            Exprs: $3,
            From: $4,
            Where: $5,
            GroupBy: $6,
            Having: $7,
            Option: $2,
        }
    }

select_option_opt:
    SQL_SMALL_RESULT
|    SQL_BIG_RESULT
|    SQL_BUFFER_RESULT

distinct_opt:
    {
        $$ = false
    }
|   ALL
    {
        $$ = false
    }
|   distinct_keyword
    {
        $$ = true
    }

distinct_keyword:
    DISTINCT
|   DISTINCTROW

having_opt:
    {
        $$ = nil
    }
|   HAVING expression
    {
        $$ = &tree.Where{Type: tree.AstHaving, Expr: $2}
    }

group_by_opt:
    {
        $$ = nil
    }
|   GROUP BY expression_list
    {
        $$ = tree.GroupBy($3)
    }

where_expression_opt:
    {
        $$ = nil
    }
|   WHERE expression
    {
        $$ = &tree.Where{Type: tree.AstWhere, Expr: $2}
    }

select_expression_list:
    select_expression
    {
        $$ = tree.SelectExprs{$1}
    }
|   select_expression_list ',' select_expression
    {
        $$ = append($1, $3)
    }

select_expression:
    '*' %prec '*'
    {
        $$ = tree.SelectExpr{Expr: tree.StarExpr()}
    }
|   expression as_name_opt
    {
        $$ = tree.SelectExpr{Expr: $1, As: tree.UnrestrictedIdentifier($2)}
    }
|   ident '.' '*' %prec '*'
    {
        $$ = tree.SelectExpr{Expr: tree.SetUnresolvedNameWithStar($1)}
    }
|   ident '.' ident '.' '*' %prec '*'
    {
        $$ = tree.SelectExpr{Expr: tree.SetUnresolvedNameWithStar($3, $1)}
    }

from_opt:
    {
        prefix := tree.ObjectNamePrefix{ExplicitSchema: false}
        tn := tree.NewTableName(tree.Identifier(""), prefix)
        $$ = &tree.From{
            Tables: tree.TableExprs{&tree.AliasedTableExpr{Expr: tn}},
        }
    }
|   from_clause
    {
        $$ = $1
    }

from_clause:
    FROM table_references
    {
        $$ = &tree.From{
            Tables: tree.TableExprs{$2},
        }
    }

table_references:
    escaped_table_reference
   	{
   		if t, ok := $1.(*tree.JoinTableExpr); ok {
   			$$ = t
   		} else {
   			$$ = &tree.JoinTableExpr{Left: $1, Right: nil, JoinType: tree.JOIN_TYPE_CROSS}
   		}
    }
|   table_references ',' escaped_table_reference
    {
        $$ = &tree.JoinTableExpr{Left: $1, Right: $3, JoinType: tree.JOIN_TYPE_CROSS}
    }

escaped_table_reference:
    table_reference %prec LOWER_THAN_SET

table_reference:
    table_factor
|   join_table
	{
		$$ = $1
	}

join_table:
    table_reference inner_join table_factor join_condition_opt
    {
        $$ = &tree.JoinTableExpr{
            Left: $1,
            JoinType: $2,
            Right: $3,
            Cond: $4,
        }
    }
|   table_reference straight_join table_factor on_expression_opt
    {
        $$ = &tree.JoinTableExpr{
            Left: $1,
            JoinType: $2,
            Right: $3,
            Cond: $4,
        }
    }
|   table_reference outer_join table_factor join_condition
    {
        $$ = &tree.JoinTableExpr{
            Left: $1,
            JoinType: $2,
            Right: $3,
            Cond: $4,
        }
    }
|   table_reference natural_join table_factor
    {
        $$ = &tree.JoinTableExpr{
            Left: $1,
            JoinType: $2,
            Right: $3,
        }
    }

natural_join:
    NATURAL JOIN
    {
        $$ = tree.JOIN_TYPE_NATURAL
    }
|   NATURAL outer_join
    {
        if $2 == tree.JOIN_TYPE_LEFT {
            $$ = tree.JOIN_TYPE_NATURAL_LEFT
        } else {
            $$ = tree.JOIN_TYPE_NATURAL_RIGHT
        }
    }

outer_join:
    LEFT JOIN
    {
        $$ = tree.JOIN_TYPE_LEFT
    }
|   LEFT OUTER JOIN
    {
        $$ = tree.JOIN_TYPE_LEFT
    }
|   RIGHT JOIN
    {
        $$ = tree.JOIN_TYPE_RIGHT
    }
|   RIGHT OUTER JOIN
    {
        $$ = tree.JOIN_TYPE_RIGHT
    }

values_stmt:
    VALUES row_constructor_list order_by_opt limit_opt
    {
        $$ = &tree.ValuesStatement{
            Rows: $2,
            OrderBy: $3,
            Limit: $4,
        }
    }

row_constructor_list:
    row_constructor
    {
        $$ = []tree.Exprs{$1}
    }
|   row_constructor_list ',' row_constructor
    {
        $$ = append($1, $3)
    }

row_constructor:
    ROW '(' data_values ')'
    {
        $$ = $3
    }

on_expression_opt:
    %prec JOIN
    {
        $$ = nil
    }
|   ON expression
    {
        $$ = &tree.OnJoinCond{Expr: $2}
    }

straight_join:
    STRAIGHT_JOIN
    {
        $$ = tree.JOIN_TYPE_STRAIGHT
    }

inner_join:
    JOIN
    {
        $$ = tree.JOIN_TYPE_INNER
    }
|   INNER JOIN
    {
        $$ = tree.JOIN_TYPE_INNER
    }
|   CROSS JOIN
    {
        $$ = tree.JOIN_TYPE_CROSS
    }

join_condition_opt:
    %prec JOIN
    {
        $$ = nil
    }
|   join_condition
    {
        $$ = $1
    }

join_condition:
    ON expression
    {
        $$ = &tree.OnJoinCond{Expr: $2}
    }
|   USING '(' column_list ')'
    {
        $$ = &tree.UsingJoinCond{Cols: $3}
    }

column_list:
    ident
    {
        $$ = tree.IdentifierList{tree.Identifier($1)}
    }
|   column_list ',' ident
    {
        $$ = append($1, tree.Identifier($3))
    }

table_factor:
    aliased_table_name
    {
        $$ = $1
    }
|   table_subquery as_opt_id column_list_opt
    {
        $$ = &tree.AliasedTableExpr{
            Expr: $1,
            As: tree.AliasClause{
                Alias: tree.Identifier($2),
                Cols: $3,
            },
        }
    }
|   table_function as_opt_id
    {
        if $2 != "" {
            $$ = &tree.AliasedTableExpr{
                Expr: $1,
                As: tree.AliasClause{
                    Alias: tree.Identifier($2),
                },
            }
        } else {
            $$ = $1
        }
    }
|   '(' table_references ')'
	{
		$$ = $2
	}

table_subquery:
    select_with_parens %prec SUBQUERY_AS_EXPR
    {
    	$$ = &tree.ParenTableExpr{Expr: $1.(*tree.ParenSelect).Select}
    }

table_function:
    ident '(' expression_list_opt ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.TableFunction{
       	    Func: &tree.FuncExpr{
        	Func: tree.FuncName2ResolvableFunctionReference(name),
        	Exprs: $3,
        	Type: tree.FUNC_TYPE_TABLE,
            },
        }
    }

aliased_table_name:
    table_name as_opt_id index_hint_list_opt
    {
        $$ = &tree.AliasedTableExpr{
            Expr: $1,
            As: tree.AliasClause{
                Alias: tree.Identifier($2),
            },
            IndexHints: $3,
        }
    }

index_hint_list_opt:
	{
		$$ = nil
	}
|	index_hint_list

index_hint_list:
	index_hint
	{
		$$ = []*tree.IndexHint{$1}
	}
|	index_hint_list index_hint
	{
		$$ = append($1, $2)
	}

index_hint:
	index_hint_type index_hint_scope '(' index_name_list ')'
	{
		$$ = &tree.IndexHint{
			IndexNames: $4,
			HintType: $1,
			HintScope: $2,
		}
	}

index_hint_type:
	USE key_or_index
	{
		$$ = tree.HintUse
	}
|	IGNORE key_or_index
	{
		$$ = tree.HintIgnore
	}
|	FORCE key_or_index
	{
		$$ = tree.HintForce
	}

index_hint_scope:
	{
		$$ = tree.HintForScan
	}
|	FOR JOIN
	{
		$$ = tree.HintForJoin
	}
|	FOR ORDER BY
	{
		$$ = tree.HintForOrderBy
	}
|	FOR GROUP BY
	{
		$$ = tree.HintForGroupBy
	}

index_name_list:
	{
		$$ = nil
	}
|	ident
	{
		$$ = []string{$1}
	}
|	index_name_list ',' ident
	{
		$$ = append($1, $3)
	}
|	PRIMARY
	{
		$$ = []string{$1}
	}
|	index_name_list ',' PRIMARY
	{
		$$ = append($1, $3)
	}

as_opt_id:
    {
        $$ = ""
    }
|   table_alias
    {
        $$ = $1
    }
|   AS table_alias
    {
        $$ = $2
    }

table_alias:
    table_id
|   STRING

as_name_opt:
    {
        $$ = ""
    }
|   ident
    {
        $$ = $1
    }
|   AS ident
    {
        $$ = $2
    }
|    STRING
    {
        $$ = $1
    }
|   AS STRING
    {
        $$ = $2
    }

stmt_name:
    ident

database_id:
    id_or_var
|   non_reserved_keyword

table_id:
    id_or_var
|   non_reserved_keyword

id_or_var:
    ID
|   AT_ID
|   AT_AT_ID

create_stmt:
    create_ddl_stmt
|   create_role_stmt
|   create_user_stmt
|   create_account_stmt

create_ddl_stmt:
    create_table_stmt
|   create_database_stmt
|   create_index_stmt
|    create_view_stmt
|   create_function_stmt
|   create_extension_stmt

create_extension_stmt:
    CREATE EXTENSION extension_lang AS extension_name FILE STRING
    {
        $$ = &tree.CreateExtension{
            Language: $3,
            Name: tree.Identifier($5),
            Filename: tree.Identifier($7),
        }
    }

extension_lang:
    ident
    {
        $$ = $1
    }

extension_name:
    ident
    {
        $$ = $1
    }


create_function_stmt:
    CREATE FUNCTION func_name '(' func_args_list_opt ')' RETURNS func_return LANGUAGE func_lang AS STRING 
    {
        $$ = &tree.CreateFunction{
            Name: $3,
            Args: $5,
            ReturnType: $8,
            Language: $10,
            Body: $12,
        }
    }

func_name:
    ident
    {
        prefix := tree.ObjectNamePrefix{ExplicitSchema: false}
        $$ = tree.NewFuncName(tree.Identifier($1), prefix)
    }
|   ident '.' ident
    {
        prefix := tree.ObjectNamePrefix{SchemaName: tree.Identifier($1), ExplicitSchema: true}
        $$ = tree.NewFuncName(tree.Identifier($3), prefix)
    }

func_args_list_opt:
    {
        $$ = tree.FunctionArgs(nil)
    }
|   func_args_list

func_args_list:
    func_arg
    {
        $$ = tree.FunctionArgs{$1}
    }
|   func_args_list ',' func_arg
    {
        $$ = append($1, $3)
    }

func_arg:
    func_arg_decl
    {
        $$ = tree.FunctionArg($1)
    }

func_arg_decl:
    column_type
    {
        $$ = tree.NewFunctionArgDecl(nil, $1, nil)
    }
|   column_name column_type
    {
        $$ = tree.NewFunctionArgDecl($1, $2, nil)
    }
|   column_name column_type DEFAULT literal
    {
        $$ = tree.NewFunctionArgDecl($1, $2, $4)
    }

func_lang:
    ident
    {
        $$ = $1
    }

func_return:
    column_type
    {
        $$ = tree.NewReturnType($1)
    }

create_view_stmt:
    CREATE VIEW not_exists_opt table_name column_list_opt AS select_stmt
    {
        $$ = &tree.CreateView{
            Name: $4,
            ColNames: $5,
            AsSource: $7,
            IfNotExists: $3,
        }
    }

create_account_stmt:
    CREATE ACCOUNT not_exists_opt account_name account_auth_option account_status_option account_comment_opt
    {
   		$$ = &tree.CreateAccount{
        	IfNotExists:$3,
            Name:$4,
            AuthOption:$5,
            StatusOption:$6,
            Comment:$7,
    	}
    }

account_name:
    ident
    {
    	$$ = $1
    }

account_auth_option:
    ADMIN_NAME equal_opt account_admin_name account_identified
    {
    $$ = tree.AccountAuthOption{
        Equal:$2,
        AdminName:$3,
        IdentifiedType:$4,
    }
    }

account_admin_name:
    STRING
    {
    	$$ = $1
    }
|	ident
	{
		$$ = $1
	}

account_identified:
    IDENTIFIED BY STRING
    {
    $$ = tree.AccountIdentified{
        Typ: tree.AccountIdentifiedByPassword,
        Str: $3,
    }
    }
|   IDENTIFIED BY RANDOM PASSWORD
    {
    $$ = tree.AccountIdentified{
        Typ: tree.AccountIdentifiedByRandomPassword,
    }
    }
|   IDENTIFIED WITH STRING
    {
    $$ = tree.AccountIdentified{
        Typ: tree.AccountIdentifiedWithSSL,
        Str: $3,
    }
    }

account_status_option:
    {
        $$ = tree.AccountStatus{
        Exist: false,
    }
    }
|   OPEN
    {
    $$ = tree.AccountStatus{
        Exist: true,
        Option: tree.AccountStatusOpen,
    }
    }
|   SUSPEND
    {
    $$ = tree.AccountStatus{
        Exist: true,
        Option: tree.AccountStatusSuspend,
    }
    }

account_comment_opt:
    {
        $$ = tree.AccountComment{
        Exist: false,
    }
    }
|   COMMENT_KEYWORD STRING
    {
    $$ = tree.AccountComment{
        Exist: true,
        Comment: $2,
    }
    }

create_user_stmt:
    CREATE USER not_exists_opt user_spec_list_of_create_user default_role_opt pwd_or_lck_opt user_comment_or_attribute_opt
    {
        $$ = &tree.CreateUser{
            IfNotExists: $3,
            Users: $4,
            Role: $5,
            MiscOpt: $6,
            CommentOrAttribute: $7,
        }
    }

account_role_name:
    ID
    {
    $$ = $1
    }

user_comment_or_attribute_opt:
    {
        $$ = tree.AccountCommentOrAttribute{
            Exist: false,
        }
    }
|   COMMENT_KEYWORD STRING
    {
    $$ = tree.AccountCommentOrAttribute{
        Exist: true,
        IsComment: true,
        Str: $2,
    }
    }
|   ATTRIBUTE STRING
    {
    $$ = tree.AccountCommentOrAttribute{
        Exist: true,
        IsComment: false,
        Str: $2,
    }
    }

//conn_options:
//    {
//        $$ = nil
//    }
//|   WITH conn_option_list
//    {
//        $$ = $2
//    }
//
//conn_option_list:
//    conn_option
//    {
//        $$ = []tree.ResourceOption{$1}
//    }
//|   conn_option_list conn_option
//    {
//        $$ = append($1, $2)
//    }
//
//conn_option:
//    MAX_QUERIES_PER_HOUR INTEGRAL
//    {
//        $$ = &tree.ResourceOptionMaxQueriesPerHour{Count: $2.(int64)}
//    }
//|   MAX_UPDATES_PER_HOUR INTEGRAL
//    {
//        $$ = &tree.ResourceOptionMaxUpdatesPerHour{Count: $2.(int64)}
//    }
//|   MAX_CONNECTIONS_PER_HOUR INTEGRAL
//    {
//        $$ = &tree.ResourceOptionMaxConnectionPerHour{Count: $2.(int64)}
//    }
//|   MAX_USER_CONNECTIONS INTEGRAL
//    {
//        $$ = &tree.ResourceOptionMaxUserConnections{Count: $2.(int64)}
//    }


//require_clause_opt:
//    {
//        $$ = nil
//    }
//|   require_clause
//
//require_clause:
//    REQUIRE NONE
//    {
//        t := &tree.TlsOptionNone{}
//        $$ = []tree.TlsOption{t}
//    }
//|   REQUIRE SSL
//    {
//        t := &tree.TlsOptionSSL{}
//        $$ = []tree.TlsOption{t}
//    }
//|   REQUIRE X509
//    {
//        t := &tree.TlsOptionX509{}
//        $$ = []tree.TlsOption{t}
//    }
//|   REQUIRE require_list
//    {
//        $$ = $2
//    }
//
//require_list:
//    require_elem
//    {
//        $$ = []tree.TlsOption{$1}
//    }
//|   require_list AND require_elem
//    {
//        $$ = append($1, $3)
//    }
//|   require_list require_elem
//    {
//        $$ = append($1, $2)
//    }
//
//require_elem:
//    ISSUER STRING
//    {
//        $$ = &tree.TlsOptionIssuer{Issuer: $2}
//    }
//|   SUBJECT STRING
//    {
//        $$ = &tree.TlsOptionSubject{Subject: $2}
//    }
//|   CIPHER STRING
//    {
//        $$ = &tree.TlsOptionCipher{Cipher: $2}
//    }
//|   SAN STRING
//    {
//        $$ = &tree.TlsOptionSan{San: $2}
//    }
user_spec_list_of_create_user:
    user_spec_with_identified
    {
        $$ = []*tree.User{$1}
    }
|   user_spec_list_of_create_user ',' user_spec_with_identified
    {
        $$ = append($1, $3)
    }

user_spec_with_identified:
    user_name user_identified
    {
        $$ = &tree.User{
            Username: $1.Username,
            Hostname: $1.Hostname,
            AuthOption: $2,
        }
    }

user_spec_list:
    user_spec
    {
        $$ = []*tree.User{$1}
    }
|   user_spec_list ',' user_spec
    {
        $$ = append($1, $3)
    }

user_spec:
    user_name user_identified_opt
    {
        $$ = &tree.User{
            Username: $1.Username,
            Hostname: $1.Hostname,
            AuthOption: $2,
        }
    }

user_name:
    name_string
    {
        $$ = &tree.UsernameRecord{Username: $1, Hostname: "%"}
    }
|   name_string '@' name_string
    {
        $$ = &tree.UsernameRecord{Username: $1, Hostname: $3}
    }
|   name_string AT_ID
    {
        $$ = &tree.UsernameRecord{Username: $1, Hostname: $2}
    }

user_identified_opt:
    {
        $$ = nil
    }
|   user_identified
    {
        $$ = $1
    }

user_identified:
    IDENTIFIED BY STRING
    {
    $$ = &tree.AccountIdentified{
        Typ: tree.AccountIdentifiedByPassword,
        Str: $3,
    }
    }
|   IDENTIFIED BY RANDOM PASSWORD
    {
    $$ = &tree.AccountIdentified{
        Typ: tree.AccountIdentifiedByRandomPassword,
    }
    }
|   IDENTIFIED WITH STRING
    {
    $$ = &tree.AccountIdentified{
        Typ: tree.AccountIdentifiedWithSSL,
        Str: $3,
    }
    }

name_string:
    ident
|   STRING

create_role_stmt:
    CREATE ROLE not_exists_opt role_spec_list
    {
        $$ = &tree.CreateRole{
            IfNotExists: $3,
            Roles: $4,
        }
    }

role_spec_list:
    role_spec
    {
        $$ = []*tree.Role{$1}
    }
|   role_spec_list ',' role_spec
    {
        $$ = append($1, $3)
    }

role_spec:
    role_name
    {
        $$ = &tree.Role{UserName: $1}
    }
//|   name_string '@' name_string
//    {
//        $$ = &tree.Role{UserName: $1, HostName: $3}
//    }
//|   name_string AT_ID
//    {
//        $$ = &tree.Role{UserName: $1, HostName: $2}
//    }

role_name:
    ID
|   STRING

index_prefix:
    {
        $$ = tree.INDEX_CATEGORY_NONE
    }
|   FULLTEXT
    {
        $$ = tree.INDEX_CATEGORY_FULLTEXT
    }
|   SPATIAL
    {
        $$ = tree.INDEX_CATEGORY_SPATIAL
    }
|   UNIQUE
    {
        $$ = tree.INDEX_CATEGORY_UNIQUE
    }

create_index_stmt:
    CREATE index_prefix INDEX id_or_var using_opt ON table_name '(' index_column_list ')' index_option_list
    {
        var io *tree.IndexOption = nil
        if $11 == nil && $5 != tree.INDEX_TYPE_INVALID {
            io = &tree.IndexOption{IType: $5}
        } else if $11 != nil{
            io = $11
            io.IType = $5
        }
        $$ = &tree.CreateIndex{
            Name: tree.Identifier($4),
            Table: *$7,
            IndexCat: $2,
            KeyParts: $9,
            IndexOption: io,
            MiscOption: nil,
        }
    }

index_option_list:
    {
        $$ = nil
    }
|   index_option_list index_option
    {
        // Merge the options
        if $1 == nil {
            $$ = $2
        } else {
            opt1 := $1
            opt2 := $2
            if len(opt2.Comment) > 0 {
                opt1.Comment = opt2.Comment
            } else if opt2.KeyBlockSize > 0 {
                opt1.KeyBlockSize = opt2.KeyBlockSize
            } else if len(opt2.ParserName) > 0 {
                opt1.ParserName = opt2.ParserName
            } else if opt2.Visible != tree.VISIBLE_TYPE_INVALID {
                opt1.Visible = opt2.Visible
            }
            $$ = opt1
        }
    }

index_option:
    KEY_BLOCK_SIZE equal_opt INTEGRAL
    {
        $$ = &tree.IndexOption{KeyBlockSize: uint64($3.(int64))}
    }
|   COMMENT_KEYWORD STRING
    {
        $$ = &tree.IndexOption{Comment: $2}
    }
|   WITH PARSER id_or_var
    {
        $$ = &tree.IndexOption{ParserName: $3}
    }
|   VISIBLE
    {
        $$ = &tree.IndexOption{Visible: tree.VISIBLE_TYPE_VISIBLE}
    }
|   INVISIBLE
    {
        $$ = &tree.IndexOption{Visible: tree.VISIBLE_TYPE_INVISIBLE}
    }

index_column_list:
    index_column
    {
        $$ = []*tree.KeyPart{$1}
    }
|   index_column_list ',' index_column
    {
        $$ = append($1, $3)
    }

index_column:
    column_name length_opt asc_desc_opt
    {
        // Order is parsed but just ignored as MySQL did.
        $$ = &tree.KeyPart{ColName: $1, Length: int($2), Direction: $3}
    }
|   '(' expression ')' asc_desc_opt
    {
        $$ = &tree.KeyPart{Expr: $2, Direction: $4}
    }

using_opt:
    {
        $$ = tree.INDEX_TYPE_INVALID
    }
|   USING BTREE
    {
        $$ = tree.INDEX_TYPE_BTREE
    }
|   USING HASH
    {
        $$ = tree.INDEX_TYPE_HASH
    }
|   USING RTREE
    {
        $$ = tree.INDEX_TYPE_RTREE
    }
|    USING BSI
    {
        $$ = tree.INDEX_TYPE_BSI
    }

create_database_stmt:
    CREATE database_or_schema not_exists_opt ident create_option_list_opt
    {
        $$ = &tree.CreateDatabase{
            IfNotExists: $3,
            Name: tree.Identifier($4),
            CreateOptions: $5,
        }
    }
// CREATE comment_opt database_or_schema comment_opt not_exists_opt ident

database_or_schema:
    DATABASE
|   SCHEMA

not_exists_opt:
    {
        $$ = false
    }
|   IF NOT EXISTS
    {
        $$ = true
    }

create_option_list_opt:
    {
        $$ = nil
    }
|   create_option_list
    {
        $$ = $1
    }

create_option_list:
    create_option
    {
        $$ = []tree.CreateOption{$1}
    }
|   create_option_list create_option
    {
        $$ = append($1, $2)
    }

create_option:
    default_opt charset_keyword equal_opt charset_name
    {
        $$ = &tree.CreateOptionCharset{IsDefault: $1, Charset: $4}
    }
|   default_opt COLLATE equal_opt collate_name
    {
        $$ = &tree.CreateOptionCollate{IsDefault: $1, Collate: $4}
    }
|   default_opt ENCRYPTION equal_opt STRING
    {
        $$ = &tree.CreateOptionEncryption{Encrypt: $4}
    }

default_opt:
    {
        $$ = false
    }
|   DEFAULT
    {
        $$ = true
    }

create_table_stmt:
    CREATE temporary_opt TABLE not_exists_opt table_name '(' table_elem_list_opt ')' table_option_list_opt partition_by_opt cluster_by_opt
    {
        $$ = &tree.CreateTable {
            Temporary: $2,
            IfNotExists: $4,
            Table: *$5,
            Defs: $7,
            Options: $9,
            PartitionOption: $10,
            ClusterByOption: $11, 
        }
    }
|   CREATE EXTERNAL TABLE not_exists_opt table_name '(' table_elem_list_opt ')' load_param_opt_2
    {
        $$ = &tree.CreateTable {
            IfNotExists: $4,
            Table: *$5,
            Defs: $7,
            Param: $9,
        }
    }
|   CREATE CLUSTER TABLE not_exists_opt table_name '(' table_elem_list_opt ')' table_option_list_opt partition_by_opt cluster_by_opt
    {
        $$ = &tree.CreateTable {
            IsClusterTable: true,
            IfNotExists: $4,
            Table: *$5,
            Defs: $7,
            Options: $9,
            PartitionOption: $10,
            ClusterByOption: $11,
        }
    }
load_param_opt_2:
    load_param_opt tail_param_opt
    {
        $$ = $1
        $$.Tail = $2
    }

load_param_opt:
    INFILE STRING
    {
        $$ = &tree.ExternParam{
            ExParamConst: tree.ExParamConst{
                Filepath: $2,
                CompressType: tree.AUTO,
                Format: tree.CSV,
            },
        }
    }
|   INFILE '{' infile_or_s3_params '}'
    {
        $$ = &tree.ExternParam{
            ExParamConst: tree.ExParamConst{
                Option: $3,
            },
        }
    }
|   URL S3OPTION '{' infile_or_s3_params '}'
    {
        $$ = &tree.ExternParam{
            ExParamConst: tree.ExParamConst{
                ScanType: tree.S3,
                Option: $4,
            },
        }
    }

infile_or_s3_params:
    infile_or_s3_param
    {
        $$ = $1
    }
|   infile_or_s3_params ',' infile_or_s3_param
    {
        $$ = append($1, $3...)
    }

infile_or_s3_param:
    {
        $$ = []string{}
    }
|   STRING '=' STRING
    {
        $$ = append($$, $1)
        $$ = append($$, $3)
    }

tail_param_opt:
    load_fields load_lines ignore_lines columns_or_variable_list_opt load_set_spec_opt
    {
        $$ = &tree.TailParameter{
            Fields: $1,
            Lines: $2,
            IgnoredLines: uint64($3),
            ColumnList: $4,
            Assignments: $5,
        }
    }

temporary_opt:
    {
        $$ = false
    }
|   TEMPORARY
    {
        $$ = true
    }

partition_by_opt:
    {
        $$ = nil
    }
|   PARTITION BY partition_method partition_num_opt sub_partition_opt partition_list_opt
    {
        $3.Num = uint64($4)
        $$ = &tree.PartitionOption{
            PartBy: *$3,
            SubPartBy: $5,
            Partitions: $6,
        }
    }

cluster_by_opt:
    {
        $$ = nil
    }
|   CLUSTER BY column_name
    {
        $$ = &tree.ClusterByOption{
            ColumnList : []*tree.UnresolvedName{$3},
        }

    }
    | CLUSTER BY '(' column_name_list ')'
    {
        $$ = &tree.ClusterByOption{
            ColumnList : $4,
        }
    }

sub_partition_opt:
    {
        $$ = nil
    }
|   SUBPARTITION BY sub_partition_method sub_partition_num_opt
    {
        $$ = &tree.PartitionBy{
            IsSubPartition: true,
            PType: $3,
            Num: uint64($4),
        }
    }

partition_list_opt:
    {
        $$ = nil
    }
|   '(' partition_list ')'
    {
        $$ = $2
    }

partition_list:
    partition
    {
        $$ = []*tree.Partition{$1}
    }
|   partition_list ',' partition
    {
        $$ = append($1, $3)
    }

partition:
    PARTITION ID values_opt sub_partition_list_opt
    {
        $$ = &tree.Partition{
            Name: tree.Identifier($2),
            Values: $3,
            Options: nil,
            Subs: $4,
        }
    }
|   PARTITION ID values_opt partition_option_list sub_partition_list_opt
    {
        $$ = &tree.Partition{
            Name: tree.Identifier($2),
            Values: $3,
            Options: $4,
            Subs: $5,
        }
    }

sub_partition_list_opt:
    {
        $$ = nil
    }
|   '(' sub_partition_list ')'
    {
        $$ = $2
    }

sub_partition_list:
    sub_partition
    {
        $$ = []*tree.SubPartition{$1}
    }
|   sub_partition_list ',' sub_partition
    {
        $$ = append($1, $3)
    }

sub_partition:
    SUBPARTITION ID
    {
        $$ = &tree.SubPartition{
            Name: tree.Identifier($2),
            Options: nil,
        }
    }
|   SUBPARTITION ID partition_option_list
    {
        $$ = &tree.SubPartition{
            Name: tree.Identifier($2),
            Options: $3,
        }
    }

partition_option_list:
    table_option
    {
        $$ = []tree.TableOption{$1}
    }
|   partition_option_list table_option
    {
        $$ = append($1, $2)
    }

values_opt:
    {
        $$ = nil
    }
|   VALUES LESS THAN MAXVALUE
    {
        expr := tree.NewMaxValue()
        $$ = &tree.ValuesLessThan{ValueList: tree.Exprs{expr}}
    }
|   VALUES LESS THAN '(' expression_list ')'
    {
        $$ = &tree.ValuesLessThan{ValueList: $5}
    }
|   VALUES IN '(' expression_list ')'
    {
    $$ = &tree.ValuesIn{ValueList: $4}
    }

sub_partition_num_opt:
    {
        $$ = 0
    }
|   SUBPARTITIONS INTEGRAL
    {
        res := $2.(int64)
        if res == 0 {
            yylex.Error("partitions can not be 0")
            return 1
        }
        $$ = res
    }

partition_num_opt:
    {
        $$ = 0
    }
|   PARTITIONS INTEGRAL
    {
        res := $2.(int64)
        if res == 0 {
            yylex.Error("partitions can not be 0")
            return 1
        }
        $$ = res
    }

partition_method:
    RANGE '(' bit_expr ')'
    {
        $$ = &tree.PartitionBy{
            PType: &tree.RangeType{
                Expr: $3,
            },
        }
    }
|   RANGE fields_or_columns '(' column_name_list ')'
    {
        $$ = &tree.PartitionBy{
            PType: &tree.RangeType{
                ColumnList: $4,
            },
        }
    }
|   LIST '(' bit_expr ')'
    {
        $$ = &tree.PartitionBy{
            PType: &tree.ListType{
                Expr: $3,
            },
        }
    }
|   LIST fields_or_columns '(' column_name_list ')'
    {
        $$ = &tree.PartitionBy{
            PType: &tree.ListType{
                ColumnList: $4,
            },
        }
    }
|   sub_partition_method

sub_partition_method:
    linear_opt KEY algorithm_opt '(' ')'
    {
        $$ = &tree.PartitionBy{
            PType: &tree.KeyType{
                Linear: $1,
                Algorithm: $3,
            },
        }
    }
|   linear_opt KEY algorithm_opt '(' column_name_list ')'
    {
        $$ = &tree.PartitionBy{
            PType: &tree.KeyType{
                Linear: $1,
                ColumnList: $5,
                Algorithm: $3,
            },
        }
    }
|   linear_opt HASH '(' bit_expr ')'
    {
        $$ = &tree.PartitionBy{
            PType: &tree.HashType{
                Linear: $1,
                Expr: $4,
            },
        }
    }

algorithm_opt:
    {
        $$ = 2
    }
|   ALGORITHM '=' INTEGRAL
    {
        $$ = $3.(int64)
    }

linear_opt:
    {
        $$ = false
    }
|   LINEAR
    {
        $$ = true
    }

table_option_list_opt:
    {
        $$ = nil
    }
|   table_option_list
    {
        $$ = $1
    }

table_option_list:
    table_option
    {
        $$ = []tree.TableOption{$1}
    }
|   table_option_list ',' table_option
    {
        $$ = append($1, $3)
    }
|   table_option_list table_option
    {
        $$ = append($1, $2)
    }

table_option:
    AUTO_INCREMENT equal_opt INTEGRAL
    {
        $$ = tree.NewTableOptionAutoIncrement(uint64($3.(int64)))
    }
|   AVG_ROW_LENGTH equal_opt INTEGRAL
    {
        $$ = tree.NewTableOptionAvgRowLength(uint64($3.(int64)))
    }
|   default_opt charset_keyword equal_opt charset_name
    {
        $$ = tree.NewTableOptionCharset($4)
    }
|   default_opt COLLATE equal_opt charset_name
    {
        $$ = tree.NewTableOptionCollate($4)
    }
|   CHECKSUM equal_opt INTEGRAL
    {
        $$ = tree.NewTableOptionChecksum(uint64($3.(int64)))
    }
|   COMMENT_KEYWORD equal_opt STRING
    {
    	str := util.DealCommentString($3)
        $$ = tree.NewTableOptionComment(str)
    }
|   COMPRESSION equal_opt STRING
    {
        $$ = tree.NewTableOptionCompression($3)
    }
|   CONNECTION equal_opt STRING
    {
        $$ = tree.NewTableOptionConnection($3)
    }
|   DATA DIRECTORY equal_opt STRING
    {
        $$ = tree.NewTableOptionDataDirectory($4)
    }
|   INDEX DIRECTORY equal_opt STRING
    {
        $$ = tree.NewTableOptionIndexDirectory($4)
    }
|   DELAY_KEY_WRITE equal_opt INTEGRAL
    {
        $$ = tree.NewTableOptionDelayKeyWrite(uint64($3.(int64)))
    }
|   ENCRYPTION equal_opt STRING
    {
        $$ = tree.NewTableOptionEncryption($3)
    }
|   ENGINE equal_opt table_alias
    {
        $$ = tree.NewTableOptionEngine($3)
    }
|   KEY_BLOCK_SIZE equal_opt INTEGRAL
    {
        $$ = tree.NewTableOptionKeyBlockSize(uint64($3.(int64)))
    }
|   MAX_ROWS equal_opt INTEGRAL
    {
        $$ = tree.NewTableOptionMaxRows(uint64($3.(int64)))
    }
|   MIN_ROWS equal_opt INTEGRAL
    {
        $$ = tree.NewTableOptionMinRows(uint64($3.(int64)))
    }
|   PACK_KEYS equal_opt INTEGRAL
    {
        $$ = &tree.TableOptionPackKeys{Value: $3.(int64)}
    }
|   PACK_KEYS equal_opt DEFAULT
    {
        $$ = &tree.TableOptionPackKeys{Default: true}
    }
|   PASSWORD equal_opt STRING
    {
        $$ = tree.NewTableOptionPassword($3)
    }
|   ROW_FORMAT equal_opt row_format_options
    {
        $$ = tree.NewTableOptionRowFormat($3)
    }
|   STATS_AUTO_RECALC equal_opt INTEGRAL
    {
        $$ = &tree.TableOptionStatsAutoRecalc{Value: uint64($3.(int64))}
    }
|   STATS_AUTO_RECALC equal_opt DEFAULT
    {
        $$ = &tree.TableOptionStatsAutoRecalc{Default: true}
    }
|   STATS_PERSISTENT equal_opt INTEGRAL
    {
        $$ = &tree.TableOptionStatsPersistent{Value: uint64($3.(int64))}
    }
|   STATS_PERSISTENT equal_opt DEFAULT
    {
        $$ = &tree.TableOptionStatsPersistent{Default: true}
    }
|   STATS_SAMPLE_PAGES equal_opt INTEGRAL
    {
        $$ = &tree.TableOptionStatsSamplePages{Value: uint64($3.(int64))}
    }
|   STATS_SAMPLE_PAGES equal_opt DEFAULT
    {
        $$ = &tree.TableOptionStatsSamplePages{Default: true}
    }
|   TABLESPACE equal_opt ident storage_opt
    {
        $$= tree.NewTableOptionTablespace($3, $4)
    }
|   UNION equal_opt '(' table_name_list ')'
    {
        $$= tree.NewTableOptionUnion($4)
    }
|    PROPERTIES '(' properties_list ')'
    {
        $$ = &tree.TableOptionProperties{Preperties: $3}
    }
// |   INSERT_METHOD equal_opt insert_method_options

properties_list:
    property_elem
    {
        $$ = []tree.Property{$1}
    }
|    properties_list ',' property_elem
    {
        $$ = append($1, $3)
    }

property_elem:
    STRING '=' STRING
    {
        $$ = tree.Property{Key: $1, Value: $3}
    }

storage_opt:
    {
        $$ = ""
    }
|   STORAGE DISK
    {
        $$ = " " + $1 + " " + $2
    }
|   STORAGE MEMORY
    {
        $$ = " " + $1 + " " + $2
    }

row_format_options:
    DEFAULT
    {
        $$ = tree.ROW_FORMAT_DEFAULT
    }
|   DYNAMIC
    {
        $$ = tree.ROW_FORMAT_DYNAMIC
    }
|   FIXED
    {
        $$ = tree.ROW_FORMAT_FIXED
    }
|   COMPRESSED
    {
        $$ = tree.ROW_FORMAT_COMPRESSED
    }
|   REDUNDANT
    {
        $$ = tree.ROW_FORMAT_REDUNDANT
    }
|   COMPACT
    {
        $$ = tree.ROW_FORMAT_COMPACT
    }

charset_name:
    name_string
|   BINARY

collate_name:
    name_string
|   BINARY

table_name_list:
    table_name
    {
        $$ = tree.TableNames{$1}
    }
|   table_name_list ',' table_name
    {
        $$ = append($1, $3)
    }

// Accepted patterns:
// <table>
// <schema>.<table>
table_name:
    ident
    {
        prefix := tree.ObjectNamePrefix{ExplicitSchema: false}
        $$ = tree.NewTableName(tree.Identifier($1), prefix)
    }
|   ident '.' ident
    {
        prefix := tree.ObjectNamePrefix{SchemaName: tree.Identifier($1), ExplicitSchema: true}
        $$ = tree.NewTableName(tree.Identifier($3), prefix)
    }

table_elem_list_opt:
    {
        $$ = tree.TableDefs(nil)
    }
|   table_elem_list

table_elem_list:
    table_elem
    {
        $$ = tree.TableDefs{$1}
    }
|   table_elem_list ',' table_elem
    {
        $$ = append($1, $3)
    }

table_elem:
    column_def
    {
        $$ = tree.TableDef($1)
    }
|   constaint_def
    {
        $$ = $1
    }

constaint_def:
    constraint_keyword constraint_elem
    {
        if $1 != "" {
            switch v := $2.(type) {
            case *tree.PrimaryKeyIndex:
                v.Name = $1
            case *tree.ForeignKey:
                v.Name = $1
            }
        }
        $$ = $2
    }
|    constraint_elem
    {
        $$ = $1
    }

constraint_elem:
    PRIMARY KEY index_name_and_type_opt '(' index_column_list ')' index_option_list
    {
         $$ = &tree.PrimaryKeyIndex{
            KeyParts: $5,
            Name: $3[0],
            Empty: $3[1] == "",
            IndexOption: $7,
        }
    }
|    FULLTEXT key_or_index_opt index_name '(' index_column_list ')' index_option_list
    {
        $$ = &tree.FullTextIndex{
            KeyParts: $5,
            Name: $3,
            Empty: true,
            IndexOption: $7,
        }
    }
|    key_or_index not_exists_opt index_name_and_type_opt '(' index_column_list ')' index_option_list
    {
        keyTyp := tree.INDEX_TYPE_INVALID
        if $3[1] != "" {
               t := strings.ToLower($3[1])
            switch t {
            case "zonemap":
                keyTyp = tree.INDEX_TYPE_ZONEMAP
            case "bsi":
                keyTyp = tree.INDEX_TYPE_BSI
            default:
                yylex.Error("Invail the type of index")
                return 1
            }
        }
        $$ = &tree.Index{
            IfNotExists: $2,
            KeyParts: $5,
            Name: $3[0],
            KeyType: keyTyp,
            IndexOption: $7,
        }
    }
|    UNIQUE key_or_index_opt index_name_and_type_opt '(' index_column_list ')' index_option_list
    {
        $$ = &tree.UniqueIndex{
            KeyParts: $5,
            Name: $3[0],
            Empty: $3[1] == "",
            IndexOption: $7,
        }
    }
|    FOREIGN KEY not_exists_opt index_name '(' index_column_list ')' references_def
    {
        $$ = &tree.ForeignKey{
            IfNotExists: $3,
            KeyParts: $6,
            Name: $4,
            Refer: $8,
            Empty: true,
        }
    }
|    CHECK '(' expression ')' enforce_opt
    {
        $$ = &tree.CheckIndex{
            Expr: $3,
            Enforced: $5,
        }
    }

enforce_opt:
    {
        $$ = false
    }
|    enforce

key_or_index_opt:
    {
        $$ = ""
    }
|    key_or_index
    {
        $$ = $1
    }

key_or_index:
    KEY
|    INDEX

index_name_and_type_opt:
    index_name
    {
        $$ = make([]string, 2)
        $$[0] = $1
        $$[1] = ""
    }
|    index_name USING index_type
    {
        $$ = make([]string, 2)
        $$[0] = $1
        $$[1] = $3
    }
|    ident TYPE index_type
    {
        $$ = make([]string, 2)
        $$[0] = $1
        $$[1] = $3
    }

index_type:
    BTREE
|    HASH
|    RTREE
|    ZONEMAP
|    BSI

index_name:
    {
        $$ = ""
    }
|    ident

column_def:
    column_name column_type column_attribute_list_opt
    {
        $$ = tree.NewColumnTableDef($1, $2, $3)
    }

column_name_unresolved:
    ident
    {
        $$ = tree.SetUnresolvedName($1)
    }
|   ident '.' ident
    {
        $$ = tree.SetUnresolvedName($1, $3)
    }
|   ident '.' ident '.' ident
    {
        $$ = tree.SetUnresolvedName($1, $3, $5)
    }

ident:
    ID
|   not_keyword
|   non_reserved_keyword

column_name:
    ident
    {
        $$ = tree.SetUnresolvedName($1)
    }
|   ident '.' reserved_sql_id
    {
        $$ = tree.SetUnresolvedName($1, $3)
    }
|   ident '.' reserved_table_id '.' reserved_sql_id
    {
        $$ = tree.SetUnresolvedName($1, $3, $5)
    }

column_attribute_list_opt:
    {
        $$ = nil
    }
|   column_attribute_list
    {
        $$ = $1
    }

column_attribute_list:
    column_attribute_elem
    {
        $$ = []tree.ColumnAttribute{$1}
    }
|   column_attribute_list column_attribute_elem
    {
        $$ = append($1, $2)
    }

column_attribute_elem:
    NULL
    {
        $$ = tree.NewAttributeNull(true)
    }
|   NOT NULL
    {
        $$ = tree.NewAttributeNull(false)
    }
|   DEFAULT bit_expr
    {
        $$ = tree.NewAttributeDefault($2)
    }
|   AUTO_INCREMENT
    {
        $$ = tree.NewAttributeAutoIncrement()
    }
|   keys
    {
        $$ = $1
    }
|   COMMENT_KEYWORD STRING
    {
    	str := util.DealCommentString($2)
        $$ = tree.NewAttributeComment(tree.NewNumValWithType(constant.MakeString(str), str, false, tree.P_char))
    }
|   COLLATE collate_name
    {
        $$ = tree.NewAttributeCollate($2)
    }
|   COLUMN_FORMAT column_format
    {
        $$ = tree.NewAttributeColumnFormat($2)
    }
|   STORAGE storage_media
    {
        $$ = tree.NewAttributeStorage($2)
    }
|   AUTO_RANDOM field_length_opt
    {
        $$ = tree.NewAttributeAutoRandom(int($2))
   }
|   references_def
    {
        $$ = $1
    }
|   constraint_keyword_opt CHECK '(' expression ')'
    {
        $$ = tree.NewAttributeCheck($4, false, $1)
    }
|   constraint_keyword_opt CHECK '(' expression ')' enforce
    {
        $$ = tree.NewAttributeCheck($4, $6, $1)
    }
|   ON UPDATE name_datetime_precision datetime_precision_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($3))
        var es tree.Exprs = nil
        if $4 != nil {
            es = append(es, $4)
        }
        expr := &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: es,
        }
        $$ = tree.NewAttributeOnUpdate(expr)
    }
|   LOW_CARDINALITY
    {
	$$ = tree.NewAttributeLowCardinality()
    }

enforce:
    ENFORCED
    {
        $$ = true
    }
|   NOT ENFORCED
    {
        $$ = false
    }

constraint_keyword_opt:
    {
        $$ = ""
    }
 |    constraint_keyword
     {
         $$ = $1
     }

constraint_keyword:
    CONSTRAINT
    {
        $$ = ""
    }
|   CONSTRAINT ident
    {
        $$ = $2
    }

references_def:
    REFERENCES table_name index_column_list_opt match_opt on_delete_update_opt
    {
        $$ = &tree.AttributeReference{
            TableName: $2,
            KeyParts: $3,
            Match: $4,
            OnDelete: $5.OnDelete,
            OnUpdate: $5.OnUpdate,
        }
    }

on_delete_update_opt:
    %prec LOWER_THAN_ON
    {
        $$ = &tree.ReferenceOnRecord{
            OnDelete: tree.REFERENCE_OPTION_INVALID,
            OnUpdate: tree.REFERENCE_OPTION_INVALID,
        }
    }
|   on_delete %prec LOWER_THAN_ON
    {
        $$ = &tree.ReferenceOnRecord{
            OnDelete: $1,
            OnUpdate: tree.REFERENCE_OPTION_INVALID,
        }
    }
|   on_update %prec LOWER_THAN_ON
    {
        $$ = &tree.ReferenceOnRecord{
            OnDelete: tree.REFERENCE_OPTION_INVALID,
            OnUpdate: $1,
        }
    }
|   on_delete on_update
    {
        $$ = &tree.ReferenceOnRecord{
            OnDelete: $1,
            OnUpdate: $2,
        }
    }
|   on_update on_delete
    {
        $$ = &tree.ReferenceOnRecord{
            OnDelete: $2,
            OnUpdate: $1,
        }
    }

on_delete:
    ON DELETE ref_opt
    {
        $$ = $3
    }

on_update:
    ON UPDATE ref_opt
    {
        $$ = $3
    }

ref_opt:
    RESTRICT
    {
        $$ = tree.REFERENCE_OPTION_RESTRICT
    }
|   CASCADE
    {
        $$ = tree.REFERENCE_OPTION_CASCADE
    }
|   SET NULL
    {
        $$ = tree.REFERENCE_OPTION_SET_NULL
    }
|   NO ACTION
    {
        $$ = tree.REFERENCE_OPTION_NO_ACTION
    }
|   SET DEFAULT
    {
        $$ = tree.REFERENCE_OPTION_SET_DEFAULT
    }

match_opt:
    {
        $$ = tree.MATCH_INVALID
    }
|   match

match:
    MATCH FULL
    {
        $$ = tree.MATCH_FULL
    }
|   MATCH PARTIAL
    {
        $$ = tree.MATCH_PARTIAL
    }
|   MATCH SIMPLE
    {
        $$ = tree.MATCH_SIMPLE
    }

index_column_list_opt:
    {
        $$ = nil
    }
|   '(' index_column_list ')'
    {
        $$ = $2
    }

field_length_opt:
    {
        $$ = -1
    }
|   '(' INTEGRAL ')'
    {
        $$ = $2.(int64)
    }

storage_media:
    DEFAULT
|   DISK
|   MEMORY

column_format:
    DEFAULT
|   FIXED
|   DYNAMIC

subquery:
    select_with_parens %prec SUBQUERY_AS_EXPR
    {
        $$ = &tree.Subquery{Select: $1, Exists: false}
    }

bit_expr:
    bit_expr '&' bit_expr %prec '&'
    {
        $$ = tree.NewBinaryExpr(tree.BIT_AND, $1, $3)
    }
|   bit_expr '|' bit_expr %prec '|'
    {
        $$ = tree.NewBinaryExpr(tree.BIT_OR, $1, $3)
    }
|   bit_expr '^' bit_expr %prec '^'
    {
        $$ = tree.NewBinaryExpr(tree.BIT_XOR, $1, $3)
    }
|   bit_expr '+' bit_expr %prec '+'
    {
        $$ = tree.NewBinaryExpr(tree.PLUS, $1, $3)
    }
|   bit_expr '-' bit_expr %prec '-'
    {
        $$ = tree.NewBinaryExpr(tree.MINUS, $1, $3)
    }
|   bit_expr '*' bit_expr %prec '*'
    {
        $$ = tree.NewBinaryExpr(tree.MULTI, $1, $3)
    }
|   bit_expr '/' bit_expr %prec '/'
    {
        $$ = tree.NewBinaryExpr(tree.DIV, $1, $3)
    }
|   bit_expr DIV bit_expr %prec DIV
    {
        $$ = tree.NewBinaryExpr(tree.INTEGER_DIV, $1, $3)
    }
|   bit_expr '%' bit_expr %prec '%'
    {
        $$ = tree.NewBinaryExpr(tree.MOD, $1, $3)
    }
|   bit_expr MOD bit_expr %prec MOD
    {
        $$ = tree.NewBinaryExpr(tree.MOD, $1, $3)
    }
|   bit_expr SHIFT_LEFT bit_expr %prec SHIFT_LEFT
    {
        $$ = tree.NewBinaryExpr(tree.LEFT_SHIFT, $1, $3)
    }
|   bit_expr SHIFT_RIGHT bit_expr %prec SHIFT_RIGHT
    {
        $$ = tree.NewBinaryExpr(tree.RIGHT_SHIFT, $1, $3)
    }
|   simple_expr
    {
        $$ = $1
    }

simple_expr:
    normal_ident
    {
        $$ = $1
    }
|   variable
    {
        $$ = $1
    }
|   literal
    {
        $$ = $1
    }
|   '(' expression ')'
    {
        $$ = tree.NewParenExpr($2)
    }
|   '(' expression_list ',' expression ')'
    {
        $$ = tree.NewTuple(append($2, $4))
    }
|   '+'  simple_expr %prec UNARY
    {
        $$ = tree.NewUnaryExpr(tree.UNARY_PLUS, $2)
    }
|   '-'  simple_expr %prec UNARY
    {
        $$ = tree.NewUnaryExpr(tree.UNARY_MINUS, $2)
    }
|   '~'  simple_expr
    {
        $$ = tree.NewUnaryExpr(tree.UNARY_TILDE, $2)
    }
|   '!' simple_expr %prec UNARY
    {
        $$ = tree.NewUnaryExpr(tree.UNARY_MARK, $2)
    }
|   interval_expr
    {
        $$ = $1
    }
|   subquery
    {
        $$ = $1
    }
|   EXISTS subquery
    {
        $2.Exists = true
        $$ = $2
    }
|   CASE expression_opt when_clause_list else_opt END
    {
        $$ = &tree.CaseExpr{
            Expr: $2,
            Whens: $3,
            Else: $4,
        }
    }
|   CAST '(' expression AS mo_cast_type ')'
    {
        $$ = tree.NewCastExpr($3, $5)
    }
|   BINARY '(' expression ')'
    {
        locale := ""
        $$ = tree.NewCastExpr($3, &tree.T{
            InternalType: tree.InternalType{
                Family: tree.StringFamily,
                FamilyString: "BINARY",
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_VARCHAR),
            },
        })
    }
|   CONVERT '(' expression ',' mysql_cast_type ')'
    {
        $$ = tree.NewCastExpr($3, $5)
    }
|   CONVERT '(' expression USING charset_name ')'
    {
        name := tree.SetUnresolvedName("convert")
        es := tree.NewNumValWithType(constant.MakeString($5), $5, false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$3, es},
        }
    }
|   function_call_generic
    {
        $$ = $1
    }
|   function_call_keyword
    {
        $$ = $1
    }
|   function_call_nonkeyword
    {
        $$ = $1
    }
|   function_call_aggregate
    {
        $$ = $1
    }

else_opt:
    {
        $$ = nil
    }
|    ELSE expression
    {
        $$ = $2
    }

expression_opt:
    {
        $$ = nil
    }
|    expression
    {
        $$ = $1
    }

when_clause_list:
    when_clause
    {
        $$ = []*tree.When{$1}
    }
|    when_clause_list when_clause
    {
        $$ = append($1, $2)
    }

when_clause:
    WHEN expression THEN expression
    {
        $$ = &tree.When{
            Cond: $2,
            Val: $4,
        }
    }

mo_cast_type:
    column_type
|   SIGNED integer_opt
    {
        name := $1
        if $2 != "" {
            name = $2
        }
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: name,
                Width:  64,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONGLONG),
            },
        }
    }
|   UNSIGNED integer_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $2,
                Width:  64,
                Locale: &locale,
                Unsigned: true,
                Oid:    uint32(defines.MYSQL_TYPE_LONGLONG),
            },
        }
    }

mysql_cast_type:
    decimal_type
|   BINARY length_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.StringFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_VARCHAR),
                DisplayWith: $2,
            },
        }
    }
|   CHAR length_option_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.StringFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_VARCHAR),
                DisplayWith: $2,
            },
        }
    }
|   DATE
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.DateFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_DATE),
            },
        }
    }
|   YEAR length_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                DisplayWith: $2,
                Width:  16,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_YEAR),
            },
        }
    }
|   DATETIME timestamp_option_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family:             tree.TimestampFamily,
                Precision:          $2,
                FamilyString: $1,
                DisplayWith: $2,
                TimePrecisionIsSet: false,
                Locale:             &locale,
                Oid:                uint32(defines.MYSQL_TYPE_DATETIME),
            },
        }
    }
|   TIME length_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.TimeFamily,
                FamilyString: $1,
                DisplayWith: $2,
                Precision: $2,
                TimePrecisionIsSet: false,
                Locale: &locale,
                Oid: uint32(defines.MYSQL_TYPE_TIME),
            },
        }
    }
|   SIGNED integer_opt
    {
        name := $1
        if $2 != "" {
            name = $2
        }
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: name,
                Width:  64,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONGLONG),
            },
        }
    }
|   UNSIGNED integer_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $2,
                Width:  64,
                Locale: &locale,
                Unsigned: true,
                Oid:    uint32(defines.MYSQL_TYPE_LONGLONG),
            },
        }
    }

integer_opt:
    {}
|    INTEGER
|    INT

window_frame_bound:
  CURRENT ROW
    {
        $$ = &tree.WindowFrameBoundCurrentRow{}
    }
| UNBOUNDED PRECEDING
    {
        $$ = &tree.WindowFrameBoundPreceding{}
    }
| expression PRECEDING
    {
        $$ = &tree.WindowFrameBoundPreceding{
            Expr: $1,
        }
    }
| UNBOUNDED FOLLOWING
    {
        $$ = &tree.WindowFrameBoundFollowing{}
    }
| expression FOLLOWING
    {
        $$ = &tree.WindowFrameBoundFollowing{
            Expr: $1,
        }
    }

window_frame_unit:
    ROWS
    {
        $$ = tree.WIN_FRAME_UNIT_ROWS
    }
|   RANGE
    {
        $$ = tree.WIN_FRAME_UNIT_RANGE
    }
|   GROUPS
    {
        $$ = tree.WIN_FRAME_UNIT_GROUPS
    }

window_frame:
    window_frame_unit window_frame_bound
    {
        $$ = &tree.WindowFrame{
            Unit: $1,
            StartBound: $2,
        }
    }
|   window_frame_unit BETWEEN window_frame_bound AND window_frame_bound
    {
        $$ = &tree.WindowFrame{
            Unit: $1,
            StartBound: $3,
            EndBound: $5,
        }
    }

window_frame_opt:
    {
        $$ = nil
    }
|   window_frame
    {
        $$ = $1
    }


window_partition_by:
   PARTITION BY expression_list
    {
        $$ = $3
    }

window_partition_by_opt:
    {
        $$ = nil
    }
|   window_partition_by
    {
        $$ = $1
    }

separator_opt:
    {
        $$ = ","
    }
|   SEPARATOR STRING
    {
       $$ = $2
    }

window_spec_opt:
    {
        $$ = nil
    }
|   OVER '(' window_partition_by_opt order_by_opt window_frame_opt ')'
    {
        $$ = &tree.WindowSpec{
            PartitionBy: $3,
            OrderBy: $4,
            WindowFrame: $5,
        }
    }

function_call_aggregate:
    GROUP_CONCAT '(' func_type_opt expression_list order_by_opt separator_opt ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: append($4,tree.NewNumValWithType(constant.MakeString($6), $6, false, tree.P_char)),
            Type: $3,
            WindowSpec: $8,
            AggType: 2,
        }
    }
|   AVG '(' func_type_opt expression  ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   APPROX_COUNT_DISTINCT '(' expression_list ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
            WindowSpec: $5,
        }
    }
|   APPROX_PERCENTILE '(' expression_list ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
            WindowSpec: $5,
        }
    }
|   BIT_AND '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   BIT_OR '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   BIT_XOR '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   COUNT '(' func_type_opt expression_list ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $4,
            Type: $3,
            WindowSpec: $6,
        }
    }
|   COUNT '(' '*' ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        es := tree.NewNumValWithType(constant.MakeString("*"), "*", false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{es},
            WindowSpec: $5,
        }
    }
|   MAX '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   MIN '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   SUM '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   std_dev_pop '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   STDDEV_SAMP '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   VAR_POP '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   VAR_SAMP '(' func_type_opt expression ')' window_spec_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
            WindowSpec: $6,
        }
    }
|   MEDIAN '(' func_type_opt expression ')' window_spec_opt
    {
	name := tree.SetUnresolvedName(strings.ToLower($1))
	$$ = &tree.FuncExpr{
	    Func: tree.FuncName2ResolvableFunctionReference(name),
	    Exprs: tree.Exprs{$4},
	    Type: $3,
	    WindowSpec: $6,
	}
    }

std_dev_pop:
    STD
|   STDDEV
|   STDDEV_POP

function_call_generic:
    ID '(' expression_list_opt ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
        }
    }
|   substr_option '(' expression_list_opt ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
        }
    }
|   substr_option '(' expression FROM expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$3, $5},
        }
    }
|   substr_option '(' expression FROM expression FOR expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$3, $5, $7},
        }
    }
|   EXTRACT '(' time_unit FROM expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        timeUinit := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{timeUinit, $5},
        }
    }
|   func_not_keyword '(' expression_list_opt ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
        }
    }
|   VARIANCE '(' func_type_opt expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$4},
            Type: $3,
        }
    }
|   TRIM '(' expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        arg0 := tree.NewNumValWithType(constant.MakeInt64(0), "0", false, tree.P_int64)
        arg1 := tree.NewNumValWithType(constant.MakeString("both"), "both", false, tree.P_char)
        arg2 := tree.NewNumValWithType(constant.MakeString(" "), " ", false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{arg0, arg1, arg2, $3},
        }
    }
|   TRIM '(' expression FROM expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        arg0 := tree.NewNumValWithType(constant.MakeInt64(1), "1", false, tree.P_int64)
        arg1 := tree.NewNumValWithType(constant.MakeString("both"), "both", false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{arg0, arg1, $3, $5},
        }
    }
|   TRIM '(' trim_direction FROM expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        arg0 := tree.NewNumValWithType(constant.MakeInt64(2), "2", false, tree.P_int64)
        arg1 := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
        arg2 := tree.NewNumValWithType(constant.MakeString(" "), " ", false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{arg0, arg1, arg2, $5},
        }
    }
|   TRIM '(' trim_direction expression FROM expression ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        arg0 := tree.NewNumValWithType(constant.MakeInt64(3), "3", false, tree.P_int64)
        arg1 := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{arg0, arg1, $4, $6},
        }
    }
|   VALUES '(' insert_column ')'
    {
    	column := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
        name := tree.SetUnresolvedName(strings.ToLower($1))
    	$$ = &tree.FuncExpr{
                    Func: tree.FuncName2ResolvableFunctionReference(name),
                    Exprs: tree.Exprs{column},
        }
    }


trim_direction:
    BOTH
|    LEADING
|    TRAILING

substr_option:
    SUBSTRING
|    SUBSTR
|    MID

time_unit:
    time_stamp_unit
    {
        $$ = $1
    }
|    SECOND_MICROSECOND
|    MINUTE_MICROSECOND
|    MINUTE_SECOND
|    HOUR_MICROSECOND
|    HOUR_SECOND
|    HOUR_MINUTE
|    DAY_MICROSECOND
|    DAY_SECOND
|    DAY_MINUTE
|    DAY_HOUR
|    YEAR_MONTH

time_stamp_unit:
    MICROSECOND
|    SECOND
|    MINUTE
|    HOUR
|    DAY
|    WEEK
|    MONTH
|    QUARTER
|    YEAR
|    SQL_TSI_SECOND
|    SQL_TSI_MINUTE
|    SQL_TSI_HOUR
|    SQL_TSI_DAY
|    SQL_TSI_WEEK
|    SQL_TSI_MONTH
|    SQL_TSI_QUARTER
|    SQL_TSI_YEAR

function_call_nonkeyword:
    CURTIME datetime_precision
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        var es tree.Exprs = nil
        if $2 != nil {
            es = append(es, $2)
        }
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: es,
        }
    }
|   SYSDATE datetime_precision
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        var es tree.Exprs = nil
        if $2 != nil {
            es = append(es, $2)
        }
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: es,
        }
    }
|	TIMESTAMPDIFF '(' time_stamp_unit ',' expression ',' expression ')'
	{
        name := tree.SetUnresolvedName(strings.ToLower($1))
        arg1 := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
		$$ =  &tree.FuncExpr{
             Func: tree.FuncName2ResolvableFunctionReference(name),
             Exprs: tree.Exprs{arg1, $5, $7},
        }
	}
function_call_keyword:
    name_confict '(' expression_list_opt ')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
        }
    }
|   name_braces braces_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
        }
    }
|    SCHEMA '('')'
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
        }
    }
|   name_datetime_precision datetime_precision_opt
    {
        name := tree.SetUnresolvedName(strings.ToLower($1))
        var es tree.Exprs = nil
        if $2 != nil {
            es = append(es, $2)
        }
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: es,
        }
    }
|   CHAR '(' expression_list ')'
    {
        name := tree.SetUnresolvedName("char")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
        }
    }
|   CHAR '(' expression_list USING charset_name ')'
    {
        cn := tree.NewNumValWithType(constant.MakeString($5), $5, false, tree.P_char)
        es := $3
        es = append(es, cn)
        name := tree.SetUnresolvedName("char")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: es,
        }
    }
|   DATE STRING
    {
        val := tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_char)
        name := tree.SetUnresolvedName("date")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{val},
        }
    }
|   TIME STRING
    {
        val := tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_char)
        name := tree.SetUnresolvedName("time")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{val},
        }
    }
|   INSERT '(' expression_list_opt ')'
    {
        name := tree.SetUnresolvedName("insert")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
        }
    }
|   MOD '(' bit_expr ',' bit_expr ')'
    {
        es := tree.Exprs{$3}
        es = append(es, $5)
        name := tree.SetUnresolvedName("mod")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: es,
        }
    }
|   PASSWORD '(' expression_list_opt ')'
    {
        name := tree.SetUnresolvedName("password")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: $3,
        }
    }
|   TIMESTAMP STRING
    {
        val := tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_char)
        name := tree.SetUnresolvedName("timestamp")
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{val},
        }
    }

datetime_precision_opt:
    {
        $$ = nil
    }
|   datetime_precision
    {
        $$ = $1
    }

datetime_precision:
   '(' ')'
    {
        $$ = nil
    }
|   '(' INTEGRAL ')'
    {
        ival, errStr := util.GetInt64($2)
        if errStr != "" {
            yylex.Error(errStr)
            return 1
        }
        str := fmt.Sprintf("%v", $2)
        $$ = tree.NewNumValWithType(constant.MakeInt64(ival), str, false, tree.P_int64)
    }

name_datetime_precision:
    CURRENT_TIME
|   CURRENT_TIMESTAMP
|   LOCALTIME
|   LOCALTIMESTAMP
|   UTC_TIME
|   UTC_TIMESTAMP

braces_opt:
    {}
|   '(' ')'
    {}

name_braces:
    CURRENT_USER
|   CURRENT_DATE
|   CURRENT_ROLE
|   UTC_DATE

name_confict:
    ASCII
|   CHARSET
|   COALESCE
|   COLLATION
|   DATE
|   DATABASE
|   DAY
|   HOUR
|   IF
|   INTERVAL
|   FORMAT
|   LEFT
|   MICROSECOND
|   MINUTE
|   MONTH
|   QUARTER
|   REPEAT
|   REPLACE
|   REVERSE
|   RIGHT
|   ROW_COUNT
|   SECOND
|   TIME
|   TIMESTAMP
|   TRUNCATE
|   USER
|   WEEK
|   YEAR
|   UUID

interval_expr:
    INTERVAL expression time_unit
    {
         name := tree.SetUnresolvedName("interval")
        arg2 := tree.NewNumValWithType(constant.MakeString($3), $3, false, tree.P_char)
        $$ = &tree.FuncExpr{
            Func: tree.FuncName2ResolvableFunctionReference(name),
            Exprs: tree.Exprs{$2, arg2},
        }
    }

func_type_opt:
    {
        $$ = tree.FUNC_TYPE_DEFAULT
    }
|   DISTINCT
    {
        $$ = tree.FUNC_TYPE_DISTINCT
    }
|   ALL
    {
        $$ = tree.FUNC_TYPE_ALL
    }

tuple_expression:
    '(' expression_list ')'
    {
        $$ = tree.NewTuple($2)
    }

expression_list_opt:
    {
        $$ = nil
    }
|   expression_list
    {
        $$ = $1
    }

expression_list:
    expression
    {
        $$ = tree.Exprs{$1}
    }
|   expression_list ',' expression
    {
        $$ = append($1, $3)
    }

// See https://dev.mysql.com/doc/refman/8.0/en/expressions.html
expression:
    expression AND expression %prec AND
    {
        $$ = tree.NewAndExpr($1, $3)
    }
|   expression OR expression %prec OR
    {
        $$ = tree.NewOrExpr($1, $3)
    }
|   expression PIPE_CONCAT expression %prec PIPE_CONCAT
    {
        name := tree.SetUnresolvedName(strings.ToLower("concat"))
        $$ = &tree.FuncExpr{
             Func: tree.FuncName2ResolvableFunctionReference(name),
             Exprs: tree.Exprs{$1, $3},
        }
    }
|   expression XOR expression %prec XOR
    {
        $$ = tree.NewXorExpr($1, $3)
    }
|   NOT expression %prec NOT
    {
        $$ = tree.NewNotExpr($2)
    }
|   MAXVALUE
    {
        $$ = tree.NewMaxValue()
    }
|   boolean_primary
    {
        $$ = $1
    }

boolean_primary:
    boolean_primary IS NULL %prec IS
    {
        $$ = tree.NewIsNullExpr($1)
    }
|   boolean_primary IS NOT NULL %prec IS
    {
        $$ = tree.NewIsNotNullExpr($1)
    }
|   boolean_primary IS UNKNOWN %prec IS
    {
        $$ = tree.NewIsUnknownExpr($1)
    }
|   boolean_primary IS NOT UNKNOWN %prec IS
    {
        $$ = tree.NewIsNotUnknownExpr($1)
    }
|   boolean_primary IS TRUE %prec IS
    {
        $$ = tree.NewIsTrueExpr($1)
    }
|   boolean_primary IS NOT TRUE %prec IS
    {
        $$ = tree.NewIsNotTrueExpr($1)
    }
|   boolean_primary IS FALSE %prec IS
    {
        $$ = tree.NewIsFalseExpr($1)
    }
|   boolean_primary IS NOT FALSE %prec IS
    {
        $$ = tree.NewIsNotFalseExpr($1)
    }
|   boolean_primary comparison_operator predicate %prec '='
    {
        $$ = tree.NewComparisonExpr($2, $1, $3)
    }
|   boolean_primary comparison_operator and_or_some subquery %prec '='
    {
        $$ = tree.NewSubqueryComparisonExpr($2, $3, $1, $4)
        $$ = tree.NewSubqueryComparisonExpr($2, $3, $1, $4)
    }
|   predicate

predicate:
    bit_expr IN col_tuple
    {
        $$ = tree.NewComparisonExpr(tree.IN, $1, $3)
    }
|   bit_expr NOT IN col_tuple
    {
        $$ = tree.NewComparisonExpr(tree.NOT_IN, $1, $4)
    }
|   bit_expr LIKE simple_expr like_escape_opt
    {
        $$ = tree.NewComparisonExprWithEscape(tree.LIKE, $1, $3, $4)
    }
|   bit_expr NOT LIKE simple_expr like_escape_opt
    {
        $$ = tree.NewComparisonExprWithEscape(tree.NOT_LIKE, $1, $4, $5)
    }
|   bit_expr ILIKE simple_expr like_escape_opt
    {
        $$ = tree.NewComparisonExprWithEscape(tree.ILIKE, $1, $3, $4)
    }
|   bit_expr NOT ILIKE simple_expr like_escape_opt
    {
        $$ = tree.NewComparisonExprWithEscape(tree.NOT_ILIKE, $1, $4, $5)
    }
|   bit_expr REGEXP bit_expr
    {
        $$ = tree.NewComparisonExpr(tree.REG_MATCH, $1, $3)
    }
|   bit_expr NOT REGEXP bit_expr
    {
        $$ = tree.NewComparisonExpr(tree.NOT_REG_MATCH, $1, $4)
    }
|   bit_expr BETWEEN bit_expr AND predicate
    {
        $$ = tree.NewRangeCond(false, $1, $3, $5)
    }
|   bit_expr NOT BETWEEN bit_expr AND predicate
    {
        $$ = tree.NewRangeCond(true, $1, $4, $6)
    }
|   bit_expr

like_escape_opt:
    {
        $$ = nil
    }
|   ESCAPE simple_expr
    {
        $$ = $2
    }

col_tuple:
    tuple_expression
    {
        $$ = $1
    }
|   subquery
    {
        $$ = $1
    }
// |   LIST_ARG

and_or_some:
    ALL
    {
        $$ = tree.ALL
    }
|    ANY
    {
        $$ = tree.ANY
    }
|    SOME
    {
        $$ = tree.SOME
    }

comparison_operator:
    '='
    {
        $$ = tree.EQUAL
    }
|   '<'
    {
        $$ = tree.LESS_THAN
    }
|   '>'
    {
        $$ = tree.GREAT_THAN
    }
|   LE
    {
        $$ = tree.LESS_THAN_EQUAL
    }
|   GE
    {
        $$ = tree.GREAT_THAN_EQUAL
    }
|   NE
    {
        $$ = tree.NOT_EQUAL
    }
|   NULL_SAFE_EQUAL
    {
        $$ = tree.NULL_SAFE_EQUAL
    }

keys:
    PRIMARY KEY
    {
        $$ = tree.NewAttributePrimaryKey()
    }
|   UNIQUE KEY
    {
        $$ = tree.NewAttributeUniqueKey()
    }
|   UNIQUE
    {
        $$ = tree.NewAttributeUnique()
    }
|   KEY
    {
        $$ = tree.NewAttributeKey()
    }

literal:
    STRING
    {
        $$ = tree.NewNumValWithType(constant.MakeString($1), $1, false, tree.P_char)
    }
|   INTEGRAL
    {
        str := fmt.Sprintf("%v", $1)
        switch v := $1.(type) {
        case uint64:
            $$ = tree.NewNumValWithType(constant.MakeUint64(v), str, false, tree.P_uint64)
        case int64:
            $$ = tree.NewNumValWithType(constant.MakeInt64(v), str, false, tree.P_int64)
        default:
            yylex.Error("parse integral fail")
            return 1
        }
    }
|   FLOAT
    {
        fval := $1.(float64)
        $$ = tree.NewNumValWithType(constant.MakeFloat64(fval), yylex.(*Lexer).scanner.LastToken, false, tree.P_float64)
    }
|   TRUE
    {
        $$ = tree.NewNumValWithType(constant.MakeBool(true), "true", false, tree.P_bool)
    }
|   FALSE
    {
        $$ = tree.NewNumValWithType(constant.MakeBool(false), "false", false, tree.P_bool)
    }
|   NULL
    {
        $$ = tree.NewNumValWithType(constant.MakeUnknown(), "null", false, tree.P_null)
    }
|   HEXNUM
    {
        $$ = tree.NewNumValWithType(constant.MakeString($1), $1, false, tree.P_hexnum)
    }
|   DECIMAL_VALUE
    {
        $$ = tree.NewNumValWithType(constant.MakeString($1), $1, false, tree.P_decimal)
    }
|   BIT_LITERAL
    {
        switch v := $1.(type) {
        case uint64:
            $$ = tree.NewNumValWithType(constant.MakeUint64(v), yylex.(*Lexer).scanner.LastToken, false, tree.P_uint64)
        case int64:
            $$ = tree.NewNumValWithType(constant.MakeInt64(v), yylex.(*Lexer).scanner.LastToken, false, tree.P_int64)
        case string:
            $$ = tree.NewNumValWithType(constant.MakeString(v), v, false, tree.P_bit)
        default:
            yylex.Error("parse integral fail")
            return 1
        }
    }
|   VALUE_ARG
    {
        $$ = tree.NewParamExpr(yylex.(*Lexer).GetParamIndex())
    }
|   UNDERSCORE_BINARY STRING
    {
        $$ = tree.NewNumValWithType(constant.MakeString($2), $2, false, tree.P_ScoreBinary)
    }


column_type:
    numeric_type unsigned_opt zero_fill_opt
    {
        $$ = $1
        $$.InternalType.Unsigned = $2
        $$.InternalType.Zerofill = $3
    }
|   char_type
|   time_type
|   spatial_type

numeric_type:
    int_type length_opt
    {
        $$ = $1
        $$.InternalType.DisplayWith = $2
    }
|   decimal_type
    {
        $$ = $1
    }

int_type:
    BIT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BitFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_BIT),
            },
        }
    }
|   BOOL
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BoolFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:uint32(defines.MYSQL_TYPE_BOOL),
            },
        }
    }
|   BOOLEAN
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BoolFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:uint32(defines.MYSQL_TYPE_BOOL),
            },
        }
    }
|   INT1
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  8,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_TINY),
            },
        }
    }
|   TINYINT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  8,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_TINY),
            },
        }
    }
|   INT2
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  16,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_SHORT),
            },
        }
    }
|   SMALLINT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  16,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_SHORT),
            },
        }
    }
|   INT3
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  24,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_INT24),
            },
        }
    }
|   MEDIUMINT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  24,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_INT24),
            },
        }
    }
|   INT4
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  32,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONG),
            },
        }
    }
|   INT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  32,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONG),
            },
        }
    }
|   INTEGER
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  32,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONG),
            },
        }
    }
|   INT8
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  64,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONGLONG),
            },
        }
    }
|   BIGINT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                Width:  64,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONGLONG),
            },
        }
    }

decimal_type:
    DOUBLE float_length_opt
    {
        locale := ""
        if $2.DisplayWith > 255 {
            yylex.Error("Display width for double out of range (max = 255)")
            return 1
        }
        if $2.Precision != tree.NotDefineDec && $2.Precision > $2.DisplayWith {
            yylex.Error("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column 'a'))")
                return 1
        }
        $$ = &tree.T{
            InternalType: tree.InternalType{
        		Family: tree.FloatFamily,
                FamilyString: $1,
        		Width:  64,
        		Locale: &locale,
       			Oid: uint32(defines.MYSQL_TYPE_DOUBLE),
                DisplayWith: $2.DisplayWith,
                Precision: $2.Precision,
        	},
        }
    }
|   FLOAT_TYPE float_length_opt
    {
        locale := ""
        if $2.Precision != tree.NotDefineDec && $2.Precision > $2.DisplayWith {
        	yylex.Error("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column 'a'))")
        	return 1
        }
        if $2.DisplayWith >= 24 {
            $$ = &tree.T{
            	InternalType: tree.InternalType{
            		Family: tree.FloatFamily,
            		FamilyString: $1,
            		Width:  64,
            		Locale: &locale,
           			Oid:    uint32(defines.MYSQL_TYPE_DOUBLE),
            		DisplayWith: $2.DisplayWith,
            		Precision: $2.Precision,
            	},
            }
        } else {
            $$ = &tree.T{
            	InternalType: tree.InternalType{
            		Family: tree.FloatFamily,
            		FamilyString: $1,
            		Width:  32,
            		Locale: &locale,
            		Oid:    uint32(defines.MYSQL_TYPE_FLOAT),
            		DisplayWith: $2.DisplayWith,
            		Precision: $2.Precision,
            	},
            }
        }
    }

|   DECIMAL decimal_length_opt
    {
        locale := ""
        if $2.Precision != tree.NotDefineDec && $2.Precision > $2.DisplayWith {
        yylex.Error("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column 'a'))")
        return 1
        }
        if $2.DisplayWith > 38 || $2.DisplayWith < 0 {
            yylex.Error("For decimal(M), M must between 0 and 38.")
                return 1
        } else if $2.DisplayWith <= 16 {
            $$ = &tree.T{
            InternalType: tree.InternalType{
            Family: tree.FloatFamily,
            FamilyString: $1,
            Width:  64,
            Locale: &locale,
            Oid:    uint32(defines.MYSQL_TYPE_DECIMAL),
            DisplayWith: $2.DisplayWith,
            Precision: $2.Precision,
            },
        }
        } else {
            $$ = &tree.T{
            InternalType: tree.InternalType{
            Family: tree.FloatFamily,
            FamilyString: $1,
            Width:  128,
            Locale: &locale,
            Oid:    uint32(defines.MYSQL_TYPE_DECIMAL),
            DisplayWith: $2.DisplayWith,
            Precision: $2.Precision,
            },
                }
        }
    }
// |   DECIMAL decimal_length_opt
//     {
//         $$ = tree.TYPE_DOUBLE
//         $$.InternalType.DisplayWith = $2.DisplayWith
//         $$.InternalType.Precision = $2.Precision
//     }
// |   NUMERIC decimal_length_opt
//     {
//         $$ = tree.TYPE_DOUBLE
//         $$.InternalType.DisplayWith = $2.DisplayWith
//         $$.InternalType.Precision = $2.Precision
//     }
|   REAL float_length_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.FloatFamily,
                FamilyString: $1,
                Width:  64,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_DOUBLE),
                DisplayWith: $2.DisplayWith,
                Precision: $2.Precision,
            },
        }
    }

time_type:
    DATE
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.DateFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_DATE),
            },
        }
    }
|   TIME timestamp_option_opt
    {
        locale := ""
        if $2 < 0 || $2 > 6 {
                yylex.Error("For Time(fsp), fsp must in [0, 6]")
                return 1
                } else {
                $$ = &tree.T{
                    InternalType: tree.InternalType{
                Family:             tree.TimeFamily,
                Precision:          $2,
                    FamilyString: $1,
                    DisplayWith: 26,
                TimePrecisionIsSet: true,
                Locale:             &locale,
                Oid:                uint32(defines.MYSQL_TYPE_TIME),
            },
        }
        }
    }
|   TIMESTAMP timestamp_option_opt
    {
        locale := ""
        if $2 < 0 || $2 > 6 {
                yylex.Error("For Timestamp(fsp), fsp must in [0, 6]")
                return 1
                } else {
                $$ = &tree.T{
                    InternalType: tree.InternalType{
                Family:             tree.TimestampFamily,
                Precision:          $2,
                    FamilyString: $1,
                    DisplayWith: 26,
                TimePrecisionIsSet: true,
                Locale:             &locale,
                Oid:                uint32(defines.MYSQL_TYPE_TIMESTAMP),
            },
        }
        }
    }
|   DATETIME timestamp_option_opt
    {
        locale := ""
        if $2 < 0 || $2 > 6 {
                yylex.Error("For Datetime(fsp), fsp must in [0, 6]")
                return 1
                } else {
                $$ = &tree.T{
                    InternalType: tree.InternalType{
                Family:             tree.TimestampFamily,
                Precision:          $2,
                    FamilyString: $1,
                    DisplayWith: 26,
                TimePrecisionIsSet: true,
                Locale:             &locale,
                Oid:                uint32(defines.MYSQL_TYPE_DATETIME),
            },
        }
        }
    }
|   YEAR length_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.IntFamily,
                FamilyString: $1,
                DisplayWith: $2,
                Width:  16,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_YEAR),
            },
        }
    }

char_type:
    CHAR length_option_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.StringFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_STRING),
                DisplayWith: $2,
            },
        }
    }
|   VARCHAR length_option_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.StringFamily,
                Locale: &locale,
                FamilyString: $1,
                DisplayWith: $2,
                Oid:    uint32(defines.MYSQL_TYPE_VARCHAR),
            },
        }
    }
|   BINARY length_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.StringFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_VARCHAR),
                DisplayWith: $2,
            },
        }
    }
|   VARBINARY length_opt
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.StringFamily,
                Locale: &locale,
                FamilyString: $1,
                DisplayWith: $2,
                Oid:    uint32(defines.MYSQL_TYPE_VARCHAR),
            },
        }
    }
|   TEXT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_TEXT),
            },
        }
    }
|   TINYTEXT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_TEXT),
            },
        }
    }
|   MEDIUMTEXT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_TEXT),
            },
        }
    }
|   LONGTEXT
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_TEXT),
            },
        }
    }
|   BLOB
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_BLOB),
            },
        }
    }
|   TINYBLOB
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_TINY_BLOB),
            },
        }
    }
|   MEDIUMBLOB
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_MEDIUM_BLOB),
            },
        }
    }
|   LONGBLOB
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.BlobFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:    uint32(defines.MYSQL_TYPE_LONG_BLOB),
            },
        }
    }
|   JSON
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.JsonFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:uint32(defines.MYSQL_TYPE_JSON),
            },
        }
    }
|   ENUM '(' enum_values ')'
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.EnumFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:uint32(defines.MYSQL_TYPE_ENUM),
                EnumValues: $3,
            },
        }
    }
|   SET '(' enum_values ')'
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.SetFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:uint32(defines.MYSQL_TYPE_SET),
                EnumValues: $3,
            },
        }
    }
|  UUID
    {
       locale := ""
        $$ = &tree.T{
         InternalType: tree.InternalType{
        Family: tree.UuidFamily,
           FamilyString: $1,
        Width:  128,
        Locale: &locale,
        Oid:    uint32(defines.MYSQL_TYPE_UUID),
    },
    }
}

do_stmt:
    DO expression_list
    {
        $$ = &tree.Do {
            Exprs: $2,
        }
    }

declare_stmt:
    DECLARE var_name_list column_type
    {
        $$ = &tree.Declare {
            Variables: $2,
            ColumnType: $3,
            DefaultVal: tree.NewNumValWithType(constant.MakeUnknown(), "null", false, tree.P_null),
        }
    }
    |
    DECLARE var_name_list column_type DEFAULT expression
    {
        $$ = &tree.Declare {
            Variables: $2,
            ColumnType: $3,
            DefaultVal: $5,
        }
    }

spatial_type:
    GEOMETRY
    {
        locale := ""
        $$ = &tree.T{
            InternalType: tree.InternalType{
                Family: tree.GeometryFamily,
                FamilyString: $1,
                Locale: &locale,
                Oid:uint32(defines.MYSQL_TYPE_GEOMETRY),
            },
        }
    }
// |   POINT
// |   LINESTRING
// |   POLYGON
// |   GEOMETRYCOLLECTION
// |   MULTIPOINT
// |   MULTILINESTRING
// |   MULTIPOLYGON

// TODO:
// need to encode SQL string
enum_values:
    STRING
    {
        $$ = make([]string, 0, 4)
        $$ = append($$, $1)
    }
|   enum_values ',' STRING
    {
        $$ = append($1, $3)
    }

length_opt:
    /* EMPTY */
    {
        $$ = 0
    }
|    length

timestamp_option_opt:
    /* EMPTY */
        {
            $$ = 0
        }
|    '(' INTEGRAL ')'
    {
        $$ = int32($2.(int64))
    }

length_option_opt:
    {
        $$ = int32(-1)
    }
|    '(' INTEGRAL ')'
    {
        $$ = int32($2.(int64))
    }

length:
   '(' INTEGRAL ')'
    {
        $$ = tree.GetDisplayWith(int32($2.(int64)))
    }

float_length_opt:
    /* EMPTY */
    {
        $$ = tree.LengthScaleOpt{
            DisplayWith: tree.NotDefineDisplayWidth,
            Precision: tree.NotDefineDec,
        }
    }
|   '(' INTEGRAL ')'
    {
        $$ = tree.LengthScaleOpt{
            DisplayWith: tree.GetDisplayWith(int32($2.(int64))),
            Precision: tree.NotDefineDec,
        }
    }
|   '(' INTEGRAL ',' INTEGRAL ')'
    {
        $$ = tree.LengthScaleOpt{
            DisplayWith: tree.GetDisplayWith(int32($2.(int64))),
            Precision: int32($4.(int64)),
        }
    }

decimal_length_opt:
    /* EMPTY */
    {
        $$ = tree.LengthScaleOpt{
            DisplayWith: 34,           // this is the default precision for decimal
            Precision: 0,
        }
    }
|   '(' INTEGRAL ')'
    {
        $$ = tree.LengthScaleOpt{
            DisplayWith: tree.GetDisplayWith(int32($2.(int64))),
            Precision: 0,
        }
    }
|   '(' INTEGRAL ',' INTEGRAL ')'
    {
        $$ = tree.LengthScaleOpt{
            DisplayWith: tree.GetDisplayWith(int32($2.(int64))),
            Precision: int32($4.(int64)),
        }
    }

unsigned_opt:
    /* EMPTY */
    {
        $$ = false
    }
|   UNSIGNED
    {
        $$ = true
    }
|   SIGNED
    {
        $$ = false
    }

zero_fill_opt:
    /* EMPTY */
    {}
|   ZEROFILL
    {
        $$ = true
    }

charset_keyword:
    CHARSET
|   CHARACTER SET
|   CHAR SET

equal_opt:
    {
        $$ = ""
    }
|   '='
    {
        $$ = string($1)
    }

sql_id:
    id_or_var
|   non_reserved_keyword

reserved_sql_id:
    sql_id
|   reserved_keyword

reserved_table_id:
    table_id
|   reserved_keyword

reserved_keyword:
    ADD
|   ALL
|   AND
|   AS
|   ASC
|   ASCII
|   AUTO_INCREMENT
|   BETWEEN
|   BINARY
|   BY
|   CASE
|   CHAR
|   COLLATE
|   COLLATION
|   CONVERT
|   COALESCE
|   CREATE
|   CROSS
|   CURRENT_DATE
|   CURRENT_ROLE
|   CURRENT_USER
|   CURRENT_TIME
|   CURRENT_TIMESTAMP
|   CIPHER
|   SAN
|   SSL
|   SUBJECT
|   DATABASE
|   DATABASES
|   DEFAULT
|   DELETE
|   DESC
|   DESCRIBE
|   DISTINCT
|   DISTINCTROW
|   DIV
|   DROP
|   ELSE
|   END
|   ESCAPE
|   EXISTS
|   EXPLAIN
|   FALSE
|   FIRST
|   FOR
|   FORCE
|   FROM
|   GROUP
|   HAVING
|   HOUR
|   IDENTIFIED
|   IF
|   IGNORE
|   IN
|   INFILE
|   INDEX
|   INNER
|   INSERT
|   INTERVAL
|   INTO
|   IS
|   ISSUER
|   JOIN
|   KEY
|   LAST
|   LEFT
|   LIKE
|	ILIKE
|   LIMIT
|   LOCALTIME
|   LOCALTIMESTAMP
|   LOCK
|   LOAD
|   IMPORT
|   MATCH
|   MAXVALUE
|   MOD
|   MICROSECOND
|   MINUTE
|   NATURAL
|   NOT
|   NONE
|   NULL
|   NULLS
|   ON
|   OR
|   ORDER
|   OUTER
|   REGEXP
|   RENAME
|   REPLACE
|   RIGHT
|   REQUIRE
|   REPEAT
|   ROW_COUNT
|    REFERENCES
|   RECURSIVE
|   REVERSE
|   SCHEMA
|   SCHEMAS
|   SELECT
|   SECOND
|   SEPARATOR
|   SET
|   SHOW
|   STRAIGHT_JOIN
|   TABLE
|   THEN
|   TO
|   TRUE
|   TRUNCATE
|   UNION
|   UNIQUE
|   UPDATE
|   USE
|   USING
|   UTC_DATE
|   UTC_TIME
|   UTC_TIMESTAMP
|   VALUES
|   WHEN
|   WHERE
|   WEEK
|   WITH
|   TERMINATED
|   OPTIONALLY
|   ENCLOSED
|   ESCAPED
|   STARTING
|   LINES
|   ROWS
|   INT1
|   INT2
|   INT3
|   INT4
|   INT8
|   CHECK
|    CONSTRAINT
|   PRIMARY
|   FULLTEXT
|   FOREIGN
|    ROW
|   OUTFILE
|    SQL_SMALL_RESULT
|    SQL_BIG_RESULT
|    LEADING
|    TRAILING
|   CHARACTER
|    LOW_PRIORITY
|    HIGH_PRIORITY
|    DELAYED
|   PARTITION
|    QUICK
|   EXCEPT
|   ADMIN_NAME
|   RANDOM
|   SUSPEND
|   REUSE
|   CURRENT
|   OPTIONAL
|   FAILED_LOGIN_ATTEMPTS
|   PASSWORD_LOCK_TIME
|   UNBOUNDED
|   SECONDARY
|   DECLARE
|   MODUMP
|   OVER
|   PRECEDING
|   FOLLOWING
|   GROUPS
|   LOCKS
|   TABLE_NUMBER
|   COLUMN_NUMBER
|   TABLE_VALUES
|   RETURNS
|   MYSQL_COMPATBILITY_MODE

non_reserved_keyword:
    ACCOUNT
|   ACCOUNTS
|   AGAINST
|   AVG_ROW_LENGTH
|   AUTO_RANDOM
|   ATTRIBUTE
|   ACTION
|   ALGORITHM
|   BEGIN
|   BIGINT
|   BIT
|   BLOB
|   BOOL
|   CHAIN
|   CHECKSUM
|   CLUSTER
|   COMPRESSION
|   COMMENT_KEYWORD
|   COMMIT
|   COMMITTED
|   CHARSET
|   COLUMNS
|   CONNECTION
|   CONSISTENT
|   COMPRESSED
|   COMPACT
|   COLUMN_FORMAT
|   CASCADE
|   DATA
|   DATETIME
|   DECIMAL
|   DYNAMIC
|   DISK
|   DO
|   DOUBLE
|   DIRECTORY
|   DUPLICATE
|   DELAY_KEY_WRITE
|   ENUM
|   ENCRYPTION
|   ENGINE
|   EXPANSION
|   EXTENDED
|   EXPIRE
|   ERRORS
|   ENFORCED
|   FORMAT
|   FLOAT_TYPE
|   FULL
|   FIXED
|   FIELDS
|   GEOMETRY
|   GEOMETRYCOLLECTION
|   GLOBAL
|   GRANT
|   INT
|   INTEGER
|   INDEXES
|   ISOLATION
|   JSON
|   KEY_BLOCK_SIZE
|   KEYS
|   LANGUAGE
|   LESS
|   LEVEL
|   LINESTRING
|   LONGBLOB
|   LONGTEXT
|   LOCAL
|   LINEAR
|   LIST
|   MEDIUMBLOB
|   MEDIUMINT
|   MEDIUMTEXT
|   MEMORY
|   MODE
|   MULTILINESTRING
|   MULTIPOINT
|   MULTIPOLYGON
|   MAX_QUERIES_PER_HOUR
|   MAX_UPDATES_PER_HOUR
|   MAX_CONNECTIONS_PER_HOUR
|   MAX_USER_CONNECTIONS
|   MAX_ROWS
|   MIN_ROWS
|   MONTH
|   NAMES
|   NCHAR
|   NUMERIC
|   NEVER
|   NO
|   OFFSET
|   ONLY
|   OPTIMIZE
|   OPEN
|   OPTION
|   PACK_KEYS
|   PARTIAL
|   PARTITIONS
|   POINT
|   POLYGON
|   PROCEDURE
|   PROXY
|   QUERY
|   PROFILES
|   ROLE
|   RANGE
|   READ
|   REAL
|   REORGANIZE
|   REDUNDANT
|   REPAIR
|   REPEATABLE
|   RELEASE
|   REVOKE
|   REPLICATION
|   ROW_FORMAT
|   ROLLBACK
|   RESTRICT
|   SESSION
|   SERIALIZABLE
|   SHARE
|   SIGNED
|   SMALLINT
|   SNAPSHOT
|   SPATIAL
|   START
|   STATUS
|   STORAGE
|	STREAM
|   STATS_AUTO_RECALC
|   STATS_PERSISTENT
|   STATS_SAMPLE_PAGES
|   SUBPARTITIONS
|   SUBPARTITION
|   SIMPLE
|   TEXT
|   THAN
|   TINYBLOB
|   TIME %prec LOWER_THAN_STRING
|   TINYINT
|   TINYTEXT
|   TRANSACTION
|   TRIGGER
|   UNCOMMITTED
|   UNSIGNED
|   UNUSED
|   UNLOCK
|   USER
|   VARBINARY
|   VARCHAR
|   VARIABLES
|   VIEW
|   WRITE
|   WARNINGS
|   WORK
|   X509
|   ZEROFILL
|   YEAR
|   TYPE
|   HEADER
|   MAX_FILE_SIZE
|   FORCE_QUOTE
|   QUARTER
|   UNKNOWN
|   ANY
|   SOME
|   TIMESTAMP %prec LOWER_THAN_STRING
|   DATE %prec LOWER_THAN_STRING
|   TABLES
|   EXTERNAL
|   URL
|   PASSWORD %prec LOWER_THAN_EQ
|   HASH
|   ENGINES
|   TRIGGERS
|   HISTORY
|   LOW_CARDINALITY
|   S3OPTION
|   EXTENSION
|   NODE
|   UUID
|   PARALLEL

func_not_keyword:
    DATE_ADD
|    DATE_SUB
|   NOW
|    ADDDATE
|   CURDATE
|   POSITION
|   SESSION_USER
|   SUBDATE
|   SYSTEM_USER
|   TRANSLATE

not_keyword:
    ADDDATE
|   BIT_AND
|   BIT_OR
|   BIT_XOR
|   CAST
|   COUNT
|   APPROX_COUNT_DISTINCT
|   APPROX_PERCENTILE
|   CURDATE
|   CURTIME
|   DATE_ADD
|   DATE_SUB
|   EXTRACT
|   GROUP_CONCAT
|   MAX
|   MID
|   MIN
|   NOW
|   POSITION
|   SESSION_USER
|   STD
|   STDDEV
|   STDDEV_POP
|   STDDEV_SAMP
|   SUBDATE
|   SUBSTR
|   SUBSTRING
|   SUM
|   SYSDATE
|   SYSTEM_USER
|   TRANSLATE
|   TRIM
|   VARIANCE
|   VAR_POP
|   VAR_SAMP
|   AVG
|	TIMESTAMPDIFF

//mo_keywords:
//    PROPERTIES
//  BSI
//  ZONEMAP

%%