#At file:///opt/local/work/next-4284-dd-review/ based on revid:kostja@stripped
3101 Konstantin Osipov 2010-02-16
Bug#46272, review comments:
a preview of the patch that removes the infinite loops
around thr_lock.c API and mysql_lock_tables().
modified:
sql/ha_ndbcluster_binlog.cc
sql/lock.cc
sql/log_event_old.cc
sql/mysql_priv.h
sql/sql_base.cc
sql/sql_handler.cc
sql/sql_insert.cc
sql/sql_update.cc
=== modified file 'sql/ha_ndbcluster_binlog.cc'
--- a/sql/ha_ndbcluster_binlog.cc 2010-02-04 22:08:08 +0000
+++ b/sql/ha_ndbcluster_binlog.cc 2010-02-15 22:12:20 +0000
@@ -2346,7 +2346,6 @@ static int open_ndb_binlog_index(THD *th
thd->proc_info= "Opening " NDB_REP_DB "." NDB_REP_TABLE;
tables->required_type= FRMTYPE_TABLE;
- uint counter;
thd->clear_error();
if (simple_open_n_lock_tables(thd, tables))
{
@@ -2374,7 +2373,6 @@ int ndb_add_ndb_binlog_index(THD *thd, v
{
ndb_binlog_index_row &row= *(ndb_binlog_index_row *) _row;
int error= 0;
- bool need_reopen;
/*
Turn of binlogging to prevent the table changes to be written to
the binary log.
=== modified file 'sql/lock.cc'
--- a/sql/lock.cc 2010-02-11 10:23:39 +0000
+++ b/sql/lock.cc 2010-02-15 22:12:20 +0000
@@ -97,7 +97,7 @@ static void print_lock_error(int error,
/* Map the return value of thr_lock to an error from errmsg.txt */
static int thr_lock_errno_to_mysql[]=
-{ 0, 1, ER_LOCK_WAIT_TIMEOUT, ER_LOCK_DEADLOCK };
+{ 0, ER_LOCK_DEADLOCK, ER_LOCK_WAIT_TIMEOUT, ER_LOCK_DEADLOCK };
/**
Perform semantic checks for mysql_lock_tables.
@@ -263,8 +263,7 @@ static void reset_lock_data_and_free(MYS
@retval NULL on error or if some tables should be reopen.
*/
-MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count,
- uint flags, bool *need_reopen)
+MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count, uint flags)
{
MYSQL_LOCK *sql_lock;
TABLE *write_lock_used;
@@ -272,130 +271,85 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd,
DBUG_ENTER("mysql_lock_tables");
- *need_reopen= FALSE;
-
if (mysql_lock_tables_check(thd, tables, count, flags))
DBUG_RETURN (NULL);
- for (;;)
- {
- if (! (sql_lock= get_lock_data(thd, tables, count, GET_LOCK_STORE_LOCKS,
- &write_lock_used)))
- break;
+ if (! (sql_lock= get_lock_data(thd, tables, count, GET_LOCK_STORE_LOCKS,
+ &write_lock_used)))
+ DBUG_RETURN(NULL);
- if (global_read_lock && write_lock_used &&
- ! (flags & MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK))
- {
- /*
- Someone has issued LOCK ALL TABLES FOR READ and we want a write lock
- Wait until the lock is gone
- */
- if (thd->global_read_lock.wait_if_global_read_lock(thd, 1, 1))
- {
- /* Clear the lock type of all lock data to avoid reusage. */
- reset_lock_data_and_free(&sql_lock);
- break;
- }
- if (thd->version != refresh_version)
- {
- /* Clear the lock type of all lock data to avoid reusage. */
- reset_lock_data_and_free(&sql_lock);
- goto retry;
- }
- }
- if (!(flags & MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY) &&
- write_lock_used &&
- opt_readonly &&
- !(thd->security_ctx->master_access & SUPER_ACL) &&
- !thd->slave_thread)
- {
- /*
- Someone has issued SET GLOBAL READ_ONLY=1 and we want a write lock.
- We do not wait for READ_ONLY=0, and fail.
- */
- reset_lock_data_and_free(&sql_lock);
- my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
- break;
- }
-
- thd_proc_info(thd, "System lock");
- DBUG_PRINT("info", ("thd->proc_info %s", thd->proc_info));
- if (sql_lock->table_count && lock_external(thd, sql_lock->table,
- sql_lock->table_count))
+ if (global_read_lock && write_lock_used &&
+ ! (flags & MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK))
+ {
+ /*
+ Someone has issued LOCK ALL TABLES FOR READ and we want a write lock
+ Wait until the lock is gone
+ */
+ if (thd->global_read_lock.wait_if_global_read_lock(thd, 1, 1))
{
/* Clear the lock type of all lock data to avoid reusage. */
reset_lock_data_and_free(&sql_lock);
- break;
- }
- DBUG_PRINT("info", ("thd->proc_info %s", thd->proc_info));
- /* Copy the lock data array. thr_multi_lock() reorders its contens. */
- memcpy(sql_lock->locks + sql_lock->lock_count, sql_lock->locks,
- sql_lock->lock_count * sizeof(*sql_lock->locks));
- /* Lock on the copied half of the lock data array. */
- rc= thr_lock_errno_to_mysql[(int) thr_multi_lock(sql_lock->locks +
- sql_lock->lock_count,
- sql_lock->lock_count,
- thd->lock_id,
- thd->variables.lock_wait_timeout)];
- if (rc > 1) /* a timeout or a deadlock */
- {
- if (sql_lock->table_count)
- (void) unlock_external(thd, sql_lock->table, sql_lock->table_count);
- reset_lock_data_and_free(&sql_lock);
- my_error(rc, MYF(0));
- break;
+ goto end;
}
- else if (rc == 1) /* aborted or killed */
- {
- /*
- reset_lock_data is required here. If thr_multi_lock fails it
- resets lock type for tables, which were locked before (and
- including) one that caused error. Lock type for other tables
- preserved.
- */
- reset_lock_data(sql_lock);
- sql_lock->lock_count= 0; // Locks are already freed
- // Fall through: unlock, reset lock data, free and retry
- }
- else
- {
- /* Success */
- break;
- }
- thd_proc_info(thd, 0);
+ }
- /* going to retry, unlock all tables */
- if (sql_lock->lock_count)
- thr_multi_unlock(sql_lock->locks, sql_lock->lock_count);
+ if (!(flags & MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY) &&
+ write_lock_used &&
+ opt_readonly &&
+ !(thd->security_ctx->master_access & SUPER_ACL) &&
+ !thd->slave_thread)
+ {
+ /*
+ Someone has issued SET GLOBAL READ_ONLY=1 and we want a write lock.
+ We do not wait for READ_ONLY=0, and fail.
+ */
+ reset_lock_data_and_free(&sql_lock);
+ my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
+ goto end;
+ }
+ thd_proc_info(thd, "System lock");
+ DBUG_PRINT("info", ("thd->proc_info %s", thd->proc_info));
+ if (sql_lock->table_count && lock_external(thd, sql_lock->table,
+ sql_lock->table_count))
+ {
+ /* Clear the lock type of all lock data to avoid reusage. */
+ reset_lock_data_and_free(&sql_lock);
+ goto end;
+ }
+ DBUG_PRINT("info", ("thd->proc_info %s", thd->proc_info));
+ /* Copy the lock data array. thr_multi_lock() reorders its contens. */
+ memcpy(sql_lock->locks + sql_lock->lock_count, sql_lock->locks,
+ sql_lock->lock_count * sizeof(*sql_lock->locks));
+ /* Lock on the copied half of the lock data array. */
+ rc= thr_lock_errno_to_mysql[(int) thr_multi_lock(sql_lock->locks +
+ sql_lock->lock_count,
+ sql_lock->lock_count,
+ thd->lock_id,
+ thd->variables.lock_wait_timeout)];
+ if (rc >= 1) /* a timeout or a deadlock */
+ {
if (sql_lock->table_count)
(void) unlock_external(thd, sql_lock->table, sql_lock->table_count);
-
- /*
- If thr_multi_lock fails it resets lock type for tables, which
- were locked before (and including) one that caused error. Lock
- type for other tables preserved.
- */
reset_lock_data_and_free(&sql_lock);
-retry:
- /* Let upper level close all used tables and retry or give error. */
- *need_reopen= TRUE;
- break;
+ my_error(rc, MYF(0));
}
+end:
thd_proc_info(thd, 0);
+
if (thd->killed)
{
thd->send_kill_message();
if (sql_lock)
{
- mysql_unlock_tables(thd,sql_lock);
- sql_lock=0;
+ mysql_unlock_tables(thd, sql_lock);
+ sql_lock= 0;
}
}
thd->set_time_after_lock();
- DBUG_RETURN (sql_lock);
+ DBUG_RETURN(sql_lock);
}
=== modified file 'sql/log_event_old.cc'
--- a/sql/log_event_old.cc 2010-02-06 10:28:06 +0000
+++ b/sql/log_event_old.cc 2010-02-15 22:12:20 +0000
@@ -1455,8 +1455,6 @@ int Old_rows_log_event::do_apply_event(R
*/
if (!thd->lock)
{
- bool need_reopen= 1; /* To execute the first lap of the loop below */
-
/*
lock_tables() reads the contents of thd->lex, so they must be
initialized. Contrary to in
@@ -1465,80 +1463,31 @@ int Old_rows_log_event::do_apply_event(R
*/
lex_start(thd);
- while ((error= lock_tables(thd, rli->tables_to_lock,
- rli->tables_to_lock_count, 0,
- &need_reopen)))
+ if ((error= lock_tables(thd, rli->tables_to_lock,
+ rli->tables_to_lock_count, 0)))
{
- if (!need_reopen)
- {
- if (thd->is_slave_error || thd->is_fatal_error)
- {
- /*
- Error reporting borrowed from Query_log_event with many excessive
- simplifications (we don't honour --slave-skip-errors)
- */
- uint actual_error= thd->net.last_errno;
- rli->report(ERROR_LEVEL, actual_error,
- "Error '%s' in %s event: when locking tables",
- (actual_error ? thd->net.last_error :
- "unexpected success or fatal error"),
- get_type_str());
- thd->is_fatal_error= 1;
- }
- else
- {
- rli->report(ERROR_LEVEL, error,
- "Error in %s event: when locking tables",
- get_type_str());
- }
- const_cast<Relay_log_info*>(rli)->slave_close_thread_tables(thd);
- DBUG_RETURN(error);
- }
-
- /*
- So we need to reopen the tables.
-
- We need to flush the pending RBR event, since it keeps a
- pointer to an open table.
-
- ALTERNATIVE SOLUTION (not implemented): Extract a pointer to
- the pending RBR event and reset the table pointer after the
- tables has been reopened.
-
- NOTE: For this new scheme there should be no pending event:
- need to add code to assert that is the case.
- */
- error= thd->binlog_flush_pending_rows_event(FALSE);
- if (error)
+ if (thd->is_slave_error || thd->is_fatal_error)
{
- rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
- ER(ER_SLAVE_FATAL_ERROR),
- "call to binlog_flush_pending_rows_event() failed");
- thd->is_slave_error= 1;
- DBUG_RETURN(error);
+ /*
+ Error reporting borrowed from Query_log_event with many excessive
+ simplifications (we don't honour --slave-skip-errors)
+ */
+ uint actual_error= thd->net.last_errno;
+ rli->report(ERROR_LEVEL, actual_error,
+ "Error '%s' in %s event: when locking tables",
+ (actual_error ? thd->net.last_error :
+ "unexpected success or fatal error"),
+ get_type_str());
+ thd->is_fatal_error= 1;
}
- TABLE_LIST *tables= rli->tables_to_lock;
- close_tables_for_reopen(thd, &tables, NULL);
-
- uint tables_count= rli->tables_to_lock_count;
- if ((error= open_tables(thd, &tables, &tables_count, 0)))
+ else
{
- if (thd->is_slave_error || thd->is_fatal_error)
- {
- /*
- Error reporting borrowed from Query_log_event with many excessive
- simplifications (we don't honour --slave-skip-errors)
- */
- uint actual_error= thd->net.last_errno;
- rli->report(ERROR_LEVEL, actual_error,
- "Error '%s' on reopening tables",
- (actual_error ? thd->net.last_error :
- "unexpected success or fatal error"));
- thd->is_slave_error= 1;
- }
- const_cast<Relay_log_info*>(rli)->slave_close_thread_tables(thd);
- DBUG_RETURN(error);
+ rli->report(ERROR_LEVEL, error,
+ "Error in %s event: when locking tables",
+ get_type_str());
}
+ const_cast<Relay_log_info*>(rli)->slave_close_thread_tables(thd);
+ DBUG_RETURN(error);
}
/*
=== modified file 'sql/mysql_priv.h'
--- a/sql/mysql_priv.h 2010-02-15 11:16:49 +0000
+++ b/sql/mysql_priv.h 2010-02-15 22:12:20 +0000
@@ -1587,8 +1587,7 @@ inline bool open_and_lock_tables(THD *th
TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
thr_lock_type lock_type, uint flags);
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags);
-bool lock_tables(THD *thd, TABLE_LIST *tables, uint counter, uint flags,
- bool *need_reopen);
+bool lock_tables(THD *thd, TABLE_LIST *tables, uint counter, uint flags);
TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
const char *table_name, bool link_in_list);
bool rm_temporary_table(handlerton *base, char *path);
@@ -2141,8 +2140,7 @@ extern char *opt_ssl_ca, *opt_ssl_capath
extern struct st_VioSSLFd * ssl_acceptor_fd;
#endif /* HAVE_OPENSSL */
-MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **table, uint count,
- uint flags, bool *need_reopen);
+MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **table, uint count, uint flags);
/* mysql_lock_tables() and open_table() flags bits */
#define MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK 0x0001
#define MYSQL_LOCK_IGNORE_FLUSH 0x0002
=== modified file 'sql/sql_base.cc'
--- a/sql/sql_base.cc 2010-02-15 11:16:49 +0000
+++ b/sql/sql_base.cc 2010-02-15 22:12:20 +0000
@@ -3309,7 +3309,6 @@ bool
Locked_tables_list::reopen_tables(THD *thd)
{
Open_table_context ot_ctx_unused(thd);
- bool lt_refresh_unused;
size_t reopen_count= 0;
MYSQL_LOCK *lock;
MYSQL_LOCK *merged_lock;
@@ -3349,7 +3348,7 @@ Locked_tables_list::reopen_tables(THD *t
break something else.
*/
lock= mysql_lock_tables(thd, m_reopen_array, reopen_count,
- MYSQL_OPEN_REOPEN, <_refresh_unused);
+ MYSQL_OPEN_REOPEN);
thd->in_lock_tables= 0;
if (lock == NULL || (merged_lock=
mysql_lock_merge(thd->lock, lock)) == NULL)
@@ -4991,7 +4990,6 @@ TABLE *open_ltable(THD *thd, TABLE_LIST
{
TABLE *table;
Open_table_context ot_ctx(thd);
- bool refresh;
bool error;
DBUG_ENTER("open_ltable");
@@ -5003,7 +5001,6 @@ TABLE *open_ltable(THD *thd, TABLE_LIST
/* open_ltable can be used only for BASIC TABLEs */
table_list->required_type= FRMTYPE_TABLE;
-retry:
while ((error= open_table(thd, table_list, thd->mem_root, &ot_ctx, 0)) &&
ot_ctx.can_recover_from_failed_open())
{
@@ -5050,18 +5047,9 @@ retry:
DBUG_ASSERT(thd->lock == 0); // You must lock everything at once
if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
- lock_flags, &refresh)))
+ lock_flags)))
{
- if (refresh)
- {
- close_thread_tables(thd);
- table_list->table= NULL;
- table_list->mdl_request.ticket= NULL;
- thd->mdl_context.rollback_to_savepoint(ot_ctx.start_of_statement_svp());
- goto retry;
- }
- else
- table= 0;
+ table= 0;
}
}
}
@@ -5105,42 +5093,27 @@ bool open_and_lock_tables_derived(THD *t
Prelocking_strategy *prelocking_strategy)
{
uint counter;
- bool need_reopen;
- /*
- Remember the set of metadata locks which this connection
- managed to acquire before the start of the current statement.
- It can be either transaction-scope locks, or HANDLER locks,
- or LOCK TABLES locks. If mysql_lock_tables() fails with
- need_reopen request, we'll use it to instruct
- close_tables_for_reopen() to release all locks of this
- statement.
- */
- MDL_ticket *start_of_statement_svp= thd->mdl_context.mdl_savepoint();
DBUG_ENTER("open_and_lock_tables_derived");
DBUG_PRINT("enter", ("derived handling: %d", derived));
- for ( ; ; )
- {
- if (open_tables(thd, &tables, &counter, flags, prelocking_strategy))
- DBUG_RETURN(TRUE);
- DBUG_EXECUTE_IF("sleep_open_and_lock_after_open", {
- const char *old_proc_info= thd->proc_info;
- thd->proc_info= "DBUG sleep";
- my_sleep(6000000);
- thd->proc_info= old_proc_info;});
+ if (open_tables(thd, &tables, &counter, flags, prelocking_strategy))
+ DBUG_RETURN(TRUE);
+
+ DBUG_EXECUTE_IF("sleep_open_and_lock_after_open", {
+ const char *old_proc_info= thd->proc_info;
+ thd->proc_info= "DBUG sleep";
+ my_sleep(6000000);
+ thd->proc_info= old_proc_info;});
+
+ if (lock_tables(thd, tables, counter, flags))
+ DBUG_RETURN(TRUE);
- if (!lock_tables(thd, tables, counter, flags,
- &need_reopen))
- break;
- if (!need_reopen)
- DBUG_RETURN(TRUE);
- close_tables_for_reopen(thd, &tables, start_of_statement_svp);
- }
if (derived &&
(mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
(thd->fill_derived_tables() &&
mysql_handle_derived(thd->lex, &mysql_derived_filling))))
DBUG_RETURN(TRUE); /* purecov: inspected */
+
DBUG_RETURN(FALSE);
}
@@ -5198,37 +5171,28 @@ static void mark_real_tables_as_free_for
}
-/*
- Lock all tables in list
-
- SYNOPSIS
- lock_tables()
- thd Thread handler
- tables Tables to lock
- count Number of opened tables
- flags Options (see mysql_lock_tables() for details)
- need_reopen Out parameter which if TRUE indicates that some
- tables were dropped or altered during this call
- and therefore invoker should reopen tables and
- try to lock them once again (in this case
- lock_tables() will also return error).
+/**
+ Lock all tables in a list.
- NOTES
- You can't call lock_tables twice, as this would break the dead-lock-free
- handling thr_lock gives us. You most always get all needed locks at
- once.
-
- If query for which we are calling this function marked as requiring
- prelocking, this function will change locked_tables_mode to
- LTM_PRELOCKED.
+ @param thd Thread handler
+ @param tables Tables to lock
+ @param count Number of opened tables
+ @param flags Options (see mysql_lock_tables() for details)
+
+ You can't call lock_tables() while holding thr_lock locks, as
+ this would break the dead-lock-free handling thr_lock gives us.
+ You most always get all needed locks at once.
+
+ If the query for which we are calling this function is marked as
+ requiring prelocking, this function will change
+ locked_tables_mode to LTM_PRELOCKED.
- RETURN VALUES
- 0 ok
- -1 Error
+ @retval FALSE Success.
+ @retval TRUE A lock wait timeout, deadlock or out of memory.
*/
bool lock_tables(THD *thd, TABLE_LIST *tables, uint count,
- uint flags, bool *need_reopen)
+ uint flags)
{
TABLE_LIST *table;
@@ -5239,7 +5203,6 @@ bool lock_tables(THD *thd, TABLE_LIST *t
*/
DBUG_ASSERT(thd->locked_tables_mode <= LTM_LOCK_TABLES ||
!thd->lex->requires_prelocking());
- *need_reopen= FALSE;
if (!tables && !thd->lex->requires_prelocking())
DBUG_RETURN(thd->decide_logging_format(tables));
@@ -5284,7 +5247,7 @@ bool lock_tables(THD *thd, TABLE_LIST *t
DEBUG_SYNC(thd, "before_lock_tables_takes_lock");
if (! (thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
- flags, need_reopen)))
+ flags)))
DBUG_RETURN(TRUE);
DEBUG_SYNC(thd, "after_lock_tables_takes_lock");
=== modified file 'sql/sql_handler.cc'
--- a/sql/sql_handler.cc 2010-02-12 07:05:43 +0000
+++ b/sql/sql_handler.cc 2010-02-15 22:12:20 +0000
@@ -438,7 +438,6 @@ bool mysql_ha_read(THD *thd, TABLE_LIST
uint num_rows;
uchar *UNINIT_VAR(key);
uint UNINIT_VAR(key_len);
- bool need_reopen;
DBUG_ENTER("mysql_ha_read");
DBUG_PRINT("enter",("'%s'.'%s' as '%s'",
tables->db, tables->table_name, tables->alias));
@@ -455,7 +454,6 @@ bool mysql_ha_read(THD *thd, TABLE_LIST
List_iterator<Item> it(list);
it++;
-retry:
if ((hash_tables= (TABLE_LIST*) my_hash_search(&thd->handler_tables_hash,
(uchar*) tables->alias,
strlen(tables->alias) + 1)))
@@ -502,7 +500,7 @@ retry:
thd->open_tables= hash_tables->table;
- lock= mysql_lock_tables(thd, &thd->open_tables, 1, 0, &need_reopen);
+ lock= mysql_lock_tables(thd, &thd->open_tables, 1, 0);
/*
In 5.1 and earlier, mysql_lock_tables() could replace the TABLE
@@ -513,12 +511,6 @@ retry:
/* Restore previous context. */
thd->open_tables= backup_open_tables;
- if (need_reopen)
- {
- mysql_ha_close_table(thd, hash_tables);
- goto retry;
- }
-
if (!lock)
goto err0; // mysql_lock_tables() printed error message already
=== modified file 'sql/sql_insert.cc'
--- a/sql/sql_insert.cc 2010-02-11 10:23:39 +0000
+++ b/sql/sql_insert.cc 2010-02-15 22:12:20 +0000
@@ -2557,7 +2557,6 @@ pthread_handler_t handle_delayed_insert(
if (di->tables_in_use && ! thd->lock && !thd->killed)
{
- bool need_reopen;
/*
Request for new delayed insert.
Lock the table, but avoid to be blocked by a global read lock.
@@ -2569,29 +2568,10 @@ pthread_handler_t handle_delayed_insert(
inserts are done.
*/
if (! (thd->lock= mysql_lock_tables(thd, &di->table, 1,
- MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK,
- &need_reopen)))
+ MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK)))
{
- if (need_reopen && !thd->killed)
- {
- /*
- We were waiting to obtain TL_WRITE_DELAYED (probably due to
- someone having or requesting TL_WRITE_ALLOW_READ) and got
- aborted. Try to reopen table and if it fails die.
- */
- TABLE_LIST *tl_ptr = &di->table_list;
- close_tables_for_reopen(thd, &tl_ptr, NULL);
- di->table= 0;
- if (di->open_and_lock_table())
- {
- thd->killed= THD::KILL_CONNECTION;
- }
- }
- else
- {
- /* Fatal error */
- thd->killed= THD::KILL_CONNECTION;
- }
+ /* Fatal error */
+ thd->killed= THD::KILL_CONNECTION;
}
mysql_cond_broadcast(&di->cond_client);
}
@@ -3542,7 +3522,6 @@ static TABLE *create_table_from_items(TH
List_iterator_fast<Item> it(*items);
Item *item;
Field *tmp_field;
- bool not_used;
DBUG_ENTER("create_table_from_items");
tmp_table.alias= 0;
@@ -3667,7 +3646,7 @@ static TABLE *create_table_from_items(TH
the table) and thus can't get aborted.
*/
if (! ((*lock)= mysql_lock_tables(thd, &table, 1,
- MYSQL_LOCK_IGNORE_FLUSH, ¬_used)) ||
+ MYSQL_LOCK_IGNORE_FLUSH)) ||
hooks->postlock(&table, 1))
{
if (*lock)
=== modified file 'sql/sql_update.cc'
--- a/sql/sql_update.cc 2010-02-08 20:19:55 +0000
+++ b/sql/sql_update.cc 2010-02-15 22:12:20 +0000
@@ -203,33 +203,26 @@ int mysql_update(THD *thd,
SQL_SELECT *select;
READ_RECORD info;
SELECT_LEX *select_lex= &thd->lex->select_lex;
- bool need_reopen;
ulonglong id;
List<Item> all_fields;
THD::killed_state killed_status= THD::NOT_KILLED;
MDL_ticket *start_of_statement_svp= thd->mdl_context.mdl_savepoint();
DBUG_ENTER("mysql_update");
- for ( ; ; )
- {
- if (open_tables(thd, &table_list, &table_count, 0))
- DBUG_RETURN(1);
+ if (open_tables(thd, &table_list, &table_count, 0))
+ DBUG_RETURN(1);
- if (table_list->multitable_view)
- {
- DBUG_ASSERT(table_list->view != 0);
- DBUG_PRINT("info", ("Switch to multi-update"));
- /* pass counter value */
- thd->lex->table_count= table_count;
- /* convert to multiupdate */
- DBUG_RETURN(2);
- }
- if (!lock_tables(thd, table_list, table_count, 0, &need_reopen))
- break;
- if (!need_reopen)
- DBUG_RETURN(1);
- close_tables_for_reopen(thd, &table_list, start_of_statement_svp);
+ if (table_list->multitable_view)
+ {
+ DBUG_ASSERT(table_list->view != 0);
+ DBUG_PRINT("info", ("Switch to multi-update"));
+ /* pass counter value */
+ thd->lex->table_count= table_count;
+ /* convert to multiupdate */
+ DBUG_RETURN(2);
}
+ if (lock_tables(thd, table_list, table_count, 0))
+ DBUG_RETURN(1);
if (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
(thd->fill_derived_tables() &&
@@ -970,17 +963,14 @@ int mysql_multi_update_prepare(THD *thd)
uint table_count= lex->table_count;
const bool using_lock_tables= thd->locked_tables_mode != LTM_NONE;
bool original_multiupdate= (thd->lex->sql_command == SQLCOM_UPDATE_MULTI);
- bool need_reopen= FALSE;
MDL_ticket *start_of_statement_svp= thd->mdl_context.mdl_savepoint();
DBUG_ENTER("mysql_multi_update_prepare");
/* following need for prepared statements, to run next time multi-update */
thd->lex->sql_command= SQLCOM_UPDATE_MULTI;
-reopen_tables:
-
/* open tables and create derived ones, but do not lock and fill them */
- if (((original_multiupdate || need_reopen) &&
+ if ((original_multiupdate &&
open_tables(thd, &table_list, &table_count, 0)) ||
mysql_handle_derived(lex, &mysql_derived_prepare))
DBUG_RETURN(TRUE);
@@ -1096,58 +1086,11 @@ reopen_tables:
/* now lock and fill tables */
if (!thd->stmt_arena->is_stmt_prepare() &&
- lock_tables(thd, table_list, table_count, 0, &need_reopen))
+ lock_tables(thd, table_list, table_count, 0))
{
- if (!need_reopen)
- DBUG_RETURN(TRUE);
-
- DBUG_PRINT("info", ("lock_tables failed, reopening"));
-
- /*
- We have to reopen tables since some of them were altered or dropped
- during lock_tables() or something was done with their triggers.
- Let us do some cleanups to be able do setup_table() and setup_fields()
- once again.
- */
- List_iterator_fast<Item> it(*fields);
- Item *item;
- while ((item= it++))
- item->cleanup();
-
- /*
- To not to hog memory (as a result of the
- unit->reinit_exec_mechanism() call below):
- */
- lex->unit.cleanup();
-
- for (SELECT_LEX *sl= lex->all_selects_list;
- sl;
- sl= sl->next_select_in_list())
- {
- SELECT_LEX_UNIT *unit= sl->master_unit();
- unit->reinit_exec_mechanism(); // reset unit->prepared flags
- /*
- Reset 'clean' flag back to force normal execution of
- unit->cleanup() in Prepared_statement::cleanup_stmt()
- (call to lex->unit.cleanup() above sets this flag to TRUE).
- */
- unit->unclean();
- }
-
- /*
- Also we need to cleanup Natural_join_column::table_field items.
- To not to traverse a join tree we will cleanup whole
- thd->free_list (in PS execution mode that list may not contain
- items from 'fields' list, so the cleanup above is necessary to.
- */
- cleanup_items(thd->free_list);
- cleanup_items(thd->stmt_arena->free_list);
- close_tables_for_reopen(thd, &table_list, start_of_statement_svp);
-
- DEBUG_SYNC(thd, "multi_update_reopen_tables");
-
- goto reopen_tables;
+ DBUG_RETURN(TRUE);
}
+ /* @todo: downgrade the metadata locks here. */
/*
Check that we are not using table that we are updating, but we should
Attachment: [text/bzr-bundle] bzr/kostja@sun.com-20100215221220-bjq4fw96v25omjke.bundle
| Thread |
|---|
| • bzr commit into mysql-5.5-next-mr branch (kostja:3101) Bug#46272 | Konstantin Osipov | 15 Feb |
