mariadb/mysql-test/main/sp-threads.test

202 lines
4.2 KiB
Text
Raw Normal View History

Fixes to embedded server to be able to run tests with it (Needed for "list of pushes" web page and autopush) include/mysql.h: Fix to embedded server to be able to run tests on it libmysql/libmysql.c: Fix to embedded server to be able to run tests on it libmysqld/emb_qcache.cc: Fix to embedded server to be able to run tests on it libmysqld/embedded_priv.h: Fix to embedded server to be able to run tests on it libmysqld/lib_sql.cc: Fix to embedded server to be able to run tests on it libmysqld/libmysqld.c: Fix to embedded server to be able to run tests on it mysql-test/mysql-test-run.sh: Fix to embedded server to be able to run tests on it mysql-test/r/binlog.result: Updated test for embedded server mysql-test/r/ctype_cp932.result: Updated test for embedded server mysql-test/r/innodb.result: Updated test for embedded server mysql-test/r/mysqltest.result: Updated test for embedded server mysql-test/r/query_cache.result: Updated test for embedded server mysql-test/r/query_cache_notembedded.result: Updated test for embedded server mysql-test/r/sp-error.result: Updated test for embedded server mysql-test/r/sp.result: Updated test for embedded server mysql-test/r/subselect.result: Updated test for embedded server mysql-test/r/view.result: Updated test for embedded server mysql-test/r/view_grant.result: Updated test for embedded server mysql-test/t/backup.test: Updated test for embedded server mysql-test/t/binlog.test: Updated test for embedded server mysql-test/t/blackhole.test: Updated test for embedded server mysql-test/t/compress.test: Updated test for embedded server mysql-test/t/ctype_cp932.test: Updated test for embedded server mysql-test/t/delayed.test: Updated test for embedded server mysql-test/t/handler.test: Updated test for embedded server mysql-test/t/innodb.test: Updated test for embedded server mysql-test/t/mysql.test: Updated test for embedded server mysql-test/t/mysql_client_test.test: Updated test for embedded server mysql-test/t/mysqltest.test: Updated test for embedded server mysql-test/t/query_cache.test: Updated test for embedded server mysql-test/t/query_cache_notembedded.test: Updated test for embedded server mysql-test/t/read_only.test: Updated test for embedded server mysql-test/t/skip_grants.test: Updated test for embedded server mysql-test/t/sp-destruct.test: Updated test for embedded server mysql-test/t/sp-error.test: Updated test for embedded server mysql-test/t/sp-threads.test: Updated test for embedded server mysql-test/t/sp.test: Updated test for embedded server mysql-test/t/subselect.test: Updated test for embedded server mysql-test/t/temp_table.test: Updated test for embedded server mysql-test/t/view.test: Updated test for embedded server mysql-test/t/view_grant.test: Updated test for embedded server mysql-test/t/wait_timeout.test: Updated test for embedded server mysys/mf_dirname.c: Review fix: Don't access data outside of array mysys/my_bitmap.c: Remove compiler warnings scripts/mysql_fix_privilege_tables.sql: Add flush privileges to .sql script so that one doesn't have to reboot mysqld when one runs the mysql_fix_privilege_script sql-common/client.c: Updated test for embedded server sql/item.cc: Remove DBUG_PRINT statement that can cause crashes when running with --debug sql/mysqld.cc: Fix to embedded server to be able to run tests on it sql/protocol.cc: Fix to embedded server to be able to run tests on it (Trivial reconstruction of code) sql/protocol.h: Fix to embedded server to be able to run tests on it sql/sql_base.cc: Better comment sql/sql_class.cc: Fix to embedded server to be able to run tests on it sql/sql_class.h: Fix to embedded server to be able to run tests on it sql/sql_cursor.cc: Fix to embedded server to be able to run tests on it sql/sql_parse.cc: Fix to embedded server to be able to run tests on it Don't crash for disabled commands when using embedded server sql/sql_prepare.cc: Fix to embedded server to be able to run tests on it mysql-test/r/ctype_cp932_notembedded.result: New BitKeeper file ``mysql-test/r/ctype_cp932_notembedded.result'' mysql-test/r/innodb_notembedded.result: New BitKeeper file ``mysql-test/r/innodb_notembedded.result'' mysql-test/r/sp.result.orig: New BitKeeper file ``mysql-test/r/sp.result.orig'' mysql-test/r/sp_notembedded.result: New BitKeeper file ``mysql-test/r/sp_notembedded.result'' mysql-test/r/subselect_notembedded.result: New BitKeeper file ``mysql-test/r/subselect_notembedded.result'' mysql-test/t/ctype_cp932_notembedded.test: New BitKeeper file ``mysql-test/t/ctype_cp932_notembedded.test'' mysql-test/t/innodb_notembedded.test: New BitKeeper file ``mysql-test/t/innodb_notembedded.test'' mysql-test/t/sp.test.orig: New BitKeeper file ``mysql-test/t/sp.test.orig'' mysql-test/t/sp_notembedded.test: New BitKeeper file ``mysql-test/t/sp_notembedded.test'' mysql-test/t/subselect_notembedded.test: New BitKeeper file ``mysql-test/t/subselect_notembedded.test''
2006-02-24 17:34:15 +01:00
# This test should work in embedded server after mysqltest is fixed
-- source include/not_embedded.inc
#
# Testing stored procedures with multiple connections,
# except security/privilege tests, they go to sp-security.test
#
# Save the initial number of concurrent sessions
--source include/count_sessions.inc
connect (con1root,localhost,root,,);
connect (con2root,localhost,root,,);
connect (con3root,localhost,root,,);
connection con1root;
use test;
--disable_warnings
drop table if exists t1;
--enable_warnings
create table t1 (s1 int, s2 int, s3 int);
delimiter //;
create procedure bug4934()
begin
insert into t1 values (1,0,1);
end//
delimiter ;//
connection con2root;
use test;
call bug4934();
select * from t1;
connection con1root;
drop table t1;
create table t1 (s1 int, s2 int, s3 int);
drop procedure bug4934;
delimiter //;
create procedure bug4934()
begin
end//
delimiter ;//
connection con2root;
select * from t1;
call bug4934();
select * from t1;
connection con1root;
drop table t1;
drop procedure bug4934;
Fix for bug #9486 "Can't perform multi-update in stored procedure". New more SP-locking friendly approach to handling locks in multi-update. Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql-test/r/sp-threads.result: Added test for bug #9486 "Can't perform multi-update in stored procedure". mysql-test/t/sp-threads.test: Added test for bug #9486 "Can't perform multi-update in stored procedure". sql/sp_head.cc: SP_TABLE, sp_head::merge_table_list()/add_used_tables_to_table_list(): Since some queries during their execution (e.g. multi-update) may change type of lock for some of their tables and thus change lock_type member for some of elements of table list, we should store type of lock in SP_TABLE struct explicitly instead of using lock_type member of TABLE_LIST object pointed by SP_TABLE::table. sql/sql_lex.h: Removed no longer used LEX::multi_lock_option member. sql/sql_prepare.cc: mysql_test_update(): We don't need to bother about LEX::multi_lock_option if we convert multi-update to update anymore. Since nowdays multi-update uses TABLE_LIST::lock_type for specifying lock level of updated tables instead of LEX::multi_lock_option. sql/sql_update.cc: mysql_update()/mysql_multi_update_prepare(): Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql_multi_update(): We should return FALSE if no error occurs. sql/sql_yacc.yy: update: Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage).
2005-04-15 18:31:47 +02:00
#
# Bug#9486 Can't perform multi-update in stored procedure
Fix for bug #9486 "Can't perform multi-update in stored procedure". New more SP-locking friendly approach to handling locks in multi-update. Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql-test/r/sp-threads.result: Added test for bug #9486 "Can't perform multi-update in stored procedure". mysql-test/t/sp-threads.test: Added test for bug #9486 "Can't perform multi-update in stored procedure". sql/sp_head.cc: SP_TABLE, sp_head::merge_table_list()/add_used_tables_to_table_list(): Since some queries during their execution (e.g. multi-update) may change type of lock for some of their tables and thus change lock_type member for some of elements of table list, we should store type of lock in SP_TABLE struct explicitly instead of using lock_type member of TABLE_LIST object pointed by SP_TABLE::table. sql/sql_lex.h: Removed no longer used LEX::multi_lock_option member. sql/sql_prepare.cc: mysql_test_update(): We don't need to bother about LEX::multi_lock_option if we convert multi-update to update anymore. Since nowdays multi-update uses TABLE_LIST::lock_type for specifying lock level of updated tables instead of LEX::multi_lock_option. sql/sql_update.cc: mysql_update()/mysql_multi_update_prepare(): Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql_multi_update(): We should return FALSE if no error occurs. sql/sql_yacc.yy: update: Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage).
2005-04-15 18:31:47 +02:00
#
--disable_warnings
drop procedure if exists bug9486;
drop table if exists t1, t2;
--enable_warnings
create table t1 (id1 int, val int);
create table t2 (id2 int);
create procedure bug9486()
update t1, t2 set val= 1 where id1=id2;
call bug9486();
# Let us check that SP invocation requires write lock for t2.
connection con2root;
lock tables t2 write;
connection con1root;
let $con1root_id=`SELECT CONNECTION_ID()`;
Fix for bug #9486 "Can't perform multi-update in stored procedure". New more SP-locking friendly approach to handling locks in multi-update. Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql-test/r/sp-threads.result: Added test for bug #9486 "Can't perform multi-update in stored procedure". mysql-test/t/sp-threads.test: Added test for bug #9486 "Can't perform multi-update in stored procedure". sql/sp_head.cc: SP_TABLE, sp_head::merge_table_list()/add_used_tables_to_table_list(): Since some queries during their execution (e.g. multi-update) may change type of lock for some of their tables and thus change lock_type member for some of elements of table list, we should store type of lock in SP_TABLE struct explicitly instead of using lock_type member of TABLE_LIST object pointed by SP_TABLE::table. sql/sql_lex.h: Removed no longer used LEX::multi_lock_option member. sql/sql_prepare.cc: mysql_test_update(): We don't need to bother about LEX::multi_lock_option if we convert multi-update to update anymore. Since nowdays multi-update uses TABLE_LIST::lock_type for specifying lock level of updated tables instead of LEX::multi_lock_option. sql/sql_update.cc: mysql_update()/mysql_multi_update_prepare(): Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql_multi_update(): We should return FALSE if no error occurs. sql/sql_yacc.yy: update: Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage).
2005-04-15 18:31:47 +02:00
send call bug9486();
connection con2root;
# There should be call statement in locked state.
let $wait_condition=SELECT COUNT(*)=1 FROM information_schema.processlist WHERE
id=$con1root_id AND state='Waiting for table metadata lock';
--source include/wait_condition.inc
--replace_result $con1root_id con1root_id
eval SELECT state,info FROM information_schema.processlist WHERE id=$con1root_id;
Fix for bug #9486 "Can't perform multi-update in stored procedure". New more SP-locking friendly approach to handling locks in multi-update. Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql-test/r/sp-threads.result: Added test for bug #9486 "Can't perform multi-update in stored procedure". mysql-test/t/sp-threads.test: Added test for bug #9486 "Can't perform multi-update in stored procedure". sql/sp_head.cc: SP_TABLE, sp_head::merge_table_list()/add_used_tables_to_table_list(): Since some queries during their execution (e.g. multi-update) may change type of lock for some of their tables and thus change lock_type member for some of elements of table list, we should store type of lock in SP_TABLE struct explicitly instead of using lock_type member of TABLE_LIST object pointed by SP_TABLE::table. sql/sql_lex.h: Removed no longer used LEX::multi_lock_option member. sql/sql_prepare.cc: mysql_test_update(): We don't need to bother about LEX::multi_lock_option if we convert multi-update to update anymore. Since nowdays multi-update uses TABLE_LIST::lock_type for specifying lock level of updated tables instead of LEX::multi_lock_option. sql/sql_update.cc: mysql_update()/mysql_multi_update_prepare(): Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql_multi_update(): We should return FALSE if no error occurs. sql/sql_yacc.yy: update: Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage).
2005-04-15 18:31:47 +02:00
unlock tables;
connection con1root;
reap;
drop procedure bug9486;
drop table t1, t2;
Fix for bug #11158 "Can't perform multi-delete in stored procedure". In order to make multi-delete SP friendly we need to have all table locks for the elements of main statement table list properly set at the end of parsing. Also performed small cleanup: We don't need relink_tables_for_multidelete() any longer since the only case now when TABLE_LIST::correspondent_table is non-zero are tables in auxilary table list of multi-delete and these tables are handled specially in mysql_multi_delete_prepare(). mysql-test/r/sp-threads.result: Added test case for bug #11158 "Can't perform multi-delete in stored procedure". mysql-test/t/sp-threads.test: Added test case for bug #11158 "Can't perform multi-delete in stored procedure". sql/mysql_priv.h: - Removed third argument from the declaration of multi_delete_precheck() as nowdays we calculate number of tables in multi-delete from which we are going to delete rows right at the end of statement parsing. - Introduced definition of multi_delete_set_locks_and_link_aux_tables() which is responsible for propagation of proper table locks from multi-delete's auxilary table list to the main list and binding corresponding tables in these two lists. sql/sql_base.cc: Removed relink_tables_for_multidelete() routine and its invocations. We don't need them in 5.0 since the only case now when TABLE_LIST::correspondent_table is non-zero are tables in auxilary table list of multi-delete and these tables are handled specially in mysql_multi_delete_prepare(). sql/sql_lex.h: LEX::table_count Added description of new role of this LEX member for multi-delete. Now for this statement we store number of tables from which we should delete records there. sql/sql_parse.cc: multi_delete_precheck(): Moved code which is responsible for iterating through auxilary table list and binding its elements with corresponding elements of main table list, and properly updating locks in it to separate function - multi_delete_set_locks_and_link_aux_tables(). This is because in order to make multi-delete SP friendly we need to have all locks set properly at the end of statement parsing. So we are introducing new function which will be called from parser. We also calculate number of tables from which we are going to perform deletions there and store this number for later usage in LEX::table_count. Also removed some no longer needed code. sql/sql_prepare.cc: mysql_test_multidelete(): Now multi_delete_precheck() takes only two arguments, so we don't need to pass fake third parameter. sql/sql_yacc.yy: delete: In order to make multi-delete SP friendly we need to have all table locks for the elements of main statement table list properly set at the end of parsing.
2005-06-08 23:07:52 +02:00
#
# Bug#11158 Can't perform multi-delete in stored procedure
Fix for bug #11158 "Can't perform multi-delete in stored procedure". In order to make multi-delete SP friendly we need to have all table locks for the elements of main statement table list properly set at the end of parsing. Also performed small cleanup: We don't need relink_tables_for_multidelete() any longer since the only case now when TABLE_LIST::correspondent_table is non-zero are tables in auxilary table list of multi-delete and these tables are handled specially in mysql_multi_delete_prepare(). mysql-test/r/sp-threads.result: Added test case for bug #11158 "Can't perform multi-delete in stored procedure". mysql-test/t/sp-threads.test: Added test case for bug #11158 "Can't perform multi-delete in stored procedure". sql/mysql_priv.h: - Removed third argument from the declaration of multi_delete_precheck() as nowdays we calculate number of tables in multi-delete from which we are going to delete rows right at the end of statement parsing. - Introduced definition of multi_delete_set_locks_and_link_aux_tables() which is responsible for propagation of proper table locks from multi-delete's auxilary table list to the main list and binding corresponding tables in these two lists. sql/sql_base.cc: Removed relink_tables_for_multidelete() routine and its invocations. We don't need them in 5.0 since the only case now when TABLE_LIST::correspondent_table is non-zero are tables in auxilary table list of multi-delete and these tables are handled specially in mysql_multi_delete_prepare(). sql/sql_lex.h: LEX::table_count Added description of new role of this LEX member for multi-delete. Now for this statement we store number of tables from which we should delete records there. sql/sql_parse.cc: multi_delete_precheck(): Moved code which is responsible for iterating through auxilary table list and binding its elements with corresponding elements of main table list, and properly updating locks in it to separate function - multi_delete_set_locks_and_link_aux_tables(). This is because in order to make multi-delete SP friendly we need to have all locks set properly at the end of statement parsing. So we are introducing new function which will be called from parser. We also calculate number of tables from which we are going to perform deletions there and store this number for later usage in LEX::table_count. Also removed some no longer needed code. sql/sql_prepare.cc: mysql_test_multidelete(): Now multi_delete_precheck() takes only two arguments, so we don't need to pass fake third parameter. sql/sql_yacc.yy: delete: In order to make multi-delete SP friendly we need to have all table locks for the elements of main statement table list properly set at the end of parsing.
2005-06-08 23:07:52 +02:00
#
--disable_warnings
drop procedure if exists bug11158;
--enable_warnings
create procedure bug11158() delete t1 from t1, t2 where t1.id = t2.id;
create table t1 (id int, j int);
insert into t1 values (1, 1), (2, 2);
create table t2 (id int);
insert into t2 values (1);
# Procedure should work and cause proper effect (delete only first row)
call bug11158();
select * from t1;
# Also let us test that we obtain only read (and thus non exclusive) lock
# for table from which we are not going to delete rows.
connection con2root;
lock tables t2 read;
connection con1root;
call bug11158();
connection con2root;
unlock tables;
connection con1root;
# Clean-up
drop procedure bug11158;
drop table t1, t2;
Fix for bug #9486 "Can't perform multi-update in stored procedure". New more SP-locking friendly approach to handling locks in multi-update. Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql-test/r/sp-threads.result: Added test for bug #9486 "Can't perform multi-update in stored procedure". mysql-test/t/sp-threads.test: Added test for bug #9486 "Can't perform multi-update in stored procedure". sql/sp_head.cc: SP_TABLE, sp_head::merge_table_list()/add_used_tables_to_table_list(): Since some queries during their execution (e.g. multi-update) may change type of lock for some of their tables and thus change lock_type member for some of elements of table list, we should store type of lock in SP_TABLE struct explicitly instead of using lock_type member of TABLE_LIST object pointed by SP_TABLE::table. sql/sql_lex.h: Removed no longer used LEX::multi_lock_option member. sql/sql_prepare.cc: mysql_test_update(): We don't need to bother about LEX::multi_lock_option if we convert multi-update to update anymore. Since nowdays multi-update uses TABLE_LIST::lock_type for specifying lock level of updated tables instead of LEX::multi_lock_option. sql/sql_update.cc: mysql_update()/mysql_multi_update_prepare(): Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage). mysql_multi_update(): We should return FALSE if no error occurs. sql/sql_yacc.yy: update: Now we mark all tables of multi-update as needing write lock at parsing stage and if possible downgrade lock at execution stage. Old approach (don't set lock type until execution stage) was not working well with SP-locking (For its work SP-locking mechanism needs to know all lock types right after parsing stage).
2005-04-15 18:31:47 +02:00
Implementation of Monty's idea: Now we can open mysql.proc table for lookup of stored routines definitions even if we already have some tables open and locked. To avoid deadlocks in this case we have to put certain restrictions on locking of mysql.proc table. This allows to use stored routines safely under LOCK TABLES without explicitly mentioning mysql.proc in the list of locked tables. It also fixes bug #11554 "Server crashes on statement indirectly using non-cached function". mysql-test/r/sp-error.result: Added test which checks that now we can read stored routines definitions under LOCK TABLES even if we have not locked mysql.proc explicitly. Also added check for restrictions which this ability puts on mysql.proc locking. Updated test for bug #9566 to correspond this new situation. mysql-test/r/sp-threads.result: Added test for bug #11554 "Server crashes on statement indirectly using non-cached function". mysql-test/t/sp-error.test: Added test which checks that now we can read stored routines definitions under LOCK TABLES even if we have not locked mysql.proc explicitly. Also added check for restrictions which this ability puts on mysql.proc locking. Updated test for bug #9566 to correspond this new situation. mysql-test/t/sp-threads.test: Added test for bug #11554 "Server crashes on statement indirectly using non-cached function". sql/lock.cc: get_lock_data(): To be able to open and lock for reading system tables like 'mysql.proc', when we already have some tables opened and locked, and avoid deadlocks we have to disallow write-locking of these tables with any other tables. sql/mysql_priv.h: open_table() has new parameter which allows to open table even if some-one has done a flush or holding namelock on it. sql/share/errmsg.txt: Added error message saying that one cannot write-lock some of system tables with any other tables. sql/sp.cc: open_proc_table_for_read()/close_proc_table(): Added functions to be able open and close mysql.proc table when we already have some tables open and locked. open_proc_table_for_update(): Added function to simplify opening of mysql.proc for updates. db_find_routine_aux()/db_find_routine()/db_update_routine()/... Moved responsibility for opening mysql.proc table from db_find_routine_aux() one level up, since this level knows better which type of table access for reading of for update it needs. sp_function_exists(): Removed unused function. sql/sp.h: sp_function_exists(): Removed unused function. sql/sql_base.cc: open_table(): Added new parameter which allows to open table even if some-one has done a flush or holding namelock on it. open_unireg_entry(): Mark 'mysql.proc' as a system table which has special restrictions on its locking, but thanks to them can be open and locked even if we already have some open and locked. sql/sql_class.cc: Moved THD members holding information about open and locked tables to separate Open_tables_state class to be able to save/restore this state easier. Added THD::push_open_tables_state()/pop_open_tables_state() methods for saving/restoring this state. sql/sql_class.h: Moved THD members holding information about open and locked tables to separate Open_tables_state class to be able to save/restore this state easier. Added THD::push_open_tables_state()/pop_open_tables_state() methods for saving/restoring this state. sql/sql_lex.cc: Removed LEX::proc_table member which was not really used. sql/sql_lex.h: Removed LEX::proc_table member which was not really used. sql/sql_table.cc: open_table() has new parameter which allows to open table even if some-one has done a flush or holding namelock on it. sql/table.h: Added TABLE_SHARE::system_table indicating that this table is system table like 'mysql.proc' and we want to be able to open and read-lock it even when we already have some tables open and locked (and because of this we have to put some restrictions on write locking it).
2005-07-13 11:48:13 +02:00
#
# Bug#11554 Server crashes on statement indirectly using non-cached function
Implementation of Monty's idea: Now we can open mysql.proc table for lookup of stored routines definitions even if we already have some tables open and locked. To avoid deadlocks in this case we have to put certain restrictions on locking of mysql.proc table. This allows to use stored routines safely under LOCK TABLES without explicitly mentioning mysql.proc in the list of locked tables. It also fixes bug #11554 "Server crashes on statement indirectly using non-cached function". mysql-test/r/sp-error.result: Added test which checks that now we can read stored routines definitions under LOCK TABLES even if we have not locked mysql.proc explicitly. Also added check for restrictions which this ability puts on mysql.proc locking. Updated test for bug #9566 to correspond this new situation. mysql-test/r/sp-threads.result: Added test for bug #11554 "Server crashes on statement indirectly using non-cached function". mysql-test/t/sp-error.test: Added test which checks that now we can read stored routines definitions under LOCK TABLES even if we have not locked mysql.proc explicitly. Also added check for restrictions which this ability puts on mysql.proc locking. Updated test for bug #9566 to correspond this new situation. mysql-test/t/sp-threads.test: Added test for bug #11554 "Server crashes on statement indirectly using non-cached function". sql/lock.cc: get_lock_data(): To be able to open and lock for reading system tables like 'mysql.proc', when we already have some tables opened and locked, and avoid deadlocks we have to disallow write-locking of these tables with any other tables. sql/mysql_priv.h: open_table() has new parameter which allows to open table even if some-one has done a flush or holding namelock on it. sql/share/errmsg.txt: Added error message saying that one cannot write-lock some of system tables with any other tables. sql/sp.cc: open_proc_table_for_read()/close_proc_table(): Added functions to be able open and close mysql.proc table when we already have some tables open and locked. open_proc_table_for_update(): Added function to simplify opening of mysql.proc for updates. db_find_routine_aux()/db_find_routine()/db_update_routine()/... Moved responsibility for opening mysql.proc table from db_find_routine_aux() one level up, since this level knows better which type of table access for reading of for update it needs. sp_function_exists(): Removed unused function. sql/sp.h: sp_function_exists(): Removed unused function. sql/sql_base.cc: open_table(): Added new parameter which allows to open table even if some-one has done a flush or holding namelock on it. open_unireg_entry(): Mark 'mysql.proc' as a system table which has special restrictions on its locking, but thanks to them can be open and locked even if we already have some open and locked. sql/sql_class.cc: Moved THD members holding information about open and locked tables to separate Open_tables_state class to be able to save/restore this state easier. Added THD::push_open_tables_state()/pop_open_tables_state() methods for saving/restoring this state. sql/sql_class.h: Moved THD members holding information about open and locked tables to separate Open_tables_state class to be able to save/restore this state easier. Added THD::push_open_tables_state()/pop_open_tables_state() methods for saving/restoring this state. sql/sql_lex.cc: Removed LEX::proc_table member which was not really used. sql/sql_lex.h: Removed LEX::proc_table member which was not really used. sql/sql_table.cc: open_table() has new parameter which allows to open table even if some-one has done a flush or holding namelock on it. sql/table.h: Added TABLE_SHARE::system_table indicating that this table is system table like 'mysql.proc' and we want to be able to open and read-lock it even when we already have some tables open and locked (and because of this we have to put some restrictions on write locking it).
2005-07-13 11:48:13 +02:00
#
--disable_warnings
drop function if exists bug11554;
drop view if exists v1;
--enable_warnings
create table t1 (i int);
create function bug11554 () returns int return 1;
create view v1 as select bug11554() as f;
connection con2root;
# This should not crash server
insert into t1 (select f from v1);
# Clean-up
connection con1root;
drop function bug11554;
drop table t1;
drop view v1;
# Bug#12228 Crash happens during calling specific SP in multithread environment
--disable_warnings
drop procedure if exists p1;
drop procedure if exists p2;
--enable_warnings
connection con1root;
delimiter |;
create table t1 (s1 int)|
create procedure p1() select * from t1|
create procedure p2()
begin
insert into t1 values (1);
call p1();
select * from t1;
end|
delimiter ;|
connection con2root;
use test;
lock table t1 write;
connection con1root;
send call p2();
connection con3root;
use test;
drop procedure p1;
create procedure p1() select * from t1;
connection con2root;
unlock tables;
connection con1root;
# Crash will be here if we hit Bug#12228
reap;
drop procedure p1;
drop procedure p2;
drop table t1;
#
# Bug#NNNN New bug synopsis
#
#--disable_warnings
#drop procedure if exists bugNNNN;
#--enable_warnings
#create procedure bugNNNN...
connection default;
disconnect con1root;
disconnect con2root;
disconnect con3root;
# Wait till we reached the initial number of concurrent sessions
--source include/wait_until_count_sessions.inc