mirror of
https://github.com/MariaDB/server.git
synced 2025-01-21 06:22:28 +01:00
0228c98936
This change is supposed to reduce number of ER_LOCK_DEADLOCK errors which occur when multi-statement transaction encounters conflicting metadata lock in cases when waiting is possible. The idea is not to fail ER_LOCK_DEADLOCK error immediately when we encounter conflicting metadata lock. Instead we release all metadata locks acquired by current statement and start to wait until conflicting lock go away. To avoid deadlocks we use simple empiric which aborts waiting with ER_LOCK_DEADLOCK error if it turns out that somebody is waiting for metadata locks owned by this transaction. This patch also fixes bug #46273 "MySQL 5.4.4 new MDL: Bug#989 is not fully fixed in case of ALTER". The bug was that concurrent execution of UPDATE or MULTI-UPDATE statement as a part of multi-statement transaction that already has used table being updated and ALTER TABLE statement might have resulted of loss of isolation between this transaction and ALTER TABLE statement, which manifested itself as changes performed by ALTER TABLE becoming visible in transaction and wrong binary log order as a consequence. This problem occurred when UPDATE or MULTI-UPDATE's wait in mysql_lock_tables() call was aborted due to metadata lock upgrade performed by concurrent ALTER TABLE. After such abort all metadata locks held by transaction were released but transaction silently continued to be executed as if nothing has happened. We solve this problem by changing our code not to release all locks in such case. Instead we release only locks which were acquired by current statement and then try to reacquire them by restarting open/lock tables process. We piggyback on simple deadlock detector implementation since this change has to be done anyway for it. mysql-test/include/handler.inc: After introduction of basic deadlock detector for metadata locks it became necessary to change parts of test for HANDLER statements which covered some of scenarios in which ER_LOCK_DEADLOCK error was detected in absence of real deadlock (with new deadlock detector this no longer happens). Also adjusted test to the fact that HANDLER READ for the table no longer will be blocked by ALTER TABLE for the same table which awaits for metadata lock upgrade (this is due to removal of mysql_lock_abort() from wait_while_table_is_used()). mysql-test/r/handler_innodb.result: After introduction of basic deadlock detector for metadata locks it became necessary to change parts of test for HANDLER statements which covered some of scenarios in which ER_LOCK_DEADLOCK error was detected in absence of real deadlock (with new deadlock detector this no longer happens). Also adjusted test to the fact that HANDLER READ for the table no longer will be blocked by ALTER TABLE for the same table which awaits for metadata lock upgrade (this is due to removal of mysql_lock_abort() from wait_while_table_is_used()). mysql-test/r/handler_myisam.result: After introduction of basic deadlock detector for metadata locks it became necessary to change parts of test for HANDLER statements which covered some of scenarios in which ER_LOCK_DEADLOCK error was detected in absence of real deadlock (with new deadlock detector this no longer happens). Also adjusted test to the fact that HANDLER READ for the table no longer will be blocked by ALTER TABLE for the same table which awaits for metadata lock upgrade (this is due to removal of mysql_lock_abort() from wait_while_table_is_used()). mysql-test/r/mdl_sync.result: Added test coverage for basic deadlock detection in metadata locking subsystem and for bug #46273 "MySQL 5.4.4 new MDL: Bug#989 is not fully fixed in case of ALTER". mysql-test/r/sp-lock.result: Adjusted test coverage for metadata locking for stored routines since after introduction of basic deadlock detector for metadata locks number of scenarios in which ER_LOCK_DEADLOCK error in absence of deadlock has decreased. mysql-test/t/mdl_sync.test: Added test coverage for basic deadlock detection in metadata locking subsystem and for bug #46273 "MySQL 5.4.4 new MDL: Bug#989 is not fully fixed in case of ALTER". mysql-test/t/sp-lock.test: Adjusted test coverage for metadata locking for stored routines since after introduction of basic deadlock detector for metadata locks number of scenarios in which ER_LOCK_DEADLOCK error in absence of deadlock has decreased. sql/log_event_old.cc: close_tables_for_reopen() now takes one more argument which specifies at which point it should stop releasing metadata locks acquired by this connection. sql/mdl.cc: Changed metadata locking subsystem to support basic deadlock detection with a help of the following simple empiric -- we assume that there is a deadlock if there is a connection which has to wait for a metadata lock which is currently acquired by some connection which is itself waiting to be able to acquire some shared metadata lock. To implement this change: - Added MDL_context::can_wait_lead_to_deadlock()/_impl() methods which allow to find out if there is someone waiting for metadata lock which is held by the connection and therefore deadlocks are possible if this connection is going to wait for some metadata lock. To do this added version of MDL_ticket::has_pending_conflicting_lock() method which assumes that its caller already owns LOCK_mdl mutex. - Changed MDL_context::wait_for_locks() to use one of the above methods to check if somebody is waiting for metadata lock owned by this context (and therefore deadlock is possible) and emit ER_LOCK_DEADLOCK error in this case. Also now we mark context of connections waiting inside of this method by setting MDL_context::m_is_waiting_in_mdl member. Thanks to this such connection could be waken up if some other connection starts waiting for one of its metadata locks and so a deadlock can occur. - Adjusted notify_shared_lock() to wake up connections which wait inside MDL_context::wait_for_locks() while holding shared metadata lock. - Changed MDL_ticket::upgrade_shared_lock_to_exclusive() to add temporary ticket for exclusive lock to MDL_lock::waiting queue, so request for metadata lock upgrade can be properly detected by our empiric. Also now this method invokes a callback which forces transactions holding shared metadata lock on the table to call MDL_context:: can_wait_lead_to_deadlock() method even if they don't need any new metadata locks. Thanks to this such transactions can detect deadlocks/ livelocks between MDL and table-level locks. Also reduced timeouts between calls to notify_shared_lock() in MDL_ticket::upgrade_shared_lock_to_exclusive() and MDL_context::acquire_exclusive_locks(). This was necessary to get rid of call to mysql_lock_abort() in wait_while_table_is_used(). (Now we instead rely on notify_shared_lock() timely calling mysql_lock_abort_for_thread() for the table on which lock is being upgraded/acquired). sql/mdl.h: - Added a version of MDL_ticket::has_pending_conflicting_lock() method to be used in situations when caller already has acquired LOCK_mdl mutex. - Added MDL_context::can_wait_lead_to_deadlock()/_impl() methods which allow to find out if there is someone waiting for metadata lock which is held by this connection and thus deadlocks are possible if this connections will start waiting for some metadata lock. - Added MDL_context::m_is_waiting_in_mdl member to mark connections waiting in MDL_context::wait_for_locks() method of metadata locking subsystem. Added getter method for this private member to make it accessible in notify_shared_lock() auxiliary so we can wake-up such connections if they hold shared metadata locks. - Finally, added mysql_abort_transactions_with_shared_lock() callback to be able force transactions which don't need any new metadata locks still call MDL_context::can_wait_lead_to_deadlock() and detect some of deadlocks between metadata locks and table-level locks. sql/mysql_priv.h: close_tables_for_reopen() now takes one more argument which specifies at which point it should stop releasing metadata locks acquired by this connection. sql/sql_base.cc: Changed approach to metadata locking for multi-statement transactions. We no longer fail ER_LOCK_DEADLOCK error immediately when we encounter conflicting metadata lock. Instead we release all metadata locks acquired by current statement and start to wait until conflicting locks to go away by calling MDL_context::wait_for_locks() method. To avoid deadlocks the latter implements simple empiric which aborts waiting with ER_LOCK_DEADLOCK error if it turns out that somebody is waiting for metadata locks owned by this transaction. To implement the change described above: - Introduced Open_table_context::m_start_of_statement_svp member to store state of metadata locks at the start of the statement. - Changed Open_table_context::request_backoff_action() not to fail with ER_LOCK_DEADLOCK immediately if back-off is requested due to conflicting metadata lock. - Added new argument for close_tables_for_reopen() procedure which allows to specify subset of metadata locks to be released. - Changed open_tables() not to release all metadata locks acquired by current transaction when metadata lock conflict is discovered. Instead we release only locks acquired by current statement. - Changed open_ltable() and open_and_lock_tables_derived() not to emit ER_LOCK_DEADLOCK error when mysql_lock_tables() is aborted in multi-statement transaction when somebody tries to acquire exclusive metadata lock on the table. Instead we release metadata locks acquired by current statement and try to wait until they can be re-acquired. - Adjusted tdc_wait_for_old_versions() to check if there is someone waiting for one of metadata locks held by this connection and run deadlock detection in order to avoid deadlocks in some situations. - Added mysql_abort_transactions_with_shared_lock() callback which allows to force transactions holding shared metadata lock on the table to call MDL_context::can_wait_lead_to_deadlock() even if they don't need any new metadata locks so they can detect potential deadlocks between metadata locking subsystem and table-level locks. - Adjusted wait_while_table_is_used() not to set TABLE::version to 0 as it is now done only when necessary by the above-mentioned callback. Also removed unnecessary call to mysql_lock_abort(). Instead we rely on code performing metadata lock upgrade aborting waits on the table-level lock for this table by calling mysql_lock_abort_for_thread() (invoked by mysql_notify_thread_having_shared_lock()). In future this should allow to reduce number of scenarios in which we produce ER_LOCK_DEADLOCK error even though no real deadlock exists. sql/sql_class.h: Introduced Open_table_context::m_start_of_statement_svp member to store state of metadata locks at the start of the statement. Replaced Open_table_context::m_can_deadlock member with m_has_locks member to reflect the fact that we no longer unconditionally emit ER_LOCK_DEADLOCK error for transaction having some metadata locks when conflicting metadata lock is discovered. sql/sql_insert.cc: close_tables_for_reopen() now takes one more argument which specifies at which point it should stop releasing metadata locks acquired by this connection. sql/sql_plist.h: Made I_P_List_iterator<T, B> usable with const lists. sql/sql_show.cc: close_tables_for_reopen() now takes one more argument which specifies at which point it should stop releasing metadata locks acquired by this connection. sql/sql_update.cc: Changed UPDATE and MULTI-UPDATE code not to release all metadata locks when calls to mysql_lock_tables() are aborted. Instead we release only locks which are acquired by this statement and then try to reacquire them by calling open_tables(). This solves bug #46273 "MySQL 5.4.4 new MDL: Bug#989 is not fully fixed in case of ALTER".
697 lines
18 KiB
Text
697 lines
18 KiB
Text
#
|
|
# Test coverage for changes performed by the fix
|
|
# for Bug#30977 "Concurrent statement using stored function
|
|
# and DROP FUNCTION breaks SBR.
|
|
#
|
|
#
|
|
# 1) Verify that the preceding transaction is
|
|
# (implicitly) committed before CREATE/ALTER/DROP
|
|
# PROCEDURE. Note, that this is already tested
|
|
# in implicit_commit.test, but here we use an alternative
|
|
# approach.
|
|
#
|
|
# Start a transaction, create a savepoint,
|
|
# then call a DDL operation on a procedure, and then check
|
|
# that the savepoint is no longer present.
|
|
drop table if exists t1;
|
|
drop procedure if exists p1;
|
|
drop procedure if exists p2;
|
|
drop procedure if exists p3;
|
|
drop procedure if exists p4;
|
|
drop function if exists f1;
|
|
create table t1 (a int);
|
|
#
|
|
# Test 'CREATE PROCEDURE'.
|
|
#
|
|
begin;
|
|
savepoint sv;
|
|
create procedure p1() begin end;
|
|
rollback to savepoint sv;
|
|
ERROR 42000: SAVEPOINT sv does not exist
|
|
#
|
|
# Test 'ALTER PROCEDURE'.
|
|
#
|
|
begin;
|
|
savepoint sv;
|
|
alter procedure p1 comment 'changed comment';
|
|
rollback to savepoint sv;
|
|
ERROR 42000: SAVEPOINT sv does not exist
|
|
#
|
|
# Test 'DROP PROCEDURE'.
|
|
#
|
|
begin;
|
|
savepoint sv;
|
|
drop procedure p1;
|
|
rollback to savepoint sv;
|
|
ERROR 42000: SAVEPOINT sv does not exist
|
|
#
|
|
# Test 'CREATE FUNCTION'.
|
|
#
|
|
begin;
|
|
savepoint sv;
|
|
create function f1() returns int return 1;
|
|
rollback to savepoint sv;
|
|
ERROR 42000: SAVEPOINT sv does not exist
|
|
#
|
|
# Test 'ALTER FUNCTION'.
|
|
#
|
|
begin;
|
|
savepoint sv;
|
|
alter function f1 comment 'new comment';
|
|
rollback to savepoint sv;
|
|
ERROR 42000: SAVEPOINT sv does not exist
|
|
#
|
|
# Test 'DROP FUNCTION'.
|
|
#
|
|
begin;
|
|
savepoint sv;
|
|
drop function f1;
|
|
rollback to savepoint sv;
|
|
ERROR 42000: SAVEPOINT sv does not exist
|
|
#
|
|
# 2) Verify that procedure DDL operations fail
|
|
# under lock tables.
|
|
#
|
|
# Auxiliary routines to test ALTER.
|
|
create procedure p1() begin end;
|
|
create function f1() returns int return 1;
|
|
lock table t1 write;
|
|
create procedure p2() begin end;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
alter procedure p1 comment 'changed comment';
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
drop procedure p1;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
create function f2() returns int return 1;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
alter function f1 comment 'changed comment';
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
lock table t1 read;
|
|
create procedure p2() begin end;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
alter procedure p1 comment 'changed comment';
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
drop procedure p1;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
create function f2() returns int return 1;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
alter function f1 comment 'changed comment';
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
unlock tables;
|
|
#
|
|
# Even if we locked a temporary table.
|
|
# Todo: this is a restriction we could possibly lift.
|
|
#
|
|
drop table t1;
|
|
create temporary table t1 (a int);
|
|
lock table t1 read;
|
|
create procedure p2() begin end;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
alter procedure p1 comment 'changed comment';
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
drop procedure p1;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
create function f2() returns int return 1;
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
alter function f1 comment 'changed comment';
|
|
ERROR HY000: Can't execute the given command because you have active locked tables or an active transaction
|
|
unlock tables;
|
|
drop function f1;
|
|
drop procedure p1;
|
|
drop temporary table t1;
|
|
#
|
|
# 3) Verify that CREATE/ALTER/DROP routine grab an
|
|
# exclusive lock.
|
|
#
|
|
# For that, start a transaction, use a routine. In a concurrent
|
|
# connection, try to drop or alter the routine. It should place
|
|
# a pending or exclusive lock and block. In another concurrnet
|
|
# connection, try to use the routine.
|
|
# That should block on the pending exclusive lock.
|
|
#
|
|
# Establish helper connections.
|
|
#
|
|
# Test DROP PROCEDURE.
|
|
#
|
|
# --> connection default
|
|
create procedure p1() begin end;
|
|
create function f1() returns int
|
|
begin
|
|
call p1();
|
|
return 1;
|
|
end|
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'drop procedure p1'...
|
|
drop procedure p1;
|
|
# --> connection con2
|
|
# Waitng for 'drop procedure t1' to get blocked on MDL lock...
|
|
# Demonstrate that there is a pending exclusive lock.
|
|
# Sending 'select f1()'...
|
|
select f1();
|
|
# --> connection con3
|
|
# Waitng for 'select f1()' to get blocked by a pending MDL lock...
|
|
# --> connection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'drop procedure p1'...
|
|
# --> connection con2
|
|
# Reaping 'select f1()'
|
|
ERROR 42000: PROCEDURE test.p1 does not exist
|
|
# --> connection default
|
|
#
|
|
# Test CREATE PROCEDURE.
|
|
#
|
|
create procedure p1() begin end;
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'create procedure p1'...
|
|
create procedure p1() begin end;
|
|
# --> connection con2
|
|
# Waitng for 'create procedure t1' to get blocked on MDL lock...
|
|
# Demonstrate that there is a pending exclusive lock.
|
|
# Sending 'select f1()'...
|
|
select f1();
|
|
# --> connection con3
|
|
# Waitng for 'select f1()' to get blocked by a pending MDL lock...
|
|
# --> connection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'create procedure p1'...
|
|
ERROR 42000: PROCEDURE p1 already exists
|
|
# --> connection con2
|
|
# Reaping 'select f1()'
|
|
f1()
|
|
1
|
|
#
|
|
# Test ALTER PROCEDURE.
|
|
#
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'alter procedure p1'...
|
|
alter procedure p1 contains sql;
|
|
# --> connection con2
|
|
# Waitng for 'alter procedure t1' to get blocked on MDL lock...
|
|
# Demonstrate that there is a pending exclusive lock.
|
|
# Sending 'select f1()'...
|
|
select f1();
|
|
# --> connection con3
|
|
# Waitng for 'select f1()' to get blocked by a pending MDL lock...
|
|
# --> connection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'alter procedure p1'...
|
|
# --> connection con2
|
|
# Reaping 'select f1()'
|
|
f1()
|
|
1
|
|
# --> connection default
|
|
#
|
|
# Test DROP FUNCTION.
|
|
#
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'drop function f1'...
|
|
drop function f1;
|
|
# --> connection con2
|
|
# Waitng for 'drop function f1' to get blocked on MDL lock...
|
|
# Demonstrate that there is a pending exclusive lock.
|
|
# Sending 'select f1()'...
|
|
select f1();
|
|
# --> connection con3
|
|
# Waitng for 'select f1()' to get blocked by a pending MDL lock...
|
|
# --> connection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'drop function f1'...
|
|
# --> connection con2
|
|
# Reaping 'select f1()'
|
|
ERROR 42000: FUNCTION test.f1 does not exist
|
|
# --> connection default
|
|
#
|
|
# Test CREATE FUNCTION.
|
|
#
|
|
create function f1() returns int return 1;
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'create function f1'...
|
|
create function f1() returns int return 2;
|
|
# --> connection con2
|
|
# Waitng for 'create function f1' to get blocked on MDL lock...
|
|
# Demonstrate that there is a pending exclusive lock.
|
|
# Sending 'select f1()'...
|
|
select f1();
|
|
# --> connection con3
|
|
# Waitng for 'select f1()' to get blocked by a pending MDL lock...
|
|
# --> connection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'create function f1'...
|
|
ERROR 42000: FUNCTION f1 already exists
|
|
# --> connection con2
|
|
# Reaping 'select f1()'
|
|
f1()
|
|
1
|
|
# --> connection default
|
|
#
|
|
# Test ALTER FUNCTION.
|
|
#
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'alter function f1'...
|
|
alter function f1 contains sql;
|
|
# --> connection con2
|
|
# Waitng for 'alter function f1' to get blocked on MDL lock...
|
|
# Demonstrate that there is a pending exclusive lock.
|
|
# Sending 'select f1()'...
|
|
select f1();
|
|
# --> connection con3
|
|
# Waitng for 'select f1()' to get blocked by a pending MDL lock...
|
|
# --> connection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'alter function f1'...
|
|
# --> connection con2
|
|
# Reaping 'select f1()'
|
|
f1()
|
|
1
|
|
# --> connection default
|
|
drop function f1;
|
|
drop procedure p1;
|
|
#
|
|
# 4) MDL lock should not be taken for
|
|
# unrolled CALL statements.
|
|
# The primary goal of metadata locks is a consistent binary log.
|
|
# When a call statement is unrolled, it doesn't get to the
|
|
# binary log, instead the statements that are contained
|
|
# in the procedure body do. This can nest to any level.
|
|
#
|
|
create procedure p1() begin end;
|
|
create procedure p2() begin end;
|
|
create table t1 (a int);
|
|
create procedure p3()
|
|
begin
|
|
call p1();
|
|
call p1();
|
|
call p2();
|
|
end|
|
|
create procedure p4()
|
|
begin
|
|
call p1();
|
|
call p1();
|
|
call p2();
|
|
call p2();
|
|
call p3();
|
|
end|
|
|
begin;
|
|
select * from t1;
|
|
a
|
|
savepoint sv;
|
|
call p4();
|
|
# Prepared statement should not add any locks either.
|
|
prepare stmt from "call p4()";
|
|
execute stmt;
|
|
execute stmt;
|
|
# --> connection con1
|
|
drop procedure p1;
|
|
drop procedure p2;
|
|
drop procedure p3;
|
|
drop procedure p4;
|
|
# --> connection default
|
|
# This is to verify there was no implicit commit.
|
|
rollback to savepoint sv;
|
|
call p4();
|
|
ERROR 42000: PROCEDURE test.p4 does not exist
|
|
commit;
|
|
drop table t1;
|
|
#
|
|
# 5) Locks should be taken on routines
|
|
# used indirectly by views or triggers.
|
|
#
|
|
#
|
|
# A function is used from a trigger.
|
|
#
|
|
create function f1() returns int return 1;
|
|
create table t1 (a int);
|
|
create table t2 (a int, b int);
|
|
create trigger t1_ai after insert on t1 for each row
|
|
insert into t2 (a, b) values (new.a, f1());
|
|
begin;
|
|
insert into t1 (a) values (1);
|
|
# --> connection con1
|
|
# Sending 'drop function f1'
|
|
drop function f1;
|
|
# --> connection con2
|
|
# Waitng for 'drop function f1' to get blocked on MDL lock...
|
|
# --> connnection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'drop function f1'...
|
|
# --> connection default
|
|
#
|
|
# A function is used from a view.
|
|
#
|
|
create function f1() returns int return 1;
|
|
create view v1 as select f1() as a;
|
|
begin;
|
|
select * from v1;
|
|
a
|
|
1
|
|
# --> connection con1
|
|
# Sending 'drop function f1'
|
|
drop function f1;
|
|
# --> connection con2
|
|
# Waitng for 'drop function f1' to get blocked on MDL lock...
|
|
# --> connnection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'drop function f1'...
|
|
# --> connection default
|
|
#
|
|
# A procedure is used from a function.
|
|
#
|
|
create function f1() returns int
|
|
begin
|
|
declare v_out int;
|
|
call p1(v_out);
|
|
return v_out;
|
|
end|
|
|
create procedure p1(out v_out int) set v_out=3;
|
|
begin;
|
|
select * from v1;
|
|
a
|
|
3
|
|
# --> connection con1
|
|
# Sending 'drop procedure p1'
|
|
drop procedure p1;
|
|
# --> connection con2
|
|
# Waitng for 'drop procedure p1' to get blocked on MDL lock...
|
|
# --> connnection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'drop procedure p1'...
|
|
# --> connection default
|
|
#
|
|
# Deep nesting: a function is used from a procedure used
|
|
# from a function used from a view used in a trigger.
|
|
#
|
|
create function f2() returns int return 4;
|
|
create procedure p1(out v_out int) set v_out=f2();
|
|
drop trigger t1_ai;
|
|
create trigger t1_ai after insert on t1 for each row
|
|
insert into t2 (a, b) values (new.a, (select max(a) from v1));
|
|
begin;
|
|
insert into t1 (a) values (3);
|
|
# --> connection con1
|
|
# Sending 'drop function f2'
|
|
drop function f2;
|
|
# --> connection con2
|
|
# Waitng for 'drop function f2' to get blocked on MDL lock...
|
|
# --> connnection default
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'drop function f2'...
|
|
# --> connection default
|
|
drop view v1;
|
|
drop function f1;
|
|
drop procedure p1;
|
|
drop table t1, t2;
|
|
#
|
|
# 6) Check that ER_LOCK_DEADLOCK is reported if
|
|
# acquisition of a shared lock fails during a transaction or
|
|
# we need to back off to flush the sp cache.
|
|
#
|
|
# Sic: now this situation does not require a back off since we
|
|
# flush the cache on the fly.
|
|
#
|
|
create function f1() returns int return 7;
|
|
create table t1 (a int);
|
|
begin;
|
|
select * from t1;
|
|
a
|
|
select f1();
|
|
f1()
|
|
7
|
|
commit;
|
|
drop table t1;
|
|
drop function f1;
|
|
#
|
|
# 7) Demonstrate that under LOCK TABLES we accumulate locks
|
|
# on stored routines, and release metadata locks in
|
|
# ROLLBACK TO SAVEPOINT. That is done only for those stored
|
|
# routines that are not part of LOCK TABLES prelocking list.
|
|
# Those stored routines that are part of LOCK TABLES
|
|
# prelocking list are implicitly locked when entering
|
|
# LOCK TABLES, and ROLLBACK TO SAVEPOINT has no effect on
|
|
# them.
|
|
#
|
|
create function f1() returns varchar(20) return "f1()";
|
|
create function f2() returns varchar(20) return "f2()";
|
|
create view v1 as select f1() as a;
|
|
set @@session.autocommit=0;
|
|
lock table v1 read;
|
|
select * from v1;
|
|
a
|
|
f1()
|
|
savepoint sv;
|
|
select f2();
|
|
f2()
|
|
f2()
|
|
# --> connection con1
|
|
# Sending 'drop function f1'...
|
|
drop function f1;
|
|
# --> connection con2
|
|
# Waitng for 'drop function f1' to get blocked on MDL lock...
|
|
# Sending 'drop function f2'...
|
|
drop function f2;
|
|
# --> connection default
|
|
# Waitng for 'drop function f2' to get blocked on MDL lock...
|
|
rollback to savepoint sv;
|
|
# --> connection con2
|
|
# Reaping 'drop function f2'...
|
|
# --> connection default
|
|
unlock tables;
|
|
# --> connection con1
|
|
# Reaping 'drop function f1'...
|
|
# --> connection default
|
|
drop function f1;
|
|
ERROR 42000: FUNCTION test.f1 does not exist
|
|
drop function f2;
|
|
ERROR 42000: FUNCTION test.f2 does not exist
|
|
drop view v1;
|
|
set @@session.autocommit=default;
|
|
#
|
|
# 8) Check the situation when we're preparing or executing a
|
|
# prepared statement, and as part of that try to flush the
|
|
# session sp cache. However, one of the procedures that
|
|
# needs a flush is in use. Verify that there is no infinite
|
|
# reprepare loop and no crash.
|
|
#
|
|
create function f1() returns int return 1;
|
|
#
|
|
# We just mention p1() in the body of f2() to make
|
|
# sure that p1() metadata is validated when validating
|
|
# 'select f2()'.
|
|
# Recursion is not allowed in stored functions, so
|
|
# an attempt to just invoke p1() from f2() which is in turn
|
|
# called from p1() would have given a run-time error.
|
|
#
|
|
create function f2() returns int
|
|
begin
|
|
if @var is null then
|
|
call p1();
|
|
end if;
|
|
return 1;
|
|
end|
|
|
create procedure p1()
|
|
begin
|
|
select f1() into @var;
|
|
execute stmt;
|
|
end|
|
|
# --> connection con2
|
|
prepare stmt from "select f2()";
|
|
# --> connection default
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'alter function f1 ...'...
|
|
alter function f1 comment "comment";
|
|
# --> connection con2
|
|
# Waitng for 'alter function f1 ...' to get blocked on MDL lock...
|
|
# Sending 'call p1()'...
|
|
call p1();
|
|
# Waitng for 'call p1()' to get blocked on MDL lock on f1...
|
|
# Let 'alter function f1 ...' go through...
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'alter function f1 ...'
|
|
# --> connection con2
|
|
# Reaping 'call p1()'...
|
|
f2()
|
|
1
|
|
deallocate prepare stmt;
|
|
# --> connection default
|
|
drop function f1;
|
|
drop function f2;
|
|
drop procedure p1;
|
|
#
|
|
# 9) Check the situation when a stored function is invoked
|
|
# from a stored procedure, and recursively invokes the
|
|
# stored procedure that is in use. But for the second
|
|
# invocation, a cache flush is requested. We can't
|
|
# flush the procedure that's in use, and are forced
|
|
# to use an old version. It is not a violation of
|
|
# consistency, since we unroll top-level calls.
|
|
# Just verify the code works.
|
|
#
|
|
create function f1() returns int return 1;
|
|
begin;
|
|
select f1();
|
|
f1()
|
|
1
|
|
# --> connection con1
|
|
# Sending 'alter function f1 ...'...
|
|
alter function f1 comment "comment";
|
|
# --> connection con2
|
|
# Waitng for 'alter function f1 ...' to get blocked on MDL lock...
|
|
#
|
|
# We just mention p1() in the body of f2() to make
|
|
# sure that p1() is prelocked for f2().
|
|
# Recursion is not allowed in stored functions, so
|
|
# an attempt to just invoke p1() from f2() which is in turn
|
|
# called from p1() would have given a run-time error.
|
|
#
|
|
create function f2() returns int
|
|
begin
|
|
if @var is null then
|
|
call p1();
|
|
end if;
|
|
return 1;
|
|
end|
|
|
create procedure p1()
|
|
begin
|
|
select f1() into @var;
|
|
select f2() into @var;
|
|
end|
|
|
# Sending 'call p1()'...
|
|
call p1();
|
|
# Waitng for 'call p1()' to get blocked on MDL lock on f1...
|
|
# Let 'alter function f1 ...' go through...
|
|
commit;
|
|
# --> connection con1
|
|
# Reaping 'alter function f1 ...'
|
|
# --> connection con2
|
|
# Reaping 'call p1()'...
|
|
# --> connection default
|
|
drop function f1;
|
|
drop function f2;
|
|
drop procedure p1;
|
|
#
|
|
# 10) A select from information_schema.routines now
|
|
# flushes the stored routines caches. Test that this
|
|
# does not remove from the cache a stored routine
|
|
# that is already prelocked.
|
|
#
|
|
create function f1() returns int return get_lock("30977", 100000);
|
|
create function f2() returns int return 2;
|
|
create function f3() returns varchar(255)
|
|
begin
|
|
declare res varchar(255);
|
|
declare c cursor for select routine_name from
|
|
information_schema.routines where routine_name='f1';
|
|
select f1() into @var;
|
|
open c;
|
|
fetch c into res;
|
|
close c;
|
|
select f2() into @var;
|
|
return res;
|
|
end|
|
|
# --> connection con1
|
|
select get_lock("30977", 0);
|
|
get_lock("30977", 0)
|
|
1
|
|
# --> connection default
|
|
# Sending 'select f3()'...
|
|
select f3();
|
|
# --> connection con1
|
|
# Waitng for 'select f3()' to get blocked on the user level lock...
|
|
# Do something to change the cache version.
|
|
create function f4() returns int return 4;
|
|
drop function f4;
|
|
select release_lock("30977");
|
|
release_lock("30977")
|
|
1
|
|
# --> connection default
|
|
# Reaping 'select f3()'...
|
|
# Routine 'f2()' should exist and get executed successfully.
|
|
f3()
|
|
f1
|
|
select @var;
|
|
@var
|
|
2
|
|
drop function f1;
|
|
drop function f2;
|
|
drop function f3;
|
|
# 11) Check the situation when the connection is flushing the
|
|
# SP cache which contains a procedure that is being executed.
|
|
#
|
|
# Function f1() calls p1(). Procedure p1() has a DROP
|
|
# VIEW statement, which, we know, invalidates the routines cache.
|
|
# During cache flush p1() must not be flushed since it's in
|
|
# use.
|
|
#
|
|
create function f1() returns int
|
|
begin
|
|
call p1();
|
|
return 1;
|
|
end|
|
|
create procedure p1()
|
|
begin
|
|
create view v1 as select 1;
|
|
drop view v1;
|
|
select f1() into @var;
|
|
set @exec_count=@exec_count+1;
|
|
end|
|
|
set @exec_count=0;
|
|
call p1();
|
|
ERROR HY000: Recursive limit 0 (as set by the max_sp_recursion_depth variable) was exceeded for routine p1
|
|
select @exec_count;
|
|
@exec_count
|
|
0
|
|
set @@session.max_sp_recursion_depth=5;
|
|
set @exec_count=0;
|
|
call p1();
|
|
ERROR HY000: Explicit or implicit commit is not allowed in stored function or trigger.
|
|
select @exec_count;
|
|
@exec_count
|
|
0
|
|
drop procedure p1;
|
|
drop function f1;
|
|
set @@session.max_sp_recursion_depth=default;
|
|
# --> connection con1
|
|
# --> connection con2
|
|
# --> connection con3
|
|
# --> connection default
|
|
#
|
|
# End of 5.5 tests
|
|
#
|