From 2a4221489bdb97123ae981488ee3de5f18e19604 Mon Sep 17 00:00:00 2001 From: "kroki/tomash@moonlight.intranet" <> Date: Tue, 29 Aug 2006 16:59:20 +0400 Subject: [PATCH 1/2] BUG#21096: locking issue ; temporary table conflicts. The problem was that during DROP TEMPORARY TABLE we tried to acquire the name lock, though temporary tables belongs to one connection, and no race is possible. The solution is to not use table name locking while executing DROP TEMPORARY TABLE. --- mysql-test/r/temp_table.result | 17 ++++++++++++ mysql-test/t/temp_table.test | 48 +++++++++++++++++++++++++++++++++- sql/sql_table.cc | 5 ++-- 3 files changed, 67 insertions(+), 3 deletions(-) diff --git a/mysql-test/r/temp_table.result b/mysql-test/r/temp_table.result index 0b6bc48c350..80d4e8cc06d 100644 --- a/mysql-test/r/temp_table.result +++ b/mysql-test/r/temp_table.result @@ -108,3 +108,20 @@ d c bar 2 foo 1 drop table t1, t2; +DROP TABLE IF EXISTS t1; +CREATE TABLE t1 (i INT); +LOCK TABLE t1 WRITE; +CREATE TEMPORARY TABLE t1 (i INT); +The following command should not block +DROP TEMPORARY TABLE t1; +DROP TABLE t1; +CREATE TABLE t1 (i INT); +CREATE TEMPORARY TABLE t2 (i INT); +DROP TEMPORARY TABLE t2, t1; +ERROR 42S02: Unknown table 't1' +SELECT * FROM t2; +ERROR 42S02: Table 'test.t2' doesn't exist +SELECT * FROM t1; +i +DROP TABLE t1; +End of 4.1 tests. diff --git a/mysql-test/t/temp_table.test b/mysql-test/t/temp_table.test index 309855d0b2d..69082840988 100644 --- a/mysql-test/t/temp_table.test +++ b/mysql-test/t/temp_table.test @@ -99,4 +99,50 @@ insert into t2 values (NULL, 'foo'), (NULL, 'bar'); select d, c from t1 left join t2 on b = c where a = 3 order by d; drop table t1, t2; -# End of 4.1 tests + +# +# BUG#21096: locking issue ; temporary table conflicts. +# +# The problem was that on DROP TEMPORARY table name lock was acquired, +# which should not be done. +# +--disable_warnings +DROP TABLE IF EXISTS t1; +--enable_warnings + +CREATE TABLE t1 (i INT); + +LOCK TABLE t1 WRITE; + +connect (conn1, localhost, root,,); + +CREATE TEMPORARY TABLE t1 (i INT); + +--echo The following command should not block +DROP TEMPORARY TABLE t1; + +disconnect conn1; +connection default; + +DROP TABLE t1; + +# +# Check that it's not possible to drop a base table with +# DROP TEMPORARY statement. +# +CREATE TABLE t1 (i INT); +CREATE TEMPORARY TABLE t2 (i INT); + +--error 1051 +DROP TEMPORARY TABLE t2, t1; + +# Table t2 should have been dropped. +--error 1146 +SELECT * FROM t2; +# But table t1 should still be there. +SELECT * FROM t1; + +DROP TABLE t1; + + +--echo End of 4.1 tests. diff --git a/sql/sql_table.cc b/sql/sql_table.cc index 631d2d89bbb..5fc4bb6d79f 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -214,7 +214,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, bool some_tables_deleted=0, tmp_table_deleted=0, foreign_key_error=0; DBUG_ENTER("mysql_rm_table_part2"); - if (lock_table_names(thd, tables)) + if (!drop_temporary && lock_table_names(thd, tables)) DBUG_RETURN(1); for (table=tables ; table ; table=table->next) @@ -311,7 +311,8 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, } } - unlock_table_names(thd, tables); + if (!drop_temporary) + unlock_table_names(thd, tables); DBUG_RETURN(error); } From acaa584c5523753cab5b3a50ed3c95672b462541 Mon Sep 17 00:00:00 2001 From: "dlenev@mockturtle.local" <> Date: Thu, 28 Sep 2006 23:47:49 +0400 Subject: [PATCH 2/2] Fix for bug#22338 "Valgrind warning: uninitialized variable in create_tmp_table()". The fix for bug 21787 "COUNT(*) + ORDER BY + LIMIT returns wrong result" introduced valgrind warnings which occured during execution of information_schema.test and sp-prelocking.test in version 5.0. There were no user visible effects. The latter fix made create_tmp_table() dependant on THD::lex::current_select value. Valgrind warnings occured when this function was executed and THD::lex::current_select member pointed to uninitialized SELECT_LEX instance. This fix tries to remove this dependancy by moving some logic outside of create_tmp_table() function. --- sql/sql_select.cc | 43 ++++++++++++++++++++++++------------------- 1 file changed, 24 insertions(+), 19 deletions(-) diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 02ec7ae08ed..da96c98cd4f 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -932,17 +932,28 @@ JOIN::optimize() tmp_table_param.hidden_field_count= (all_fields.elements - fields_list.elements); + ORDER *tmp_group= ((!simple_group && !procedure && + !(test_flags & TEST_NO_KEY_GROUP)) ? group_list : + (ORDER*) 0); + /* + Pushing LIMIT to the temporary table creation is not applicable + when there is ORDER BY or GROUP BY or there is no GROUP BY, but + there are aggregate functions, because in all these cases we need + all result rows. + */ + ha_rows tmp_rows_limit= ((order == 0 || skip_sort_order || + test(select_options & OPTION_BUFFER_RESULT)) && + !tmp_group && + !thd->lex->current_select->with_sum_func) ? + select_limit : HA_POS_ERROR; + if (!(exec_tmp_table1 = create_tmp_table(thd, &tmp_table_param, all_fields, - ((!simple_group && !procedure && - !(test_flags & TEST_NO_KEY_GROUP)) ? - group_list : (ORDER*) 0), + tmp_group, group_list ? 0 : select_distinct, group_list && simple_group, select_options, - (order == 0 || skip_sort_order || - test(select_options & OPTION_BUFFER_RESULT)) ? - select_limit : HA_POS_ERROR, + tmp_rows_limit, (char *) ""))) DBUG_RETURN(1); @@ -5566,6 +5577,13 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, thd->variables.max_heap_table_size) : thd->variables.tmp_table_size)/ table->reclength); set_if_bigger(table->max_rows,1); // For dummy start options + /* + Push the LIMIT clause to the temporary table creation, so that we + materialize only up to 'rows_limit' records instead of all result records. + */ + set_if_smaller(table->max_rows, rows_limit); + param->end_write_records= rows_limit; + keyinfo=param->keyinfo; if (group) @@ -5686,19 +5704,6 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, } } - /* - Push the LIMIT clause to the temporary table creation, so that we - materialize only up to 'rows_limit' records instead of all result records. - This optimization is not applicable when there is GROUP BY or there is - no GROUP BY, but there are aggregate functions, because both must be - computed for all result rows. - */ - if (!group && !thd->lex->current_select->with_sum_func) - { - set_if_smaller(table->max_rows, rows_limit); - param->end_write_records= rows_limit; - } - if (thd->is_fatal_error) // If end of memory goto err; /* purecov: inspected */ table->db_record_offset=1;