1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Backport of:

Browse Source 
------------------------------------------------------------
revno: 2617.68.25
committer: Dmitry Lenev <dlenev@mysql.com>
branch nick: mysql-next-bg-pre2-2
timestamp: Wed 2009-09-16 18:26:50 +0400
message:
  Follow-up for one of pre-requisite patches for fixing bug #30977
  "Concurrent statement using stored function and DROP FUNCTION
  breaks SBR".

  Made enum_mdl_namespace enum part of MDL_key class and removed MDL_
  prefix from the names of enum members. In order to do the latter
  changed name of PROCEDURE symbol to PROCEDURE_SYM (otherwise macro
  which was automatically generated for this symbol conflicted with
  MDL_key::PROCEDURE enum member).
This commit is contained in:
Konstantin Osipov 2009-12-10 11:21:38 +03:00
parent 4f85df4b95
commit 2e73ea7ea8
16 changed files with 72 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sql/lex.h
View File

@ -416,7 +416,7 @@ static SYMBOL symbols[] = {
{ "PREV", SYM(PREV_SYM)}, { "PREV", SYM(PREV_SYM)},
{ "PRIMARY", SYM(PRIMARY_SYM)}, { "PRIMARY", SYM(PRIMARY_SYM)},
{ "PRIVILEGES", SYM(PRIVILEGES)}, { "PRIVILEGES", SYM(PRIVILEGES)},
{ "PROCEDURE", SYM(PROCEDURE)}, { "PROCEDURE", SYM(PROCEDURE_SYM)},
{ "PROCESS" , SYM(PROCESS)}, { "PROCESS" , SYM(PROCESS)},
{ "PROCESSLIST", SYM(PROCESSLIST_SYM)}, { "PROCESSLIST", SYM(PROCESSLIST_SYM)},
{ "PROFILE", SYM(PROFILE_SYM)}, { "PROFILE", SYM(PROFILE_SYM)},

3
sql/lock.cc
View File

@ -957,7 +957,8 @@ bool lock_table_names(THD *thd, TABLE_LIST *table_list)
for (lock_table= table_list; lock_table; lock_table= lock_table->next_local) for (lock_table= table_list; lock_table; lock_table= lock_table->next_local)
{ {
lock_table->mdl_request.init(MDL_TABLE, lock_table->db, lock_table->table_name, lock_table->mdl_request.init(MDL_key::TABLE,
lock_table->db, lock_table->table_name,
MDL_EXCLUSIVE); MDL_EXCLUSIVE);
mdl_requests.push_front(&lock_table->mdl_request); mdl_requests.push_front(&lock_table->mdl_request);
} }

8
sql/mdl.cc
View File

@ -307,7 +307,7 @@ void MDL_context::merge(MDL_context *src)
@param mdl_type The MDL lock type for the request. @param mdl_type The MDL lock type for the request.
*/ */
void MDL_request::init(enum_mdl_namespace mdl_namespace, void MDL_request::init(MDL_key::enum_mdl_namespace mdl_namespace,
const char *db_arg, const char *db_arg,
const char *name_arg, const char *name_arg,
enum enum_mdl_type mdl_type_arg) enum enum_mdl_type mdl_type_arg)
@ -355,7 +355,7 @@ void MDL_request::init(const MDL_key *key_arg,
*/ */
MDL_request * MDL_request *
MDL_request::create(enum_mdl_namespace mdl_namespace, const char *db, MDL_request::create(MDL_key::enum_mdl_namespace mdl_namespace, const char *db,
const char *name, enum_mdl_type mdl_type, const char *name, enum_mdl_type mdl_type,
MEM_ROOT *root) MEM_ROOT *root)
{ {
@ -1444,7 +1444,7 @@ void MDL_context::release_global_shared_lock()
*/ */
bool bool
MDL_context::is_exclusive_lock_owner(enum_mdl_namespace mdl_namespace, MDL_context::is_exclusive_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
const char *db, const char *name) const char *db, const char *name)
{ {
MDL_request mdl_request; MDL_request mdl_request;
@ -1470,7 +1470,7 @@ MDL_context::is_exclusive_lock_owner(enum_mdl_namespace mdl_namespace,
*/ */
bool bool
MDL_context::is_lock_owner(enum_mdl_namespace mdl_namespace, MDL_context::is_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
const char *db, const char *name) const char *db, const char *name)
{ {
MDL_key key(mdl_namespace, db, name); MDL_key key(mdl_namespace, db, name);

45
sql/mdl.h
View File

@ -47,20 +47,6 @@ enum enum_mdl_type {MDL_SHARED=0, MDL_SHARED_HIGH_PRIO,
enum enum_mdl_state { MDL_PENDING, MDL_ACQUIRED }; enum enum_mdl_state { MDL_PENDING, MDL_ACQUIRED };
/**
Object namespaces
Different types of objects exist in different namespaces
- MDL_TABLE is for tables and views.
- MDL_FUNCTION is for stored functions.
- MDL_PROCEDURE is for stored procedures.
- MDL_TRIGGER is for triggers.
Note that although there isn't metadata locking on triggers,
it's necessary to have a separate namespace for them since
MDL_key is also used outside of the MDL subsystem.
*/
enum enum_mdl_namespace { MDL_TABLE=0, MDL_FUNCTION, MDL_PROCEDURE, MDL_TRIGGER };
/** Maximal length of key for metadata locking subsystem. */ /** Maximal length of key for metadata locking subsystem. */
#define MAX_MDLKEY_LENGTH (1 + NAME_LEN + 1 + NAME_LEN + 1) #define MAX_MDLKEY_LENGTH (1 + NAME_LEN + 1 + NAME_LEN + 1)
@ -77,6 +63,23 @@ enum enum_mdl_namespace { MDL_TABLE=0, MDL_FUNCTION, MDL_PROCEDURE, MDL_TRIGGER
class MDL_key class MDL_key
{ {
public: public:
/**
Object namespaces
Different types of objects exist in different namespaces
- TABLE is for tables and views.
- FUNCTION is for stored functions.
- PROCEDURE is for stored procedures.
- TRIGGER is for triggers.
Note that although there isn't metadata locking on triggers,
it's necessary to have a separate namespace for them since
MDL_key is also used outside of the MDL subsystem.
*/
enum enum_mdl_namespace { TABLE=0,
FUNCTION,
PROCEDURE,
TRIGGER };
const uchar *ptr() const { return (uchar*) m_ptr; } const uchar *ptr() const { return (uchar*) m_ptr; }
uint length() const { return m_length; } uint length() const { return m_length; }
@ -185,7 +188,8 @@ public:
MDL_key key; MDL_key key;
public: public:
void init(enum_mdl_namespace namespace_arg, const char *db_arg, const char *name_arg, void init(MDL_key::enum_mdl_namespace namespace_arg,
const char *db_arg, const char *name_arg,
enum_mdl_type mdl_type_arg); enum_mdl_type mdl_type_arg);
void init(const MDL_key *key_arg, enum_mdl_type mdl_type_arg); void init(const MDL_key *key_arg, enum_mdl_type mdl_type_arg);
/** Set type of lock request. Can be only applied to pending locks. */ /** Set type of lock request. Can be only applied to pending locks. */
@ -196,9 +200,9 @@ public:
} }
bool is_shared() const { return type < MDL_EXCLUSIVE; } bool is_shared() const { return type < MDL_EXCLUSIVE; }
static MDL_request *create(enum_mdl_namespace mdl_namespace, const char *db, static MDL_request *create(MDL_key::enum_mdl_namespace mdl_namespace,
const char *name, enum_mdl_type mdl_type, const char *db, const char *name,
MEM_ROOT *root); enum_mdl_type mdl_type, MEM_ROOT *root);
/* /*
This is to work around the ugliness of TABLE_LIST This is to work around the ugliness of TABLE_LIST
@ -340,10 +344,11 @@ public:
void release_lock(MDL_ticket *ticket); void release_lock(MDL_ticket *ticket);
void release_global_shared_lock(); void release_global_shared_lock();
bool is_exclusive_lock_owner(enum_mdl_namespace mdl_namespace, bool is_exclusive_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
const char *db, const char *db,
const char *name); const char *name);
bool is_lock_owner(enum_mdl_namespace mdl_namespace, const char *db, const char *name); bool is_lock_owner(MDL_key::enum_mdl_namespace mdl_namespace,
const char *db, const char *name);
inline bool has_locks() const inline bool has_locks() const
{ {

3
sql/sp.cc
View File

@ -1473,7 +1473,8 @@ bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
void sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena, void sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
sp_name *rt, char rt_type) sp_name *rt, char rt_type)
{ {
MDL_key key((rt_type == TYPE_ENUM_FUNCTION) ? MDL_FUNCTION : MDL_PROCEDURE, MDL_key key((rt_type == TYPE_ENUM_FUNCTION) ? MDL_key::FUNCTION :
MDL_key::PROCEDURE,
rt->m_db.str, rt->m_name.str); rt->m_db.str, rt->m_name.str);
(void)sp_add_used_routine(prelocking_ctx, arena, &key, 0); (void)sp_add_used_routine(prelocking_ctx, arena, &key, 0);
prelocking_ctx->sroutines_list_own_last= prelocking_ctx->sroutines_list.next; prelocking_ctx->sroutines_list_own_last= prelocking_ctx->sroutines_list.next;

6
sql/sp_head.cc
View File

@ -3975,7 +3975,8 @@ sp_head::add_used_tables_to_table_list(THD *thd,
table->prelocking_placeholder= 1; table->prelocking_placeholder= 1;
table->belong_to_view= belong_to_view; table->belong_to_view= belong_to_view;
table->trg_event_map= stab->trg_event_map; table->trg_event_map= stab->trg_event_map;
table->mdl_request.init(MDL_TABLE, table->db, table->table_name, MDL_SHARED); table->mdl_request.init(MDL_key::TABLE, table->db, table->table_name,
MDL_SHARED);
/* Everyting else should be zeroed */ /* Everyting else should be zeroed */
@ -4017,7 +4018,8 @@ sp_add_to_query_tables(THD *thd, LEX *lex,
table->lock_type= locktype; table->lock_type= locktype;
table->select_lex= lex->current_select; table->select_lex= lex->current_select;
table->cacheable_table= 1; table->cacheable_table= 1;
table->mdl_request.init(MDL_TABLE, table->db, table->table_name, MDL_SHARED); table->mdl_request.init(MDL_key::TABLE, table->db, table->table_name,
MDL_SHARED);
lex->add_to_query_tables(table); lex->add_to_query_tables(table);
return table; return table;

17
sql/sql_base.cc
View File

@ -476,7 +476,7 @@ TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
To be able perform any operation on table we should own To be able perform any operation on table we should own
some kind of metadata lock on it. some kind of metadata lock on it.
*/ */
DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_TABLE, table_list->db, DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, table_list->db,
table_list->table_name)); table_list->table_name));
/* Read table definition from cache */ /* Read table definition from cache */
@ -2546,7 +2546,7 @@ bool open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
TABLES breaks metadata locking protocol (potentially can lead TABLES breaks metadata locking protocol (potentially can lead
to deadlocks) it should be disallowed. to deadlocks) it should be disallowed.
*/ */
if (thd->mdl_context.is_lock_owner(MDL_TABLE, table_list->db, if (thd->mdl_context.is_lock_owner(MDL_key::TABLE, table_list->db,
table_list->table_name)) table_list->table_name))
{ {
char path[FN_REFLEN + 1]; char path[FN_REFLEN + 1];
@ -3781,13 +3781,13 @@ open_and_process_routine(THD *thd, Query_tables_list *prelocking_ctx,
switch (rt->mdl_request.key.mdl_namespace()) switch (rt->mdl_request.key.mdl_namespace())
{ {
case MDL_FUNCTION: case MDL_key::FUNCTION:
case MDL_PROCEDURE: case MDL_key::PROCEDURE:
{ {
char qname_buff[NAME_LEN*2+1+1]; char qname_buff[NAME_LEN*2+1+1];
sp_name name(&rt->mdl_request.key, qname_buff); sp_name name(&rt->mdl_request.key, qname_buff);
sp_head *sp; sp_head *sp;
int type= (rt->mdl_request.key.mdl_namespace() == MDL_FUNCTION) ? int type= (rt->mdl_request.key.mdl_namespace() == MDL_key::FUNCTION) ?
TYPE_ENUM_FUNCTION : TYPE_ENUM_PROCEDURE; TYPE_ENUM_FUNCTION : TYPE_ENUM_PROCEDURE;
if (sp_cache_routine(thd, type, &name, &sp)) if (sp_cache_routine(thd, type, &name, &sp))
@ -3800,7 +3800,7 @@ open_and_process_routine(THD *thd, Query_tables_list *prelocking_ctx,
} }
} }
break; break;
case MDL_TRIGGER: case MDL_key::TRIGGER:
break; break;
default: default:
/* Impossible type value. */ /* Impossible type value. */
@ -4305,7 +4305,7 @@ handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
*/ */
if (rt != (Sroutine_hash_entry*)prelocking_ctx->sroutines_list.first || if (rt != (Sroutine_hash_entry*)prelocking_ctx->sroutines_list.first ||
rt->mdl_request.key.mdl_namespace() != MDL_PROCEDURE) rt->mdl_request.key.mdl_namespace() != MDL_key::PROCEDURE)
{ {
*need_prelocking= TRUE; *need_prelocking= TRUE;
sp_update_stmt_used_routines(thd, prelocking_ctx, &sp->m_sroutines, sp_update_stmt_used_routines(thd, prelocking_ctx, &sp->m_sroutines,
@ -8234,7 +8234,8 @@ void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
safe_mutex_assert_owner(&LOCK_open); safe_mutex_assert_owner(&LOCK_open);
DBUG_ASSERT(remove_type == TDC_RT_REMOVE_UNUSED || DBUG_ASSERT(remove_type == TDC_RT_REMOVE_UNUSED ||
thd->mdl_context.is_exclusive_lock_owner(MDL_TABLE, db, table_name)); thd->mdl_context.is_exclusive_lock_owner(MDL_key::TABLE,
db, table_name));
key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1; key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;

2
sql/sql_delete.cc
View File

@ -1177,7 +1177,7 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
thd->lex->alter_info.flags & ALTER_ADMIN_PARTITION) thd->lex->alter_info.flags & ALTER_ADMIN_PARTITION)
goto trunc_by_del; goto trunc_by_del;
mdl_request.init(MDL_TABLE, table_list->db, table_list->table_name, MDL_EXCLUSIVE); mdl_request.init(MDL_key::TABLE, table_list->db, table_list->table_name, MDL_EXCLUSIVE);
if (thd->mdl_context.acquire_exclusive_lock(&mdl_request)) if (thd->mdl_context.acquire_exclusive_lock(&mdl_request))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);

2
sql/sql_handler.cc
View File

@ -264,7 +264,7 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, bool reopen)
memcpy(hash_tables->db, tables->db, dblen); memcpy(hash_tables->db, tables->db, dblen);
memcpy(hash_tables->table_name, tables->table_name, namelen); memcpy(hash_tables->table_name, tables->table_name, namelen);
memcpy(hash_tables->alias, tables->alias, aliaslen); memcpy(hash_tables->alias, tables->alias, aliaslen);
hash_tables->mdl_request.init(MDL_TABLE, db, name, MDL_SHARED); hash_tables->mdl_request.init(MDL_key::TABLE, db, name, MDL_SHARED);
/* add to hash */ /* add to hash */
if (my_hash_insert(&thd->handler_tables_hash, (uchar*) hash_tables)) if (my_hash_insert(&thd->handler_tables_hash, (uchar*) hash_tables))

2
sql/sql_parse.cc
View File

@ -6024,7 +6024,7 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
ptr->next_name_resolution_table= NULL; ptr->next_name_resolution_table= NULL;
/* Link table in global list (all used tables) */ /* Link table in global list (all used tables) */
lex->add_to_query_tables(ptr); lex->add_to_query_tables(ptr);
ptr->mdl_request.init(MDL_TABLE, ptr->db, ptr->table_name, MDL_SHARED); ptr->mdl_request.init(MDL_key::TABLE, ptr->db, ptr->table_name, MDL_SHARED);
DBUG_RETURN(ptr); DBUG_RETURN(ptr);
} }

2
sql/sql_show.cc
View File

@ -3081,7 +3081,7 @@ try_acquire_high_prio_shared_mdl_lock(THD *thd, TABLE_LIST *table,
bool can_deadlock) bool can_deadlock)
{ {
bool error; bool error;
table->mdl_request.init(MDL_TABLE, table->db, table->table_name, table->mdl_request.init(MDL_key::TABLE, table->db, table->table_name,
MDL_SHARED_HIGH_PRIO); MDL_SHARED_HIGH_PRIO);
while (!(error= while (!(error=
thd->mdl_context.try_acquire_shared_lock(&table->mdl_request)) && thd->mdl_context.try_acquire_shared_lock(&table->mdl_request)) &&

10
sql/sql_table.cc
View File

@ -4140,7 +4140,7 @@ bool mysql_create_table(THD *thd, const char *db, const char *table_name,
if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE)) if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
{ {
target_mdl_request.init(MDL_TABLE, db, table_name, MDL_EXCLUSIVE); target_mdl_request.init(MDL_key::TABLE, db, table_name, MDL_EXCLUSIVE);
if (thd->mdl_context.try_acquire_exclusive_lock(&target_mdl_request)) if (thd->mdl_context.try_acquire_exclusive_lock(&target_mdl_request))
{ {
result= TRUE; result= TRUE;
@ -4361,7 +4361,8 @@ static int prepare_for_repair(THD *thd, TABLE_LIST *table_list,
uint key_length; uint key_length;
key_length= create_table_def_key(thd, key, table_list, 0); key_length= create_table_def_key(thd, key, table_list, 0);
table_list->mdl_request.init(MDL_TABLE, table_list->db, table_list->table_name, table_list->mdl_request.init(MDL_key::TABLE,
table_list->db, table_list->table_name,
MDL_EXCLUSIVE); MDL_EXCLUSIVE);
if (thd->mdl_context.acquire_exclusive_lock(&table_list->mdl_request)) if (thd->mdl_context.acquire_exclusive_lock(&table_list->mdl_request))
DBUG_RETURN(0); DBUG_RETURN(0);
@ -5271,7 +5272,7 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table, TABLE_LIST* src_table,
} }
else else
{ {
table->mdl_request.init(MDL_TABLE, db, table_name, MDL_EXCLUSIVE); table->mdl_request.init(MDL_key::TABLE, db, table_name, MDL_EXCLUSIVE);
if (thd->mdl_context.try_acquire_exclusive_lock(&table->mdl_request)) if (thd->mdl_context.try_acquire_exclusive_lock(&table->mdl_request))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
@ -6637,7 +6638,8 @@ view_err:
} }
else else
{ {
target_mdl_request.init(MDL_TABLE, new_db, new_name, MDL_EXCLUSIVE); target_mdl_request.init(MDL_key::TABLE, new_db, new_name,
MDL_EXCLUSIVE);
if (thd->mdl_context.try_acquire_exclusive_lock(&target_mdl_request)) if (thd->mdl_context.try_acquire_exclusive_lock(&target_mdl_request))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
if (target_mdl_request.ticket == NULL) if (target_mdl_request.ticket == NULL)

4
sql/sql_trigger.cc
View File

@ -1888,7 +1888,7 @@ bool Table_triggers_list::change_table_name(THD *thd, const char *db,
In the future, only an exclusive metadata lock will be enough. In the future, only an exclusive metadata lock will be enough.
*/ */
#ifndef DBUG_OFF #ifndef DBUG_OFF
if (thd->mdl_context.is_exclusive_lock_owner(MDL_TABLE, db, old_table)) if (thd->mdl_context.is_exclusive_lock_owner(MDL_key::TABLE, db, old_table))
safe_mutex_assert_owner(&LOCK_open); safe_mutex_assert_owner(&LOCK_open);
#endif #endif
@ -2057,7 +2057,7 @@ add_tables_and_routines_for_triggers(THD *thd,
if (trigger) if (trigger)
{ {
MDL_key key(MDL_TRIGGER, trigger->m_db.str, trigger->m_name.str); MDL_key key(MDL_key::TRIGGER, trigger->m_db.str, trigger->m_name.str);
if (sp_add_used_routine(prelocking_ctx, thd->stmt_arena, if (sp_add_used_routine(prelocking_ctx, thd->stmt_arena,
&key, table_list->belong_to_view)) &key, table_list->belong_to_view))

20
sql/sql_yacc.yy
View File

@ -922,7 +922,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%token PREV_SYM %token PREV_SYM
%token PRIMARY_SYM /* SQL-2003-R */ %token PRIMARY_SYM /* SQL-2003-R */
%token PRIVILEGES /* SQL-2003-N */ %token PRIVILEGES /* SQL-2003-N */
%token PROCEDURE /* SQL-2003-R */ %token PROCEDURE_SYM /* SQL-2003-R */
%token PROCESS %token PROCESS
%token PROCESSLIST_SYM %token PROCESSLIST_SYM
%token PROFILE_SYM %token PROFILE_SYM
@ -5807,7 +5807,7 @@ alter:
lex->sql_command= SQLCOM_ALTER_DB_UPGRADE; lex->sql_command= SQLCOM_ALTER_DB_UPGRADE;
lex->name= $3; lex->name= $3;
} }
| ALTER PROCEDURE sp_name | ALTER PROCEDURE_SYM sp_name
{ {
LEX *lex= Lex; LEX *lex= Lex;
@ -9439,7 +9439,7 @@ dec_num:
procedure_clause: procedure_clause:
/* empty */ /* empty */
| PROCEDURE ident /* Procedure name */ | PROCEDURE_SYM ident /* Procedure name */
{ {
LEX *lex=Lex; LEX *lex=Lex;
@ -9695,7 +9695,7 @@ drop:
spname->init_qname(thd); spname->init_qname(thd);
lex->spname= spname; lex->spname= spname;
} }
| DROP PROCEDURE if_exists sp_name | DROP PROCEDURE_SYM if_exists sp_name
{ {
LEX *lex=Lex; LEX *lex=Lex;
if (lex->sphead) if (lex->sphead)
@ -10446,7 +10446,7 @@ show_param:
{ {
Lex->sql_command = SQLCOM_SHOW_SLAVE_STAT; Lex->sql_command = SQLCOM_SHOW_SLAVE_STAT;
} }
| CREATE PROCEDURE sp_name | CREATE PROCEDURE_SYM sp_name
{ {
LEX *lex= Lex; LEX *lex= Lex;
@ -10466,7 +10466,7 @@ show_param:
lex->sql_command= SQLCOM_SHOW_CREATE_TRIGGER; lex->sql_command= SQLCOM_SHOW_CREATE_TRIGGER;
lex->spname= $3; lex->spname= $3;
} }
| PROCEDURE STATUS_SYM wild_and_where | PROCEDURE_SYM STATUS_SYM wild_and_where
{ {
LEX *lex= Lex; LEX *lex= Lex;
lex->sql_command= SQLCOM_SHOW_STATUS_PROC; lex->sql_command= SQLCOM_SHOW_STATUS_PROC;
@ -10480,7 +10480,7 @@ show_param:
if (prepare_schema_table(YYTHD, lex, 0, SCH_PROCEDURES)) if (prepare_schema_table(YYTHD, lex, 0, SCH_PROCEDURES))
MYSQL_YYABORT; MYSQL_YYABORT;
} }
| PROCEDURE CODE_SYM sp_name | PROCEDURE_SYM CODE_SYM sp_name
{ {
Lex->sql_command= SQLCOM_SHOW_PROC_CODE; Lex->sql_command= SQLCOM_SHOW_PROC_CODE;
Lex->spname= $3; Lex->spname= $3;
@ -12671,7 +12671,7 @@ revoke_command:
lex->sql_command= SQLCOM_REVOKE; lex->sql_command= SQLCOM_REVOKE;
lex->type= TYPE_ENUM_FUNCTION; lex->type= TYPE_ENUM_FUNCTION;
} }
| grant_privileges ON PROCEDURE grant_ident FROM grant_list | grant_privileges ON PROCEDURE_SYM grant_ident FROM grant_list
{ {
LEX *lex= Lex; LEX *lex= Lex;
if (lex->columns.elements) if (lex->columns.elements)
@ -12713,7 +12713,7 @@ grant_command:
lex->sql_command= SQLCOM_GRANT; lex->sql_command= SQLCOM_GRANT;
lex->type= TYPE_ENUM_FUNCTION; lex->type= TYPE_ENUM_FUNCTION;
} }
| grant_privileges ON PROCEDURE grant_ident TO_SYM grant_list | grant_privileges ON PROCEDURE_SYM grant_ident TO_SYM grant_list
require_clause grant_options require_clause grant_options
{ {
LEX *lex= Lex; LEX *lex= Lex;
@ -13721,7 +13721,7 @@ sf_tail:
; ;
sp_tail: sp_tail:
PROCEDURE remember_name sp_name PROCEDURE_SYM remember_name sp_name
{ {
LEX *lex= Lex; LEX *lex= Lex;
sp_head *sp; sp_head *sp;

3
sql/table.cc
View File

@ -4822,7 +4822,8 @@ size_t max_row_length(TABLE *table, const uchar *data)
void init_mdl_requests(TABLE_LIST *table_list) void init_mdl_requests(TABLE_LIST *table_list)
{ {
for ( ; table_list ; table_list= table_list->next_global) for ( ; table_list ; table_list= table_list->next_global)
table_list->mdl_request.init(MDL_TABLE, table_list->db, table_list->table_name, table_list->mdl_request.init(MDL_key::TABLE,
table_list->db, table_list->table_name,
MDL_SHARED); MDL_SHARED);
} }

2
sql/table.h
View File

@ -1125,7 +1125,7 @@ struct TABLE_LIST
table_name_length= table_name_length_arg; table_name_length= table_name_length_arg;
alias= (char*) alias_arg; alias= (char*) alias_arg;
lock_type= lock_type_arg; lock_type= lock_type_arg;
mdl_request.init(MDL_TABLE, db, table_name, MDL_SHARED); mdl_request.init(MDL_key::TABLE, db, table_name, MDL_SHARED);
} }
/* /*