/* Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ /* sql_yacc.yy */ /** @defgroup Parser Parser @{ */ %{ /* Note: YYTHD is passed as an argument to yyparse(), and subsequently to yylex(). */ #define YYLIP (& YYTHD->m_parser_state->m_lip) #define YYPS (& YYTHD->m_parser_state->m_yacc) #define YYCSCL (YYLIP->query_charset) #define YYINITDEPTH 100 #define YYMAXDEPTH 3200 /* Because of 64K stack */ #define Lex (YYTHD->lex) #define Select Lex->current_select() #include "sql_parse.h" /* comp_*_creator */ #include "sql_table.h" /* primary_key_name */ #include "partition_info.h" /* partition_info */ #include "sql_partition.h" /* mem_alloc_error */ #include "auth_common.h" /* *_ACL */ #include "password.h" /* my_make_scrambled_password_323, my_make_scrambled_password */ #include "sql_class.h" /* Key_part_spec, enum_filetype */ #include "rpl_slave.h" #include "rpl_msr.h" /* multisource replication */ #include "rpl_filter.h" #include "log_event.h" #include "lex_symbol.h" #include "item_create.h" #include "sp_head.h" #include "sp_instr.h" #include "sp_pcontext.h" #include "sp_rcontext.h" #include "sp.h" #include "sql_alter.h" // Sql_cmd_alter_table* #include "sql_truncate.h" // Sql_cmd_truncate_table #include "sql_admin.h" // Sql_cmd_analyze/Check..._table #include "sql_partition_admin.h" // Sql_cmd_alter_table_*_part. #include "sql_handler.h" // Sql_cmd_handler_* #include "sql_signal.h" #include "sql_get_diagnostics.h" // Sql_cmd_get_diagnostics #include "sql_servers.h" #include "event_parse_data.h" #include #include #include "keycaches.h" #include "set_var.h" #include "opt_explain_traditional.h" #include "opt_explain_json.h" #include "rpl_slave.h" // Sql_cmd_change_repl_filter #include "sql_show_status.h" // build_show_session_status, ... #include "parse_location.h" #include "parse_tree_helpers.h" #include "lex_token.h" #include "item_cmpfunc.h" #include "item_geofunc.h" #include "item_json_func.h" #include "sql_plugin.h" // plugin_is_ready #include "parse_tree_hints.h" /* this is to get the bison compilation windows warnings out */ #ifdef _MSC_VER /* warning C4065: switch statement contains 'default' but no 'case' labels */ #pragma warning (disable : 4065) #endif using std::min; using std::max; int yylex(void *yylval, void *yythd); #define yyoverflow(A,B,C,D,E,F,G,H) \ { \ ulong val= *(H); \ if (my_yyoverflow((B), (D), (F), &val)) \ { \ yyerror(NULL, YYTHD, (char*) (A)); \ return 2; \ } \ else \ { \ *(H)= (YYSIZE_T)val; \ } \ } #define MYSQL_YYABORT \ do \ { \ LEX::cleanup_lex_after_parse_error(YYTHD);\ YYABORT; \ } while (0) #define MYSQL_YYABORT_UNLESS(A) \ if (!(A)) \ { \ my_syntax_error(ER(ER_SYNTAX_ERROR));\ MYSQL_YYABORT; \ } #define NEW_PTN new(YYTHD->mem_root) /** Parse_tree_node::contextualize_() function call wrapper */ #define TMP_CONTEXTUALIZE(x) \ do \ { \ Parse_context pc(YYTHD, Select);\ if ((x)->contextualize_(&pc)) \ MYSQL_YYABORT; \ } while(0) /** Parse_tree_node::contextualize() function call wrapper */ #define CONTEXTUALIZE(x) \ do \ { \ Parse_context pc(YYTHD, Select); \ if (YYTHD->is_error() || (x)->contextualize(&pc)) \ MYSQL_YYABORT; \ } while(0) /** Item::itemize() function call wrapper */ #define ITEMIZE(x, y) \ do \ { \ Parse_context pc(YYTHD, Select); \ if (YYTHD->is_error() || (x)->itemize(&pc, (y))) \ MYSQL_YYABORT; \ } while(0) /** PT_statement::make_cmd() wrapper to raise postponed error message on OOM @note x may be NULL because of OOM error. */ #define MAKE_CMD(x) \ do \ { \ if (YYTHD->is_error()) \ MYSQL_YYABORT; \ Lex->m_sql_cmd= (x)->make_cmd(YYTHD); \ } while(0) #ifndef DBUG_OFF #define YYDEBUG 1 #else #define YYDEBUG 0 #endif /** @brief Bison callback to report a syntax/OOM error This function is invoked by the bison-generated parser when a syntax error, a parse error or an out-of-memory condition occurs. This function is not invoked when the parser is requested to abort by semantic action code by means of YYABORT or YYACCEPT macros. This is why these macros should not be used (use MYSQL_YYABORT/MYSQL_YYACCEPT instead). The parser will abort immediately after invoking this callback. This function is not for use in semantic actions and is internal to the parser, as it performs some pre-return cleanup. In semantic actions, please use my_syntax_error or my_error to push an error into the error stack and MYSQL_YYABORT to abort from the parser. */ void MYSQLerror(YYLTYPE *, THD *thd, const char *s) { /* Restore the original LEX if it was replaced when parsing a stored procedure. We must ensure that a parsing error does not leave any side effects in the THD. */ LEX::cleanup_lex_after_parse_error(thd); /* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */ if (strcmp(s,"parse error") == 0 || strcmp(s,"syntax error") == 0) s= ER(ER_SYNTAX_ERROR); my_syntax_error(s); } #ifndef DBUG_OFF void turn_parser_debug_on() { /* MYSQLdebug is in sql/sql_yacc.cc, in bison generated code. Turning this option on is **VERY** verbose, and should be used when investigating a syntax error problem only. The syntax to run with bison traces is as follows : - Starting a server manually : mysqld --debug="d,parser_debug" ... - Running a test : mysql-test-run.pl --mysqld="--debug=d,parser_debug" ... The result will be in the process stderr (var/log/master.err) */ extern int yydebug; yydebug= 1; } #endif static bool is_native_function(THD *thd, const LEX_STRING *name) { if (find_native_function_builder(thd, *name)) return true; if (is_lex_native_function(name)) return true; return false; } /** Helper action for a case statement (entering the CASE). This helper is used for both 'simple' and 'searched' cases. This helper, with the other case_stmt_action_..., is executed when the following SQL code is parsed: 
CREATE PROCEDURE proc_19194_simple(i int)
BEGIN
  DECLARE str CHAR(10);

  CASE i
    WHEN 1 THEN SET str="1";
    WHEN 2 THEN SET str="2";
    WHEN 3 THEN SET str="3";
    ELSE SET str="unknown";
  END CASE;

  SELECT str;
END
The actions are used to generate the following code: 
SHOW PROCEDURE CODE proc_19194_simple;
Pos     Instruction
0       set str@1 NULL
1       set_case_expr (12) 0 i@0
2       jump_if_not 5(12) (case_expr@0 = 1)
3       set str@1 _latin1'1'
4       jump 12
5       jump_if_not 8(12) (case_expr@0 = 2)
6       set str@1 _latin1'2'
7       jump 12
8       jump_if_not 11(12) (case_expr@0 = 3)
9       set str@1 _latin1'3'
10      jump 12
11      set str@1 _latin1'unknown'
12      stmt 0 "SELECT str"
@param thd thread handler */ void case_stmt_action_case(THD *thd) { LEX *lex= thd->lex; sp_head *sp= lex->sphead; sp_pcontext *pctx= lex->get_sp_current_parsing_ctx(); sp->m_parser_data.new_cont_backpatch(); /* BACKPATCH: Creating target label for the jump to "case_stmt_action_end_case" (Instruction 12 in the example) */ pctx->push_label(thd, EMPTY_STR, sp->instructions()); } /** Helper action for a case then statements. This helper is used for both 'simple' and 'searched' cases. @param lex the parser lex context */ bool case_stmt_action_then(THD *thd, LEX *lex) { sp_head *sp= lex->sphead; sp_pcontext *pctx= lex->get_sp_current_parsing_ctx(); sp_instr_jump *i = new (thd->mem_root) sp_instr_jump(sp->instructions(), pctx); if (!i || sp->add_instr(thd, i)) return true; /* BACKPATCH: Resolving forward jump from "case_stmt_action_when" to "case_stmt_action_then" (jump_if_not from instruction 2 to 5, 5 to 8 ... in the example) */ sp->m_parser_data.do_backpatch(pctx->pop_label(), sp->instructions()); /* BACKPATCH: Registering forward jump from "case_stmt_action_then" to "case_stmt_action_end_case" (jump from instruction 4 to 12, 7 to 12 ... in the example) */ return sp->m_parser_data.add_backpatch_entry(i, pctx->last_label()); } /** Helper action for an end case. This helper is used for both 'simple' and 'searched' cases. @param lex the parser lex context @param simple true for simple cases, false for searched cases */ void case_stmt_action_end_case(LEX *lex, bool simple) { sp_head *sp= lex->sphead; sp_pcontext *pctx= lex->get_sp_current_parsing_ctx(); /* BACKPATCH: Resolving forward jump from "case_stmt_action_then" to "case_stmt_action_end_case" (jump from instruction 4 to 12, 7 to 12 ... in the example) */ sp->m_parser_data.do_backpatch(pctx->pop_label(), sp->instructions()); if (simple) pctx->pop_case_expr_id(); sp->m_parser_data.do_cont_backpatch(sp->instructions()); } static bool add_create_index_prepare (LEX *lex, Table_ident *table) { lex->sql_command= SQLCOM_CREATE_INDEX; if (!lex->current_select()->add_table_to_list(lex->thd, table, NULL, TL_OPTION_UPDATING, TL_READ_NO_INSERT, MDL_SHARED_UPGRADABLE)) return TRUE; lex->alter_info.reset(); lex->alter_info.flags= Alter_info::ALTER_ADD_INDEX; lex->col_list.empty(); lex->change= NullS; return FALSE; } static bool add_create_index (LEX *lex, keytype type, const LEX_STRING &name, KEY_CREATE_INFO *info= NULL, bool generated= 0) { Key *key; key= new Key(type, name, info ? info : &lex->key_create_info, generated, lex->col_list); if (key == NULL) return TRUE; lex->alter_info.key_list.push_back(key); lex->col_list.empty(); return FALSE; } /** Compare a LEX_USER against the current user as defined by the exact user and host used during authentication. @param user A pointer to a user which needs to be matched against the current. @see SET PASSWORD rules @retval true The specified user is the authorized user @retval false The user doesn't match */ bool match_authorized_user(Security_context *ctx, LEX_USER *user) { if(user->user.str && my_strcasecmp(system_charset_info, ctx->priv_user().str, user->user.str) == 0) { /* users match; let's compare hosts. 1. first compare with the host we actually authorized, 2. then see if we match the host mask of the priv_host */ if (user->host.str && my_strcasecmp(system_charset_info, user->host.str, ctx->priv_host().str) == 0) { /* specified user exactly match the authorized user */ return true; } } return false; } static void init_index_hints(List *hints, index_hint_type type, index_clause_map clause) { List_iterator it(*hints); Index_hint *hint; while ((hint= it++)) { hint->type= type; hint->clause= clause; } } bool my_yyoverflow(short **a, YYSTYPE **b, YYLTYPE **c, ulong *yystacksize); #include "parse_tree_nodes.h" #include "parse_tree_items.h" %} %yacc %parse-param { class THD *YYTHD } %lex-param { class THD *YYTHD } %pure-parser /* We have threads */ /* Currently there are 159 shift/reduce conflicts. We should not introduce new conflicts any more. */ %expect 155 /* Comments for TOKENS. For each token, please include in the same line a comment that contains the following tags: SQL-2015-R : Reserved keyword as per SQL-2015 draft SQL-2003-R : Reserved keyword as per SQL-2003 SQL-2003-N : Non Reserved keyword as per SQL-2003 SQL-1999-R : Reserved keyword as per SQL-1999 SQL-1999-N : Non Reserved keyword as per SQL-1999 MYSQL : MySQL extention (unspecified) MYSQL-FUNC : MySQL extention, function INTERNAL : Not a real token, lex optimization OPERATOR : SQL operator FUTURE-USE : Reserved for futur use This makes the code grep-able, and helps maintenance. */ %token ABORT_SYM /* INTERNAL (used in lex) */ %token ACCESSIBLE_SYM %token ACCOUNT_SYM %token ACTION /* SQL-2003-N */ %token ADD /* SQL-2003-R */ %token ADDDATE_SYM /* MYSQL-FUNC */ %token AFTER_SYM /* SQL-2003-N */ %token AGAINST %token AGGREGATE_SYM %token ALGORITHM_SYM %token ALL /* SQL-2003-R */ %token ALTER /* SQL-2003-R */ %token ALWAYS_SYM %token ANALYSE_SYM %token ANALYZE_SYM %token AND_AND_SYM /* OPERATOR */ %token AND_SYM /* SQL-2003-R */ %token ANY_SYM /* SQL-2003-R */ %token AS /* SQL-2003-R */ %token ASC /* SQL-2003-N */ %token ASCII_SYM /* MYSQL-FUNC */ %token ASENSITIVE_SYM /* FUTURE-USE */ %token AT_SYM /* SQL-2003-R */ %token AUTOEXTEND_SIZE_SYM %token AUTO_INC %token AVG_ROW_LENGTH %token AVG_SYM /* SQL-2003-N */ %token BACKUP_SYM %token BEFORE_SYM /* SQL-2003-N */ %token BEGIN_SYM /* SQL-2003-R */ %token BETWEEN_SYM /* SQL-2003-R */ %token BIGINT /* SQL-2003-R */ %token BINARY /* SQL-2003-R */ %token BINLOG_SYM %token BIN_NUM %token BIT_AND /* MYSQL-FUNC */ %token BIT_OR /* MYSQL-FUNC */ %token BIT_SYM /* MYSQL-FUNC */ %token BIT_XOR /* MYSQL-FUNC */ %token BLOB_SYM /* SQL-2003-R */ %token BLOCK_SYM %token BOOLEAN_SYM /* SQL-2003-R */ %token BOOL_SYM %token BOTH /* SQL-2003-R */ %token BTREE_SYM %token BY /* SQL-2003-R */ %token BYTE_SYM %token CACHE_SYM %token CALL_SYM /* SQL-2003-R */ %token CASCADE /* SQL-2003-N */ %token CASCADED /* SQL-2003-R */ %token CASE_SYM /* SQL-2003-R */ %token CAST_SYM /* SQL-2003-R */ %token CATALOG_NAME_SYM /* SQL-2003-N */ %token CHAIN_SYM /* SQL-2003-N */ %token CHANGE %token CHANGED %token CHANNEL_SYM %token CHARSET %token CHAR_SYM /* SQL-2003-R */ %token CHECKSUM_SYM %token CHECK_SYM /* SQL-2003-R */ %token CIPHER_SYM %token CLASS_ORIGIN_SYM /* SQL-2003-N */ %token CLIENT_SYM %token CLOSE_SYM /* SQL-2003-R */ %token COALESCE /* SQL-2003-N */ %token CODE_SYM %token COLLATE_SYM /* SQL-2003-R */ %token COLLATION_SYM /* SQL-2003-N */ %token COLUMNS %token COLUMN_SYM /* SQL-2003-R */ %token COLUMN_FORMAT_SYM %token COLUMN_NAME_SYM /* SQL-2003-N */ %token COMMENT_SYM %token COMMITTED_SYM /* SQL-2003-N */ %token COMMIT_SYM /* SQL-2003-R */ %token COMPACT_SYM %token COMPLETION_SYM %token COMPRESSED_SYM %token COMPRESSION_SYM %token ENCRYPTION_SYM %token CONCURRENT %token CONDITION_SYM /* SQL-2003-R, SQL-2008-R */ %token CONNECTION_SYM %token CONSISTENT_SYM %token CONSTRAINT /* SQL-2003-R */ %token CONSTRAINT_CATALOG_SYM /* SQL-2003-N */ %token CONSTRAINT_NAME_SYM /* SQL-2003-N */ %token CONSTRAINT_SCHEMA_SYM /* SQL-2003-N */ %token CONTAINS_SYM /* SQL-2003-N */ %token CONTEXT_SYM %token CONTINUE_SYM /* SQL-2003-R */ %token CONVERT_SYM /* SQL-2003-N */ %token COUNT_SYM /* SQL-2003-N */ %token CPU_SYM %token CREATE /* SQL-2003-R */ %token CROSS /* SQL-2003-R */ %token CUBE_SYM /* SQL-2003-R */ %token CURDATE /* MYSQL-FUNC */ %token CURRENT_SYM /* SQL-2003-R */ %token CURRENT_USER /* SQL-2003-R */ %token CURSOR_SYM /* SQL-2003-R */ %token CURSOR_NAME_SYM /* SQL-2003-N */ %token CURTIME /* MYSQL-FUNC */ %token DATABASE %token DATABASES %token DATAFILE_SYM %token DATA_SYM /* SQL-2003-N */ %token DATETIME %token DATE_ADD_INTERVAL /* MYSQL-FUNC */ %token DATE_SUB_INTERVAL /* MYSQL-FUNC */ %token DATE_SYM /* SQL-2003-R */ %token DAY_HOUR_SYM %token DAY_MICROSECOND_SYM %token DAY_MINUTE_SYM %token DAY_SECOND_SYM %token DAY_SYM /* SQL-2003-R */ %token DEALLOCATE_SYM /* SQL-2003-R */ %token DECIMAL_NUM %token DECIMAL_SYM /* SQL-2003-R */ %token DECLARE_SYM /* SQL-2003-R */ %token DEFAULT /* SQL-2003-R */ %token DEFAULT_AUTH_SYM /* INTERNAL */ %token DEFINER_SYM %token DELAYED_SYM %token DELAY_KEY_WRITE_SYM %token DELETE_SYM /* SQL-2003-R */ %token DESC /* SQL-2003-N */ %token DESCRIBE /* SQL-2003-R */ %token DES_KEY_FILE %token DETERMINISTIC_SYM /* SQL-2003-R */ %token DIAGNOSTICS_SYM /* SQL-2003-N */ %token DIRECTORY_SYM %token DISABLE_SYM %token DISCARD %token DISK_SYM %token DISTINCT /* SQL-2003-R */ %token DIV_SYM %token DOUBLE_SYM /* SQL-2003-R */ %token DO_SYM %token DROP /* SQL-2003-R */ %token DUAL_SYM %token DUMPFILE %token DUPLICATE_SYM %token DYNAMIC_SYM /* SQL-2003-R */ %token EACH_SYM /* SQL-2003-R */ %token ELSE /* SQL-2003-R */ %token ELSEIF_SYM %token ENABLE_SYM %token ENCLOSED %token END /* SQL-2003-R */ %token ENDS_SYM %token END_OF_INPUT /* INTERNAL */ %token ENGINES_SYM %token ENGINE_SYM %token ENUM %token EQ /* OPERATOR */ %token EQUAL_SYM /* OPERATOR */ %token ERROR_SYM %token ERRORS %token ESCAPED %token ESCAPE_SYM /* SQL-2003-R */ %token EVENTS_SYM %token EVENT_SYM %token EVERY_SYM /* SQL-2003-N */ %token EXCHANGE_SYM %token EXECUTE_SYM /* SQL-2003-R */ %token EXISTS /* SQL-2003-R */ %token EXIT_SYM %token EXPANSION_SYM %token EXPIRE_SYM %token EXPORT_SYM %token EXTENDED_SYM %token EXTENT_SIZE_SYM %token EXTRACT_SYM /* SQL-2003-N */ %token FALSE_SYM /* SQL-2003-R */ %token FAST_SYM %token FAULTS_SYM %token FETCH_SYM /* SQL-2003-R */ %token FILE_SYM %token FILE_BLOCK_SIZE_SYM %token FILTER_SYM %token FIRST_SYM /* SQL-2003-N */ %token FIXED_SYM %token FLOAT_NUM %token FLOAT_SYM /* SQL-2003-R */ %token FLUSH_SYM %token FOLLOWS_SYM /* MYSQL */ %token FORCE_SYM %token FOREIGN /* SQL-2003-R */ %token FOR_SYM /* SQL-2003-R */ %token FORMAT_SYM %token FOUND_SYM /* SQL-2003-R */ %token FROM %token FULL /* SQL-2003-R */ %token FULLTEXT_SYM %token FUNCTION_SYM /* SQL-2003-R */ %token GE %token GENERAL %token GENERATED %token GROUP_REPLICATION %token GEOMETRYCOLLECTION %token GEOMETRY_SYM %token GET_FORMAT /* MYSQL-FUNC */ %token GET_SYM /* SQL-2003-R */ %token GLOBAL_SYM /* SQL-2003-R */ %token GRANT /* SQL-2003-R */ %token GRANTS %token GROUP_SYM /* SQL-2003-R */ %token GROUP_CONCAT_SYM %token GT_SYM /* OPERATOR */ %token HANDLER_SYM %token HASH_SYM %token HAVING /* SQL-2003-R */ %token HELP_SYM %token HEX_NUM %token HIGH_PRIORITY %token HOST_SYM %token HOSTS_SYM %token HOUR_MICROSECOND_SYM %token HOUR_MINUTE_SYM %token HOUR_SECOND_SYM %token HOUR_SYM /* SQL-2003-R */ %token IDENT %token IDENTIFIED_SYM %token IDENT_QUOTED %token IF %token IGNORE_SYM %token IGNORE_SERVER_IDS_SYM %token IMPORT %token INDEXES %token INDEX_SYM %token INFILE %token INITIAL_SIZE_SYM %token INNER_SYM /* SQL-2003-R */ %token INOUT_SYM /* SQL-2003-R */ %token INSENSITIVE_SYM /* SQL-2003-R */ %token INSERT /* SQL-2003-R */ %token INSERT_METHOD %token INSTANCE_SYM %token INSTALL_SYM %token INTERVAL_SYM /* SQL-2003-R */ %token INTO /* SQL-2003-R */ %token INT_SYM /* SQL-2003-R */ %token INVOKER_SYM %token IN_SYM /* SQL-2003-R */ %token IO_AFTER_GTIDS /* MYSQL, FUTURE-USE */ %token IO_BEFORE_GTIDS /* MYSQL, FUTURE-USE */ %token IO_SYM %token IPC_SYM %token IS /* SQL-2003-R */ %token ISOLATION /* SQL-2003-R */ %token ISSUER_SYM %token ITERATE_SYM %token JOIN_SYM /* SQL-2003-R */ %token JSON_SEPARATOR_SYM /* MYSQL */ %token JSON_UNQUOTED_SEPARATOR_SYM /* MYSQL */ %token JSON_SYM /* MYSQL */ %token KEYS %token KEY_BLOCK_SIZE %token KEY_SYM /* SQL-2003-N */ %token KILL_SYM %token LANGUAGE_SYM /* SQL-2003-R */ %token LAST_SYM /* SQL-2003-N */ %token LE /* OPERATOR */ %token LEADING /* SQL-2003-R */ %token LEAVES %token LEAVE_SYM %token LEFT /* SQL-2003-R */ %token LESS_SYM %token LEVEL_SYM %token LEX_HOSTNAME %token LIKE /* SQL-2003-R */ %token LIMIT %token LINEAR_SYM %token LINES %token LINESTRING %token LIST_SYM %token LOAD %token LOCAL_SYM /* SQL-2003-R */ %token LOCATOR_SYM /* SQL-2003-N */ %token LOCKS_SYM %token LOCK_SYM %token LOGFILE_SYM %token LOGS_SYM %token LONGBLOB %token LONGTEXT %token LONG_NUM %token LONG_SYM %token LOOP_SYM %token LOW_PRIORITY %token LT /* OPERATOR */ %token MASTER_AUTO_POSITION_SYM %token MASTER_BIND_SYM %token MASTER_CONNECT_RETRY_SYM %token MASTER_DELAY_SYM %token MASTER_HOST_SYM %token MASTER_LOG_FILE_SYM %token MASTER_LOG_POS_SYM %token MASTER_PASSWORD_SYM %token MASTER_PORT_SYM %token MASTER_RETRY_COUNT_SYM %token MASTER_SERVER_ID_SYM %token MASTER_SSL_CAPATH_SYM %token MASTER_TLS_VERSION_SYM %token MASTER_SSL_CA_SYM %token MASTER_SSL_CERT_SYM %token MASTER_SSL_CIPHER_SYM %token MASTER_SSL_CRL_SYM %token MASTER_SSL_CRLPATH_SYM %token MASTER_SSL_KEY_SYM %token MASTER_SSL_SYM %token MASTER_SSL_VERIFY_SERVER_CERT_SYM %token MASTER_SYM %token MASTER_USER_SYM %token MASTER_HEARTBEAT_PERIOD_SYM %token MATCH /* SQL-2003-R */ %token MAX_CONNECTIONS_PER_HOUR %token MAX_QUERIES_PER_HOUR %token MAX_ROWS %token MAX_SIZE_SYM %token MAX_SYM /* SQL-2003-N */ %token MAX_UPDATES_PER_HOUR %token MAX_USER_CONNECTIONS_SYM %token MAX_VALUE_SYM /* SQL-2003-N */ %token MEDIUMBLOB %token MEDIUMINT %token MEDIUMTEXT %token MEDIUM_SYM %token MEMORY_SYM %token MERGE_SYM /* SQL-2003-R */ %token MESSAGE_TEXT_SYM /* SQL-2003-N */ %token MICROSECOND_SYM /* MYSQL-FUNC */ %token MIGRATE_SYM %token MINUTE_MICROSECOND_SYM %token MINUTE_SECOND_SYM %token MINUTE_SYM /* SQL-2003-R */ %token MIN_ROWS %token MIN_SYM /* SQL-2003-N */ %token MODE_SYM %token MODIFIES_SYM /* SQL-2003-R */ %token MODIFY_SYM %token MOD_SYM /* SQL-2003-N */ %token MONTH_SYM /* SQL-2003-R */ %token MULTILINESTRING %token MULTIPOINT %token MULTIPOLYGON %token MUTEX_SYM %token MYSQL_ERRNO_SYM %token NAMES_SYM /* SQL-2003-N */ %token NAME_SYM /* SQL-2003-N */ %token NATIONAL_SYM /* SQL-2003-R */ %token NATURAL /* SQL-2003-R */ %token NCHAR_STRING %token NCHAR_SYM /* SQL-2003-R */ %token NDBCLUSTER_SYM %token NE /* OPERATOR */ %token NEG %token NEVER_SYM %token NEW_SYM /* SQL-2003-R */ %token NEXT_SYM /* SQL-2003-N */ %token NODEGROUP_SYM %token NONE_SYM /* SQL-2003-R */ %token NOT2_SYM %token NOT_SYM /* SQL-2003-R */ %token NOW_SYM %token NO_SYM /* SQL-2003-R */ %token NO_WAIT_SYM %token NO_WRITE_TO_BINLOG %token NULL_SYM /* SQL-2003-R */ %token NUM %token NUMBER_SYM /* SQL-2003-N */ %token NUMERIC_SYM /* SQL-2003-R */ %token NVARCHAR_SYM %token OFFSET_SYM %token ON /* SQL-2003-R */ %token ONE_SYM %token ONLY_SYM /* SQL-2003-R */ %token OPEN_SYM /* SQL-2003-R */ %token OPTIMIZE %token OPTIMIZER_COSTS_SYM %token OPTIONS_SYM %token OPTION /* SQL-2003-N */ %token OPTIONALLY %token OR2_SYM %token ORDER_SYM /* SQL-2003-R */ %token OR_OR_SYM /* OPERATOR */ %token OR_SYM /* SQL-2003-R */ %token OUTER %token OUTFILE %token OUT_SYM /* SQL-2003-R */ %token OWNER_SYM %token PACK_KEYS_SYM %token PAGE_SYM %token PARAM_MARKER %token PARSER_SYM %token PARSE_GCOL_EXPR_SYM %token PARTIAL /* SQL-2003-N */ %token PARTITION_SYM /* SQL-2003-R */ %token PARTITIONS_SYM %token PARTITIONING_SYM %token PASSWORD %token PHASE_SYM %token PLUGIN_DIR_SYM /* INTERNAL */ %token PLUGIN_SYM %token PLUGINS_SYM %token POINT_SYM %token POLYGON %token PORT_SYM %token POSITION_SYM /* SQL-2003-N */ %token PRECEDES_SYM /* MYSQL */ %token PRECISION /* SQL-2003-R */ %token PREPARE_SYM /* SQL-2003-R */ %token PRESERVE_SYM %token PREV_SYM %token PRIMARY_SYM /* SQL-2003-R */ %token PRIVILEGES /* SQL-2003-N */ %token PROCEDURE_SYM /* SQL-2003-R */ %token PROCESS %token PROCESSLIST_SYM %token PROFILE_SYM %token PROFILES_SYM %token PROXY_SYM %token PURGE %token QUARTER_SYM %token QUERY_SYM %token QUICK %token RANGE_SYM /* SQL-2003-R */ %token READS_SYM /* SQL-2003-R */ %token READ_ONLY_SYM %token READ_SYM /* SQL-2003-N */ %token READ_WRITE_SYM %token REAL /* SQL-2003-R */ %token REBUILD_SYM %token RECOVER_SYM %token REDOFILE_SYM %token REDO_BUFFER_SIZE_SYM %token REDUNDANT_SYM %token REFERENCES /* SQL-2003-R */ %token REGEXP %token RELAY %token RELAYLOG_SYM %token RELAY_LOG_FILE_SYM %token RELAY_LOG_POS_SYM %token RELAY_THREAD %token RELEASE_SYM /* SQL-2003-R */ %token RELOAD %token REMOVE_SYM %token RENAME %token REORGANIZE_SYM %token REPAIR %token REPEATABLE_SYM /* SQL-2003-N */ %token REPEAT_SYM /* MYSQL-FUNC */ %token REPLACE /* MYSQL-FUNC */ %token REPLICATION %token REPLICATE_DO_DB %token REPLICATE_IGNORE_DB %token REPLICATE_DO_TABLE %token REPLICATE_IGNORE_TABLE %token REPLICATE_WILD_DO_TABLE %token REPLICATE_WILD_IGNORE_TABLE %token REPLICATE_REWRITE_DB %token REQUIRE_SYM %token RESET_SYM %token RESIGNAL_SYM /* SQL-2003-R */ %token RESOURCES %token RESTORE_SYM %token RESTRICT %token RESUME_SYM %token RETURNED_SQLSTATE_SYM /* SQL-2003-N */ %token RETURNS_SYM /* SQL-2003-R */ %token RETURN_SYM /* SQL-2003-R */ %token REVERSE_SYM %token REVOKE /* SQL-2003-R */ %token RIGHT /* SQL-2003-R */ %token ROLLBACK_SYM /* SQL-2003-R */ %token ROLLUP_SYM /* SQL-2003-R */ %token ROTATE_SYM %token ROUTINE_SYM /* SQL-2003-N */ %token ROWS_SYM /* SQL-2003-R */ %token ROW_FORMAT_SYM %token ROW_SYM /* SQL-2003-R */ %token ROW_COUNT_SYM /* SQL-2003-N */ %token RTREE_SYM %token SAVEPOINT_SYM /* SQL-2003-R */ %token SCHEDULE_SYM %token SCHEMA_NAME_SYM /* SQL-2003-N */ %token SECOND_MICROSECOND_SYM %token SECOND_SYM /* SQL-2003-R */ %token SECURITY_SYM /* SQL-2003-N */ %token SELECT_SYM /* SQL-2003-R */ %token SENSITIVE_SYM /* FUTURE-USE */ %token SEPARATOR_SYM %token SERIALIZABLE_SYM /* SQL-2003-N */ %token SERIAL_SYM %token SESSION_SYM /* SQL-2003-N */ %token SERVER_SYM %token SERVER_OPTIONS %token SET /* SQL-2003-R */ %token SET_VAR %token SHARE_SYM %token SHIFT_LEFT /* OPERATOR */ %token SHIFT_RIGHT /* OPERATOR */ %token SHOW %token SHUTDOWN %token SIGNAL_SYM /* SQL-2003-R */ %token SIGNED_SYM %token SIMPLE_SYM /* SQL-2003-N */ %token SLAVE %token SLOW %token SMALLINT /* SQL-2003-R */ %token SNAPSHOT_SYM %token SOCKET_SYM %token SONAME_SYM %token SOUNDS_SYM %token SOURCE_SYM %token SPATIAL_SYM %token SPECIFIC_SYM /* SQL-2003-R */ %token SQLEXCEPTION_SYM /* SQL-2003-R */ %token SQLSTATE_SYM /* SQL-2003-R */ %token SQLWARNING_SYM /* SQL-2003-R */ %token SQL_AFTER_GTIDS /* MYSQL */ %token SQL_AFTER_MTS_GAPS /* MYSQL */ %token SQL_BEFORE_GTIDS /* MYSQL */ %token SQL_BIG_RESULT %token SQL_BUFFER_RESULT %token SQL_CACHE_SYM %token SQL_CALC_FOUND_ROWS %token SQL_NO_CACHE_SYM %token SQL_SMALL_RESULT %token SQL_SYM /* SQL-2003-R */ %token SQL_THREAD %token SSL_SYM %token STACKED_SYM /* SQL-2003-N */ %token STARTING %token STARTS_SYM %token START_SYM /* SQL-2003-R */ %token STATS_AUTO_RECALC_SYM %token STATS_PERSISTENT_SYM %token STATS_SAMPLE_PAGES_SYM %token STATUS_SYM %token STDDEV_SAMP_SYM /* SQL-2003-N */ %token STD_SYM %token STOP_SYM %token STORAGE_SYM %token STORED_SYM %token STRAIGHT_JOIN %token STRING_SYM %token SUBCLASS_ORIGIN_SYM /* SQL-2003-N */ %token SUBDATE_SYM %token SUBJECT_SYM %token SUBPARTITIONS_SYM %token SUBPARTITION_SYM %token SUBSTRING /* SQL-2003-N */ %token SUM_SYM /* SQL-2003-N */ %token SUPER_SYM %token SUSPEND_SYM %token SWAPS_SYM %token SWITCHES_SYM %token SYSDATE %token TABLES %token TABLESPACE_SYM %token TABLE_REF_PRIORITY %token TABLE_SYM /* SQL-2003-R */ %token TABLE_CHECKSUM_SYM %token TABLE_NAME_SYM /* SQL-2003-N */ %token TEMPORARY /* SQL-2003-N */ %token TEMPTABLE_SYM %token TERMINATED %token TEXT_STRING %token TEXT_SYM %token THAN_SYM %token THEN_SYM /* SQL-2003-R */ %token TIMESTAMP /* SQL-2003-R */ %token TIMESTAMP_ADD %token TIMESTAMP_DIFF %token TIME_SYM /* SQL-2003-R */ %token TINYBLOB %token TINYINT %token TINYTEXT %token TO_SYM /* SQL-2003-R */ %token TRAILING /* SQL-2003-R */ %token TRANSACTION_SYM %token TRIGGERS_SYM %token TRIGGER_SYM /* SQL-2003-R */ %token TRIM /* SQL-2003-N */ %token TRUE_SYM /* SQL-2003-R */ %token TRUNCATE_SYM %token TYPES_SYM %token TYPE_SYM /* SQL-2003-N */ %token UDF_RETURNS_SYM %token ULONGLONG_NUM %token UNCOMMITTED_SYM /* SQL-2003-N */ %token UNDEFINED_SYM %token UNDERSCORE_CHARSET %token UNDOFILE_SYM %token UNDO_BUFFER_SIZE_SYM %token UNDO_SYM /* FUTURE-USE */ %token UNICODE_SYM %token UNINSTALL_SYM %token UNION_SYM /* SQL-2003-R */ %token UNIQUE_SYM %token UNKNOWN_SYM /* SQL-2003-R */ %token UNLOCK_SYM %token UNSIGNED %token UNTIL_SYM %token UPDATE_SYM /* SQL-2003-R */ %token UPGRADE_SYM %token USAGE /* SQL-2003-N */ %token USER /* SQL-2003-R */ %token USE_FRM %token USE_SYM %token USING /* SQL-2003-R */ %token UTC_DATE_SYM %token UTC_TIMESTAMP_SYM %token UTC_TIME_SYM %token VALIDATION_SYM /* MYSQL */ %token VALUES /* SQL-2003-R */ %token VALUE_SYM /* SQL-2003-R */ %token VARBINARY %token VARCHAR /* SQL-2003-R */ %token VARIABLES %token VARIANCE_SYM %token VARYING /* SQL-2003-R */ %token VAR_SAMP_SYM %token VIEW_SYM /* SQL-2003-N */ %token VIRTUAL_SYM %token WAIT_SYM %token WARNINGS %token WEEK_SYM %token WEIGHT_STRING_SYM %token WHEN_SYM /* SQL-2003-R */ %token WHERE /* SQL-2003-R */ %token WHILE_SYM %token WITH /* SQL-2003-R */ %token WITH_CUBE_SYM /* INTERNAL */ %token WITH_ROLLUP_SYM /* INTERNAL */ %token WITHOUT_SYM /* SQL-2003-R */ %token WORK_SYM /* SQL-2003-N */ %token WRAPPER_SYM %token WRITE_SYM /* SQL-2003-N */ %token X509_SYM %token XA_SYM %token XID_SYM /* MYSQL */ %token XML_SYM %token XOR %token YEAR_MONTH_SYM %token YEAR_SYM /* SQL-2003-R */ %token ZEROFILL /* Tokens from MySQL 8.0 */ %token JSON_OBJECTAGG /* SQL-2015-R */ %token JSON_ARRAYAGG /* SQL-2015-R */ /* Resolve column attribute ambiguity -- force precedence of "UNIQUE KEY" against simple "UNIQUE" and "KEY" attributes: */ %right UNIQUE_SYM KEY_SYM %left JOIN_SYM INNER_SYM STRAIGHT_JOIN CROSS LEFT RIGHT /* A dummy token to force the priority of table_ref production in a join. */ %left TABLE_REF_PRIORITY %left SET_VAR %left OR_OR_SYM OR_SYM OR2_SYM %left XOR %left AND_SYM AND_AND_SYM %left BETWEEN_SYM CASE_SYM WHEN_SYM THEN_SYM ELSE %left EQ EQUAL_SYM GE GT_SYM LE LT NE IS LIKE REGEXP IN_SYM %left '|' %left '&' %left SHIFT_LEFT SHIFT_RIGHT %left '-' '+' %left '*' '/' '%' DIV_SYM MOD_SYM %left '^' %left NEG '~' %right NOT_SYM NOT2_SYM %right BINARY COLLATE_SYM %left INTERVAL_SYM %type IDENT IDENT_QUOTED TEXT_STRING DECIMAL_NUM FLOAT_NUM NUM LONG_NUM HEX_NUM LEX_HOSTNAME ULONGLONG_NUM field_ident select_alias ident ident_or_text IDENT_sys TEXT_STRING_sys TEXT_STRING_literal NCHAR_STRING opt_component key_cache_name sp_opt_label BIN_NUM label_ident TEXT_STRING_filesystem ident_or_empty opt_constraint constraint opt_ident TEXT_STRING_sys_nonewline filter_wild_db_table_string %type opt_table_alias %type table_ident table_ident_nodb references %type opt_db password %type text_string opt_gconcat_separator %type type type_with_opt_collate int_type real_type lock_option udf_type if_exists opt_local opt_table_options table_options table_option opt_if_not_exists opt_no_write_to_binlog opt_temporary all_or_any opt_distinct opt_ignore_leaves fulltext_options spatial_type union_option transaction_access_mode_types opt_natural_language_mode opt_query_expansion opt_ev_status opt_ev_on_completion ev_on_completion opt_ev_comment ev_alter_on_schedule_completion opt_ev_rename_to opt_ev_sql_stmt trg_action_time trg_event field_def ordering_direction opt_ordering_direction /* Bit field of MYSQL_START_TRANS_OPT_* flags. */ %type opt_start_transaction_option_list %type start_transaction_option_list %type start_transaction_option %type opt_chain opt_release %type delete_option %type ulong_num real_ulong_num merge_insert_types ws_nweights func_datetime_precision ws_level_flag_desc ws_level_flag_reverse ws_level_flags opt_ws_levels ws_level_list ws_level_list_item ws_level_number ws_level_range ws_level_list_or_range now %type ulonglong_num real_ulonglong_num size_number procedure_analyse_param %type replace_lock_option opt_low_priority insert_lock_option load_data_lock %type literal insert_ident temporal_literal simple_ident expr opt_expr opt_else sum_expr in_sum_expr variable variable_aux bool_pri predicate bit_expr table_wild simple_expr udf_expr expr_or_default set_expr_or_default geometry_function signed_literal now_or_signed_literal opt_escape sp_opt_default simple_ident_nospvar simple_ident_q field_or_var limit_option part_func_expr function_call_keyword function_call_nonkeyword function_call_generic function_call_conflict signal_allowed_expr simple_target_specification condition_number filter_db_ident filter_table_ident filter_string NUM_literal select_item opt_where_clause opt_having_clause opt_simple_limit %type when_list opt_filter_db_list filter_db_list opt_filter_table_list filter_table_list opt_filter_string_list filter_string_list opt_filter_db_pair_list filter_db_pair_list %type expr_list udf_expr_list opt_udf_expr_list opt_expr_list select_item_list ident_list ident_list_arg %type option_type opt_var_type opt_var_ident_type %type normal_key_type opt_unique constraint_key_type fulltext spatial %type btree_or_rtree %type using_list opt_use_partition use_partition %type key_part %type date_time_type; %type interval %type interval_time_stamp %type storage_engines known_storage_engines %type row_types %type isolation_types %type handler_rkey_mode %type handler_read_or_scan handler_scan_function handler_rkey_function %type cast_type %type keyword keyword_sp %type user grant_user user_func %type opt_collate opt_collate_explicit charset_name charset_name_or_default old_or_new_charset_name old_or_new_charset_name_or_default collation_name collation_name_or_default opt_load_data_charset UNDERSCORE_CHARSET ascii unicode %type comp_op %type create change drop truncate rename show describe load alter optimize keycache preload flush reset purge begin commit rollback savepoint release slave master_def master_defs master_file_def slave_until_opts repair analyze check start checksum filter_def filter_defs field_list field_list_item field_spec kill column_def key_def keycache_list keycache_list_or_parts assign_to_keycache assign_to_keycache_parts preload_list preload_list_or_parts preload_keys preload_keys_parts handler opt_column opt_restrict grant revoke lock unlock string_list field_options field_option field_opt_list table_lock_list table_lock ref_list opt_match_clause opt_on_update_delete use varchar nchar nvarchar opt_outer table_list table_name opt_place opt_attribute opt_attribute_list attribute column_list column_list_id opt_column_list grant_privileges grant_ident grant_list grant_option object_privilege object_privilege_list user_list rename_list clear_privileges flush_options flush_option opt_flush_lock flush_options_list equal optional_braces opt_mi_check_type opt_to mi_check_types normal_join table_to_table_list table_to_table opt_table_list opt_as opt_and charset help opt_extended_describe prepare prepare_src execute deallocate sp_suid sp_c_chistics sp_a_chistics sp_chistic sp_c_chistic xa opt_field_or_var_spec fields_or_vars opt_load_data_set_spec view_replace_or_algorithm view_replace view_algorithm view_or_trigger_or_sp_or_event definer_tail no_definer_tail view_suid view_tail view_list_opt view_list view_select view_check_option trigger_tail sp_tail sf_tail udf_tail event_tail install uninstall partition_entry binlog_base64_event init_key_options normal_key_options normal_key_opts all_key_opt spatial_key_options fulltext_key_options normal_key_opt fulltext_key_opt spatial_key_opt fulltext_key_opts spatial_key_opts key_using_alg part_column_list server_options_list server_option definer_opt no_definer definer get_diagnostics alter_user_command password_expire group_replication END_OF_INPUT %type call sp_proc_stmts sp_proc_stmts1 sp_proc_stmt %type sp_proc_stmt_statement sp_proc_stmt_return %type sp_proc_stmt_if %type sp_labeled_control sp_proc_stmt_unlabeled %type sp_labeled_block sp_unlabeled_block %type sp_proc_stmt_leave %type sp_proc_stmt_iterate %type sp_proc_stmt_open sp_proc_stmt_fetch sp_proc_stmt_close %type case_stmt_specification simple_case_stmt searched_case_stmt %type sp_decl_idents sp_opt_inout sp_handler_type sp_hcond_list %type sp_cond sp_hcond sqlstate signal_value opt_signal_value %type sp_decls sp_decl %type sp_name %type index_hint_type %type index_hint_clause %type data_or_xml %type signal_stmt resignal_stmt %type signal_condition_information_item_name %type which_area; %type diagnostics_information; %type statement_information_item; %type statement_information_item_name; %type statement_information; %type condition_information_item; %type condition_information_item_name; %type condition_information; %type signal_information_item_list; %type opt_set_signal_information; %type trigger_follows_precedes_clause; %type trigger_action_order; %type xid; %type opt_join_or_resume; %type opt_suspend; %type opt_one_phase; %type opt_convert_xid opt_ignore %type '-' '+' '*' '/' '%' '(' ')' ',' '!' '{' '}' '&' '|' AND_SYM OR_SYM OR_OR_SYM BETWEEN_SYM CASE_SYM THEN_SYM WHEN_SYM DIV_SYM MOD_SYM OR2_SYM AND_AND_SYM %type SHOW DESC DESCRIBE describe_command /* A bit field of SLAVE_IO, SLAVE_SQL flags. */ %type opt_slave_thread_option_list %type slave_thread_option_list %type slave_thread_option %type key_usage_element %type key_usage_list opt_key_usage_list index_hint_definition index_hints_list opt_index_hints_list opt_key_definition cache_key_list_or_empty cache_keys_spec %type subselect %type order_expr grouping_expr %type order_list group_list gorder_list opt_gorder_clause %type field_length opt_field_length type_datetime_precision %type opt_bin_mod %type precision opt_precision float_options %type opt_binary %type limit_options %type limit_clause opt_limit_clause %type query_spec_option query_spec_option_list opt_query_spec_options %type select_option select_option_list select_options empty_select_options %type join_table order_or_limit opt_union_order_or_limit option_value union_opt %type table_reference_list from_clause opt_from_clause %type select_part2_derived %type olap_opt %type opt_group_clause %type order_clause opt_order_clause %type opt_procedure_analyse_params %type opt_procedure_analyse_clause %type opt_select_lock_type %type union_order_or_limit %type table_expression %type select_derived_union table_factor table_ref esc_table_ref derived_table_list select_derived %type join_table_list %type select_paren_derived %type query_specification query_expression_body %type internal_variable_name %type option_value_following_option_type %type option_value_no_option_type %type option_value_list option_value_list_continued %type start_option_value_list %type transaction_access_mode opt_transaction_access_mode %type isolation_level opt_isolation_level %type transaction_characteristics %type start_option_value_list_following_option_type %type set %type union_list opt_union_clause %type line_term line_term_list opt_line_term %type field_term field_term_list opt_field_term %type into_destination into opt_into %type select_var_ident %type select_var_list %type select_options_and_item_list %type select_part2 %type select_paren %type select_init %type
in the SQL:2003 standard. */ /* Warning - may return NULL in case of incomplete SELECT */ table_ref: table_factor | join_table { $$= NEW_PTN PT_table_ref_join_table($1); } ; join_table_list: derived_table_list { $$= NEW_PTN PT_join_table_list(@$, $1); } ; /* The ODBC escape syntax for Outer Join is: '{' OJ join_table '}' The parser does not define OJ as a token, any ident is accepted instead in $2 (ident). Also, all productions from table_ref can be escaped, not only join_table. Both syntax extensions are safe and are ignored. */ esc_table_ref: table_ref | '{' ident table_ref '}' { $$= $3; } ; /* Equivalent to
in the SQL:2003 standard. */ /* Warning - may return NULL in case of incomplete SELECT */ derived_table_list: esc_table_ref | derived_table_list ',' esc_table_ref { $$= NEW_PTN PT_derived_table_list(@$, $1, $3); } ; /* Notice that JOIN is a left-associative operation, and it must be parsed as such, that is, the parser must process first the left join operand then the right one. Such order of processing ensures that the parser produces correct join trees which is essential for semantic analysis and subsequent optimization phases. */ join_table: /* INNER JOIN variants */ /* Use %prec to evaluate production 'table_ref' before 'normal_join' so that [INNER | CROSS] JOIN is properly nested as other left-associative joins. */ table_ref normal_join table_ref %prec TABLE_REF_PRIORITY { $$= NEW_PTN PT_join_table($1, @2, $3); } | table_ref STRAIGHT_JOIN table_factor { $$= NEW_PTN PT_join_table($1, @2, $3); } | table_ref normal_join table_ref ON expr { $$= NEW_PTN PT_join_table_on($1, @2, $3, $5); } | table_ref STRAIGHT_JOIN table_factor ON expr { $$= NEW_PTN PT_join_table_on($1, @2, $3, $5); } | table_ref normal_join table_ref USING '(' using_list ')' { $$= NEW_PTN PT_join_table_using($1, @2, $3, $6); } | table_ref NATURAL JOIN_SYM table_factor { $$= NEW_PTN PT_join_table($1, @2, $4); } /* LEFT JOIN variants */ | table_ref LEFT opt_outer JOIN_SYM table_ref ON expr { $$= NEW_PTN PT_join_table_on($1, @2, $5, $7); } | table_ref LEFT opt_outer JOIN_SYM table_factor USING '(' using_list ')' { $$= NEW_PTN PT_join_table_using($1, @2, $5, $8); } | table_ref NATURAL LEFT opt_outer JOIN_SYM table_factor { $$= NEW_PTN PT_join_table($1, @2, $6); } /* RIGHT JOIN variants */ | table_ref RIGHT opt_outer JOIN_SYM table_ref ON expr { $$= NEW_PTN PT_join_table_on($1, @2, $5, $7); } | table_ref RIGHT opt_outer JOIN_SYM table_factor USING '(' using_list ')' { $$= NEW_PTN PT_join_table_using($1, @2, $5, $8); } | table_ref NATURAL RIGHT opt_outer JOIN_SYM table_factor { $$= NEW_PTN PT_join_table($1, @2, $6); } ; normal_join: JOIN_SYM {} | INNER_SYM JOIN_SYM {} | CROSS JOIN_SYM {} ; /* table PARTITION (list of partitions), reusing using_list instead of creating a new rule for partition_list. */ opt_use_partition: /* empty */ { $$= NULL; } | use_partition ; use_partition: PARTITION_SYM '(' using_list ')' { $$= $3; } ; /* This is a flattening of the rules
and
in the SQL:2003 standard, since we don't have I.e.
::=
[ ] */ /* Warning - may return NULL in case of incomplete SELECT */ table_factor: table_ident opt_use_partition opt_table_alias opt_key_definition { $$= NEW_PTN PT_table_factor_table_ident($1, $2, $3, $4); } | SELECT_SYM select_options select_item_list table_expression { $$= NEW_PTN PT_table_factor_select_sym(@$, $1, $2, $3, $4); } /* Represents a flattening of the following rules from the SQL:2003 standard. This sub-rule corresponds to the sub-rule
::= ... | [ AS ] The following rules have been flattened into query_expression_body (since we have no ). ::=
::= ::= ::= [ ] For the time being we use the non-standard rule select_derived_union which is a compromise between the standard and our parser. Possibly this rule could be replaced by our query_expression_body. */ | '(' select_derived_union ')' opt_table_alias { $$= NEW_PTN PT_table_factor_parenthesis($2, $4, @4); } ; /* This rule accepts just about anything. The reason is that we have empty-producing rules in the beginning of rules, in this case subselect_start. This forces bison to take a decision which rules to reduce by long before it has seen any tokens. This approach ties us to a very limited class of parseable languages, and unfortunately SQL is not one of them. The chosen 'solution' was this rule, which produces just about anything, even complete bogus statements, for instance ( table UNION SELECT 1 ). Fortunately, we know that the semantic value returned by select_derived->value is NULL if it contained a derived table, and a pointer to the base table's TABLE_LIST if it was a base table. So in the rule regarding union's, we throw a parse error manually and pretend it was bison that did it. Also worth noting is that this rule concerns query expressions in the from clause only. Top level select statements and other types of subqueries have their own union rules. */ select_derived_union: select_derived opt_union_order_or_limit { $$= NEW_PTN PT_select_derived_union_select($1, $2, @2); } | select_derived_union UNION_SYM union_option query_specification { $$= NEW_PTN PT_select_derived_union_union($1, @2, $3, $4); } ; /* The equivalent of select_part2 for nested queries. */ select_part2_derived: { /* TODO: remove this semantic action (currently this removal adds shift/reduce conflict) */ } opt_query_spec_options select_item_list { $$= NEW_PTN PT_select_part2_derived($2, $3); } ; /* handle contents of parentheses in join expression */ select_derived: derived_table_list { $$= NEW_PTN PT_select_derived(@1, $1); } ; opt_outer: /* empty */ {} | OUTER {} ; index_hint_clause: /* empty */ { $$= old_mode ? INDEX_HINT_MASK_JOIN : INDEX_HINT_MASK_ALL; } | FOR_SYM JOIN_SYM { $$= INDEX_HINT_MASK_JOIN; } | FOR_SYM ORDER_SYM BY { $$= INDEX_HINT_MASK_ORDER; } | FOR_SYM GROUP_SYM BY { $$= INDEX_HINT_MASK_GROUP; } ; index_hint_type: FORCE_SYM { $$= INDEX_HINT_FORCE; } | IGNORE_SYM { $$= INDEX_HINT_IGNORE; } ; index_hint_definition: index_hint_type key_or_index index_hint_clause '(' key_usage_list ')' { init_index_hints($5, $1, $3); $$= $5; } | USE_SYM key_or_index index_hint_clause '(' opt_key_usage_list ')' { init_index_hints($5, INDEX_HINT_USE, $3); $$= $5; } ; index_hints_list: index_hint_definition | index_hints_list index_hint_definition { $2->concat($1); $$= $2; } ; opt_index_hints_list: /* empty */ { $$= NULL; } | index_hints_list ; opt_key_definition: opt_index_hints_list ; opt_key_usage_list: /* empty */ { $$= new (YYTHD->mem_root) List; Index_hint *hint= new (YYTHD->mem_root) Index_hint(NULL, 0); if ($$ == NULL || hint == NULL || $$->push_front(hint)) MYSQL_YYABORT; } | key_usage_list ; key_usage_element: ident { $$= new (YYTHD->mem_root) Index_hint($1.str, $1.length); if ($$ == NULL) MYSQL_YYABORT; } | PRIMARY_SYM { $$= new (YYTHD->mem_root) Index_hint(STRING_WITH_LEN("PRIMARY")); if ($$ == NULL) MYSQL_YYABORT; } ; key_usage_list: key_usage_element { $$= new (YYTHD->mem_root) List; if ($$ == NULL || $$->push_front($1)) MYSQL_YYABORT; } | key_usage_list ',' key_usage_element { if ($$->push_front($3)) MYSQL_YYABORT; } ; using_list: ident { if (!($$= new List)) MYSQL_YYABORT; String *s= new (YYTHD->mem_root) String((const char *) $1.str, $1.length, system_charset_info); if (s == NULL) MYSQL_YYABORT; $$->push_back(s); } | using_list ',' ident { String *s= new (YYTHD->mem_root) String((const char *) $3.str, $3.length, system_charset_info); if (s == NULL) MYSQL_YYABORT; $1->push_back(s); $$= $1; } ; interval: interval_time_stamp {} | DAY_HOUR_SYM { $$=INTERVAL_DAY_HOUR; } | DAY_MICROSECOND_SYM { $$=INTERVAL_DAY_MICROSECOND; } | DAY_MINUTE_SYM { $$=INTERVAL_DAY_MINUTE; } | DAY_SECOND_SYM { $$=INTERVAL_DAY_SECOND; } | HOUR_MICROSECOND_SYM { $$=INTERVAL_HOUR_MICROSECOND; } | HOUR_MINUTE_SYM { $$=INTERVAL_HOUR_MINUTE; } | HOUR_SECOND_SYM { $$=INTERVAL_HOUR_SECOND; } | MINUTE_MICROSECOND_SYM { $$=INTERVAL_MINUTE_MICROSECOND; } | MINUTE_SECOND_SYM { $$=INTERVAL_MINUTE_SECOND; } | SECOND_MICROSECOND_SYM { $$=INTERVAL_SECOND_MICROSECOND; } | YEAR_MONTH_SYM { $$=INTERVAL_YEAR_MONTH; } ; interval_time_stamp: DAY_SYM { $$=INTERVAL_DAY; } | WEEK_SYM { $$=INTERVAL_WEEK; } | HOUR_SYM { $$=INTERVAL_HOUR; } | MINUTE_SYM { $$=INTERVAL_MINUTE; } | MONTH_SYM { $$=INTERVAL_MONTH; } | QUARTER_SYM { $$=INTERVAL_QUARTER; } | SECOND_SYM { $$=INTERVAL_SECOND; } | MICROSECOND_SYM { $$=INTERVAL_MICROSECOND; } | YEAR_SYM { $$=INTERVAL_YEAR; } ; date_time_type: DATE_SYM {$$= MYSQL_TIMESTAMP_DATE; } | TIME_SYM {$$= MYSQL_TIMESTAMP_TIME; } | TIMESTAMP {$$= MYSQL_TIMESTAMP_DATETIME; } | DATETIME {$$= MYSQL_TIMESTAMP_DATETIME; } ; table_alias: /* empty */ | AS | EQ ; opt_table_alias: /* empty */ { $$=0; } | table_alias ident { $$= (LEX_STRING*) sql_memdup(&$2,sizeof(LEX_STRING)); if ($$ == NULL) MYSQL_YYABORT; } ; opt_all: /* empty */ | ALL ; opt_where_clause: /* empty */ { $$= NULL; } | WHERE expr { $$= new PTI_context(@$, $2); } ; opt_having_clause: /* empty */ { $$= NULL; } | HAVING expr { $$= new PTI_context(@$, $2); } ; opt_escape: ESCAPE_SYM simple_expr { $$= $2; } | /* empty */ { $$= NULL; } ; /* group by statement in select */ opt_group_clause: /* empty */ { $$= NULL; } | GROUP_SYM BY group_list olap_opt { $$= NEW_PTN PT_group($3, $4); } ; group_list: group_list ',' grouping_expr { $1->push_back($3); $$= $1; } | grouping_expr { $$= NEW_PTN PT_order_list(); if ($$ == NULL) MYSQL_YYABORT; $$->push_back($1); } ; olap_opt: /* empty */ { $$= UNSPECIFIED_OLAP_TYPE; } | WITH_CUBE_SYM { $$= CUBE_TYPE; } /* 'WITH CUBE' is reserved in the MySQL syntax, but not implemented, and cause LALR(2) conflicts. This syntax is not standard. MySQL syntax: GROUP BY col1, col2, col3 WITH CUBE SQL-2003: GROUP BY ... CUBE(col1, col2, col3) */ | WITH_ROLLUP_SYM { $$= ROLLUP_TYPE; } /* 'WITH ROLLUP' is needed for backward compatibility, and cause LALR(2) conflicts. This syntax is not standard. MySQL syntax: GROUP BY col1, col2, col3 WITH ROLLUP SQL-2003: GROUP BY ... ROLLUP(col1, col2, col3) */ ; /* Order by statement in ALTER TABLE */ alter_order_clause: ORDER_SYM BY alter_order_list ; alter_order_list: alter_order_list ',' alter_order_item | alter_order_item ; alter_order_item: simple_ident_nospvar opt_ordering_direction { ITEMIZE($1, &$1); THD *thd= YYTHD; ORDER *order= (ORDER *) thd->alloc(sizeof(ORDER)); if (order == NULL) MYSQL_YYABORT; order->item_ptr= $1; order->direction= ($2 == 1) ? ORDER::ORDER_ASC : ORDER::ORDER_DESC; order->is_position= false; add_order_to_list(thd, order); } ; /* Order by statement in select */ opt_order_clause: /* empty */ { $$= NULL; } | order_clause ; order_clause: ORDER_SYM BY order_list { $$= NEW_PTN PT_order($3); } ; order_list: order_list ',' order_expr { $1->push_back($3); $$= $1; } | order_expr { $$= NEW_PTN PT_order_list(); if ($$ == NULL) MYSQL_YYABORT; $$->push_back($1); } ; opt_ordering_direction: /* empty */ { $$ = 1; } | ordering_direction ; ordering_direction: ASC { $$ =1; } | DESC { $$ =0; } ; opt_limit_clause: /* empty */ { $$= NULL; } | limit_clause ; limit_clause: LIMIT limit_options { $$= NEW_PTN PT_limit_clause($2); } ; limit_options: limit_option { $$.limit= $1; $$.opt_offset= NULL; $$.is_offset_first= false; } | limit_option ',' limit_option { $$.limit= $3; $$.opt_offset= $1; $$.is_offset_first= true; } | limit_option OFFSET_SYM limit_option { $$.limit= $1; $$.opt_offset= $3; $$.is_offset_first= false; } ; limit_option: ident { $$= NEW_PTN PTI_limit_option_ident(@$, $1, @1.raw); } | param_marker { $$= NEW_PTN PTI_limit_option_param_marker(@$, $1); } | ULONGLONG_NUM { $$= NEW_PTN Item_uint(@$, $1.str, $1.length); } | LONG_NUM { $$= NEW_PTN Item_uint(@$, $1.str, $1.length); } | NUM { $$= NEW_PTN Item_uint(@$, $1.str, $1.length); } ; opt_simple_limit: /* empty */ { $$= NULL; } | LIMIT limit_option { $$= $2; } ; ulong_num: NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } | HEX_NUM { $$= (ulong) my_strtoll($1.str, (char**) 0, 16); } | LONG_NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } | ULONGLONG_NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } | DECIMAL_NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } | FLOAT_NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } ; real_ulong_num: NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } | HEX_NUM { $$= (ulong) my_strtoll($1.str, (char**) 0, 16); } | LONG_NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } | ULONGLONG_NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); } | dec_num_error { MYSQL_YYABORT; } ; ulonglong_num: NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } | ULONGLONG_NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } | LONG_NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } | DECIMAL_NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } | FLOAT_NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } ; real_ulonglong_num: NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } | ULONGLONG_NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } | LONG_NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); } | dec_num_error { MYSQL_YYABORT; } ; dec_num_error: dec_num { my_syntax_error(ER(ER_ONLY_INTEGERS_ALLOWED)); } ; dec_num: DECIMAL_NUM | FLOAT_NUM ; opt_procedure_analyse_clause: /* empty */ { $$= NULL; } | PROCEDURE_SYM ANALYSE_SYM '(' opt_procedure_analyse_params ')' { push_deprecated_warn_no_replacement(YYTHD, "PROCEDURE ANALYSE"); $$= NEW_PTN PT_procedure_analyse($4); } ; opt_procedure_analyse_params: /* empty */ { $$.max_tree_elements= Proc_analyse_params::default_max_tree_elements; $$.max_treemem= Proc_analyse_params::default_max_treemem; } | procedure_analyse_param { $$.max_tree_elements= static_cast($1); $$.max_treemem= Proc_analyse_params::default_max_treemem; } | procedure_analyse_param ',' procedure_analyse_param { $$.max_tree_elements= static_cast($1); $$.max_treemem= static_cast($3); } ; procedure_analyse_param: NUM { int error; $$= (ulonglong) my_strtoll10($1.str, (char**) 0, &error); if (error != 0) { my_error(ER_WRONG_PARAMETERS_TO_PROCEDURE, MYF(0), "ANALYSE"); MYSQL_YYABORT; } } ; select_var_list: select_var_list ',' select_var_ident { $$= $1; if ($$ == NULL || $$->push_back($3)) MYSQL_YYABORT; } | select_var_ident { $$= NEW_PTN PT_select_var_list; if ($$ == NULL || $$->push_back($1)) MYSQL_YYABORT; } ; select_var_ident: '@' ident_or_text { $$= NEW_PTN PT_select_var($2); } | ident_or_text { $$= NEW_PTN PT_select_sp_var($1); } ; opt_into: /* empty */ { $$= NULL; } | into ; into: INTO into_destination { $$= $2; } ; into_destination: OUTFILE TEXT_STRING_filesystem opt_load_data_charset opt_field_term opt_line_term { $$= NEW_PTN PT_into_destination_outfile($2, $3, $4, $5); } | DUMPFILE TEXT_STRING_filesystem { $$= NEW_PTN PT_into_destination_dumpfile($2); } | select_var_list { $$= $1; } ; /* DO statement */ do_stmt: DO_SYM empty_select_options select_item_list { $$= NEW_PTN PT_select( NEW_PTN PT_select_init2(NULL, NEW_PTN PT_select_part2( NEW_PTN PT_select_options_and_item_list($2, $3)), NULL), SQLCOM_DO); } ; empty_select_options: /* empty */ { $$.query_spec_options= 0; $$.sql_cache= SELECT_LEX::SQL_CACHE_UNSPECIFIED; } ; /* Drop : delete tables or index or user */ drop: DROP opt_temporary table_or_tables if_exists { LEX *lex=Lex; lex->sql_command = SQLCOM_DROP_TABLE; lex->drop_temporary= $2; lex->drop_if_exists= $4; YYPS->m_lock_type= TL_UNLOCK; YYPS->m_mdl_type= MDL_EXCLUSIVE; } table_list opt_restrict {} | DROP INDEX_SYM ident ON table_ident {} { LEX *lex=Lex; Alter_drop *ad= new Alter_drop(Alter_drop::KEY, $3.str); if (ad == NULL) MYSQL_YYABORT; lex->sql_command= SQLCOM_DROP_INDEX; lex->alter_info.reset(); lex->alter_info.flags= Alter_info::ALTER_DROP_INDEX; lex->alter_info.drop_list.push_back(ad); if (!lex->current_select()->add_table_to_list(lex->thd, $5, NULL, TL_OPTION_UPDATING, TL_READ_NO_INSERT, MDL_SHARED_UPGRADABLE)) MYSQL_YYABORT; } opt_index_lock_algorithm {} | DROP DATABASE if_exists ident { LEX *lex=Lex; lex->sql_command= SQLCOM_DROP_DB; lex->drop_if_exists=$3; lex->name= $4; } | DROP FUNCTION_SYM if_exists ident '.' ident { THD *thd= YYTHD; LEX *lex= thd->lex; sp_name *spname; if ($4.str && (check_and_convert_db_name(&$4, FALSE) != IDENT_NAME_OK)) MYSQL_YYABORT; if (sp_check_name(&$6)) MYSQL_YYABORT; if (lex->sphead) { my_error(ER_SP_NO_DROP_SP, MYF(0), "FUNCTION"); MYSQL_YYABORT; } lex->sql_command = SQLCOM_DROP_FUNCTION; lex->drop_if_exists= $3; spname= new sp_name(to_lex_cstring($4), $6, true); if (spname == NULL) MYSQL_YYABORT; spname->init_qname(thd); lex->spname= spname; } | DROP FUNCTION_SYM if_exists ident { /* Unlike DROP PROCEDURE, "DROP FUNCTION ident" should work even if there is no current database. In this case it applies only to UDF. Hence we can't merge rules for "DROP FUNCTION ident.ident" and "DROP FUNCTION ident" into one "DROP FUNCTION sp_name" rule. sp_name assumes that database name should be always provided - either explicitly or implicitly. */ THD *thd= YYTHD; LEX *lex= thd->lex; LEX_STRING db= NULL_STR; sp_name *spname; if (lex->sphead) { my_error(ER_SP_NO_DROP_SP, MYF(0), "FUNCTION"); MYSQL_YYABORT; } if (thd->db().str && lex->copy_db_to(&db.str, &db.length)) MYSQL_YYABORT; if (sp_check_name(&$4)) MYSQL_YYABORT; lex->sql_command = SQLCOM_DROP_FUNCTION; lex->drop_if_exists= $3; spname= new sp_name(to_lex_cstring(db), $4, false); if (spname == NULL) MYSQL_YYABORT; spname->init_qname(thd); lex->spname= spname; } | DROP PROCEDURE_SYM if_exists sp_name { LEX *lex=Lex; if (lex->sphead) { my_error(ER_SP_NO_DROP_SP, MYF(0), "PROCEDURE"); MYSQL_YYABORT; } lex->sql_command = SQLCOM_DROP_PROCEDURE; lex->drop_if_exists= $3; lex->spname= $4; } | DROP USER if_exists clear_privileges user_list { LEX *lex=Lex; lex->sql_command= SQLCOM_DROP_USER; lex->drop_if_exists= $3; } | DROP VIEW_SYM if_exists { LEX *lex= Lex; lex->sql_command= SQLCOM_DROP_VIEW; lex->drop_if_exists= $3; YYPS->m_lock_type= TL_UNLOCK; YYPS->m_mdl_type= MDL_EXCLUSIVE; } table_list opt_restrict {} | DROP EVENT_SYM if_exists sp_name { Lex->drop_if_exists= $3; Lex->spname= $4; Lex->sql_command = SQLCOM_DROP_EVENT; } | DROP TRIGGER_SYM if_exists sp_name { LEX *lex= Lex; lex->sql_command= SQLCOM_DROP_TRIGGER; lex->drop_if_exists= $3; lex->spname= $4; } | DROP TABLESPACE_SYM tablespace_name drop_ts_options_list { LEX *lex= Lex; lex->alter_tablespace_info->ts_cmd_type= DROP_TABLESPACE; } | DROP LOGFILE_SYM GROUP_SYM logfile_group_name drop_ts_options_list { LEX *lex= Lex; lex->alter_tablespace_info->ts_cmd_type= DROP_LOGFILE_GROUP; } | DROP SERVER_SYM if_exists ident_or_text { Lex->sql_command = SQLCOM_DROP_SERVER; Lex->m_sql_cmd= new (YYTHD->mem_root) Sql_cmd_drop_server($4, $3); } ; table_list: table_name | table_list ',' table_name ; table_name: table_ident { if (!Select->add_table_to_list(YYTHD, $1, NULL, TL_OPTION_UPDATING, YYPS->m_lock_type, YYPS->m_mdl_type)) MYSQL_YYABORT; } ; table_alias_ref_list: table_ident_opt_wild { $$.init(YYTHD->mem_root); if ($$.push_back($1)) MYSQL_YYABORT; // OOM } | table_alias_ref_list ',' table_ident_opt_wild { $$= $1; if ($$.push_back($3)) MYSQL_YYABORT; // OOM } ; if_exists: /* empty */ { $$= 0; } | IF EXISTS { $$= 1; } ; opt_temporary: /* empty */ { $$= 0; } | TEMPORARY { $$= 1; } ; drop_ts_options_list: /* empty */ | drop_ts_options drop_ts_options: drop_ts_option | drop_ts_options drop_ts_option | drop_ts_options_list ',' drop_ts_option ; drop_ts_option: opt_ts_engine | ts_wait /* ** Insert : add new data to table */ insert_stmt: INSERT /* #1 */ insert_lock_option /* #2 */ opt_ignore /* #3 */ opt_INTO /* #4 */ table_ident /* #5 */ opt_use_partition /* #6 */ insert_from_constructor /* #7 */ opt_insert_update_list /* #8 */ { $$= NEW_PTN PT_insert(false, $1, $2, $3, $5, $6, $7.column_list, $7.row_value_list, NULL, $8.column_list, $8.value_list); } | INSERT /* #1 */ insert_lock_option /* #2 */ opt_ignore /* #3 */ opt_INTO /* #4 */ table_ident /* #5 */ opt_use_partition /* #6 */ SET /* #7 */ update_list /* #8 */ opt_insert_update_list /* #9 */ { PT_insert_values_list *one_row= NEW_PTN PT_insert_values_list; if (one_row == NULL || one_row->push_back(&$8.value_list->value)) MYSQL_YYABORT; // OOM $$= NEW_PTN PT_insert(false, $1, $2, $3, $5, $6, $8.column_list, one_row, NULL, $9.column_list, $9.value_list); } | INSERT /* #1 */ insert_lock_option /* #2 */ opt_ignore /* #3 */ opt_INTO /* #4 */ table_ident /* #5 */ opt_use_partition /* #6 */ insert_from_subquery /* #7 */ opt_insert_update_list /* #8 */ { $$= NEW_PTN PT_insert(false, $1, $2, $3, $5, $6, $7.column_list, NULL, $7.insert_query_expression, $8.column_list, $8.value_list); } ; replace_stmt: REPLACE /* #1 */ replace_lock_option /* #2 */ opt_INTO /* #3 */ table_ident /* #4 */ opt_use_partition /* #5 */ insert_from_constructor /* #6 */ { $$= NEW_PTN PT_insert(true, $1, $2, false, $4, $5, $6.column_list, $6.row_value_list, NULL, NULL, NULL); } | REPLACE /* #1 */ replace_lock_option /* #2 */ opt_INTO /* #3 */ table_ident /* #4 */ opt_use_partition /* #5 */ SET /* #6 */ update_list /* #7 */ { PT_insert_values_list *one_row= NEW_PTN PT_insert_values_list; if (one_row == NULL || one_row->push_back(&$7.value_list->value)) MYSQL_YYABORT; // OOM $$= NEW_PTN PT_insert(true, $1, $2, false, $4, $5, $7.column_list, one_row, NULL, NULL, NULL); } | REPLACE /* #1 */ replace_lock_option /* #2 */ opt_INTO /* #3 */ table_ident /* #4 */ opt_use_partition /* #5 */ insert_from_subquery /* #6 */ { $$= NEW_PTN PT_insert(true, $1, $2, false, $4, $5, $6.column_list, NULL, $6.insert_query_expression, NULL, NULL); } ; insert_lock_option: /* empty */ { $$= TL_WRITE_CONCURRENT_DEFAULT; } | LOW_PRIORITY { $$= TL_WRITE_LOW_PRIORITY; } | DELAYED_SYM { $$= TL_WRITE_CONCURRENT_DEFAULT; push_warning_printf(YYTHD, Sql_condition::SL_WARNING, ER_WARN_LEGACY_SYNTAX_CONVERTED, ER(ER_WARN_LEGACY_SYNTAX_CONVERTED), "INSERT DELAYED", "INSERT"); } | HIGH_PRIORITY { $$= TL_WRITE; } ; replace_lock_option: opt_low_priority { $$= $1; } | DELAYED_SYM { $$= TL_WRITE_DEFAULT; push_warning_printf(YYTHD, Sql_condition::SL_WARNING, ER_WARN_LEGACY_SYNTAX_CONVERTED, ER(ER_WARN_LEGACY_SYNTAX_CONVERTED), "REPLACE DELAYED", "REPLACE"); } ; opt_INTO: /* empty */ | INTO ; insert_from_constructor: insert_values { $$.column_list= NEW_PTN PT_item_list; $$.row_value_list= $1; } | '(' ')' insert_values { $$.column_list= NEW_PTN PT_item_list; $$.row_value_list= $3; } | '(' fields ')' insert_values { $$.column_list= $2; $$.row_value_list= $4; } ; insert_from_subquery: insert_query_expression { $$.column_list= NEW_PTN PT_item_list; $$.insert_query_expression= $1; } | '(' ')' insert_query_expression { $$.column_list= NEW_PTN PT_item_list; $$.insert_query_expression= $3; } | '(' fields ')' insert_query_expression { $$.column_list= $2; $$.insert_query_expression= $4; } ; fields: fields ',' insert_ident { if ($$->push_back($3)) MYSQL_YYABORT; $$= $1; } | insert_ident { $$= NEW_PTN PT_item_list; if ($$ == NULL || $$->push_back($1)) MYSQL_YYABORT; } ; insert_values: value_or_values values_list { $$= $2; } ; insert_query_expression: create_select opt_union_clause { $$= NEW_PTN PT_insert_query_expression(false, $1, $2); } | '(' create_select ')' union_opt { $$= NEW_PTN PT_insert_query_expression(true, $2, $4); } ; value_or_values: VALUE_SYM | VALUES ; values_list: values_list ',' row_value { if ($$->push_back(&$3->value)) MYSQL_YYABORT; } | row_value { $$= NEW_PTN PT_insert_values_list; if ($$ == NULL || $$->push_back(&$1->value)) MYSQL_YYABORT; } ; equal: EQ {} | SET_VAR {} ; opt_equal: /* empty */ {} | equal {} ; row_value: '(' opt_values ')' { $$= $2; } ; opt_values: /* empty */ { $$= NEW_PTN PT_item_list; if ($$ == NULL) MYSQL_YYABORT; } | values ; values: values ',' expr_or_default { if ($1->push_back($3)) MYSQL_YYABORT; $$= $1; } | expr_or_default { $$= NEW_PTN PT_item_list; if ($$ == NULL || $$->push_back($1)) MYSQL_YYABORT; } ; expr_or_default: expr | DEFAULT { $$= NEW_PTN Item_default_value(@$); } ; opt_insert_update_list: /* empty */ { $$.value_list= NULL; $$.column_list= NULL; } | ON DUPLICATE_SYM KEY_SYM UPDATE_SYM update_list { $$= $5; } ; /* Update rows in a table */ update_stmt: UPDATE_SYM /* #1 */ opt_low_priority /* #2 */ opt_ignore /* #3 */ join_table_list /* #4 */ SET /* #5 */ update_list /* #6 */ opt_where_clause /* #7 */ opt_order_clause /* #8 */ opt_simple_limit /* #9 */ { $$= NEW_PTN PT_update($1, $2, $3, $4, $6.column_list, $6.value_list, $7, $8, $9); } ; update_list: update_list ',' update_elem { $$= $1; if ($$.column_list->push_back($3.column) || $$.value_list->push_back($3.value)) MYSQL_YYABORT; // OOM } | update_elem { $$.column_list= NEW_PTN PT_item_list; $$.value_list= NEW_PTN PT_item_list; if ($$.column_list == NULL || $$.value_list == NULL || $$.column_list->push_back($1.column) || $$.value_list->push_back($1.value)) MYSQL_YYABORT; // OOM } ; update_elem: simple_ident_nospvar equal expr_or_default { $$.column= $1; $$.value= $3; } ; opt_low_priority: /* empty */ { $$= TL_WRITE_DEFAULT; } | LOW_PRIORITY { $$= TL_WRITE_LOW_PRIORITY; } ; /* Delete rows from a table */ delete_stmt: DELETE_SYM opt_delete_options FROM table_ident opt_use_partition opt_where_clause opt_order_clause opt_simple_limit { $$= NEW_PTN PT_delete(YYTHD->mem_root, $1, $2, $4, $5, $6, $7, $8); } | DELETE_SYM opt_delete_options table_alias_ref_list FROM join_table_list opt_where_clause { $$= NEW_PTN PT_delete($1, $2, $3, $5, $6); } | DELETE_SYM opt_delete_options FROM table_alias_ref_list USING join_table_list opt_where_clause { $$= NEW_PTN PT_delete($1, $2, $4, $6, $7); } ; opt_wild: /* empty */ | '.' '*' ; opt_delete_options: /* empty */ { $$= 0; } | opt_delete_option opt_delete_options { $$= $1 | $2; } ; opt_delete_option: QUICK { $$= DELETE_QUICK; } | LOW_PRIORITY { $$= DELETE_LOW_PRIORITY; } | IGNORE_SYM { $$= DELETE_IGNORE; } ; truncate: TRUNCATE_SYM opt_table_sym { LEX* lex= Lex; lex->sql_command= SQLCOM_TRUNCATE; lex->alter_info.reset(); YYPS->m_lock_type= TL_WRITE; YYPS->m_mdl_type= MDL_EXCLUSIVE; } table_name { THD *thd= YYTHD; LEX* lex= thd->lex; DBUG_ASSERT(!lex->m_sql_cmd); lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_truncate_table(); if (lex->m_sql_cmd == NULL) MYSQL_YYABORT; } ; opt_table_sym: /* empty */ | TABLE_SYM ; opt_profile_defs: /* empty */ | profile_defs; profile_defs: profile_def | profile_defs ',' profile_def; profile_def: CPU_SYM { Lex->profile_options|= PROFILE_CPU; } | MEMORY_SYM { Lex->profile_options|= PROFILE_MEMORY; } | BLOCK_SYM IO_SYM { Lex->profile_options|= PROFILE_BLOCK_IO; } | CONTEXT_SYM SWITCHES_SYM { Lex->profile_options|= PROFILE_CONTEXT; } | PAGE_SYM FAULTS_SYM { Lex->profile_options|= PROFILE_PAGE_FAULTS; } | IPC_SYM { Lex->profile_options|= PROFILE_IPC; } | SWAPS_SYM { Lex->profile_options|= PROFILE_SWAPS; } | SOURCE_SYM { Lex->profile_options|= PROFILE_SOURCE; } | ALL { Lex->profile_options|= PROFILE_ALL; } ; opt_profile_args: /* empty */ { Lex->query_id= 0; } | FOR_SYM QUERY_SYM NUM { int error; Lex->query_id= static_cast(my_strtoll10($3.str, NULL, &error)); if (error != 0) MYSQL_YYABORT; } ; /* Show things */ show: SHOW { LEX *lex=Lex; new (&lex->create_info) HA_CREATE_INFO; } show_param ; show_param: DATABASES opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_DATABASES; if (prepare_schema_table(YYTHD, lex, 0, SCH_SCHEMATA)) MYSQL_YYABORT; } | opt_full TABLES opt_db opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_TABLES; lex->select_lex->db= $3; if (prepare_schema_table(YYTHD, lex, 0, SCH_TABLE_NAMES)) MYSQL_YYABORT; } | opt_full TRIGGERS_SYM opt_db opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_TRIGGERS; lex->select_lex->db= $3; if (prepare_schema_table(YYTHD, lex, 0, SCH_TRIGGERS)) MYSQL_YYABORT; } | EVENTS_SYM opt_db opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_EVENTS; lex->select_lex->db= $2; if (prepare_schema_table(YYTHD, lex, 0, SCH_EVENTS)) MYSQL_YYABORT; } | TABLE_SYM STATUS_SYM opt_db opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_TABLE_STATUS; lex->select_lex->db= $3; if (prepare_schema_table(YYTHD, lex, 0, SCH_TABLES)) MYSQL_YYABORT; } | OPEN_SYM TABLES opt_db opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_OPEN_TABLES; lex->select_lex->db= $3; if (prepare_schema_table(YYTHD, lex, 0, SCH_OPEN_TABLES)) MYSQL_YYABORT; } | PLUGINS_SYM { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_PLUGINS; if (prepare_schema_table(YYTHD, lex, 0, SCH_PLUGINS)) MYSQL_YYABORT; } | ENGINE_SYM known_storage_engines show_engine_param { Lex->create_info.db_type= $2; } | ENGINE_SYM ALL show_engine_param { Lex->create_info.db_type= NULL; } | opt_full COLUMNS from_or_in table_ident opt_db opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_FIELDS; if ($5) $4->change_db($5); if (prepare_schema_table(YYTHD, lex, $4, SCH_COLUMNS)) MYSQL_YYABORT; } | master_or_binary LOGS_SYM { Lex->sql_command = SQLCOM_SHOW_BINLOGS; } | SLAVE HOSTS_SYM { Lex->sql_command = SQLCOM_SHOW_SLAVE_HOSTS; } | BINLOG_SYM EVENTS_SYM binlog_in binlog_from { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_BINLOG_EVENTS; } opt_limit_clause { if ($6 != NULL) CONTEXTUALIZE($6); } | RELAYLOG_SYM EVENTS_SYM binlog_in binlog_from { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_RELAYLOG_EVENTS; } opt_limit_clause opt_channel { if ($6 != NULL) CONTEXTUALIZE($6); } | keys_or_index /* #1 */ from_or_in /* #2 */ table_ident /* #3 */ opt_db /* #4 */ opt_where_clause /* #5 */ { if ($5 != NULL) ITEMIZE($5, &$5); Select->set_where_cond($5); LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_KEYS; if ($4) $3->change_db($4); if (prepare_schema_table(YYTHD, lex, $3, SCH_STATISTICS)) MYSQL_YYABORT; } | opt_storage ENGINES_SYM { LEX *lex=Lex; lex->sql_command= SQLCOM_SHOW_STORAGE_ENGINES; if (prepare_schema_table(YYTHD, lex, 0, SCH_ENGINES)) MYSQL_YYABORT; } | PRIVILEGES { LEX *lex=Lex; lex->sql_command= SQLCOM_SHOW_PRIVILEGES; } | COUNT_SYM '(' '*' ')' WARNINGS { Lex->keep_diagnostics= DA_KEEP_DIAGNOSTICS; // SHOW WARNINGS doesn't clear them. Parse_context pc(YYTHD, Select); create_select_for_variable(&pc, "warning_count"); } | COUNT_SYM '(' '*' ')' ERRORS { Lex->keep_diagnostics= DA_KEEP_DIAGNOSTICS; // SHOW ERRORS doesn't clear them. Parse_context pc(YYTHD, Select); create_select_for_variable(&pc, "error_count"); } | WARNINGS opt_limit_clause { if ($2 != NULL) CONTEXTUALIZE($2); Lex->sql_command = SQLCOM_SHOW_WARNS; Lex->keep_diagnostics= DA_KEEP_DIAGNOSTICS; // SHOW WARNINGS doesn't clear them. } | ERRORS opt_limit_clause { if ($2 != NULL) CONTEXTUALIZE($2); Lex->sql_command = SQLCOM_SHOW_ERRORS; Lex->keep_diagnostics= DA_KEEP_DIAGNOSTICS; // SHOW ERRORS doesn't clear them. } | PROFILES_SYM { push_warning_printf(YYTHD, Sql_condition::SL_WARNING, ER_WARN_DEPRECATED_SYNTAX, ER(ER_WARN_DEPRECATED_SYNTAX), "SHOW PROFILES", "Performance Schema"); Lex->sql_command = SQLCOM_SHOW_PROFILES; } | PROFILE_SYM opt_profile_defs opt_profile_args opt_limit_clause { if ($4 != NULL) CONTEXTUALIZE($4); LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_PROFILE; if (prepare_schema_table(YYTHD, lex, NULL, SCH_PROFILES) != 0) YYABORT; } | opt_var_type STATUS_SYM opt_wild_or_where_for_show { THD *thd= YYTHD; LEX *lex= thd->lex; if (show_compatibility_56) { /* 5.6, DEPRECATED */ lex->sql_command= SQLCOM_SHOW_STATUS; lex->option_type= $1; if (prepare_schema_table(YYTHD, lex, 0, SCH_STATUS)) MYSQL_YYABORT; } else { Item *where_cond= Select->where_cond(); Select->set_where_cond(NULL); if ($1 == OPT_SESSION) { /* 5.7, SUPPORTED */ if (build_show_session_status(@$, thd, lex->wild, where_cond) == NULL) MYSQL_YYABORT; } else { /* 5.7, SUPPORTED */ if (build_show_global_status(@$, thd, lex->wild, where_cond) == NULL) MYSQL_YYABORT; } } } | opt_full PROCESSLIST_SYM { Lex->sql_command= SQLCOM_SHOW_PROCESSLIST;} | opt_var_type VARIABLES opt_wild_or_where_for_show { THD *thd= YYTHD; LEX *lex= thd->lex; if (show_compatibility_56) { /* 5.6, DEPRECATED */ lex->sql_command= SQLCOM_SHOW_VARIABLES; lex->option_type= $1; if (prepare_schema_table(YYTHD, lex, 0, SCH_VARIABLES)) MYSQL_YYABORT; } else { Item *where_cond= Select->where_cond(); Select->set_where_cond(NULL); if ($1 == OPT_SESSION) { /* 5.7, SUPPORTED */ if (build_show_session_variables(@$, thd, lex->wild, where_cond) == NULL) MYSQL_YYABORT; } else { /* 5.7, SUPPORTED */ if (build_show_global_variables(@$, thd, lex->wild, where_cond) == NULL) MYSQL_YYABORT; } } } | charset opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_CHARSETS; if (prepare_schema_table(YYTHD, lex, 0, SCH_CHARSETS)) MYSQL_YYABORT; } | COLLATION_SYM opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_COLLATIONS; if (prepare_schema_table(YYTHD, lex, 0, SCH_COLLATIONS)) MYSQL_YYABORT; } | GRANTS { LEX *lex=Lex; lex->sql_command= SQLCOM_SHOW_GRANTS; LEX_USER *curr_user; if (!(curr_user= (LEX_USER*) lex->thd->alloc(sizeof(st_lex_user)))) MYSQL_YYABORT; memset(curr_user, 0, sizeof(st_lex_user)); lex->grant_user= curr_user; } | GRANTS FOR_SYM user { LEX *lex=Lex; lex->sql_command= SQLCOM_SHOW_GRANTS; lex->grant_user=$3; lex->grant_user->auth= NULL_CSTR; } | CREATE DATABASE opt_if_not_exists ident { Lex->sql_command=SQLCOM_SHOW_CREATE_DB; Lex->create_info.options=$3; Lex->name= $4; } | CREATE TABLE_SYM table_ident { LEX *lex= Lex; lex->sql_command = SQLCOM_SHOW_CREATE; if (!lex->select_lex->add_table_to_list(YYTHD, $3, NULL,0)) MYSQL_YYABORT; lex->only_view= 0; lex->create_info.storage_media= HA_SM_DEFAULT; } | CREATE VIEW_SYM table_ident { LEX *lex= Lex; lex->sql_command = SQLCOM_SHOW_CREATE; if (!lex->select_lex->add_table_to_list(YYTHD, $3, NULL, 0)) MYSQL_YYABORT; lex->only_view= 1; } | MASTER_SYM STATUS_SYM { Lex->sql_command = SQLCOM_SHOW_MASTER_STAT; } | SLAVE STATUS_SYM opt_channel { Lex->sql_command = SQLCOM_SHOW_SLAVE_STAT; } | CREATE PROCEDURE_SYM sp_name { LEX *lex= Lex; lex->sql_command = SQLCOM_SHOW_CREATE_PROC; lex->spname= $3; } | CREATE FUNCTION_SYM sp_name { LEX *lex= Lex; lex->sql_command = SQLCOM_SHOW_CREATE_FUNC; lex->spname= $3; } | CREATE TRIGGER_SYM sp_name { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_CREATE_TRIGGER; lex->spname= $3; } | PROCEDURE_SYM STATUS_SYM opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_STATUS_PROC; if (prepare_schema_table(YYTHD, lex, 0, SCH_PROCEDURES)) MYSQL_YYABORT; } | FUNCTION_SYM STATUS_SYM opt_wild_or_where { LEX *lex= Lex; lex->sql_command= SQLCOM_SHOW_STATUS_FUNC; if (prepare_schema_table(YYTHD, lex, 0, SCH_PROCEDURES)) MYSQL_YYABORT; } | PROCEDURE_SYM CODE_SYM sp_name { Lex->sql_command= SQLCOM_SHOW_PROC_CODE; Lex->spname= $3; } | FUNCTION_SYM CODE_SYM sp_name { Lex->sql_command= SQLCOM_SHOW_FUNC_CODE; Lex->spname= $3; } | CREATE EVENT_SYM sp_name { Lex->spname= $3; Lex->sql_command = SQLCOM_SHOW_CREATE_EVENT; } | CREATE USER clear_privileges user { LEX *lex=Lex; lex->sql_command= SQLCOM_SHOW_CREATE_USER; lex->grant_user=$4; } ; show_engine_param: STATUS_SYM { Lex->sql_command= SQLCOM_SHOW_ENGINE_STATUS; } | MUTEX_SYM { Lex->sql_command= SQLCOM_SHOW_ENGINE_MUTEX; } | LOGS_SYM { Lex->sql_command= SQLCOM_SHOW_ENGINE_LOGS; } ; master_or_binary: MASTER_SYM | BINARY ; opt_storage: /* empty */ | STORAGE_SYM ; opt_db: /* empty */ { $$= 0; } | from_or_in ident { $$= $2.str; } ; opt_full: /* empty */ { Lex->verbose=0; } | FULL { Lex->verbose=1; } ; from_or_in: FROM | IN_SYM ; binlog_in: /* empty */ { Lex->mi.log_file_name = 0; } | IN_SYM TEXT_STRING_sys { Lex->mi.log_file_name = $2.str; } ; binlog_from: /* empty */ { Lex->mi.pos = 4; /* skip magic number */ } | FROM ulonglong_num { Lex->mi.pos = $2; } ; opt_wild_or_where: /* empty */ | LIKE TEXT_STRING_sys { Lex->wild= new (YYTHD->mem_root) String($2.str, $2.length, system_charset_info); if (Lex->wild == NULL) MYSQL_YYABORT; } | WHERE expr { ITEMIZE($2, &$2); Select->set_where_cond($2); if ($2) $2->top_level_item(); } ; opt_wild_or_where_for_show: /* empty */ | LIKE TEXT_STRING_sys { Lex->wild= new (YYTHD->mem_root) String($2.str, $2.length, system_charset_info); if (Lex->wild == NULL) MYSQL_YYABORT; } | WHERE expr { if (show_compatibility_56) { /* This parsed tree fragment is added as part of a SQLCOM_SHOW_STATUS or SQLCOM_SHOW_VARIABLES command. */ ITEMIZE($2, &$2); Select->set_where_cond($2); if ($2) $2->top_level_item(); } else { /* This parsed tree fragment is used to build a SQLCOM_SELECT statement, see sql/sql_show_status.cc */ Select->set_where_cond($2); } } ; /* A Oracle compatible synonym for show */ describe: describe_command table_ident { LEX *lex= Lex; lex->current_select()->parsing_place= CTX_SELECT_LIST; lex->sql_command= SQLCOM_SHOW_FIELDS; lex->select_lex->db= NULL; lex->verbose= 0; if (prepare_schema_table(YYTHD, lex, $2, SCH_COLUMNS)) MYSQL_YYABORT; } opt_describe_column { // Ensure we're resetting parsing context of the right select DBUG_ASSERT(Select->parsing_place == CTX_SELECT_LIST); Select->parsing_place= CTX_NONE; } | describe_command opt_extended_describe { Lex->describe|= DESCRIBE_NORMAL; } explainable_command ; explainable_command: select { CONTEXTUALIZE($1); } | insert_stmt { MAKE_CMD($1); } | replace_stmt { MAKE_CMD($1); } | update_stmt { MAKE_CMD($1); } | delete_stmt { MAKE_CMD($1); } | FOR_SYM CONNECTION_SYM real_ulong_num { Lex->sql_command= SQLCOM_EXPLAIN_OTHER; if (Lex->sphead) { my_error(ER_NOT_SUPPORTED_YET, MYF(0), "non-standalone EXPLAIN FOR CONNECTION"); MYSQL_YYABORT; } Lex->query_id= (my_thread_id)($3); } ; describe_command: DESC | DESCRIBE ; opt_extended_describe: /* empty */ { if ((Lex->explain_format= new Explain_format_traditional) == NULL) MYSQL_YYABORT; } | EXTENDED_SYM { if ((Lex->explain_format= new Explain_format_traditional) == NULL) MYSQL_YYABORT; push_deprecated_warn_no_replacement(YYTHD, "EXTENDED"); } | PARTITIONS_SYM { if ((Lex->explain_format= new Explain_format_traditional) == NULL) MYSQL_YYABORT; push_deprecated_warn_no_replacement(YYTHD, "PARTITIONS"); } | FORMAT_SYM EQ ident_or_text { if (!my_strcasecmp(system_charset_info, $3.str, "JSON")) { if ((Lex->explain_format= new Explain_format_JSON) == NULL) MYSQL_YYABORT; } else if (!my_strcasecmp(system_charset_info, $3.str, "TRADITIONAL")) { if ((Lex->explain_format= new Explain_format_traditional) == NULL) MYSQL_YYABORT; } else { my_error(ER_UNKNOWN_EXPLAIN_FORMAT, MYF(0), $3.str); MYSQL_YYABORT; } } ; opt_describe_column: /* empty */ {} | text_string { Lex->wild= $1; } | ident { Lex->wild= new (YYTHD->mem_root) String((const char*) $1.str, $1.length, system_charset_info); if (Lex->wild == NULL) MYSQL_YYABORT; } ; /* flush things */ flush: FLUSH_SYM opt_no_write_to_binlog { LEX *lex=Lex; lex->sql_command= SQLCOM_FLUSH; lex->type= 0; lex->no_write_to_binlog= $2; } flush_options {} ; flush_options: table_or_tables { Lex->type|= REFRESH_TABLES; /* Set type of metadata and table locks for FLUSH TABLES table_list [WITH READ LOCK]. */ YYPS->m_lock_type= TL_READ_NO_INSERT; YYPS->m_mdl_type= MDL_SHARED_HIGH_PRIO; } opt_table_list {} opt_flush_lock {} | flush_options_list ; opt_flush_lock: /* empty */ {} | WITH READ_SYM LOCK_SYM { TABLE_LIST *tables= Lex->query_tables; Lex->type|= REFRESH_READ_LOCK; for (; tables; tables= tables->next_global) { tables->mdl_request.set_type(MDL_SHARED_NO_WRITE); tables->required_type= FRMTYPE_TABLE; /* Don't try to flush views. */ tables->open_type= OT_BASE_ONLY; /* Ignore temporary tables. */ } } | FOR_SYM { if (Lex->query_tables == NULL) // Table list can't be empty { my_syntax_error(ER(ER_NO_TABLES_USED)); MYSQL_YYABORT; } } EXPORT_SYM { TABLE_LIST *tables= Lex->query_tables; Lex->type|= REFRESH_FOR_EXPORT; for (; tables; tables= tables->next_global) { tables->mdl_request.set_type(MDL_SHARED_NO_WRITE); tables->required_type= FRMTYPE_TABLE; /* Don't try to flush views. */ tables->open_type= OT_BASE_ONLY; /* Ignore temporary tables. */ } } ; flush_options_list: flush_options_list ',' flush_option | flush_option {} ; flush_option: ERROR_SYM LOGS_SYM { Lex->type|= REFRESH_ERROR_LOG; } | ENGINE_SYM LOGS_SYM { Lex->type|= REFRESH_ENGINE_LOG; } | GENERAL LOGS_SYM { Lex->type|= REFRESH_GENERAL_LOG; } | SLOW LOGS_SYM { Lex->type|= REFRESH_SLOW_LOG; } | BINARY LOGS_SYM { Lex->type|= REFRESH_BINARY_LOG; } | RELAY LOGS_SYM opt_channel { Lex->type|= REFRESH_RELAY_LOG; } | QUERY_SYM CACHE_SYM { push_deprecated_warn_no_replacement(YYTHD, "FLUSH QUERY CACHE"); Lex->type|= REFRESH_QUERY_CACHE_FREE; } | HOSTS_SYM { Lex->type|= REFRESH_HOSTS; } | PRIVILEGES { Lex->type|= REFRESH_GRANT; } | LOGS_SYM { Lex->type|= REFRESH_LOG; } | STATUS_SYM { Lex->type|= REFRESH_STATUS; } | DES_KEY_FILE { Lex->type|= REFRESH_DES_KEY_FILE; } | RESOURCES { Lex->type|= REFRESH_USER_RESOURCES; } | OPTIMIZER_COSTS_SYM { Lex->type|= REFRESH_OPTIMIZER_COSTS; } ; opt_table_list: /* empty */ {} | table_list {} ; reset: RESET_SYM { LEX *lex=Lex; lex->sql_command= SQLCOM_RESET; lex->type=0; } reset_options {} ; reset_options: reset_options ',' reset_option | reset_option ; reset_option: SLAVE { Lex->type|= REFRESH_SLAVE; } slave_reset_options opt_channel | MASTER_SYM { Lex->type|= REFRESH_MASTER; } | QUERY_SYM CACHE_SYM { push_deprecated_warn_no_replacement(YYTHD, "RESET QUERY CACHE"); Lex->type|= REFRESH_QUERY_CACHE; } ; slave_reset_options: /* empty */ { Lex->reset_slave_info.all= false; } | ALL { Lex->reset_slave_info.all= true; } ; purge: PURGE { LEX *lex=Lex; lex->type=0; lex->sql_command = SQLCOM_PURGE; } purge_options {} ; purge_options: master_or_binary LOGS_SYM purge_option ; purge_option: TO_SYM TEXT_STRING_sys { Lex->to_log = $2.str; } | BEFORE_SYM expr { ITEMIZE($2, &$2); LEX *lex= Lex; lex->purge_value_list.empty(); lex->purge_value_list.push_front($2); lex->sql_command= SQLCOM_PURGE_BEFORE; } ; /* kill threads */ kill: KILL_SYM kill_option expr { ITEMIZE($3, &$3); LEX *lex=Lex; lex->kill_value_list.empty(); lex->kill_value_list.push_front($3); lex->sql_command= SQLCOM_KILL; } ; kill_option: /* empty */ { Lex->type= 0; } | CONNECTION_SYM { Lex->type= 0; } | QUERY_SYM { Lex->type= ONLY_KILL_QUERY; } ; /* change database */ use: USE_SYM ident { LEX *lex=Lex; lex->sql_command=SQLCOM_CHANGE_DB; lex->select_lex->db= $2.str; } ; /* import, export of files */ load: LOAD data_or_xml { THD *thd= YYTHD; LEX *lex= thd->lex; if (lex->sphead) { my_error(ER_SP_BADSTATEMENT, MYF(0), $2 == FILETYPE_CSV ? "LOAD DATA" : "LOAD XML"); MYSQL_YYABORT; } } load_data_lock opt_local INFILE TEXT_STRING_filesystem { LEX *lex=Lex; lex->sql_command= SQLCOM_LOAD; lex->local_file= $5; lex->duplicates= DUP_ERROR; lex->set_ignore(false); if (!(lex->exchange= new sql_exchange($7.str, 0, $2))) MYSQL_YYABORT; } opt_duplicate INTO TABLE_SYM table_ident opt_use_partition { LEX *lex=Lex; /* Fix lock for LOAD DATA CONCURRENT REPLACE */ if (lex->duplicates == DUP_REPLACE && $4 == TL_WRITE_CONCURRENT_INSERT) $4= TL_WRITE_DEFAULT; if (!Select->add_table_to_list(YYTHD, $12, NULL, TL_OPTION_UPDATING, $4, $4 == TL_WRITE_LOW_PRIORITY ? MDL_SHARED_WRITE_LOW_PRIO : MDL_SHARED_WRITE, NULL, $13)) MYSQL_YYABORT; lex->load_field_list.empty(); lex->load_update_list.empty(); lex->load_value_list.empty(); /* We can't give an error in the middle when using LOCAL files */ if (lex->local_file && lex->duplicates == DUP_ERROR) lex->set_ignore(true); } opt_load_data_charset { Lex->exchange->cs= $15; } opt_xml_rows_identified_by opt_field_term opt_line_term opt_ignore_lines opt_field_or_var_spec opt_load_data_set_spec { Lex->exchange->field.merge_field_separators($18); Lex->exchange->line.merge_line_separators($19); } ; data_or_xml: DATA_SYM { $$= FILETYPE_CSV; } | XML_SYM { $$= FILETYPE_XML; } ; opt_local: /* empty */ { $$=0;} | LOCAL_SYM { $$=1;} ; load_data_lock: /* empty */ { $$= TL_WRITE_DEFAULT; } | CONCURRENT { $$= TL_WRITE_CONCURRENT_INSERT; } | LOW_PRIORITY { $$= TL_WRITE_LOW_PRIORITY; } ; opt_duplicate: /* empty */ { Lex->duplicates=DUP_ERROR; } | REPLACE { Lex->duplicates=DUP_REPLACE; } | IGNORE_SYM { Lex->set_ignore(true); } ; opt_field_term: /* empty */ { $$.cleanup(); } | COLUMNS field_term_list { $$= $2; } ; field_term_list: field_term_list field_term { $$= $1; $$.merge_field_separators($2); } | field_term ; field_term: TERMINATED BY text_string { $$.cleanup(); $$.field_term= $3; } | OPTIONALLY ENCLOSED BY text_string { $$.cleanup(); $$.enclosed= $4; $$.opt_enclosed= 1; } | ENCLOSED BY text_string { $$.cleanup(); $$.enclosed= $3; } | ESCAPED BY text_string { $$.cleanup(); $$.escaped= $3; } ; opt_line_term: /* empty */ { $$.cleanup(); } | LINES line_term_list { $$= $2; } ; line_term_list: line_term_list line_term { $$= $1; $$.merge_line_separators($2); } | line_term ; line_term: TERMINATED BY text_string { $$.cleanup(); $$.line_term= $3; } | STARTING BY text_string { $$.cleanup(); $$.line_start= $3; } ; opt_xml_rows_identified_by: /* empty */ { } | ROWS_SYM IDENTIFIED_SYM BY text_string { Lex->exchange->line.line_term = $4; }; opt_ignore_lines: /* empty */ | IGNORE_SYM NUM lines_or_rows { DBUG_ASSERT(Lex->exchange != 0); Lex->exchange->skip_lines= atol($2.str); } ; lines_or_rows: LINES { } | ROWS_SYM { } ; opt_field_or_var_spec: /* empty */ {} | '(' fields_or_vars ')' {} | '(' ')' {} ; fields_or_vars: fields_or_vars ',' field_or_var { Lex->load_field_list.push_back($3); } | field_or_var { Lex->load_field_list.push_back($1); } ; field_or_var: simple_ident_nospvar { ITEMIZE($1, &$$); } | '@' ident_or_text { $$= new (YYTHD->mem_root) Item_user_var_as_out_param($2); if ($$ == NULL) MYSQL_YYABORT; } ; opt_load_data_set_spec: /* empty */ {} | SET load_data_set_list {} ; load_data_set_list: load_data_set_list ',' load_data_set_elem | load_data_set_elem ; load_data_set_elem: simple_ident_nospvar equal expr_or_default { ITEMIZE($1, &$1); ITEMIZE($3, &$3); LEX *lex= Lex; uint length= (uint) (@3.cpp.end - @2.cpp.start); String *val= new (YYTHD->mem_root) String(@2.cpp.start, length, YYTHD->charset()); if (val == NULL) MYSQL_YYABORT; if (lex->load_update_list.push_back($1) || lex->load_value_list.push_back($3) || lex->load_set_str_list.push_back(val)) MYSQL_YYABORT; $3->item_name.copy(@2.cpp.start, length, YYTHD->charset()); } ; /* Common definitions */ text_literal: TEXT_STRING { $$= NEW_PTN PTI_text_literal_text_string(@$, YYTHD->m_parser_state->m_lip.text_string_is_7bit(), $1); } | NCHAR_STRING { $$= NEW_PTN PTI_text_literal_nchar_string(@$, YYTHD->m_parser_state->m_lip.text_string_is_7bit(), $1); } | UNDERSCORE_CHARSET TEXT_STRING { $$= NEW_PTN PTI_text_literal_underscore_charset(@$, YYTHD->m_parser_state->m_lip.text_string_is_7bit(), $1, $2); } | text_literal TEXT_STRING_literal { $$= NEW_PTN PTI_text_literal_concat(@$, YYTHD->m_parser_state->m_lip.text_string_is_7bit(), $1, $2); } ; text_string: TEXT_STRING_literal { $$= new (YYTHD->mem_root) String($1.str, $1.length, YYTHD->variables.collation_connection); if ($$ == NULL) MYSQL_YYABORT; } | HEX_NUM { LEX_STRING s= Item_hex_string::make_hex_str($1.str, $1.length); $$= new (YYTHD->mem_root) String(s.str, s.length, &my_charset_bin); if ($$ == NULL) MYSQL_YYABORT; } | BIN_NUM { LEX_STRING s= Item_bin_string::make_bin_str($1.str, $1.length); $$= new (YYTHD->mem_root) String(s.str, s.length, &my_charset_bin); if ($$ == NULL) MYSQL_YYABORT; } ; param_marker: PARAM_MARKER { $$= NEW_PTN Item_param(@$, (uint) (@1.raw.start - YYLIP->get_buf())); } ; signed_literal: literal { ITEMIZE($1, &$$); } | '+' NUM_literal { ITEMIZE($2, &$$); } | '-' NUM_literal { ITEMIZE($2, &$2); $2->max_length++; $$= ((Item_int *)$2)->neg(); } ; literal: text_literal { $$= $1; } | NUM_literal | temporal_literal | NULL_SYM { Lex_input_stream *lip= YYLIP; /* For the digest computation, in this context only, NULL is considered a literal, hence reduced to '?' REDUCE: TOK_GENERIC_VALUE := NULL_SYM */ lip->reduce_digest_token(TOK_GENERIC_VALUE, NULL_SYM); $$= NEW_PTN Item_null(@$); lip->next_state= MY_LEX_OPERATOR_OR_IDENT; } | FALSE_SYM { $$= NEW_PTN Item_int(@$, NAME_STRING("FALSE"), 0, 1); } | TRUE_SYM { $$= NEW_PTN Item_int(@$, NAME_STRING("TRUE"), 1, 1); } | HEX_NUM { $$= NEW_PTN Item_hex_string(@$, $1); } | BIN_NUM { $$= NEW_PTN Item_bin_string(@$, $1); } | UNDERSCORE_CHARSET HEX_NUM { $$= NEW_PTN PTI_literal_underscore_charset_hex_num(@$, $1, $2); } | UNDERSCORE_CHARSET BIN_NUM { $$= NEW_PTN PTI_literal_underscore_charset_bin_num(@$, $1, $2); } ; NUM_literal: NUM { $$= NEW_PTN PTI_num_literal_num(@$, $1); } | LONG_NUM { $$= NEW_PTN PTI_num_literal_num(@$, $1); } | ULONGLONG_NUM { $$= NEW_PTN Item_uint(@$, $1.str, $1.length); } | DECIMAL_NUM { $$= NEW_PTN Item_decimal(@$, $1.str, $1.length, YYCSCL); } | FLOAT_NUM { $$= NEW_PTN Item_float(@$, $1.str, $1.length); } ; temporal_literal: DATE_SYM TEXT_STRING { $$= NEW_PTN PTI_temporal_literal(@$, $2, MYSQL_TYPE_DATE, YYCSCL); } | TIME_SYM TEXT_STRING { $$= NEW_PTN PTI_temporal_literal(@$, $2, MYSQL_TYPE_TIME, YYCSCL); } | TIMESTAMP TEXT_STRING { $$= NEW_PTN PTI_temporal_literal(@$, $2, MYSQL_TYPE_DATETIME, YYCSCL); } ; /********************************************************************** ** Creating different items. **********************************************************************/ insert_ident: simple_ident_nospvar | table_wild ; table_wild: ident '.' '*' { $$= NEW_PTN PTI_table_wild(@$, NULL, $1.str); } | ident '.' ident '.' '*' { $$= NEW_PTN PTI_table_wild(@$, $1.str, $3.str); } ; order_expr: expr opt_ordering_direction { $$= NEW_PTN PT_order_expr($1, $2); } ; grouping_expr: expr { $$= NEW_PTN PT_order_expr($1, 1); } | expr ordering_direction { push_deprecated_warn(YYTHD, "GROUP BY with ASC/DESC", "GROUP BY ... ORDER BY ... ASC/DESC"); $$= NEW_PTN PT_order_expr($1, $2); } ; simple_ident: ident { $$= NEW_PTN PTI_simple_ident_ident(@$, $1); } | simple_ident_q ; simple_ident_nospvar: ident { $$= NEW_PTN PTI_simple_ident_nospvar_ident(@$, $1); } | simple_ident_q ; simple_ident_q: ident '.' ident { $$= NEW_PTN PTI_simple_ident_q_2d(@$, $1.str, $3.str); } | '.' ident '.' ident { push_deprecated_warn(YYTHD, ".
.", "the table.column name without a dot prefix"); $$= NEW_PTN PTI_simple_ident_q_3d(@$, NULL, $2.str, $4.str); } | ident '.' ident '.' ident { $$= NEW_PTN PTI_simple_ident_q_3d(@$, $1.str, $3.str, $5.str); } ; field_ident: ident { $$=$1;} | ident '.' ident '.' ident { TABLE_LIST *table= Select->table_list.first; if (my_strcasecmp(table_alias_charset, $1.str, table->db)) { my_error(ER_WRONG_DB_NAME, MYF(0), $1.str); MYSQL_YYABORT; } if (my_strcasecmp(table_alias_charset, $3.str, table->table_name)) { my_error(ER_WRONG_TABLE_NAME, MYF(0), $3.str); MYSQL_YYABORT; } $$=$5; } | ident '.' ident { TABLE_LIST *table= Select->table_list.first; if (my_strcasecmp(table_alias_charset, $1.str, table->alias)) { my_error(ER_WRONG_TABLE_NAME, MYF(0), $1.str); MYSQL_YYABORT; } $$=$3; } | '.' ident /* For Delphi */ { push_deprecated_warn(YYTHD, ".", "the column name without a dot prefix"); $$=$2; } ; table_ident: ident { $$= NEW_PTN Table_ident(to_lex_cstring($1)); if ($$ == NULL) MYSQL_YYABORT; } | ident '.' ident { if (YYTHD->get_protocol()->has_client_capability(CLIENT_NO_SCHEMA)) $$= NEW_PTN Table_ident(to_lex_cstring($3)); else { $$= NEW_PTN Table_ident(to_lex_cstring($1), to_lex_cstring($3)); } if ($$ == NULL) MYSQL_YYABORT; } | '.' ident { /* For Delphi */ push_deprecated_warn(YYTHD, ".
", "the table name without a dot prefix"); $$= NEW_PTN Table_ident(to_lex_cstring($2)); if ($$ == NULL) MYSQL_YYABORT; } ; table_ident_opt_wild: ident opt_wild { $$= NEW_PTN Table_ident(to_lex_cstring($1)); if ($$ == NULL) MYSQL_YYABORT; } | ident '.' ident opt_wild { $$= NEW_PTN Table_ident(YYTHD, to_lex_cstring($1), to_lex_cstring($3), 0); if ($$ == NULL) MYSQL_YYABORT; } ; table_ident_nodb: ident { LEX_CSTRING db= { any_db, strlen(any_db) }; $$= new Table_ident(YYTHD, db, to_lex_cstring($1), 0); if ($$ == NULL) MYSQL_YYABORT; } ; IDENT_sys: IDENT { $$= $1; } | IDENT_QUOTED { THD *thd= YYTHD; if (thd->charset_is_system_charset) { const CHARSET_INFO *cs= system_charset_info; int dummy_error; size_t wlen= cs->cset->well_formed_len(cs, $1.str, $1.str+$1.length, $1.length, &dummy_error); if (wlen < $1.length) { ErrConvString err($1.str, $1.length, &my_charset_bin); my_error(ER_INVALID_CHARACTER_STRING, MYF(0), cs->csname, err.ptr()); MYSQL_YYABORT; } $$= $1; } else { if (thd->convert_string(&$$, system_charset_info, $1.str, $1.length, thd->charset())) MYSQL_YYABORT; } } ; TEXT_STRING_sys_nonewline: TEXT_STRING_sys { if (!strcont($1.str, "\n")) $$= $1; else { my_error(ER_WRONG_VALUE, MYF(0), "argument contains not-allowed LF", $1.str); MYSQL_YYABORT; } } ; filter_wild_db_table_string: TEXT_STRING_sys_nonewline { if (strcont($1.str, ".")) $$= $1; else { my_error(ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN, MYF(0)); MYSQL_YYABORT; } } ; TEXT_STRING_sys: TEXT_STRING { THD *thd= YYTHD; if (thd->charset_is_system_charset) $$= $1; else { if (thd->convert_string(&$$, system_charset_info, $1.str, $1.length, thd->charset())) MYSQL_YYABORT; } } ; TEXT_STRING_literal: TEXT_STRING { THD *thd= YYTHD; if (thd->charset_is_collation_connection) $$= $1; else { if (thd->convert_string(&$$, thd->variables.collation_connection, $1.str, $1.length, thd->charset())) MYSQL_YYABORT; } } ; TEXT_STRING_filesystem: TEXT_STRING { THD *thd= YYTHD; if (thd->charset_is_character_set_filesystem) $$= $1; else { if (thd->convert_string(&$$, thd->variables.character_set_filesystem, $1.str, $1.length, thd->charset())) MYSQL_YYABORT; } } ; ident: IDENT_sys { $$=$1; } | keyword { THD *thd= YYTHD; $$.str= thd->strmake($1.str, $1.length); if ($$.str == NULL) MYSQL_YYABORT; $$.length= $1.length; } ; label_ident: IDENT_sys { $$=$1; } | keyword_sp { THD *thd= YYTHD; $$.str= thd->strmake($1.str, $1.length); if ($$.str == NULL) MYSQL_YYABORT; $$.length= $1.length; } ; ident_or_text: ident { $$=$1;} | TEXT_STRING_sys { $$=$1;} | LEX_HOSTNAME { $$=$1;} ; user: ident_or_text { THD *thd= YYTHD; if (!($$=(LEX_USER*) thd->alloc(sizeof(st_lex_user)))) MYSQL_YYABORT; /* Trim whitespace as the values will go to a CHAR field when stored. */ trim_whitespace(system_charset_info, &$1); $$->user.str= $1.str; $$->user.length= $1.length; $$->host.str= "%"; $$->host.length= 1; $$->plugin= EMPTY_CSTR; $$->auth= NULL_CSTR; $$->uses_identified_by_clause= false; $$->uses_identified_with_clause= false; $$->uses_identified_by_password_clause= false; $$->uses_authentication_string_clause= false; if (check_string_char_length($$->user, ER(ER_USERNAME), USERNAME_CHAR_LENGTH, system_charset_info, 0)) MYSQL_YYABORT; } | ident_or_text '@' ident_or_text { THD *thd= YYTHD; if (!($$=(LEX_USER*) thd->alloc(sizeof(st_lex_user)))) MYSQL_YYABORT; /* Trim whitespace as the values will go to a CHAR field when stored. */ trim_whitespace(system_charset_info, &$1); trim_whitespace(system_charset_info, &$3); $$->user.str= $1.str; $$->user.length= $1.length; $$->host.str= $3.str; $$->host.length= $3.length; $$->plugin= EMPTY_CSTR; $$->auth= NULL_CSTR; $$->uses_identified_by_clause= false; $$->uses_identified_with_clause= false; $$->uses_identified_by_password_clause= false; $$->uses_authentication_string_clause= false; if (check_string_char_length($$->user, ER(ER_USERNAME), USERNAME_CHAR_LENGTH, system_charset_info, 0) || check_host_name($$->host)) MYSQL_YYABORT; /* Convert hostname part of username to lowercase. It's OK to use in-place lowercase as long as the character set is utf8. */ my_casedn_str(system_charset_info, $3.str); $$->host.str= $3.str; } | CURRENT_USER optional_braces { if (!($$=(LEX_USER*) YYTHD->alloc(sizeof(st_lex_user)))) MYSQL_YYABORT; /* empty LEX_USER means current_user and will be handled in the get_current_user() function later */ memset($$, 0, sizeof(LEX_USER)); } ; /* Keyword that we allow for identifiers (except SP labels) */ keyword: keyword_sp {} | ACCOUNT_SYM {} | ASCII_SYM {} | ALWAYS_SYM {} | BACKUP_SYM {} | BEGIN_SYM {} | BYTE_SYM {} | CACHE_SYM {} | CHARSET {} | CHECKSUM_SYM {} | CLOSE_SYM {} | COMMENT_SYM {} | COMMIT_SYM {} | CONTAINS_SYM {} | DEALLOCATE_SYM {} | DO_SYM {} | END {} | EXECUTE_SYM {} | FLUSH_SYM {} | FOLLOWS_SYM {} | FORMAT_SYM {} | GROUP_REPLICATION {} | HANDLER_SYM {} | HELP_SYM {} | HOST_SYM {} | INSTALL_SYM {} | LANGUAGE_SYM {} | NO_SYM {} | OPEN_SYM {} | OPTIONS_SYM {} | OWNER_SYM {} | PARSER_SYM {} | PARSE_GCOL_EXPR_SYM {} | PORT_SYM {} | PRECEDES_SYM {} | PREPARE_SYM {} | REMOVE_SYM {} | REPAIR {} | RESET_SYM {} | RESTORE_SYM {} | ROLLBACK_SYM {} | SAVEPOINT_SYM {} | SECURITY_SYM {} | SERVER_SYM {} | SHUTDOWN {} | SIGNED_SYM {} | SOCKET_SYM {} | SLAVE {} | SONAME_SYM {} | START_SYM {} | STOP_SYM {} | TRUNCATE_SYM {} | UNICODE_SYM {} | UNINSTALL_SYM {} | WRAPPER_SYM {} | XA_SYM {} | UPGRADE_SYM {} ; /* * Keywords that we allow for labels in SPs. * Anything that's the beginning of a statement or characteristics * must be in keyword above, otherwise we get (harmful) shift/reduce * conflicts. */ keyword_sp: ACTION {} | ADDDATE_SYM {} | AFTER_SYM {} | AGAINST {} | AGGREGATE_SYM {} | ALGORITHM_SYM {} | ANALYSE_SYM {} | ANY_SYM {} | AT_SYM {} | AUTO_INC {} | AUTOEXTEND_SIZE_SYM {} | AVG_ROW_LENGTH {} | AVG_SYM {} | BINLOG_SYM {} | BIT_SYM {} | BLOCK_SYM {} | BOOL_SYM {} | BOOLEAN_SYM {} | BTREE_SYM {} | CASCADED {} | CATALOG_NAME_SYM {} | CHAIN_SYM {} | CHANGED {} | CHANNEL_SYM {} | CIPHER_SYM {} | CLIENT_SYM {} | CLASS_ORIGIN_SYM {} | COALESCE {} | CODE_SYM {} | COLLATION_SYM {} | COLUMN_NAME_SYM {} | COLUMN_FORMAT_SYM {} | COLUMNS {} | COMMITTED_SYM {} | COMPACT_SYM {} | COMPLETION_SYM {} | COMPRESSED_SYM {} | COMPRESSION_SYM {} | ENCRYPTION_SYM {} | CONCURRENT {} | CONNECTION_SYM {} | CONSISTENT_SYM {} | CONSTRAINT_CATALOG_SYM {} | CONSTRAINT_SCHEMA_SYM {} | CONSTRAINT_NAME_SYM {} | CONTEXT_SYM {} | CPU_SYM {} | CUBE_SYM {} /* Although a reserved keyword in SQL:2003 (and :2008), not reserved in MySQL per WL#2111 specification. */ | CURRENT_SYM {} | CURSOR_NAME_SYM {} | DATA_SYM {} | DATAFILE_SYM {} | DATETIME {} | DATE_SYM {} | DAY_SYM {} | DEFAULT_AUTH_SYM {} | DEFINER_SYM {} | DELAY_KEY_WRITE_SYM {} | DES_KEY_FILE {} | DIAGNOSTICS_SYM {} | DIRECTORY_SYM {} | DISABLE_SYM {} | DISCARD {} | DISK_SYM {} | DUMPFILE {} | DUPLICATE_SYM {} | DYNAMIC_SYM {} | ENDS_SYM {} | ENUM {} | ENGINE_SYM {} | ENGINES_SYM {} | ERROR_SYM {} | ERRORS {} | ESCAPE_SYM {} | EVENT_SYM {} | EVENTS_SYM {} | EVERY_SYM {} | EXCHANGE_SYM {} | EXPANSION_SYM {} | EXPIRE_SYM {} | EXPORT_SYM {} | EXTENDED_SYM {} | EXTENT_SIZE_SYM {} | FAULTS_SYM {} | FAST_SYM {} | FOUND_SYM {} | ENABLE_SYM {} | FULL {} | FILE_SYM {} | FILE_BLOCK_SIZE_SYM {} | FILTER_SYM {} | FIRST_SYM {} | FIXED_SYM {} | GENERAL {} | GEOMETRY_SYM {} | GEOMETRYCOLLECTION {} | GET_FORMAT {} | GRANTS {} | GLOBAL_SYM {} | HASH_SYM {} | HOSTS_SYM {} | HOUR_SYM {} | IDENTIFIED_SYM {} | IGNORE_SERVER_IDS_SYM {} | INVOKER_SYM {} | IMPORT {} | INDEXES {} | INITIAL_SIZE_SYM {} | INSTANCE_SYM {} | IO_SYM {} | IPC_SYM {} | ISOLATION {} | ISSUER_SYM {} | INSERT_METHOD {} | JSON_SYM {} | KEY_BLOCK_SIZE {} | LAST_SYM {} | LEAVES {} | LESS_SYM {} | LEVEL_SYM {} | LINESTRING {} | LIST_SYM {} | LOCAL_SYM {} | LOCKS_SYM {} | LOGFILE_SYM {} | LOGS_SYM {} | MAX_ROWS {} | MASTER_SYM {} | MASTER_HEARTBEAT_PERIOD_SYM {} | MASTER_HOST_SYM {} | MASTER_PORT_SYM {} | MASTER_LOG_FILE_SYM {} | MASTER_LOG_POS_SYM {} | MASTER_USER_SYM {} | MASTER_PASSWORD_SYM {} | MASTER_SERVER_ID_SYM {} | MASTER_CONNECT_RETRY_SYM {} | MASTER_RETRY_COUNT_SYM {} | MASTER_DELAY_SYM {} | MASTER_SSL_SYM {} | MASTER_SSL_CA_SYM {} | MASTER_SSL_CAPATH_SYM {} | MASTER_TLS_VERSION_SYM {} | MASTER_SSL_CERT_SYM {} | MASTER_SSL_CIPHER_SYM {} | MASTER_SSL_CRL_SYM {} | MASTER_SSL_CRLPATH_SYM {} | MASTER_SSL_KEY_SYM {} | MASTER_AUTO_POSITION_SYM {} | MAX_CONNECTIONS_PER_HOUR {} | MAX_QUERIES_PER_HOUR {} | MAX_SIZE_SYM {} | MAX_UPDATES_PER_HOUR {} | MAX_USER_CONNECTIONS_SYM {} | MEDIUM_SYM {} | MEMORY_SYM {} | MERGE_SYM {} | MESSAGE_TEXT_SYM {} | MICROSECOND_SYM {} | MIGRATE_SYM {} | MINUTE_SYM {} | MIN_ROWS {} | MODIFY_SYM {} | MODE_SYM {} | MONTH_SYM {} | MULTILINESTRING {} | MULTIPOINT {} | MULTIPOLYGON {} | MUTEX_SYM {} | MYSQL_ERRNO_SYM {} | NAME_SYM {} | NAMES_SYM {} | NATIONAL_SYM {} | NCHAR_SYM {} | NDBCLUSTER_SYM {} | NEVER_SYM {} | NEXT_SYM {} | NEW_SYM {} | NO_WAIT_SYM {} | NODEGROUP_SYM {} | NONE_SYM {} | NUMBER_SYM {} | NVARCHAR_SYM {} | OFFSET_SYM {} | ONE_SYM {} | ONLY_SYM {} | PACK_KEYS_SYM {} | PAGE_SYM {} | PARTIAL {} | PARTITIONING_SYM {} | PARTITIONS_SYM {} | PASSWORD {} | PHASE_SYM {} | PLUGIN_DIR_SYM {} | PLUGIN_SYM {} | PLUGINS_SYM {} | POINT_SYM {} | POLYGON {} | PRESERVE_SYM {} | PREV_SYM {} | PRIVILEGES {} | PROCESS {} | PROCESSLIST_SYM {} | PROFILE_SYM {} | PROFILES_SYM {} | PROXY_SYM {} | QUARTER_SYM {} | QUERY_SYM {} | QUICK {} | READ_ONLY_SYM {} | REBUILD_SYM {} | RECOVER_SYM {} | REDO_BUFFER_SIZE_SYM {} | REDOFILE_SYM {} | REDUNDANT_SYM {} | RELAY {} | RELAYLOG_SYM {} | RELAY_LOG_FILE_SYM {} | RELAY_LOG_POS_SYM {} | RELAY_THREAD {} | RELOAD {} | REORGANIZE_SYM {} | REPEATABLE_SYM {} | REPLICATION {} | REPLICATE_DO_DB {} | REPLICATE_IGNORE_DB {} | REPLICATE_DO_TABLE {} | REPLICATE_IGNORE_TABLE {} | REPLICATE_WILD_DO_TABLE {} | REPLICATE_WILD_IGNORE_TABLE {} | REPLICATE_REWRITE_DB {} | RESOURCES {} | RESUME_SYM {} | RETURNED_SQLSTATE_SYM {} | RETURNS_SYM {} | REVERSE_SYM {} | ROLLUP_SYM {} | ROTATE_SYM {} | ROUTINE_SYM {} | ROWS_SYM {} | ROW_COUNT_SYM {} | ROW_FORMAT_SYM {} | ROW_SYM {} | RTREE_SYM {} | SCHEDULE_SYM {} | SCHEMA_NAME_SYM {} | SECOND_SYM {} | SERIAL_SYM {} | SERIALIZABLE_SYM {} | SESSION_SYM {} | SIMPLE_SYM {} | SHARE_SYM {} | SLOW {} | SNAPSHOT_SYM {} | SOUNDS_SYM {} | SOURCE_SYM {} | SQL_AFTER_GTIDS {} | SQL_AFTER_MTS_GAPS {} | SQL_BEFORE_GTIDS {} | SQL_CACHE_SYM {} | SQL_BUFFER_RESULT {} | SQL_NO_CACHE_SYM {} | SQL_THREAD {} | STACKED_SYM {} | STARTS_SYM {} | STATS_AUTO_RECALC_SYM {} | STATS_PERSISTENT_SYM {} | STATS_SAMPLE_PAGES_SYM {} | STATUS_SYM {} | STORAGE_SYM {} | STRING_SYM {} | SUBCLASS_ORIGIN_SYM {} | SUBDATE_SYM {} | SUBJECT_SYM {} | SUBPARTITION_SYM {} | SUBPARTITIONS_SYM {} | SUPER_SYM {} | SUSPEND_SYM {} | SWAPS_SYM {} | SWITCHES_SYM {} | TABLE_NAME_SYM {} | TABLES {} | TABLE_CHECKSUM_SYM {} | TABLESPACE_SYM {} | TEMPORARY {} | TEMPTABLE_SYM {} | TEXT_SYM {} | THAN_SYM {} | TRANSACTION_SYM {} | TRIGGERS_SYM {} | TIMESTAMP {} | TIMESTAMP_ADD {} | TIMESTAMP_DIFF {} | TIME_SYM {} | TYPES_SYM {} | TYPE_SYM {} | UDF_RETURNS_SYM {} | FUNCTION_SYM {} | UNCOMMITTED_SYM {} | UNDEFINED_SYM {} | UNDO_BUFFER_SIZE_SYM {} | UNDOFILE_SYM {} | UNKNOWN_SYM {} | UNTIL_SYM {} | USER {} | USE_FRM {} | VALIDATION_SYM {} | VARIABLES {} | VIEW_SYM {} | VALUE_SYM {} | WARNINGS {} | WAIT_SYM {} | WEEK_SYM {} | WITHOUT_SYM {} | WORK_SYM {} | WEIGHT_STRING_SYM {} | X509_SYM {} | XID_SYM {} | XML_SYM {} | YEAR_SYM {} ; /* SQLCOM_SET_OPTION statement. Note that to avoid shift/reduce conflicts, we have separate rules for the first option listed in the statement. */ set: SET start_option_value_list { $$= NEW_PTN PT_set(@1, $2); } ; // Start of option value list start_option_value_list: option_value_no_option_type option_value_list_continued { $$= NEW_PTN PT_start_option_value_list_no_type($1, @1, $2); } | TRANSACTION_SYM transaction_characteristics { $$= NEW_PTN PT_start_option_value_list_transaction($2, @2); } | option_type start_option_value_list_following_option_type { $$= NEW_PTN PT_start_option_value_list_type($1, $2); } | PASSWORD equal password { $$= NEW_PTN PT_option_value_no_option_type_password($3, @3); } | PASSWORD equal PASSWORD '(' password ')' { push_deprecated_warn(YYTHD, "SET PASSWORD = " "PASSWORD('')", "SET PASSWORD = ''"); $$= NEW_PTN PT_option_value_no_option_type_password($5, @5); } | PASSWORD FOR_SYM user equal password { $$= NEW_PTN PT_option_value_no_option_type_password_for($3, $5, @5); } | PASSWORD FOR_SYM user equal PASSWORD '(' password ')' { push_deprecated_warn(YYTHD, "SET PASSWORD FOR = " "PASSWORD('')", "SET PASSWORD FOR = " "''"); $$= NEW_PTN PT_option_value_no_option_type_password_for($3, $7, @7); } ; // Start of option value list, option_type was given start_option_value_list_following_option_type: option_value_following_option_type option_value_list_continued { $$= NEW_PTN PT_start_option_value_list_following_option_type_eq($1, @1, $2); } | TRANSACTION_SYM transaction_characteristics { $$= NEW_PTN PT_start_option_value_list_following_option_type_transaction($2, @2); } ; // Remainder of the option value list after first option value. option_value_list_continued: /* empty */ { $$= NULL; } | ',' option_value_list { $$= $2; } ; // Repeating list of option values after first option value. option_value_list: option_value { $$= NEW_PTN PT_option_value_list_head(@0, $1, @1); } | option_value_list ',' option_value { $$= NEW_PTN PT_option_value_list($1, @2, $3, @3); } ; // Wrapper around option values following the first option value in the stmt. option_value: option_type option_value_following_option_type { $$= NEW_PTN PT_option_value_type($1, $2); } | option_value_no_option_type { $$= $1; } ; option_type: GLOBAL_SYM { $$=OPT_GLOBAL; } | LOCAL_SYM { $$=OPT_SESSION; } | SESSION_SYM { $$=OPT_SESSION; } ; opt_var_type: /* empty */ { $$=OPT_SESSION; } | GLOBAL_SYM { $$=OPT_GLOBAL; } | LOCAL_SYM { $$=OPT_SESSION; } | SESSION_SYM { $$=OPT_SESSION; } ; opt_var_ident_type: /* empty */ { $$=OPT_DEFAULT; } | GLOBAL_SYM '.' { $$=OPT_GLOBAL; } | LOCAL_SYM '.' { $$=OPT_SESSION; } | SESSION_SYM '.' { $$=OPT_SESSION; } ; // Option values with preceding option_type. option_value_following_option_type: internal_variable_name equal set_expr_or_default { $$= NEW_PTN PT_option_value_following_option_type(@$, $1, $3); } ; // Option values without preceding option_type. option_value_no_option_type: internal_variable_name /*$1*/ equal /*$2*/ set_expr_or_default /*$3*/ { $$= NEW_PTN PT_option_value_no_option_type_internal($1, $3, @3); } | '@' ident_or_text equal expr { $$= NEW_PTN PT_option_value_no_option_type_user_var($2, $4); } | '@' '@' opt_var_ident_type internal_variable_name equal set_expr_or_default { $$= NEW_PTN PT_option_value_no_option_type_sys_var($3, $4, $6); } | charset old_or_new_charset_name_or_default { $$= NEW_PTN PT_option_value_no_option_type_charset($2); } | NAMES_SYM equal expr { /* Bad syntax, always fails with an error */ $$= NEW_PTN PT_option_value_no_option_type_names(@2); } | NAMES_SYM charset_name_or_default opt_collate { $$= NEW_PTN PT_option_value_no_option_type_names_charset($2, $3); } ; internal_variable_name: ident { $$= NEW_PTN PT_internal_variable_name_1d($1); } | ident '.' ident { $$= NEW_PTN PT_internal_variable_name_2d(@$, $1, $3); } | DEFAULT '.' ident { $$= NEW_PTN PT_internal_variable_name_default($3); } ; transaction_characteristics: transaction_access_mode opt_isolation_level { $$= NEW_PTN PT_transaction_characteristics($1, $2); } | isolation_level opt_transaction_access_mode { $$= NEW_PTN PT_transaction_characteristics($1, $2); } ; transaction_access_mode: transaction_access_mode_types { $$= NEW_PTN PT_transaction_access_mode($1); } ; opt_transaction_access_mode: /* empty */ { $$= NULL; } | ',' transaction_access_mode { $$= $2; } ; isolation_level: ISOLATION LEVEL_SYM isolation_types { $$= NEW_PTN PT_isolation_level($3); } ; opt_isolation_level: /* empty */ { $$= NULL; } | ',' isolation_level { $$= $2; } ; transaction_access_mode_types: READ_SYM ONLY_SYM { $$= true; } | READ_SYM WRITE_SYM { $$= false; } ; isolation_types: READ_SYM UNCOMMITTED_SYM { $$= ISO_READ_UNCOMMITTED; } | READ_SYM COMMITTED_SYM { $$= ISO_READ_COMMITTED; } | REPEATABLE_SYM READ_SYM { $$= ISO_REPEATABLE_READ; } | SERIALIZABLE_SYM { $$= ISO_SERIALIZABLE; } ; password: TEXT_STRING { $$=$1.str; Lex->contains_plaintext_password= true; } ; set_expr_or_default: expr | DEFAULT { $$= NULL; } | ON { $$= NEW_PTN Item_string(@$, "ON", 2, system_charset_info); } | ALL { $$= NEW_PTN Item_string(@$, "ALL", 3, system_charset_info); } | BINARY { $$= NEW_PTN Item_string(@$, "binary", 6, system_charset_info); } ; /* Lock function */ lock: LOCK_SYM table_or_tables { LEX *lex= Lex; if (lex->sphead) { my_error(ER_SP_BADSTATEMENT, MYF(0), "LOCK"); MYSQL_YYABORT; } lex->sql_command= SQLCOM_LOCK_TABLES; } table_lock_list {} ; table_or_tables: TABLE_SYM | TABLES ; table_lock_list: table_lock | table_lock_list ',' table_lock ; table_lock: table_ident opt_table_alias lock_option { thr_lock_type lock_type= (thr_lock_type) $3; enum_mdl_type mdl_lock_type; if (lock_type >= TL_WRITE_ALLOW_WRITE) { /* LOCK TABLE ... WRITE/LOW_PRIORITY WRITE */ mdl_lock_type= MDL_SHARED_NO_READ_WRITE; } else if (lock_type == TL_READ) { /* LOCK TABLE ... READ LOCAL */ mdl_lock_type= MDL_SHARED_READ; } else { /* LOCK TABLE ... READ */ mdl_lock_type= MDL_SHARED_READ_ONLY; } if (!Select->add_table_to_list(YYTHD, $1, $2, 0, lock_type, mdl_lock_type)) MYSQL_YYABORT; } ; lock_option: READ_SYM { $$= TL_READ_NO_INSERT; } | WRITE_SYM { $$= TL_WRITE_DEFAULT; } | LOW_PRIORITY WRITE_SYM { $$= TL_WRITE_LOW_PRIORITY; push_deprecated_warn(YYTHD, "LOW_PRIORITY WRITE", "WRITE"); } | READ_SYM LOCAL_SYM { $$= TL_READ; } ; unlock: UNLOCK_SYM { LEX *lex= Lex; if (lex->sphead) { my_error(ER_SP_BADSTATEMENT, MYF(0), "UNLOCK"); MYSQL_YYABORT; } lex->sql_command= SQLCOM_UNLOCK_TABLES; } table_or_tables {} ; shutdown_stmt: SHUTDOWN { Lex->sql_command= SQLCOM_SHUTDOWN; $$= NEW_PTN PT_shutdown(); } ; alter_instance_stmt: ALTER INSTANCE_SYM alter_instance_action { Lex->sql_command= SQLCOM_ALTER_INSTANCE; $$= NEW_PTN PT_alter_instance($3); } alter_instance_action: ROTATE_SYM ident_or_text MASTER_SYM KEY_SYM { if (!my_strcasecmp(system_charset_info, $2.str, "INNODB")) { $$= ROTATE_INNODB_MASTER_KEY; } else { YYTHD->parse_error_at(@2, ER(ER_SYNTAX_ERROR)); MYSQL_YYABORT; } } ; /* ** Handler: direct access to ISAM functions */ handler: HANDLER_SYM table_ident OPEN_SYM opt_table_alias { THD *thd= YYTHD; LEX *lex= Lex; if (lex->sphead) { my_error(ER_SP_BADSTATEMENT, MYF(0), "HANDLER"); MYSQL_YYABORT; } lex->sql_command = SQLCOM_HA_OPEN; if (!lex->current_select()->add_table_to_list(thd, $2, $4, 0)) MYSQL_YYABORT; lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_handler_open(); if (lex->m_sql_cmd == NULL) MYSQL_YYABORT; } | HANDLER_SYM table_ident_nodb CLOSE_SYM { THD *thd= YYTHD; LEX *lex= Lex; if (lex->sphead) { my_error(ER_SP_BADSTATEMENT, MYF(0), "HANDLER"); MYSQL_YYABORT; } lex->sql_command = SQLCOM_HA_CLOSE; if (!lex->current_select()->add_table_to_list(thd, $2, 0, 0)) MYSQL_YYABORT; lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_handler_close(); if (lex->m_sql_cmd == NULL) MYSQL_YYABORT; } | HANDLER_SYM /* #1 */ table_ident_nodb /* #2 */ READ_SYM /* #3 */ { /* #4 */ LEX *lex=Lex; if (lex->sphead) { my_error(ER_SP_BADSTATEMENT, MYF(0), "HANDLER"); MYSQL_YYABORT; } lex->expr_allows_subselect= FALSE; lex->sql_command = SQLCOM_HA_READ; Item *one= new (YYTHD->mem_root) Item_int((int32) 1); if (one == NULL) MYSQL_YYABORT; lex->current_select()->select_limit= one; lex->current_select()->offset_limit= 0; if (!lex->current_select()->add_table_to_list(lex->thd, $2, 0, 0)) MYSQL_YYABORT; } handler_read_or_scan /* #5 */ opt_where_clause /* #6 */ opt_limit_clause /* #7 */ { if ($6 != NULL) ITEMIZE($6, &$6); Select->set_where_cond($6); if ($7 != NULL) CONTEXTUALIZE($7); THD *thd= YYTHD; LEX *lex= Lex; Lex->expr_allows_subselect= TRUE; /* Stored functions are not supported for HANDLER READ. */ if (lex->uses_stored_routines()) { my_error(ER_NOT_SUPPORTED_YET, MYF(0), "stored functions in HANDLER ... READ"); MYSQL_YYABORT; } lex->m_sql_cmd= new (thd->mem_root) Sql_cmd_handler_read($5, lex->ident.str, lex->handler_insert_list, thd->m_parser_state->m_yacc.m_ha_rkey_mode); if (lex->m_sql_cmd == NULL) MYSQL_YYABORT; } ; handler_read_or_scan: handler_scan_function { Lex->ident= null_lex_str; $$=$1; } | ident handler_rkey_function { Lex->ident= $1; $$=$2; } ; handler_scan_function: FIRST_SYM { $$= RFIRST; } | NEXT_SYM { $$= RNEXT; } ; handler_rkey_function: FIRST_SYM { $$= RFIRST; } | NEXT_SYM { $$= RNEXT; } | PREV_SYM { $$= RPREV; } | LAST_SYM { $$= RLAST; } | handler_rkey_mode { YYTHD->m_parser_state->m_yacc.m_ha_rkey_mode= $1; } '(' values ')' { CONTEXTUALIZE($4); Lex->handler_insert_list= &$4->value; $$= RKEY; } ; handler_rkey_mode: EQ { $$=HA_READ_KEY_EXACT; } | GE { $$=HA_READ_KEY_OR_NEXT; } | LE { $$=HA_READ_KEY_OR_PREV; } | GT_SYM { $$=HA_READ_AFTER_KEY; } | LT { $$=HA_READ_BEFORE_KEY; } ; /* GRANT / REVOKE */ revoke: REVOKE clear_privileges { Lex->sql_command= SQLCOM_REVOKE; } revoke_command {} ; revoke_command: grant_privileges ON opt_table grant_ident FROM user_list { LEX *lex= Lex; lex->type= 0; } | grant_privileges ON FUNCTION_SYM grant_ident FROM user_list { LEX *lex= Lex; if (lex->columns.elements) { my_syntax_error(ER(ER_SYNTAX_ERROR)); MYSQL_YYABORT; } lex->type= TYPE_ENUM_FUNCTION; } | grant_privileges ON PROCEDURE_SYM grant_ident FROM user_list { LEX *lex= Lex; if (lex->columns.elements) { my_syntax_error(ER(ER_SYNTAX_ERROR)); MYSQL_YYABORT; } lex->type= TYPE_ENUM_PROCEDURE; } | ALL opt_privileges ',' GRANT OPTION FROM user_list { Lex->sql_command = SQLCOM_REVOKE_ALL; } | PROXY_SYM ON user FROM user_list { LEX *lex= Lex; lex->users_list.push_front ($3); lex->type= TYPE_ENUM_PROXY; } ; grant: GRANT clear_privileges { Lex->sql_command= SQLCOM_GRANT; } grant_command {} ; grant_command: grant_privileges ON opt_table grant_ident TO_SYM grant_list require_clause grant_options { LEX *lex= Lex; lex->type= 0; } | grant_privileges ON FUNCTION_SYM grant_ident TO_SYM grant_list require_clause grant_options { LEX *lex= Lex; if (lex->columns.elements) { my_syntax_error(ER(ER_SYNTAX_ERROR)); MYSQL_YYABORT; } lex->type= TYPE_ENUM_FUNCTION; } | grant_privileges ON PROCEDURE_SYM grant_ident TO_SYM grant_list require_clause grant_options { LEX *lex= Lex; if (lex->columns.elements) { my_syntax_error(ER(ER_SYNTAX_ERROR)); MYSQL_YYABORT; } lex->type= TYPE_ENUM_PROCEDURE; } | PROXY_SYM ON user TO_SYM grant_list opt_grant_option { LEX *lex= Lex; lex->users_list.push_front ($3); lex->type= TYPE_ENUM_PROXY; } ; opt_table: /* Empty */ | TABLE_SYM ; grant_privileges: object_privilege_list { LEX *lex= Lex; if (lex->grant == GLOBAL_ACLS && lex->sql_command == SQLCOM_REVOKE) lex->sql_command= SQLCOM_REVOKE_ALL; } | ALL opt_privileges { Lex->all_privileges= 1; Lex->grant= GLOBAL_ACLS; } ; opt_privileges: /* empty */ | PRIVILEGES ; object_privilege_list: object_privilege | object_privilege_list ',' object_privilege ; object_privilege: SELECT_SYM { Lex->which_columns = SELECT_ACL;} opt_column_list {} | INSERT { Lex->which_columns = INSERT_ACL;} opt_column_list {} | UPDATE_SYM { Lex->which_columns = UPDATE_ACL; } opt_column_list {} | REFERENCES { Lex->which_columns = REFERENCES_ACL;} opt_column_list {} | DELETE_SYM { Lex->grant |= DELETE_ACL;} | USAGE {} | INDEX_SYM { Lex->grant |= INDEX_ACL;} | ALTER { Lex->grant |= ALTER_ACL;} | CREATE { Lex->grant |= CREATE_ACL;} | DROP { Lex->grant |= DROP_ACL;} | EXECUTE_SYM { Lex->grant |= EXECUTE_ACL;} | RELOAD { Lex->grant |= RELOAD_ACL;} | SHUTDOWN { Lex->grant |= SHUTDOWN_ACL;} | PROCESS { Lex->grant |= PROCESS_ACL;} | FILE_SYM { Lex->grant |= FILE_ACL;} | GRANT OPTION { Lex->grant |= GRANT_ACL;} | SHOW DATABASES { Lex->grant |= SHOW_DB_ACL;} | SUPER_SYM { Lex->grant |= SUPER_ACL;} | CREATE TEMPORARY TABLES { Lex->grant |= CREATE_TMP_ACL;} | LOCK_SYM TABLES { Lex->grant |= LOCK_TABLES_ACL; } | REPLICATION SLAVE { Lex->grant |= REPL_SLAVE_ACL; } | REPLICATION CLIENT_SYM { Lex->grant |= REPL_CLIENT_ACL; } | CREATE VIEW_SYM { Lex->grant |= CREATE_VIEW_ACL; } | SHOW VIEW_SYM { Lex->grant |= SHOW_VIEW_ACL; } | CREATE ROUTINE_SYM { Lex->grant |= CREATE_PROC_ACL; } | ALTER ROUTINE_SYM { Lex->grant |= ALTER_PROC_ACL; } | CREATE USER { Lex->grant |= CREATE_USER_ACL; } | EVENT_SYM { Lex->grant |= EVENT_ACL;} | TRIGGER_SYM { Lex->grant |= TRIGGER_ACL; } | CREATE TABLESPACE_SYM { Lex->grant |= CREATE_TABLESPACE_ACL; } ; opt_and: /* empty */ {} | AND_SYM {} ; require_list: require_list_element opt_and require_list | require_list_element ; require_list_element: SUBJECT_SYM TEXT_STRING { LEX *lex=Lex; if (lex->x509_subject) { my_error(ER_DUP_ARGUMENT, MYF(0), "SUBJECT"); MYSQL_YYABORT; } lex->x509_subject=$2.str; } | ISSUER_SYM TEXT_STRING { LEX *lex=Lex; if (lex->x509_issuer) { my_error(ER_DUP_ARGUMENT, MYF(0), "ISSUER"); MYSQL_YYABORT; } lex->x509_issuer=$2.str; } | CIPHER_SYM TEXT_STRING { LEX *lex=Lex; if (lex->ssl_cipher) { my_error(ER_DUP_ARGUMENT, MYF(0), "CIPHER"); MYSQL_YYABORT; } lex->ssl_cipher=$2.str; } ; grant_ident: '*' { LEX *lex= Lex; size_t dummy; if (lex->copy_db_to(&lex->current_select()->db, &dummy)) MYSQL_YYABORT; if (lex->grant == GLOBAL_ACLS) lex->grant = DB_ACLS & ~GRANT_ACL; else if (lex->columns.elements) { my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE), MYF(0)); MYSQL_YYABORT; } } | ident '.' '*' { LEX *lex= Lex; lex->current_select()->db = $1.str; if (lex->grant == GLOBAL_ACLS) lex->grant = DB_ACLS & ~GRANT_ACL; else if (lex->columns.elements) { my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE), MYF(0)); MYSQL_YYABORT; } } | '*' '.' '*' { LEX *lex= Lex; lex->current_select()->db = NULL; if (lex->grant == GLOBAL_ACLS) lex->grant= GLOBAL_ACLS & ~GRANT_ACL; else if (lex->columns.elements) { my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE), MYF(0)); MYSQL_YYABORT; } } | table_ident { LEX *lex=Lex; if (!lex->current_select()->add_table_to_list(lex->thd, $1,NULL, TL_OPTION_UPDATING)) MYSQL_YYABORT; if (lex->grant == GLOBAL_ACLS) lex->grant = TABLE_ACLS & ~GRANT_ACL; } ; user_list: user { if (Lex->users_list.push_back($1)) MYSQL_YYABORT; } | user_list ',' user { if (Lex->users_list.push_back($3)) MYSQL_YYABORT; } ; grant_list: grant_user { if (Lex->users_list.push_back($1)) MYSQL_YYABORT; } | grant_list ',' grant_user { if (Lex->users_list.push_back($3)) MYSQL_YYABORT; } ; grant_user: user IDENTIFIED_SYM BY TEXT_STRING { $$=$1; $1->auth.str= $4.str; $1->auth.length= $4.length; $1->uses_identified_by_clause= true; Lex->contains_plaintext_password= true; } | user IDENTIFIED_SYM BY PASSWORD TEXT_STRING { $$= $1; $1->auth.str= $5.str; $1->auth.length= $5.length; $1->uses_identified_by_password_clause= true; if (Lex->sql_command == SQLCOM_ALTER_USER) { my_syntax_error(ER_THD(YYTHD, ER_SYNTAX_ERROR)); MYSQL_YYABORT; } else push_deprecated_warn(YYTHD, "IDENTIFIED BY PASSWORD", "IDENTIFIED WITH AS "); } | user IDENTIFIED_SYM WITH ident_or_text { $$= $1; $1->plugin.str= $4.str; $1->plugin.length= $4.length; $1->auth= EMPTY_CSTR; $1->uses_identified_with_clause= true; } | user IDENTIFIED_SYM WITH ident_or_text AS TEXT_STRING_sys { $$= $1; $1->plugin.str= $4.str; $1->plugin.length= $4.length; $1->auth.str= $6.str; $1->auth.length= $6.length; $1->uses_identified_with_clause= true; $1->uses_authentication_string_clause= true; } | user IDENTIFIED_SYM WITH ident_or_text BY TEXT_STRING_sys { $$= $1; $1->plugin.str= $4.str; $1->plugin.length= $4.length; $1->auth.str= $6.str; $1->auth.length= $6.length; $1->uses_identified_with_clause= true; $1->uses_identified_by_clause= true; Lex->contains_plaintext_password= true; } | user { $$= $1; $1->auth= NULL_CSTR; } ; opt_column_list: /* empty */ { LEX *lex=Lex; lex->grant |= lex->which_columns; } | '(' column_list ')' ; column_list: column_list ',' column_list_id | column_list_id ; column_list_id: ident { String *new_str = new (YYTHD->mem_root) String((const char*) $1.str,$1.length,system_charset_info); if (new_str == NULL) MYSQL_YYABORT; List_iterator iter(Lex->columns); class LEX_COLUMN *point; LEX *lex=Lex; while ((point=iter++)) { if (!my_strcasecmp(system_charset_info, point->column.ptr(), new_str->ptr())) break; } lex->grant_tot_col|= lex->which_columns; if (point) point->rights |= lex->which_columns; else { LEX_COLUMN *col= new LEX_COLUMN (*new_str,lex->which_columns); if (col == NULL) MYSQL_YYABORT; lex->columns.push_back(col); } } ; require_clause: /* empty */ | REQUIRE_SYM require_list { Lex->ssl_type=SSL_TYPE_SPECIFIED; } | REQUIRE_SYM SSL_SYM { Lex->ssl_type=SSL_TYPE_ANY; } | REQUIRE_SYM X509_SYM { Lex->ssl_type=SSL_TYPE_X509; } | REQUIRE_SYM NONE_SYM { Lex->ssl_type=SSL_TYPE_NONE; } ; grant_options: /* empty */ {} | WITH grant_option_list ; opt_grant_option: /* empty */ {} | WITH GRANT OPTION { Lex->grant |= GRANT_ACL;} ; grant_option_list: grant_option_list grant_option {} | grant_option {} ; grant_option: GRANT OPTION { Lex->grant |= GRANT_ACL;} | MAX_QUERIES_PER_HOUR ulong_num { LEX *lex=Lex; lex->mqh.questions=$2; lex->mqh.specified_limits|= USER_RESOURCES::QUERIES_PER_HOUR; } | MAX_UPDATES_PER_HOUR ulong_num { LEX *lex=Lex; lex->mqh.updates=$2; lex->mqh.specified_limits|= USER_RESOURCES::UPDATES_PER_HOUR; } | MAX_CONNECTIONS_PER_HOUR ulong_num { LEX *lex=Lex; lex->mqh.conn_per_hour= $2; lex->mqh.specified_limits|= USER_RESOURCES::CONNECTIONS_PER_HOUR; } | MAX_USER_CONNECTIONS_SYM ulong_num { LEX *lex=Lex; lex->mqh.user_conn= $2; lex->mqh.specified_limits|= USER_RESOURCES::USER_CONNECTIONS; } ; begin: BEGIN_SYM { LEX *lex=Lex; lex->sql_command = SQLCOM_BEGIN; lex->start_transaction_opt= 0; } opt_work {} ; opt_work: /* empty */ {} | WORK_SYM {} ; opt_chain: /* empty */ { $$= TVL_UNKNOWN; } | AND_SYM NO_SYM CHAIN_SYM { $$= TVL_NO; } | AND_SYM CHAIN_SYM { $$= TVL_YES; } ; opt_release: /* empty */ { $$= TVL_UNKNOWN; } | RELEASE_SYM { $$= TVL_YES; } | NO_SYM RELEASE_SYM { $$= TVL_NO; } ; opt_savepoint: /* empty */ {} | SAVEPOINT_SYM {} ; commit: COMMIT_SYM opt_work opt_chain opt_release { LEX *lex=Lex; lex->sql_command= SQLCOM_COMMIT; /* Don't allow AND CHAIN RELEASE. */ MYSQL_YYABORT_UNLESS($3 != TVL_YES || $4 != TVL_YES); lex->tx_chain= $3; lex->tx_release= $4; } ; rollback: ROLLBACK_SYM opt_work opt_chain opt_release { LEX *lex=Lex; lex->sql_command= SQLCOM_ROLLBACK; /* Don't allow AND CHAIN RELEASE. */ MYSQL_YYABORT_UNLESS($3 != TVL_YES || $4 != TVL_YES); lex->tx_chain= $3; lex->tx_release= $4; } | ROLLBACK_SYM opt_work TO_SYM opt_savepoint ident { LEX *lex=Lex; lex->sql_command= SQLCOM_ROLLBACK_TO_SAVEPOINT; lex->ident= $5; } ; savepoint: SAVEPOINT_SYM ident { LEX *lex=Lex; lex->sql_command= SQLCOM_SAVEPOINT; lex->ident= $2; } ; release: RELEASE_SYM SAVEPOINT_SYM ident { LEX *lex=Lex; lex->sql_command= SQLCOM_RELEASE_SAVEPOINT; lex->ident= $3; } ; /* UNIONS : glue selects together */ opt_union_clause: /* empty */ { $$= NULL; } | union_list ; union_list: UNION_SYM union_option select_init { $$= NEW_PTN PT_union_list($2, $3); } ; union_opt: /* Empty */ { $$= NULL; } | union_list { $$= $1; } | union_order_or_limit { $$= $1; } ; opt_union_order_or_limit: /* Empty */ { $$= NULL; } | union_order_or_limit { $$= $1; } ; union_order_or_limit: order_or_limit { $$= NEW_PTN PT_union_order_or_limit($1); } ; order_or_limit: order_clause opt_limit_clause { $$= NEW_PTN PT_order_or_limit_order($1, $2); } | limit_clause { $$= $1; } ; union_option: /* empty */ { $$=1; } | DISTINCT { $$=1; } | ALL { $$=0; } ; query_specification: SELECT_SYM select_part2_derived table_expression { $$= NEW_PTN PT_query_specification_select($1, $2, $3); } | '(' select_paren_derived ')' opt_union_order_or_limit { $$= NEW_PTN PT_query_specification_parenthesis($2, $4); } ; query_expression_body: query_specification | query_expression_body UNION_SYM union_option query_specification { $$= NEW_PTN PT_query_expression_body_union(@$, $1, $3, $4); } ; /* Corresponds to in the SQL:2003 standard. */ subselect: { /* TODO: remove this semantic action (currently this removal adds reduce/reduce conflict) */ } query_expression_body { $$= NEW_PTN PT_subselect(@$, $2); } ; opt_query_spec_options: /* empty */ { $$= 0; } | query_spec_option_list ; query_spec_option_list: query_spec_option_list query_spec_option { $$= $1 | $2; } | query_spec_option ; query_spec_option: STRAIGHT_JOIN { $$= SELECT_STRAIGHT_JOIN; } | HIGH_PRIORITY { $$= SELECT_HIGH_PRIORITY; } | DISTINCT { $$= SELECT_DISTINCT; } | SQL_SMALL_RESULT { $$= SELECT_SMALL_RESULT; } | SQL_BIG_RESULT { $$= SELECT_BIG_RESULT; } | SQL_BUFFER_RESULT { $$= OPTION_BUFFER_RESULT; } | SQL_CALC_FOUND_ROWS { $$= OPTION_FOUND_ROWS; } | ALL { $$= SELECT_ALL; } ; /************************************************************************** CREATE VIEW | TRIGGER | PROCEDURE statements. **************************************************************************/ view_or_trigger_or_sp_or_event: definer definer_tail {} | no_definer no_definer_tail {} | view_replace_or_algorithm definer_opt view_tail {} ; definer_tail: view_tail | trigger_tail | sp_tail | sf_tail | event_tail ; no_definer_tail: view_tail | trigger_tail | sp_tail | sf_tail | udf_tail | event_tail ; /************************************************************************** DEFINER clause support. **************************************************************************/ definer_opt: no_definer | definer ; no_definer: /* empty */ { /* We have to distinguish missing DEFINER-clause from case when CURRENT_USER specified as definer explicitly in order to properly handle CREATE TRIGGER statements which come to replication thread from older master servers (i.e. to create non-suid trigger in this case). */ YYTHD->lex->definer= 0; } ; definer: DEFINER_SYM EQ user { YYTHD->lex->definer= get_current_user(YYTHD, $3); } ; /************************************************************************** CREATE VIEW statement parts. **************************************************************************/ view_replace_or_algorithm: view_replace {} | view_replace view_algorithm {} | view_algorithm {} ; view_replace: OR_SYM REPLACE { Lex->create_view_mode= VIEW_CREATE_OR_REPLACE; } ; view_algorithm: ALGORITHM_SYM EQ UNDEFINED_SYM { Lex->create_view_algorithm= VIEW_ALGORITHM_UNDEFINED; } | ALGORITHM_SYM EQ MERGE_SYM { Lex->create_view_algorithm= VIEW_ALGORITHM_MERGE; } | ALGORITHM_SYM EQ TEMPTABLE_SYM { Lex->create_view_algorithm= VIEW_ALGORITHM_TEMPTABLE; } ; view_suid: /* empty */ { Lex->create_view_suid= VIEW_SUID_DEFAULT; } | SQL_SYM SECURITY_SYM DEFINER_SYM { Lex->create_view_suid= VIEW_SUID_DEFINER; } | SQL_SYM SECURITY_SYM INVOKER_SYM { Lex->create_view_suid= VIEW_SUID_INVOKER; } ; view_tail: view_suid VIEW_SYM table_ident { THD *thd= YYTHD; LEX *lex= thd->lex; lex->sql_command= SQLCOM_CREATE_VIEW; /* first table in list is target VIEW name */ if (!lex->select_lex->add_table_to_list(thd, $3, NULL, TL_OPTION_UPDATING, TL_IGNORE, MDL_EXCLUSIVE)) MYSQL_YYABORT; lex->query_tables->open_strategy= TABLE_LIST::OPEN_STUB; } view_list_opt AS view_select ; view_list_opt: /* empty */ {} | '(' view_list ')' ; view_list: ident { Lex->view_list.push_back((LEX_STRING*) sql_memdup(&$1, sizeof(LEX_STRING))); } | view_list ',' ident { Lex->view_list.push_back((LEX_STRING*) sql_memdup(&$3, sizeof(LEX_STRING))); } ; view_select: { LEX *lex= Lex; lex->parsing_options.allows_variable= FALSE; lex->parsing_options.allows_select_into= FALSE; lex->parsing_options.allows_select_procedure= FALSE; } view_select_aux view_check_option { THD *thd= YYTHD; LEX *lex= Lex; lex->create_view_select.str= const_cast(@2.cpp.start); size_t len= @3.cpp.end - lex->create_view_select.str; void *create_view_select= thd->memdup(lex->create_view_select.str, len); lex->create_view_select.length= len; lex->create_view_select.str= (char *) create_view_select; trim_whitespace(thd->charset(), &lex->create_view_select); lex->parsing_options.allows_variable= TRUE; lex->parsing_options.allows_select_into= TRUE; lex->parsing_options.allows_select_procedure= TRUE; } ; view_select_aux: create_view_select { if (Lex->current_select()->set_braces(0)) { my_syntax_error(ER(ER_SYNTAX_ERROR)); MYSQL_YYABORT; } /* For statment as "CREATE VIEW v1 AS SELECT1 UNION SELECT2", parsing of Select query (SELECT1) is completed and UNION_CLAUSE is not yet parsed. So check for Lex->current_select()->master_unit()->first_select()->braces (as its done in "PT_select_init2::contextualize()) is not done here. */ } opt_union_clause { if ($3 != NULL) CONTEXTUALIZE($3); } | '(' create_view_select_paren ')' union_opt { if ($4 != NULL) CONTEXTUALIZE($4); } ; create_view_select_paren: { Lex->current_select()->set_braces(true); } create_view_select { if (setup_select_in_parentheses(Select)) MYSQL_YYABORT; } | '(' create_view_select_paren ')' ; create_view_select: SELECT_SYM { Lex->current_select()->table_list.save_and_clear(&Lex->save_list); } select_part2 { CONTEXTUALIZE($3); Lex->current_select()->table_list.push_front(&Lex->save_list); } ; view_check_option: /* empty */ { Lex->create_view_check= VIEW_CHECK_NONE; } | WITH CHECK_SYM OPTION { Lex->create_view_check= VIEW_CHECK_CASCADED; } | WITH CASCADED CHECK_SYM OPTION { Lex->create_view_check= VIEW_CHECK_CASCADED; } | WITH LOCAL_SYM CHECK_SYM OPTION { Lex->create_view_check= VIEW_CHECK_LOCAL; } ; /************************************************************************** CREATE TRIGGER statement parts. **************************************************************************/ trigger_action_order: FOLLOWS_SYM { $$= TRG_ORDER_FOLLOWS; } | PRECEDES_SYM { $$= TRG_ORDER_PRECEDES; } ; trigger_follows_precedes_clause: /* empty */ { $$.ordering_clause= TRG_ORDER_NONE; $$.anchor_trigger_name.str= NULL; $$.anchor_trigger_name.length= 0; } | trigger_action_order ident_or_text { $$.ordering_clause= $1; $$.anchor_trigger_name= $2; } ; trigger_tail: TRIGGER_SYM /* $1 */ sp_name /* $2 */ trg_action_time /* $3 */ trg_event /* $4 */ ON /* $5 */ table_ident /* $6 */ FOR_SYM /* $7 */ EACH_SYM /* $8 */ ROW_SYM /* $9 */ trigger_follows_precedes_clause /* $10 */ { /* $11 */ THD *thd= YYTHD; LEX *lex= thd->lex; if (lex->sphead) { my_error(ER_SP_NO_RECURSIVE_CREATE, MYF(0), "TRIGGER"); MYSQL_YYABORT; } lex->raw_trg_on_table_name_begin= @5.raw.start; lex->raw_trg_on_table_name_end= @7.raw.start; if (@10.is_empty()) { /* @10.is_empty() is true when a clause PRECEDES/FOLLOWS is absent. */ lex->trg_ordering_clause_begin= NULL; lex->trg_ordering_clause_end= NULL; } else { lex->trg_ordering_clause_begin= @10.cpp.start; lex->trg_ordering_clause_end= @10.cpp.end; } sp_head *sp= sp_start_parsing(thd, SP_TYPE_TRIGGER, $2); if (!sp) MYSQL_YYABORT; sp->m_trg_chistics.action_time= (enum enum_trigger_action_time_type) $3; sp->m_trg_chistics.event= (enum enum_trigger_event_type) $4; sp->m_trg_chistics.ordering_clause= $10.ordering_clause; sp->m_trg_chistics.anchor_trigger_name= $10.anchor_trigger_name; lex->stmt_definition_begin= @1.cpp.start; lex->ident.str= const_cast(@6.cpp.start); lex->ident.length= @8.cpp.start - @6.cpp.start; lex->sphead= sp; lex->spname= $2; memset(&lex->sp_chistics, 0, sizeof(st_sp_chistics)); sp->m_chistics= &lex->sp_chistics; sp->set_body_start(thd, @9.cpp.end); } sp_proc_stmt /* $12 */ { /* $13 */ THD *thd= YYTHD; LEX *lex= Lex; sp_head *sp= lex->sphead; sp_finish_parsing(thd); lex->sql_command= SQLCOM_CREATE_TRIGGER; if (sp->is_not_allowed_in_function("trigger")) MYSQL_YYABORT; /* We have to do it after parsing trigger body, because some of sp_proc_stmt alternatives are not saving/restoring LEX, so lex->query_tables can be wiped out. */ if (!lex->select_lex->add_table_to_list(thd, $6, (LEX_STRING*) 0, TL_OPTION_UPDATING, TL_READ_NO_INSERT, MDL_SHARED_NO_WRITE)) MYSQL_YYABORT; } ; /************************************************************************** CREATE FUNCTION | PROCEDURE statements parts. **************************************************************************/ udf_tail: AGGREGATE_SYM FUNCTION_SYM ident RETURNS_SYM udf_type SONAME_SYM TEXT_STRING_sys { THD *thd= YYTHD; LEX *lex= thd->lex; if (is_native_function(thd, & $3)) { my_error(ER_NATIVE_FCT_NAME_COLLISION, MYF(0), $3.str); MYSQL_YYABORT; } lex->sql_command = SQLCOM_CREATE_FUNCTION; lex->udf.type= UDFTYPE_AGGREGATE; lex->stmt_definition_begin= @2.cpp.start; lex->udf.name = $3; lex->udf.returns=(Item_result) $5; lex->udf.dl=$7.str; } | FUNCTION_SYM ident RETURNS_SYM udf_type SONAME_SYM TEXT_STRING_sys { THD *thd= YYTHD; LEX *lex= thd->lex; if (is_native_function(thd, & $2)) { my_error(ER_NATIVE_FCT_NAME_COLLISION, MYF(0), $2.str); MYSQL_YYABORT; } lex->sql_command = SQLCOM_CREATE_FUNCTION; lex->udf.type= UDFTYPE_FUNCTION; lex->stmt_definition_begin= @1.cpp.start; lex->udf.name = $2; lex->udf.returns=(Item_result) $4; lex->udf.dl=$6.str; } ; sf_tail: FUNCTION_SYM /* $1 */ sp_name /* $2 */ '(' /* $3 */ { /* $4 */ THD *thd= YYTHD; LEX *lex= thd->lex; lex->stmt_definition_begin= @1.cpp.start; lex->spname= $2; if (lex->sphead) { my_error(ER_SP_NO_RECURSIVE_CREATE, MYF(0), "FUNCTION"); MYSQL_YYABORT; } sp_head *sp= sp_start_parsing(thd, SP_TYPE_FUNCTION, lex->spname); if (!sp) MYSQL_YYABORT; lex->sphead= sp; sp->m_parser_data.set_parameter_start_ptr(@3.cpp.end); } sp_fdparam_list /* $5 */ ')' /* $6 */ { /* $7 */ Lex->sphead->m_parser_data.set_parameter_end_ptr(@6.cpp.start); } RETURNS_SYM /* $8 */ { /* $9 */ LEX *lex= Lex; lex->charset= NULL; lex->length= lex->dec= NULL; lex->interval_list.empty(); lex->type= 0; lex->gcol_info= 0; } type_with_opt_collate /* $10 */ { /* $11 */ LEX *lex= Lex; sp_head *sp= lex->sphead; /* This was disabled in 5.1.12. See bug #20701 When collation support in SP is implemented, then this test should be removed. */ if (($10 == MYSQL_TYPE_STRING || $10 == MYSQL_TYPE_VARCHAR) && (lex->type & BINCMP_FLAG)) { my_error(ER_NOT_SUPPORTED_YET, MYF(0), "return value collation"); MYSQL_YYABORT; } if (fill_field_definition(YYTHD, sp, (enum enum_field_types) $10, &sp->m_return_field_def)) MYSQL_YYABORT; memset(&lex->sp_chistics, 0, sizeof(st_sp_chistics)); } sp_c_chistics /* $12 */ { /* $13 */ THD *thd= YYTHD; LEX *lex= thd->lex; lex->sphead->m_chistics= &lex->sp_chistics; lex->sphead->set_body_start(thd, yylloc.cpp.start); } sp_proc_stmt /* $14 */ { THD *thd= YYTHD; LEX *lex= thd->lex; sp_head *sp= lex->sphead; if (sp->is_not_allowed_in_function("function")) MYSQL_YYABORT; sp_finish_parsing(thd); lex->sql_command= SQLCOM_CREATE_SPFUNCTION; if (!(sp->m_flags & sp_head::HAS_RETURN)) { my_error(ER_SP_NORETURN, MYF(0), sp->m_qname.str); MYSQL_YYABORT; } if (is_native_function(thd, & sp->m_name)) { /* This warning will be printed when [1] A client query is parsed, [2] A stored function is loaded by db_load_routine. Printing the warning for [2] is intentional, to cover the following scenario: - A user define a SF 'foo' using MySQL 5.N - An application uses select foo(), and works. - MySQL 5.{N+1} defines a new native function 'foo', as part of a new feature. - MySQL 5.{N+1} documentation is updated, and should mention that there is a potential incompatible change in case of existing stored function named 'foo'. - The user deploys 5.{N+1}. At this point, 'select foo()' means something different, and the user code is most likely broken (it's only safe if the code is 'select db.foo()'). With a warning printed when the SF is loaded (which has to occur before the call), the warning will provide a hint explaining the root cause of a later failure of 'select foo()'. With no warning printed, the user code will fail with no apparent reason. Printing a warning each time db_load_routine is executed for an ambiguous function is annoying, since that can happen a lot, but in practice should not happen unless there *are* name collisions. If a collision exists, it should not be silenced but fixed. */ push_warning_printf(thd, Sql_condition::SL_NOTE, ER_NATIVE_FCT_NAME_COLLISION, ER(ER_NATIVE_FCT_NAME_COLLISION), sp->m_name.str); } } ; sp_tail: PROCEDURE_SYM /*$1*/ sp_name /*$2*/ { /*$3*/ THD *thd= YYTHD; LEX *lex= Lex; if (lex->sphead) { my_error(ER_SP_NO_RECURSIVE_CREATE, MYF(0), "PROCEDURE"); MYSQL_YYABORT; } lex->stmt_definition_begin= @2.cpp.start; sp_head *sp= sp_start_parsing(thd, SP_TYPE_PROCEDURE, $2); if (!sp) MYSQL_YYABORT; lex->sphead= sp; } '(' /*$4*/ { /*$5*/ Lex->sphead->m_parser_data.set_parameter_start_ptr(@4.cpp.end); } sp_pdparam_list /*$6*/ ')' /*$7*/ { /*$8*/ THD *thd= YYTHD; LEX *lex= thd->lex; lex->sphead->m_parser_data.set_parameter_end_ptr(@7.cpp.start); memset(&lex->sp_chistics, 0, sizeof(st_sp_chistics)); } sp_c_chistics /*$9*/ { /*$10*/ THD *thd= YYTHD; LEX *lex= thd->lex; lex->sphead->m_chistics= &lex->sp_chistics; lex->sphead->set_body_start(thd, yylloc.cpp.start); } sp_proc_stmt /*$11*/ { /*$12*/ THD *thd= YYTHD; LEX *lex= Lex; sp_finish_parsing(thd); lex->sql_command= SQLCOM_CREATE_PROCEDURE; } ; /*************************************************************************/ xa: XA_SYM begin_or_start xid opt_join_or_resume { Lex->sql_command = SQLCOM_XA_START; Lex->m_sql_cmd= new (YYTHD->mem_root) Sql_cmd_xa_start($3, $4); } | XA_SYM END xid opt_suspend { Lex->sql_command = SQLCOM_XA_END; Lex->m_sql_cmd= new (YYTHD->mem_root) Sql_cmd_xa_end($3, $4); } | XA_SYM PREPARE_SYM xid { Lex->sql_command = SQLCOM_XA_PREPARE; Lex->m_sql_cmd= new (YYTHD->mem_root) Sql_cmd_xa_prepare($3); } | XA_SYM COMMIT_SYM xid opt_one_phase { Lex->sql_command = SQLCOM_XA_COMMIT; Lex->m_sql_cmd= new (YYTHD->mem_root) Sql_cmd_xa_commit($3, $4); } | XA_SYM ROLLBACK_SYM xid { Lex->sql_command = SQLCOM_XA_ROLLBACK; Lex->m_sql_cmd= new (YYTHD->mem_root) Sql_cmd_xa_rollback($3); } | XA_SYM RECOVER_SYM opt_convert_xid { Lex->sql_command = SQLCOM_XA_RECOVER; Lex->m_sql_cmd= new (YYTHD->mem_root) Sql_cmd_xa_recover($3); } ; opt_convert_xid: /* empty */ { $$= false; } | CONVERT_SYM XID_SYM { $$= true; } xid: text_string { MYSQL_YYABORT_UNLESS($1->length() <= MAXGTRIDSIZE); XID *xid; if (!(xid= (XID *)YYTHD->alloc(sizeof(XID)))) MYSQL_YYABORT; xid->set(1L, $1->ptr(), $1->length(), 0, 0); $$= xid; } | text_string ',' text_string { MYSQL_YYABORT_UNLESS($1->length() <= MAXGTRIDSIZE && $3->length() <= MAXBQUALSIZE); XID *xid; if (!(xid= (XID *)YYTHD->alloc(sizeof(XID)))) MYSQL_YYABORT; xid->set(1L, $1->ptr(), $1->length(), $3->ptr(), $3->length()); $$= xid; } | text_string ',' text_string ',' ulong_num { // check for overwflow of xid format id bool format_id_overflow_detected= ($5 > LONG_MAX); MYSQL_YYABORT_UNLESS($1->length() <= MAXGTRIDSIZE && $3->length() <= MAXBQUALSIZE && !format_id_overflow_detected); XID *xid; if (!(xid= (XID *)YYTHD->alloc(sizeof(XID)))) MYSQL_YYABORT; xid->set($5, $1->ptr(), $1->length(), $3->ptr(), $3->length()); $$= xid; } ; begin_or_start: BEGIN_SYM {} | START_SYM {} ; opt_join_or_resume: /* nothing */ { $$= XA_NONE; } | JOIN_SYM { $$= XA_JOIN; } | RESUME_SYM { $$= XA_RESUME; } ; opt_one_phase: /* nothing */ { $$= XA_NONE; } | ONE_SYM PHASE_SYM { $$= XA_ONE_PHASE; } ; opt_suspend: /* nothing */ { $$= XA_NONE; } | SUSPEND_SYM { $$= XA_SUSPEND; } | SUSPEND_SYM FOR_SYM MIGRATE_SYM { $$= XA_FOR_MIGRATE; } ; install: INSTALL_SYM PLUGIN_SYM ident SONAME_SYM TEXT_STRING_sys { LEX *lex= Lex; lex->sql_command= SQLCOM_INSTALL_PLUGIN; lex->m_sql_cmd= new Sql_cmd_install_plugin($3, $5); } ; uninstall: UNINSTALL_SYM PLUGIN_SYM ident { LEX *lex= Lex; lex->sql_command= SQLCOM_UNINSTALL_PLUGIN; lex->m_sql_cmd= new Sql_cmd_uninstall_plugin($3); } ; /** @} (end of group Parser) */