database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-30 16:24:05 +03:00
Code Activity

Backport of:

Browse Source 
------------------------------------------------------------
revno: 2630.4.20
committer: Dmitry Lenev <dlenev@mysql.com>
branch nick: mysql-6.0-3726-w2
timestamp: Wed 2008-06-04 16:27:06 +0400
message:
  WL#3726 "DDL locking for all metadata objects"

  After review fixes in progress.

  Got rid of TABLE_LIST::mdl_upgradable member and related functions
  by using special flag which to be passed to open_table() which
  asks it to take upgradable metadata lock on table being opened.


sql/mysql_priv.h:
  Added one more argument to open_n_lock_single_table() call to be
  able to pass flags to open_table() and mysql_lock_tables() called
  by it.
  Added new flag for controlling open_table() behavior asks it to
  take upgradable metadata locks on tables open for write.
sql/sql_base.cc:
  Added new flag for controlling open_table() behavior asks it to
  take upgradable metadata locks on tables open for write.
  This allowed us to get rid of TABLE_LIST::mdl_upgradable member.
  Added one more argument to open_n_lock_single_table() call to be
  able to pass flags to open_table() and mysql_lock_tables() called
  by it.
sql/sql_insert.cc:
  Added one more argument to open_n_lock_single_table() call to be
  able to pass flags to open_table() and mysql_lock_tables() called
  by it.
sql/sql_parse.cc:
  Got rid of TABLE_LIST::mdl_upgradable member by using special flag
  which to be passed to open_table() which asks it to take
  upgradable metadata lock on table being opened.  As result also
  got rid of adjust_mdl_locks_upgradability() function.
sql/sql_table.cc:
  Got rid of TABLE_LIST::mdl_upgradable member and related functions
  by using special flag which to be passed to open_table() which
  asks it to take upgradable metadata lock on table being opened.
sql/sql_view.cc:
  Got rid of TABLE_LIST::mdl_upgradable member and related functions
  by using special flag which to be passed to open_table() which
  asks it to take upgradable metadata lock on table being opened.
sql/table.h:
  Got rid of TABLE_LIST::mdl_upgradable member and related functions
  by using special flag which to be passed to open_table() which
  asks it to take upgradable metadata lock on table being opened.
This commit is contained in:
Konstantin Osipov
2009-12-01 16:38:00 +03:00
parent 1ed585adff
commit 93b55a006d
7 changed files with 19 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
sql/mysql_priv.h
View File

@ -1488,7 +1488,7 @@ inline int open_and_lock_tables(THD *thd, TABLE_LIST *tables)
}
/* simple open_and_lock_tables without derived handling for single table */
TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
thr_lock_type lock_type);
thr_lock_type lock_type, uint flags);
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags);
int lock_tables(THD *thd, TABLE_LIST *tables, uint counter, uint flags,
bool *need_reopen);
@ -2040,6 +2040,7 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **table, uint count,
#define MYSQL_OPEN_TEMPORARY_ONLY 0x0004
#define MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY 0x0008
#define MYSQL_LOCK_PERF_SCHEMA 0x0010
#define MYSQL_OPEN_TAKE_UPGRADABLE_MDL 0x0020
void mysql_unlock_tables(THD *thd, MYSQL_LOCK *sql_lock);
void mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock);

13
sql/sql_base.cc
View File

@ -2598,6 +2598,9 @@ void table_share_release_hook(void *share)
No version number checking is done.
MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
table not the base table or view.
MYSQL_OPEN_TAKE_UPGRADABLE_MDL - Obtain upgradable
metadata lock for tables on which we are going to
take some kind of write table-level lock.
IMPLEMENTATION
Uses a cache of open tables to find a table not in use.
@ -2825,7 +2828,8 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
{
bool retry;
if (table_list->mdl_upgradable)
if (flags & MYSQL_OPEN_TAKE_UPGRADABLE_MDL &&
table_list->lock_type >= TL_WRITE_ALLOW_WRITE)
mdl_set_upgradable(mdl_lock_data);
mdl_set_lock_priority(mdl_lock_data, (flags & MYSQL_LOCK_IGNORE_FLUSH) ?
MDL_HIGH_PRIO : MDL_NORMAL_PRIO);
@ -4146,7 +4150,6 @@ static int add_merge_table_list(TABLE_LIST *tlist)
/* Set lock type. */
child_l->lock_type= tlist->lock_type;
child_l->mdl_upgradable= tlist->mdl_upgradable;
/* Set parent reference. */
child_l->parent_l= tlist;
@ -4905,6 +4908,8 @@ static bool check_lock_and_start_stmt(THD *thd, TABLE *table,
@param[in] thd thread handle
@param[in] table_l table to open is first table in this list
@param[in] lock_type lock to use for table
@param[in] flags options to be used while opening and locking
table (see open_table(), mysql_lock_tables())
@return table
@retval != NULL OK, opened table returned
@ -4930,7 +4935,7 @@ static bool check_lock_and_start_stmt(THD *thd, TABLE *table,
*/
TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
thr_lock_type lock_type)
thr_lock_type lock_type, uint flags)
{
TABLE_LIST *save_next_global;
DBUG_ENTER("open_n_lock_single_table");
@ -4946,7 +4951,7 @@ TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
table_l->required_type= FRMTYPE_TABLE;
/* Open the table. */
if (simple_open_n_lock_tables(thd, table_l))
if (open_and_lock_tables_derived(thd, table_l, FALSE, flags))
table_l->table= NULL; /* Just to be sure. */
/* Restore list. */

2
sql/sql_insert.cc
View File

@ -2304,7 +2304,7 @@ void kill_delayed_threads(void)
bool Delayed_insert::open_and_lock_table()
{
if (!(table= open_n_lock_single_table(&thd, &table_list,
TL_WRITE_DELAYED)))
TL_WRITE_DELAYED, 0)))
{
thd.fatal_error(); // Abort waiting inserts
return TRUE;

20
sql/sql_parse.cc
View File

@ -47,7 +47,6 @@
"FUNCTION" : "PROCEDURE")
static bool execute_sqlcom_select(THD *thd, TABLE_LIST *all_tables);
static void adjust_mdl_locks_upgradability(TABLE_LIST *tables);
const char *any_db="*any*"; // Special symbol for check_access
@ -3608,9 +3607,9 @@ end_with_restore_list:
thd->options|= OPTION_TABLE_LOCK;
alloc_mdl_locks(all_tables, &thd->locked_tables_root);
thd->mdl_el_root= &thd->locked_tables_root;
adjust_mdl_locks_upgradability(all_tables);
if (!(res= simple_open_n_lock_tables(thd, all_tables)))
if (!(res= open_and_lock_tables_derived(thd, all_tables, FALSE,
MYSQL_OPEN_TAKE_UPGRADABLE_MDL)))
{
#ifdef HAVE_QUERY_CACHE
if (thd->variables.query_cache_wlock_invalidate)
@ -8106,21 +8105,6 @@ bool parse_sql(THD *thd,
return ret_value;
}
/**
Auxiliary function which marks metadata locks for all tables
on which we plan to take write lock as upgradable.
*/
static void adjust_mdl_locks_upgradability(TABLE_LIST *tables)
{
for (TABLE_LIST *tab= tables; tab; tab= tab->next_global)
{
if (tab->lock_type >= TL_WRITE_ALLOW_WRITE)
tab->mdl_upgradable= TRUE;
}
}
/**
@} (end of group Runtime_Environment)
*/

12
sql/sql_table.cc
View File

@ -4617,7 +4617,8 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
if (view_operator_func == NULL)
table->required_type=FRMTYPE_TABLE;
open_and_lock_tables(thd, table);
open_and_lock_tables_derived(thd, table, TRUE,
MYSQL_OPEN_TAKE_UPGRADABLE_MDL);
thd->no_warnings_for_error= 0;
table->next_global= save_next_global;
table->next_local= save_next_local;
@ -5074,7 +5075,6 @@ bool mysql_restore_table(THD* thd, TABLE_LIST* table_list)
bool mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
DBUG_ENTER("mysql_repair_table");
set_all_mdl_upgradable(tables);
DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
"repair", TL_WRITE, 1,
test(check_opt->sql_flags & TT_USEFRM),
@ -5087,7 +5087,6 @@ bool mysql_repair_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
bool mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
{
DBUG_ENTER("mysql_optimize_table");
set_all_mdl_upgradable(tables);
DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
"optimize", TL_WRITE, 1,0,0,0,
&handler::ha_optimize, 0));
@ -6604,9 +6603,8 @@ view_err:
DBUG_RETURN(error);
}
table_list->mdl_upgradable= TRUE;
if (!(table= open_n_lock_single_table(thd, table_list, TL_WRITE_ALLOW_READ)))
if (!(table= open_n_lock_single_table(thd, table_list, TL_WRITE_ALLOW_READ,
MYSQL_OPEN_TAKE_UPGRADABLE_MDL)))
DBUG_RETURN(TRUE);
table->use_all_columns();
mdl_lock_data= table->mdl_lock_data;
@ -7898,7 +7896,7 @@ bool mysql_checksum_table(THD *thd, TABLE_LIST *tables,
strxmov(table_name, table->db ,".", table->table_name, NullS);
t= table->table= open_n_lock_single_table(thd, table, TL_READ);
t= table->table= open_n_lock_single_table(thd, table, TL_READ, 0);
thd->clear_error(); // these errors shouldn't get client
protocol->prepare_for_resend();

3
sql/sql_view.cc
View File

@ -1329,10 +1329,7 @@ bool mysql_make_view(THD *thd, File_parser *parser, TABLE_LIST *table,
anyway.
*/
for (tbl= view_main_select_tables; tbl; tbl= tbl->next_local)
{
tbl->lock_type= table->lock_type;
tbl->mdl_upgradable= table->mdl_upgradable;
}
/*
If the view is mergeable, we might want to
INSERT/UPDATE/DELETE into tables of this view. Preserve the

15
sql/table.h
View File

@ -1371,11 +1371,6 @@ struct TABLE_LIST
*/
TAKE_EXCLUSIVE_MDL
} open_type;
/**
Indicates that for this table/view we need to take shared metadata
lock which should be upgradable to exclusive metadata lock.
*/
bool mdl_upgradable;
bool internal_tmp_table;
/** TRUE if an alias for this table was specified in the SQL. */
bool is_alias;
@ -1796,14 +1791,4 @@ size_t max_row_length(TABLE *table, const uchar *data);
void alloc_mdl_locks(TABLE_LIST *table_list, MEM_ROOT *root);
/**
Helper function which allows to mark all elements in table list
as requiring upgradable metadata locks.
*/
inline void set_all_mdl_upgradable(TABLE_LIST *tables)
{
for (; tables; tables= tables->next_global)
tables->mdl_upgradable= TRUE;
}
#endif /* TABLE_INCLUDED */