mirror of
https://github.com/MariaDB/server.git
synced 2025-01-27 01:04:19 +01:00
6bf6272fda
bug #57006 "Deadlock between HANDLER and FLUSH TABLES WITH READ LOCK" and bug #54673 "It takes too long to get readlock for 'FLUSH TABLES WITH READ LOCK'". The first bug manifested itself as a deadlock which occurred when a connection, which had some table open through HANDLER statement, tried to update some data through DML statement while another connection tried to execute FLUSH TABLES WITH READ LOCK concurrently. What happened was that FTWRL in the second connection managed to perform first step of GRL acquisition and thus blocked all upcoming DML. After that it started to wait for table open through HANDLER statement to be flushed. When the first connection tried to execute DML it has started to wait for GRL/the second connection creating deadlock. The second bug manifested itself as starvation of FLUSH TABLES WITH READ LOCK statements in cases when there was a constant stream of concurrent DML statements (in two or more connections). This has happened because requests for protection against GRL which were acquired by DML statements were ignoring presence of pending GRL and thus the latter was starved. This patch solves both these problems by re-implementing GRL using metadata locks. Similar to the old implementation acquisition of GRL in new implementation is two-step. During the first step we block all concurrent DML and DDL statements by acquiring global S metadata lock (each DML and DDL statement acquires global IX lock for its duration). During the second step we block commits by acquiring global S lock in COMMIT namespace (commit code acquires global IX lock in this namespace). Note that unlike in old implementation acquisition of protection against GRL in DML and DDL is semi-automatic. We assume that any statement which should be blocked by GRL will either open and acquires write-lock on tables or acquires metadata locks on objects it is going to modify. For any such statement global IX metadata lock is automatically acquired for its duration. The first problem is solved because waits for GRL become visible to deadlock detector in metadata locking subsystem and thus deadlocks like one in the first bug become impossible. The second problem is solved because global S locks which are used for GRL implementation are given preference over IX locks which are acquired by concurrent DML (and we can switch to fair scheduling in future if needed). Important change: FTWRL/GRL no longer blocks DML and DDL on temporary tables. Before this patch behavior was not consistent in this respect: in some cases DML/DDL statements on temporary tables were blocked while in others they were not. Since the main use cases for FTWRL are various forms of backups and temporary tables are not preserved during backups we have opted for consistently allowing DML/DDL on temporary tables during FTWRL/GRL. Important change: This patch changes thread state names which are used when DML/DDL of FTWRL is waiting for global read lock. It is now either "Waiting for global read lock" or "Waiting for commit lock" depending on the stage on which FTWRL is. Incompatible change: To solve deadlock in events code which was exposed by this patch we have to replace LOCK_event_metadata mutex with metadata locks on events. As result we have to prohibit DDL on events under LOCK TABLES. This patch also adds extensive test coverage for interaction of DML/DDL and FTWRL. Performance of new and old global read lock implementations in sysbench tests were compared. There were no significant difference between new and old implementations. mysql-test/include/check_ftwrl_compatible.inc: Added helper script which allows to check that a statement is compatible with FLUSH TABLES WITH READ LOCK. mysql-test/include/check_ftwrl_incompatible.inc: Added helper script which allows to check that a statement is incompatible with FLUSH TABLES WITH READ LOCK. mysql-test/include/handler.inc: Adjusted test case to the fact that now DROP TABLE closes open HANDLERs for the table to be dropped before checking if there active FTWRL in this connection. mysql-test/include/wait_show_condition.inc: Fixed small error in the timeout message. The correct name of variable used as parameter for this script is "$condition" and not "$wait_condition". mysql-test/r/delayed.result: Added test coverage for scenario which triggered assert in metadata locking subsystem. mysql-test/r/events_2.result: Updated test results after prohibiting event DDL operations under LOCK TABLES. mysql-test/r/flush.result: Added test coverage for bug #57006 "Deadlock between HANDLER and FLUSH TABLES WITH READ LOCK". mysql-test/r/flush_read_lock.result: Added test coverage for various aspects of FLUSH TABLES WITH READ LOCK functionality. mysql-test/r/flush_read_lock_kill.result: Adjusted test case after replacing custom global read lock implementation with one based on metadata locks. Use new debug_sync point. Do not disable concurrent inserts as now InnoDB we always use InnoDB table. mysql-test/r/handler_innodb.result: Adjusted test case to the fact that now DROP TABLE closes open HANDLERs for the table to be dropped before checking if there active FTWRL in this connection. mysql-test/r/handler_myisam.result: Adjusted test case to the fact that now DROP TABLE closes open HANDLERs for the table to be dropped before checking if there active FTWRL in this connection. mysql-test/r/mdl_sync.result: Adjusted test case after replacing custom global read lock implementation with one based on metadata locks. Replaced usage of GRL-specific debug_sync's with appropriate sync points in MDL subsystem. mysql-test/suite/perfschema/r/dml_setup_instruments.result: Updated test results after removing global COND_global_read_lock condition variable. mysql-test/suite/perfschema/r/func_file_io.result: Ensure that this test doesn't affect subsequent tests. At the end of its execution enable back P_S instrumentation which this test disables at some point. mysql-test/suite/perfschema/r/func_mutex.result: Ensure that this test doesn't affect subsequent tests. At the end of its execution enable back P_S instrumentation which this test disables at some point. mysql-test/suite/perfschema/r/global_read_lock.result: Adjusted test case to take into account that new GRL implementation is based on MDL. mysql-test/suite/perfschema/r/server_init.result: Adjusted test case after replacing custom global read lock implementation with one based on MDL and replacing LOCK_event_metadata mutex with metadata lock. mysql-test/suite/perfschema/t/func_file_io.test: Ensure that this test doesn't affect subsequent tests. At the end of its execution enable back P_S instrumentation which this test disables at some point. mysql-test/suite/perfschema/t/func_mutex.test: Ensure that this test doesn't affect subsequent tests. At the end of its execution enable back P_S instrumentation which this test disables at some point. mysql-test/suite/perfschema/t/global_read_lock.test: Adjusted test case to take into account that new GRL implementation is based on MDL. mysql-test/suite/perfschema/t/server_init.test: Adjusted test case after replacing custom global read lock implementation with one based on MDL and replacing LOCK_event_metadata mutex with metadata lock. mysql-test/suite/rpl/r/rpl_tmp_table_and_DDL.result: Updated test results after prohibiting event DDL under LOCK TABLES. mysql-test/t/delayed.test: Added test coverage for scenario which triggered assert in metadata locking subsystem. mysql-test/t/events_2.test: Updated test case after prohibiting event DDL operations under LOCK TABLES. mysql-test/t/flush.test: Added test coverage for bug #57006 "Deadlock between HANDLER and FLUSH TABLES WITH READ LOCK". mysql-test/t/flush_block_commit.test: Adjusted test case after changing thread state name which is used when COMMIT waits for FLUSH TABLES WITH READ LOCK from "Waiting for release of readlock" to "Waiting for commit lock". mysql-test/t/flush_block_commit_notembedded.test: Adjusted test case after changing thread state name which is used when DML waits for FLUSH TABLES WITH READ LOCK. Now we use "Waiting for global read lock" in this case. mysql-test/t/flush_read_lock.test: Added test coverage for various aspects of FLUSH TABLES WITH READ LOCK functionality. mysql-test/t/flush_read_lock_kill-master.opt: We no longer need to use make_global_read_lock_block_commit_loop debug tag in this test. Instead we rely on an appropriate debug_sync point in MDL code. mysql-test/t/flush_read_lock_kill.test: Adjusted test case after replacing custom global read lock implementation with one based on metadata locks. Use new debug_sync point. Do not disable concurrent inserts as now InnoDB we always use InnoDB table. mysql-test/t/lock_multi.test: Adjusted test case after changing thread state names which are used when DML or DDL waits for FLUSH TABLES WITH READ LOCK to "Waiting for global read lock". mysql-test/t/mdl_sync.test: Adjusted test case after replacing custom global read lock implementation with one based on metadata locks. Replaced usage of GRL-specific debug_sync's with appropriate sync points in MDL subsystem. Updated thread state names which are used when DDL waits for FTWRL. mysql-test/t/trigger_notembedded.test: Adjusted test case after changing thread state names which are used when DML or DDL waits for FLUSH TABLES WITH READ LOCK to "Waiting for global read lock". sql/event_data_objects.cc: Removed Event_queue_element::status/last_executed_changed members and Event_queue_element::update_timing_fields() method. We no longer use this class for updating mysql.events once event is chosen for execution. Accesses to instances of this class in scheduler thread require protection by Event_queue::LOCK_event_queue mutex and we try to avoid updating table while holding this lock. sql/event_data_objects.h: Removed Event_queue_element::status/last_executed_changed members and Event_queue_element::update_timing_fields() method. We no longer use this class for updating mysql.events once event is chosen for execution. Accesses to instances of this class in scheduler thread require protection by Event_queue::LOCK_event_queue mutex and we try to avoid updating table while holding this lock. sql/event_db_repository.cc: - Changed Event_db_repository methods to not release all metadata locks once they are done updating mysql.events table. This allows to keep metadata lock protecting against GRL and lock protecting particular event around until corresponding DDL statement is written to the binary log. - Removed logic for conditional update of "status" and "last_executed" fields from update_timing_fields_for_event() method. In the only case when this method is called now "last_executed" is always modified and tracking change of "status" is too much hassle. sql/event_db_repository.h: Removed logic for conditional update of "status" and "last_executed" fields from Event_db_repository:: update_timing_fields_for_event() method. In the only case when this method is called now "last_executed" is always modified and tracking change of "status" field is too much hassle. sql/event_queue.cc: Changed event scheduler code not to update mysql.events table while holding Event_queue::LOCK_event_queue mutex. Doing so led to a deadlock with a new GRL implementation. This deadlock didn't occur with old implementation due to fact that code acquiring protection against GRL ignored pending GRL requests (which lead to GRL starvation). One of goals of new implementation is to disallow GRL starvation and so we have to solve problem with this deadlock in a different way. sql/events.cc: Changed methods of Events class to acquire protection against GRL while perfoming DDL statement and keep it until statement is written to the binary log. Unfortunately this step together with new GRL implementation exposed deadlock involving Events::LOCK_event_metadata and GRL. To solve it Events::LOCK_event_metadata mutex was replaced with a metadata lock on event. As a side-effect events DDL has to be prohibited under LOCK TABLES even in cases when mysql.events table was explicitly locked for write. sql/events.h: Replaced Events::LOCK_event_metadata mutex with a metadata lock on event. sql/ha_ndbcluster.cc: Updated code after replacing custom global read lock implementation with one based on MDL. Since MDL subsystem should now be able to detect deadlocks involving metadata locks and GRL there is no need for special handling of active GRL. sql/handler.cc: Replaced custom implementation of global read lock with one based on metadata locks. Consequently when doing commit instead of calling method of Global_read_lock class to acquire protection against GRL we simply acquire IX in COMMIT namespace. sql/lock.cc: Replaced custom implementation of global read lock with one based on metadata locks. This step allows to expose wait for GRL to deadlock detector of MDL subsystem and thus succesfully resolve deadlocks similar to one behind bug #57006 "Deadlock between HANDLER and FLUSH TABLES WITH READ LOCK". It also solves problem with GRL starvation described in bug #54673 "It takes too long to get readlock for 'FLUSH TABLES WITH READ LOCK'" since metadata locks used by GRL give preference to FTWRL statement instead of DML statements (if needed in future this can be changed to fair scheduling). Similar to old implementation of acquisition of GRL is two-step. During the first step we block all concurrent DML and DDL statements by acquiring global S metadata lock (each DML and DDL statement acquires global IX lock for its duration). During the second step we block commits by acquiring global S lock in COMMIT namespace (commit code acquires global IX lock in this namespace). Note that unlike in old implementation acquisition of protection against GRL in DML and DDL is semi-automatic. We assume that any statement which should be blocked by GRL will either open and acquires write-lock on tables or acquires metadata locks on objects it is going to modify. For any such statement global IX metadata lock is automatically acquired for its duration. To support this change: - Global_read_lock::lock/unlock_global_read_lock and make_global_read_lock_block_commit methods were changed accordingly. - Global_read_lock::wait_if_global_read_lock() and start_waiting_global_read_lock() methods were dropped. It is now responsibility of code acquiring metadata locks opening tables to acquire protection against GRL by explicitly taking global IX lock with statement duration. - Global variables, mutex and condition variable used by old implementation was removed. - lock_routine_name() was changed to use statement duration for its global IX lock. It was also renamed to lock_object_name() as it now also used to take metadata locks on events. - Global_read_lock::set_explicit_lock_duration() was added which allows not to release locks used for GRL when leaving prelocked mode. sql/lock.h: - Renamed lock_routine_name() to lock_object_name() and changed its signature to allow its usage for events. - Removed broadcast_refresh() function. It is no longer needed with new GRL implementation. sql/log_event.cc: Release metadata locks with statement duration at the end of processing legacy event for LOAD DATA. This ensures that replication thread processing such event properly releases its protection against global read lock. sql/mdl.cc: Changed MDL subsystem to support new MDL-based implementation of global read lock. Added COMMIT and EVENTS namespaces for metadata locks. Changed thread state name for GLOBAL namespace to "Waiting for global read lock". Optimized MDL_map::find_or_insert() method to avoid taking m_mutex mutex when looking up MDL_lock objects for GLOBAL or COMMIT namespaces. We keep pre-created MDL_lock objects for these namespaces around and simply return pointers to these global objects when needed. Changed MDL_lock/MDL_scoped_lock to properly handle notification of insert delayed handler threads when FTWRL takes global S lock. Introduced concept of lock duration. In addition to locks with transaction duration which work in the way which is similar to how locks worked before (i.e. they are released at the end of transaction), locks with statement and explicit duration were introduced. Locks with statement duration are automatically released at the end of statement. Locks with explicit duration require explicit release and obsolete concept of transactional sentinel. * Changed MDL_request and MDL_ticket classes to support notion of duration. * Changed MDL_context to keep locks with different duration in different lists. Changed code handling ticket list to take this into account. * Changed methods responsible for releasing locks to take into account duration of tickets. Particularly public MDL_context::release_lock() method now only can release tickets with explicit duration (there is still internal method which allows to specify duration). To release locks with statement or transaction duration one have to use release_statement/transactional_locks() methods. * Concept of savepoint for MDL subsystem now has to take into account locks with statement duration. Consequently MDL_savepoint class was introduced and methods working with savepoints were updated accordingly. * Added methods which allow to set duration for one or all locks in the context. sql/mdl.h: Changed MDL subsystem to support new MDL-based implementation of global read lock. Added COMMIT and EVENTS namespaces for metadata locks. Introduced concept of lock duration. In addition to locks with transaction duration which work in the way which is similar to how locks worked before (i.e. they are released at the end of transaction), locks with statement and explicit duration were introduced. Locks with statement duration are automatically released at the end of statement. Locks with explicit duration require explicit release and obsolete concept of transactional sentinel. * Changed MDL_request and MDL_ticket classes to support notion of duration. * Changed MDL_context to keep locks with different duration in different lists. Changed code handling ticket list to take this into account. * Changed methods responsible for releasing locks to take into account duration of tickets. Particularly public MDL_context::release_lock() method now only can release tickets with explicit duration (there is still internal method which allows to specify duration). To release locks with statement or transaction duration one have to use release_statement/transactional_locks() methods. * Concept of savepoint for MDL subsystem now has to take into account locks with statement duration. Consequently MDL_savepoint class was introduced and methods working with savepoints were updated accordingly. * Added methods which allow to set duration for one or all locks in the context. sql/mysqld.cc: Removed global mutex and condition variables which were used by old implementation of GRL. Also we no longer need to initialize Events::LOCK_event_metadata mutex as it was replaced with metadata locks on events. sql/mysqld.h: Removed global variable, mutex and condition variables which were used by old implementation of GRL. sql/rpl_rli.cc: When slave thread closes tables which were open for handling of RBR events ensure that it releases global IX lock which was acquired as protection against GRL. sql/sp.cc: Adjusted code to the new signature of lock_object/routine_name(), to the fact that one now needs specify duration of lock when initializing MDL_request and to the fact that savepoints for MDL subsystem are now represented by MDL_savepoint class. sql/sp_head.cc: Ensure that statements in stored procedures release statement metadata locks and thus release their protectiong against GRL in proper moment in time. Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request. sql/sql_admin.cc: Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request. sql/sql_base.cc: - Implemented support for new approach to acquiring protection against global read lock. We no longer acquire such protection explicitly on the basis of statement flags. Instead we always rely on code which is responsible for acquiring metadata locks on object to be changed acquiring this protection. This is achieved by acquiring global IX metadata lock with statement duration. Code doing this also responsible for checking that current connection has no active GRL by calling an Global_read_lock::can_acquire_protection() method. Changed code in open_table() and lock_table_names() accordingly. Note that as result of this change DDL and DML on temporary tables is always compatible with GRL (before it was incompatible in some cases and compatible in other cases). - To speed-up code acquiring protection against GRL introduced m_has_protection_against_grl member in Open_table_context class. It indicates that protection was already acquired sometime during open_tables() execution and new attempts can be skipped. - Thanks to new GRL implementation calls to broadcast_refresh() became unnecessary and were removed. - Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request and to the fact that savepoints for MDL subsystem are now represented by MDL_savepoint class. sql/sql_base.h: Adjusted code to the fact that savepoints for MDL subsystem are now represented by MDL_savepoint class. Also introduced Open_table_context::m_has_protection_against_grl member which allows to avoid acquiring protection against GRL while opening tables if such protection was already acquired. sql/sql_class.cc: Changed THD::leave_locked_tables_mode() after transactional sentinel for metadata locks was obsoleted by introduction of locks with explicit duration. sql/sql_class.h: - Adjusted code to the fact that savepoints for MDL subsystem are now represented by MDL_savepoint class. - Changed Global_read_lock class according to changes in global read lock implementation: * wait_if_global_read_lock and start_waiting_global_read_lock are now gone. Instead code needing protection against GRL has to acquire global IX metadata lock with statement duration itself. To help it new can_acquire_protection() was introduced. Also as result of the above change m_protection_count member is gone too. * Added m_mdl_blocks_commits_lock member to store metadata lock blocking commits. * Adjusted code to the fact that concept of transactional sentinel was obsoleted by concept of lock duration. - Removed CF_PROTECT_AGAINST_GRL flag as it is no longer necessary. New GRL implementation acquires protection against global read lock automagically when statement acquires metadata locks on tables or other objects it is going to change. sql/sql_db.cc: Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request. sql/sql_handler.cc: Removed call to broadcast_refresh() function. It is no longer needed with new GRL implementation. Adjusted code after introducing duration concept for metadata locks. Particularly to the fact transactional sentinel was replaced with explicit duration. sql/sql_handler.h: Renamed mysql_ha_move_tickets_after_trans_sentinel() to mysql_ha_set_explicit_lock_duration() after transactional sentinel was obsoleted by locks with explicit duration. sql/sql_insert.cc: Adjusted code handling delaying inserts after switching to new GRL implementation. Now connection thread initiating delayed insert has to acquire global IX lock in addition to metadata lock on table being inserted into. This IX lock protects against GRL and similarly to SW lock on table being inserted into has to be passed to handler thread in order to avoid deadlocks. sql/sql_lex.cc: LEX::protect_against_global_read_lock member is no longer necessary since protection against GRL is automatically taken by code acquiring metadata locks/opening tables. sql/sql_lex.h: LEX::protect_against_global_read_lock member is no longer necessary since protection against GRL is automatically taken by code acquiring metadata locks/opening tables. sql/sql_parse.cc: - Implemented support for new approach to acquiring protection against global read lock. We no longer acquire such protection explicitly on the basis of statement flags. Instead we always rely on code which is responsible for acquiring metadata locks on object to be changed acquiring this protection. This is achieved by acquiring global IX metadata lock with statement duration. This lock is automatically released at the end of statement execution. - Changed implementation of CREATE/DROP PROCEDURE/FUNCTION not to release metadata locks and thus protection against of GRL in the middle of statement execution. - Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request and to the fact that savepoints for MDL subsystem are now represented by MDL_savepoint class. sql/sql_prepare.cc: Adjusted code to the to the fact that savepoints for MDL subsystem are now represented by MDL_savepoint class. sql/sql_rename.cc: With new GRL implementation there is no need to explicitly acquire protection against GRL before renaming tables. This happens automatically in code which acquires metadata locks on tables being renamed. sql/sql_show.cc: Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request and to the fact that savepoints for MDL subsystem are now represented by MDL_savepoint class. sql/sql_table.cc: - With new GRL implementation there is no need to explicitly acquire protection against GRL before dropping tables. This happens automatically in code which acquires metadata locks on tables being dropped. - Changed mysql_alter_table() not to release lock on new table name explicitly and to rely on automatic release of locks at the end of statement instead. This was necessary since now MDL_context::release_lock() is supported only for locks for explicit duration. sql/sql_trigger.cc: With new GRL implementation there is no need to explicitly acquire protection against GRL before changing table triggers. This happens automatically in code which acquires metadata locks on tables which triggers are to be changed. sql/sql_update.cc: Fix bug exposed by GRL testing. During prepare phase acquire only S metadata locks instead of SW locks to keep prepare of multi-UPDATE compatible with concurrent LOCK TABLES WRITE and global read lock. sql/sql_view.cc: With new GRL implementation there is no need to explicitly acquire protection against GRL before creating view. This happens automatically in code which acquires metadata lock on view to be created. sql/sql_yacc.yy: LEX::protect_against_global_read_lock member is no longer necessary since protection against GRL is automatically taken by code acquiring metadata locks/opening tables. sql/table.cc: Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request. sql/table.h: Adjusted code to the fact that one now needs specify duration of lock when initializing MDL_request. sql/transaction.cc: Replaced custom implementation of global read lock with one based on metadata locks. Consequently when doing commit instead of calling method of Global_read_lock class to acquire protection against GRL we simply acquire IX in COMMIT namespace. Also adjusted code to the fact that MDL savepoint is now represented by MDL_savepoint class.
2962 lines
83 KiB
Text
2962 lines
83 KiB
Text
SET DEBUG_SYNC= 'RESET';
|
|
drop table if exists t1,t2,t3;
|
|
create table t1 (i int);
|
|
create table t2 (i int);
|
|
connection: default
|
|
lock tables t2 read;
|
|
connection: con1
|
|
set debug_sync='mdl_upgrade_shared_lock_to_exclusive SIGNAL parked WAIT_FOR go';
|
|
alter table t1 rename t3;
|
|
connection: default
|
|
set debug_sync= 'now WAIT_FOR parked';
|
|
connection: con2
|
|
set debug_sync='mdl_acquire_lock_wait SIGNAL go';
|
|
drop table t1,t2;
|
|
connection: con1
|
|
connection: default
|
|
unlock tables;
|
|
connection: con2
|
|
ERROR 42S02: Unknown table 't1'
|
|
drop table t3;
|
|
SET DEBUG_SYNC= 'RESET';
|
|
#
|
|
# Basic test coverage for type-of-operation aware metadata locks.
|
|
#
|
|
drop table if exists t1, t2, t3;
|
|
set debug_sync= 'RESET';
|
|
create table t1 (c1 int);
|
|
#
|
|
# A) First let us check compatibility rules between differend kinds of
|
|
# type-of-operation aware metadata locks.
|
|
# Of course, these rules are already covered by the tests scattered
|
|
# across the test suite. But it still makes sense to have one place
|
|
# which covers all of them.
|
|
#
|
|
# 1) Acquire S (simple shared) lock on the table (by using HANDLER):
|
|
#
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that S, SH, SR and SW locks are compatible with it.
|
|
handler t1 open t;
|
|
handler t close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
select count(*) from t1;
|
|
count(*)
|
|
0
|
|
insert into t1 values (1), (1);
|
|
# Check that SNW lock is compatible with it. To do this use ALTER TABLE
|
|
# which will fail after opening the table and thus obtaining SNW metadata
|
|
# lock.
|
|
alter table t1 add primary key (c1);
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
# Check that SNRW lock is compatible with S lock.
|
|
lock table t1 write;
|
|
insert into t1 values (1);
|
|
unlock tables;
|
|
# Check that X lock is incompatible with S lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above RENAME is blocked because of S lock.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Unblock RENAME TABLE.
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping RENAME TABLE.
|
|
# Restore the original state of the things.
|
|
rename table t2 to t1;
|
|
#
|
|
# Switching to connection 'default'.
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that upgrade from SNW to X is blocked by presence of S lock.
|
|
# Sending:
|
|
alter table t1 add column c2 int;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above ALTER TABLE is blocked because of S lock.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Unblock ALTER TABLE.
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
# Restore the original state of the things.
|
|
alter table t1 drop column c2;
|
|
#
|
|
# Switching to connection 'default'.
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that upgrade from SNRW to X is blocked by presence of S lock.
|
|
lock table t1 write;
|
|
# Sending:
|
|
alter table t1 add column c2 int;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above upgrade of SNRW to X in ALTER TABLE is blocked
|
|
# because of S lock.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Unblock ALTER TABLE.
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
# Restore the original state of the things.
|
|
alter table t1 drop column c2;
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# 2) Acquire SH (shared high-priority) lock on the table.
|
|
# We have to involve DEBUG_SYNC facility for this as usually
|
|
# such kind of locks are short-lived.
|
|
#
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
select table_name, table_type, auto_increment, table_comment from information_schema.tables where table_schema='test' and table_name='t1';;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Check that S, SH, SR and SW locks are compatible with it.
|
|
handler t1 open;
|
|
handler t1 close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
insert into t1 values (1);
|
|
# Check that SNW lock is compatible with it. To do this use ALTER TABLE
|
|
# which will fail after opening the table and thus obtaining SNW metadata
|
|
# lock.
|
|
alter table t1 add primary key (c1);
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
# Check that SNRW lock is compatible with SH lock.
|
|
lock table t1 write;
|
|
delete from t1 limit 1;
|
|
unlock tables;
|
|
# Check that X lock is incompatible with SH lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above RENAME is blocked because of SH lock.
|
|
# Unblock RENAME TABLE.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping SELECT ... FROM I_S.
|
|
table_name table_type auto_increment table_comment
|
|
t1 BASE TABLE NULL
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping RENAME TABLE.
|
|
# Restore the original state of the things.
|
|
rename table t2 to t1;
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
select table_name, table_type, auto_increment, table_comment from information_schema.tables where table_schema='test' and table_name='t1';;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Check that upgrade from SNW to X is blocked by presence of SH lock.
|
|
# Sending:
|
|
alter table t1 add column c2 int;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above ALTER TABLE is blocked because of SH lock.
|
|
# Unblock RENAME TABLE.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping SELECT ... FROM I_S.
|
|
table_name table_type auto_increment table_comment
|
|
t1 BASE TABLE NULL
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
# Restore the original state of the things.
|
|
alter table t1 drop column c2;
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
select table_name, table_type, auto_increment, table_comment from information_schema.tables where table_schema='test' and table_name='t1';;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Check that upgrade from SNRW to X is blocked by presence of S lock.
|
|
lock table t1 write;
|
|
# Sending:
|
|
alter table t1 add column c2 int;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above upgrade of SNRW to X in ALTER TABLE is blocked
|
|
# because of S lock.
|
|
# Unblock RENAME TABLE.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping SELECT ... FROM I_S.
|
|
table_name table_type auto_increment table_comment
|
|
t1 BASE TABLE NULL
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
# Restore the original state of the things.
|
|
alter table t1 drop column c2;
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
#
|
|
# 3) Acquire SR lock on the table.
|
|
#
|
|
#
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that S, SH, SR and SW locks are compatible with it.
|
|
handler t1 open;
|
|
handler t1 close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
insert into t1 values (1);
|
|
# Check that SNW lock is compatible with it. To do this use ALTER TABLE
|
|
# which will fail after opening the table and thus obtaining SNW metadata
|
|
# lock.
|
|
alter table t1 add primary key (c1);
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
# Check that SNRW lock is not compatible with SR lock.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above LOCK TABLES is blocked because of SR lock.
|
|
# Unblock LOCK TABLES.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping LOCK TABLES.
|
|
delete from t1 limit 1;
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that X lock is incompatible with SR lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above RENAME is blocked because of SR lock.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping RENAME TABLE.
|
|
# Restore the original state of the things.
|
|
rename table t2 to t1;
|
|
#
|
|
# Switching to connection 'default'.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that upgrade from SNW to X is blocked by presence of SR lock.
|
|
# Sending:
|
|
alter table t1 add column c2 int;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above ALTER TABLE is blocked because of SR lock.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Unblock ALTER TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
# Restore the original state of the things.
|
|
alter table t1 drop column c2;
|
|
#
|
|
# There is no need to check that upgrade from SNRW to X is blocked
|
|
# by presence of SR lock because SNRW is incompatible with SR anyway.
|
|
#
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
#
|
|
# 4) Acquire SW lock on the table.
|
|
#
|
|
#
|
|
begin;
|
|
insert into t1 values (1);
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that S, SH, SR and SW locks are compatible with it.
|
|
handler t1 open;
|
|
handler t1 close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
# Disable result log to make test robust against
|
|
# effects of concurrent insert.
|
|
select * from t1;
|
|
insert into t1 values (1);
|
|
# Check that SNW lock is not compatible with SW lock.
|
|
# Again we use ALTER TABLE which fails after opening
|
|
# the table to avoid upgrade of SNW -> X.
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above ALTER TABLE is blocked because of SW lock.
|
|
# Unblock ALTER TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'default'.
|
|
begin;
|
|
insert into t1 values (1);
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that SNRW lock is not compatible with SW lock.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above LOCK TABLES is blocked because of SW lock.
|
|
# Unblock LOCK TABLES.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping LOCK TABLES.
|
|
delete from t1 limit 2;
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
begin;
|
|
insert into t1 values (1);
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that X lock is incompatible with SW lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above RENAME is blocked because of SW lock.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping RENAME TABLE.
|
|
# Restore the original state of the things.
|
|
rename table t2 to t1;
|
|
#
|
|
# There is no need to check that upgrade from SNW/SNRW to X is
|
|
# blocked by presence of SW lock because SNW/SNRW is incompatible
|
|
# with SW anyway.
|
|
#
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
#
|
|
# 5) Acquire SNW lock on the table. We have to use DEBUG_SYNC for
|
|
# this, to prevent SNW from being immediately upgraded to X.
|
|
#
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Check that S, SH and SR locks are compatible with it.
|
|
handler t1 open;
|
|
handler t1 close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
select count(*) from t1;
|
|
count(*)
|
|
5
|
|
# Check that SW lock is incompatible with SNW lock.
|
|
# Sending:
|
|
delete from t1 limit 2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above DELETE is blocked because of SNW lock.
|
|
# Unblock ALTER and thus DELETE.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping DELETE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Check that SNW lock is incompatible with SNW lock.
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above ALTER is blocked because of SNW lock.
|
|
# Unblock ALTERs.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping first ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping another ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Check that SNRW lock is incompatible with SNW lock.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above LOCK TABLES is blocked because of SNW lock.
|
|
# Unblock ALTER and thus LOCK TABLES.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping LOCK TABLES
|
|
insert into t1 values (1);
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Check that X lock is incompatible with SNW lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above RENAME is blocked because of SNW lock.
|
|
# Unblock ALTER and thus RENAME TABLE.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping RENAME TABLE
|
|
# Revert back to original state of things.
|
|
rename table t2 to t1;
|
|
#
|
|
# There is no need to check that upgrade from SNW/SNRW to X is
|
|
# blocked by presence of another SNW lock because SNW/SNRW is
|
|
# incompatible with SNW anyway.
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
#
|
|
# 6) Acquire SNRW lock on the table.
|
|
#
|
|
#
|
|
lock table t1 write;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that S and SH locks are compatible with it.
|
|
handler t1 open;
|
|
handler t1 close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
# Check that SR lock is incompatible with SNRW lock.
|
|
# Sending:
|
|
select count(*) from t1;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above SELECT is blocked because of SNRW lock.
|
|
# Unblock SELECT.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping SELECT.
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'default'.
|
|
lock table t1 write;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that SW lock is incompatible with SNRW lock.
|
|
# Sending:
|
|
delete from t1 limit 1;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above DELETE is blocked because of SNRW lock.
|
|
# Unblock DELETE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping DELETE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
lock table t1 write;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that SNW lock is incompatible with SNRW lock.
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above ALTER is blocked because of UNWR lock.
|
|
# Unblock ALTER.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'default'.
|
|
lock table t1 write;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that SNRW lock is incompatible with SNRW lock.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above LOCK TABLES is blocked because of SNRW lock.
|
|
# Unblock waiting LOCK TABLES.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping LOCK TABLES
|
|
insert into t1 values (1);
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
lock table t1 write;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that X lock is incompatible with SNRW lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Check that the above RENAME is blocked because of SNRW lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping RENAME TABLE
|
|
# Revert back to original state of things.
|
|
rename table t2 to t1;
|
|
#
|
|
# There is no need to check that upgrade from SNW/SNRW to X is
|
|
# blocked by presence of another SNRW lock because SNW/SNRW is
|
|
# incompatible with SNRW anyway.
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
#
|
|
# 7) Now do the same round of tests for X lock. We use additional
|
|
# table to get long-lived lock of this type.
|
|
#
|
|
create table t2 (c1 int);
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Take a lock on t2, so RENAME TABLE t1 TO t2 will get blocked
|
|
# after acquiring X lock on t1.
|
|
lock tables t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME has acquired X lock on t1 and is waiting for t2.
|
|
# Check that S lock in incompatible with X lock.
|
|
# Sending:
|
|
handler t1 open;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above HANDLER statement is blocked because of X lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping HANDLER.
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Prepare for blocking RENAME TABLE.
|
|
lock tables t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME has acquired X lock on t1 and is waiting for t2.
|
|
# Check that SH lock in incompatible with X lock.
|
|
# Sending:
|
|
select column_name from information_schema.columns where table_schema='test' and table_name='t1';;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above SELECT ... FROM I_S ... statement is blocked
|
|
# because of X lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping SELECT ... FROM I_S.
|
|
column_name
|
|
c1
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Prepare for blocking RENAME TABLE.
|
|
lock tables t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME has acquired X lock on t1 and is waiting for t2.
|
|
# Check that SR lock in incompatible with X lock.
|
|
# Sending:
|
|
select count(*) from t1;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above SELECT statement is blocked
|
|
# because of X lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping SELECT.
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Prepare for blocking RENAME TABLE.
|
|
lock tables t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME has acquired X lock on t1 and is waiting for t2.
|
|
# Check that SW lock in incompatible with X lock.
|
|
# Sending:
|
|
delete from t1 limit 1;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above DELETE statement is blocked
|
|
# because of X lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping DELETE.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Prepare for blocking RENAME TABLE.
|
|
lock tables t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME has acquired X lock on t1 and is waiting for t2.
|
|
# Check that SNW lock is incompatible with X lock.
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above ALTER statement is blocked
|
|
# because of X lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Prepare for blocking RENAME TABLE.
|
|
lock tables t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME has acquired X lock on t1 and is waiting for t2.
|
|
# Check that SNRW lock is incompatible with X lock.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above LOCK TABLE statement is blocked
|
|
# because of X lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping LOCK TABLE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Prepare for blocking RENAME TABLE.
|
|
lock tables t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME has acquired X lock on t1 and is waiting for t2.
|
|
# Check that X lock is incompatible with X lock.
|
|
# Sending:
|
|
rename table t1 to t3;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above RENAME statement is blocked
|
|
# because of X lock.
|
|
# Unblock RENAME TABLE
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping RENAME.
|
|
rename table t3 to t1;
|
|
#
|
|
# B) Now let us test compatibility in cases when both locks
|
|
# are pending. I.e. let us test rules for priorities between
|
|
# different types of metadata locks.
|
|
#
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
#
|
|
# 1) Check compatibility for pending SNW lock.
|
|
#
|
|
# Acquire SW lock in order to create pending SNW lock later.
|
|
begin;
|
|
insert into t1 values (1);
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Add pending SNW lock.
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that ALTER TABLE is waiting with pending SNW lock.
|
|
# Check that S, SH and SR locks are compatible with pending SNW
|
|
handler t1 open t;
|
|
handler t close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
# Check that SW is incompatible with pending SNW
|
|
# Sending:
|
|
delete from t1 limit 1;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above DELETE is blocked because of pending SNW lock.
|
|
# Unblock ALTER TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping ALTER.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping DELETE.
|
|
#
|
|
# We can't do similar check for SNW, SNRW and X locks because
|
|
# they will also be blocked by active SW lock.
|
|
#
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
#
|
|
# 2) Check compatibility for pending SNRW lock.
|
|
#
|
|
# Acquire SR lock in order to create pending SNRW lock.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Add pending SNRW lock.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that LOCK TABLE is waiting with pending SNRW lock.
|
|
# Check that S and SH locks are compatible with pending SNRW
|
|
handler t1 open t;
|
|
handler t close;
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
# Check that SR is incompatible with pending SNRW
|
|
# Sending:
|
|
select count(*) from t1;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above SELECT is blocked because of pending SNRW lock.
|
|
# Unblock LOCK TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping LOCK TABLE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping SELECT.
|
|
count(*)
|
|
3
|
|
# Restore pending SNRW lock.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that LOCK TABLE is waiting with pending SNRW lock.
|
|
# Check that SW is incompatible with pending SNRW
|
|
# Sending:
|
|
insert into t1 values (1);;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above INSERT is blocked because of pending SNRW lock.
|
|
# Unblock LOCK TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping LOCK TABLE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping INSERT.
|
|
# Restore pending SNRW lock.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that LOCK TABLE is waiting with pending SNRW lock.
|
|
# Check that SNW is compatible with pending SNRW
|
|
# So ALTER TABLE statements are not starved by LOCK TABLEs.
|
|
alter table t1 add primary key (c1);
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Unblock LOCK TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping LOCK TABLE.
|
|
unlock tables;
|
|
#
|
|
# We can't do similar check for SNRW and X locks because
|
|
# they will also be blocked by active SR lock.
|
|
#
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
#
|
|
# 3) Check compatibility for pending X lock.
|
|
#
|
|
# Acquire SR lock in order to create pending X lock.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Add pending X lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME TABLE is waiting with pending X lock.
|
|
# Check that SH locks are compatible with pending X
|
|
select column_name from information_schema.columns where
|
|
table_schema='test' and table_name='t1';
|
|
column_name
|
|
c1
|
|
# Check that S is incompatible with pending X
|
|
# Sending:
|
|
handler t1 open;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above HANDLER OPEN is blocked because of pending X lock.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping HANDLER t1 OPEN.
|
|
handler t1 close;
|
|
# Restore pending X lock.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Add pending X lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME TABLE is waiting with pending X lock.
|
|
# Check that SR is incompatible with pending X
|
|
# Sending:
|
|
select count(*) from t1;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above SELECT is blocked because of pending X lock.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping SELECT.
|
|
count(*)
|
|
4
|
|
# Restore pending X lock.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Add pending X lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME TABLE is waiting with pending X lock.
|
|
# Check that SW is incompatible with pending X
|
|
# Sending:
|
|
delete from t1 limit 1;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above DELETE is blocked because of pending X lock.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping DELETE.
|
|
# Restore pending X lock.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Add pending X lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME TABLE is waiting with pending X lock.
|
|
# Check that SNW is incompatible with pending X
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above ALTER TABLE is blocked because of pending X lock.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
# Restore pending X lock.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Add pending X lock.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that RENAME TABLE is waiting with pending X lock.
|
|
# Check that SNRW is incompatible with pending X
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'mdl_con3'.
|
|
# Check that the above LOCK TABLES is blocked because of pending X lock.
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Unblock RENAME TABLE.
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reaping LOCK TABLES.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
#
|
|
# C) Now let us test how type-of-operation locks are handled in
|
|
# transactional context. Obviously we are mostly interested
|
|
# in conflicting types of locks.
|
|
#
|
|
#
|
|
# 1) Let us check how various locks used within transactional
|
|
# context interact with active/pending SNW lock.
|
|
#
|
|
# We start with case when we are acquiring lock on the table
|
|
# which was not used in the transaction before.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create an active SNW lock on t2.
|
|
# We have to use DEBUG_SYNC facility as otherwise SNW lock
|
|
# will be immediately released (or upgraded to X lock).
|
|
insert into t2 values (1), (1);
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
alter table t2 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# SR lock should be acquired without any waiting.
|
|
select count(*) from t2;
|
|
count(*)
|
|
2
|
|
commit;
|
|
# Now let us check that we will wait in case of SW lock.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
# Sending:
|
|
insert into t2 values (1);;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above INSERT is blocked.
|
|
# Unblock ALTER TABLE and thus INSERT.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap INSERT.
|
|
commit;
|
|
#
|
|
# Now let us see what happens when we are acquiring lock on the table
|
|
# which is already used in transaction.
|
|
#
|
|
# *) First, case when transaction which has SR lock on the table also
|
|
# locked in SNW mode acquires yet another SR lock and then tries
|
|
# to acquire SW lock.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create an active SNW lock on t1.
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# We should still be able to get SR lock without waiting.
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
# Since the above ALTER TABLE is not upgrading SNW lock to X by waiting
|
|
# for SW lock we won't create deadlock.
|
|
# So the below INSERT should not end-up with ER_LOCK_DEADLOCK error.
|
|
# Sending:
|
|
insert into t1 values (1);;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above INSERT is blocked.
|
|
# Unblock ALTER TABLE and thus INSERT.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap INSERT.
|
|
commit;
|
|
#
|
|
# **) Now test in which transaction that has SW lock on the table
|
|
# against which there is pending SNW lock acquires SR and SW
|
|
# locks on this table.
|
|
#
|
|
begin;
|
|
insert into t1 values (1);
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create pending SNW lock on t1.
|
|
# Sending:
|
|
alter table t1 add primary key (c1);;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until ALTER TABLE starts waiting for SNW lock.
|
|
# We should still be able to get both SW and SR locks without waiting.
|
|
select count(*) from t1;
|
|
count(*)
|
|
5
|
|
delete from t1 limit 1;
|
|
# Unblock ALTER TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap ALTER TABLE.
|
|
ERROR 23000: Duplicate entry '1' for key 'PRIMARY'
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# 2) Now similar tests for active SNW lock which is being upgraded
|
|
# to X lock.
|
|
#
|
|
# Again we start with case when we are acquiring lock on the
|
|
# table which was not used in the transaction before.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Start transaction which will prevent SNW -> X upgrade from
|
|
# completing immediately.
|
|
begin;
|
|
select count(*) from t2;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create SNW lock pending upgrade to X on t2.
|
|
# Sending:
|
|
alter table t2 add column c2 int;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until ALTER TABLE starts waiting X lock.
|
|
# Check that attempt to acquire SR lock on t2 causes waiting.
|
|
# Sending:
|
|
select count(*) from t2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above SELECT is blocked.
|
|
# Unblock ALTER TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap ALTER TABLE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap SELECT.
|
|
count(*)
|
|
3
|
|
commit;
|
|
# Do similar check for SW lock.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Start transaction which will prevent SNW -> X upgrade from
|
|
# completing immediately.
|
|
begin;
|
|
select count(*) from t2;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create SNW lock pending upgrade to X on t2.
|
|
# Sending:
|
|
alter table t2 drop column c2;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until ALTER TABLE starts waiting X lock.
|
|
# Check that attempt to acquire SW lock on t2 causes waiting.
|
|
# Sending:
|
|
insert into t2 values (1);;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above INSERT is blocked.
|
|
# Unblock ALTER TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap ALTER TABLE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap INSERT.
|
|
commit;
|
|
#
|
|
# Test for the case in which we are acquiring lock on the table
|
|
# which is already used in transaction.
|
|
#
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create SNW lock pending upgrade to X.
|
|
# Sending:
|
|
alter table t1 add column c2 int;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until ALTER TABLE starts waiting X lock.
|
|
# Check that transaction is still able to acquire SR lock.
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
# Waiting trying to acquire SW lock will cause deadlock and
|
|
# therefore should cause an error.
|
|
delete from t1 limit 1;
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
# Unblock ALTER TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap ALTER TABLE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# 3) Check how various locks used within transactional context
|
|
# interact with active/pending SNRW lock.
|
|
#
|
|
# Once again we start with case when we are acquiring lock on
|
|
# the table which was not used in the transaction before.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
lock table t2 write;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Attempt to acquire SR should be blocked. It should
|
|
# not cause errors as it does not creates deadlock.
|
|
# Sending:
|
|
select count(*) from t2;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that the above SELECT is blocked
|
|
# Unblock SELECT.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap SELECT.
|
|
count(*)
|
|
4
|
|
commit;
|
|
# Repeat the same test for SW lock.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
lock table t2 write;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Again attempt to acquire SW should be blocked and should
|
|
# not cause any errors.
|
|
# Sending:
|
|
delete from t2 limit 1;;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Check that the above DELETE is blocked
|
|
# Unblock DELETE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap DELETE.
|
|
commit;
|
|
#
|
|
# Now coverage for the case in which we are acquiring lock on
|
|
# the table which is already used in transaction and against
|
|
# which there is a pending SNRW lock request.
|
|
#
|
|
# *) Let us start with case when transaction has only a SR lock.
|
|
#
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until LOCK TABLE is blocked creating pending request for X lock.
|
|
# Check that another instance of SR lock is granted without waiting.
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
# Attempt to wait for SW lock will lead to deadlock, thus
|
|
# the below statement should end with ER_LOCK_DEADLOCK error.
|
|
delete from t1 limit 1;
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
# Unblock LOCK TABLES.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap LOCK TABLES.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# **) Now case when transaction has a SW lock.
|
|
#
|
|
begin;
|
|
delete from t1 limit 1;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Sending:
|
|
lock table t1 write;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until LOCK TABLE is blocked creating pending request for X lock.
|
|
# Check that both SR and SW locks are granted without waiting
|
|
# and errors.
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
insert into t1 values (1, 1);
|
|
# Unblock LOCK TABLES.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap LOCK TABLES.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# 4) Check how various locks used within transactional context
|
|
# interact with active/pending X lock.
|
|
#
|
|
# As usual we start with case when we are acquiring lock on
|
|
# the table which was not used in the transaction before.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Start transaction which will prevent X lock from going away
|
|
# immediately.
|
|
begin;
|
|
select count(*) from t2;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create pending X lock on t2.
|
|
# Sending:
|
|
rename table t2 to t3;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until RENAME TABLE starts waiting with pending X lock.
|
|
# Check that attempt to acquire SR lock on t2 causes waiting.
|
|
# Sending:
|
|
select count(*) from t2;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above SELECT is blocked.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap RENAME TABLE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap SELECT.
|
|
ERROR 42S02: Table 'test.t2' doesn't exist
|
|
commit;
|
|
rename table t3 to t2;
|
|
# The same test for SW lock.
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Start transaction which will prevent X lock from going away
|
|
# immediately.
|
|
begin;
|
|
select count(*) from t2;
|
|
count(*)
|
|
3
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Create pending X lock on t2.
|
|
# Sending:
|
|
rename table t2 to t3;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until RENAME TABLE starts waiting with pending X lock.
|
|
# Check that attempt to acquire SW lock on t2 causes waiting.
|
|
# Sending:
|
|
delete from t2 limit 1;;
|
|
#
|
|
# Switching to connection 'mdl_con2'.
|
|
# Check that the above DELETE is blocked.
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap RENAME TABLE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap DELETE.
|
|
ERROR 42S02: Table 'test.t2' doesn't exist
|
|
commit;
|
|
rename table t3 to t2;
|
|
#
|
|
# Coverage for the case in which we are acquiring lock on
|
|
# the table which is already used in transaction and against
|
|
# which there is a pending X lock request.
|
|
#
|
|
# *) The first case is when transaction has only a SR lock.
|
|
#
|
|
begin;
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until RENAME TABLE is blocked creating pending request for X lock.
|
|
# Check that another instance of SR lock is granted without waiting.
|
|
select count(*) from t1;
|
|
count(*)
|
|
4
|
|
# Attempt to wait for SW lock will lead to deadlock, thus
|
|
# the below statement should end with ER_LOCK_DEADLOCK error.
|
|
delete from t1 limit 1;
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# **) The second case is when transaction has a SW lock.
|
|
#
|
|
begin;
|
|
delete from t1 limit 1;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Sending:
|
|
rename table t1 to t2;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until RENAME TABLE is blocked creating pending request for X lock.
|
|
# Check that both SR and SW locks are granted without waiting
|
|
# and errors.
|
|
select count(*) from t1;
|
|
count(*)
|
|
3
|
|
insert into t1 values (1, 1);
|
|
# Unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'mdl_con1'.
|
|
# Reap RENAME TABLE.
|
|
ERROR 42S01: Table 't2' already exists
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Clean-up.
|
|
set debug_sync= 'RESET';
|
|
drop table t1, t2;
|
|
#
|
|
# Additional coverage for some scenarios in which not quite
|
|
# correct use of S metadata locks by HANDLER statement might
|
|
# have caused deadlocks.
|
|
#
|
|
drop table if exists t1, t2;
|
|
create table t1 (i int);
|
|
create table t2 (j int);
|
|
insert into t1 values (1);
|
|
#
|
|
# First, check scenario in which we upgrade SNRW lock to X lock
|
|
# on a table while having HANDLER READ trying to acquire TL_READ
|
|
# on the same table.
|
|
#
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
lock table t1 write;
|
|
# Upgrade SNRW to X lock.
|
|
# Sending:
|
|
alter table t1 add column j int;;
|
|
#
|
|
# Switching to connection 'handler_con2'.
|
|
# Wait until ALTER is blocked during upgrade.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# The below statement should not cause deadlock.
|
|
handler t1 read first;;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
# Reap ALTER TABLE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap HANDLER READ.
|
|
i j
|
|
1 NULL
|
|
handler t1 close;
|
|
#
|
|
# Now, check scenario in which upgrade of SNRW lock to X lock
|
|
# can be blocked by HANDLER which is open in connection currently
|
|
# waiting to get table-lock owned by connection doing upgrade.
|
|
#
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
lock table t1 write, t2 read;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Execute statement which will be blocked on table-level lock
|
|
# owned by connection 'handler_con1'.
|
|
# Sending:
|
|
insert into t2 values (1);;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
# Wait until INSERT is blocked on table-level lock.
|
|
# Sending 'alter table t1 drop column j'. It should not cause
|
|
# deadlock.
|
|
alter table t1 drop column j;
|
|
# Switching to connection 'handler_con2'.
|
|
# Wait until ALTER is blocked during upgrade.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap INSERT.
|
|
ERROR HY000: Wait on a lock was aborted due to a pending exclusive lock
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
# Reaping 'alter table t1 drop column j'
|
|
unlock tables;
|
|
# Switching to connection 'default'.
|
|
# Then, check the scenario in which upgrade of SNRW lock to X
|
|
# lock is blocked by HANDLER which is open in connection currently
|
|
# waiting to get SW lock on the same table.
|
|
#
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
lock table t1 write;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# The below insert should be blocked because active SNRW lock on 't1'.
|
|
# Sending:
|
|
insert into t1 values (1);;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
# Wait until INSERT is blocked because of SNRW lock.
|
|
# The below ALTER TABLE will be blocked because of presence of HANDLER.
|
|
# Sending:
|
|
alter table t1 add column j int;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# INSERT should be chosen as victim for resolving deadlock.
|
|
# Reaping INSERT.
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
# Close HANDLER to unblock ALTER TABLE.
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
# Reaping ALTER TABLE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# Finally, test in which upgrade of SNRW lock to X lock is blocked
|
|
# by HANDLER which is open in connection currently waiting to get
|
|
# SR lock on the table on which lock is upgraded.
|
|
#
|
|
handler t1 open;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
lock table t1 write, t2 write;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# The below insert should be blocked because active SNRW lock on 't1'.
|
|
# Sending:
|
|
insert into t2 values (1);;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
# Wait until INSERT is blocked because of SNRW lock.
|
|
# The below ALTER TABLE will be blocked because of presence of HANDLER.
|
|
# Sending:
|
|
alter table t1 drop column j;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# INSERT should be chosen as victim for resolving deadlock.
|
|
# Reaping INSERT.
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
# Close HANDLER to unblock ALTER TABLE.
|
|
handler t1 close;
|
|
#
|
|
# Switching to connection 'handler_con1'.
|
|
# Reaping ALTER TABLE.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Clean-up.
|
|
drop tables t1, t2;
|
|
#
|
|
# Test coverage for basic deadlock detection in metadata
|
|
# locking subsystem.
|
|
#
|
|
drop tables if exists t0, t1, t2, t3, t4, t5;
|
|
set debug_sync= 'RESET';
|
|
create table t1 (i int);
|
|
create table t2 (j int);
|
|
create table t3 (k int);
|
|
create table t4 (k int);
|
|
#
|
|
# Test for the case in which no deadlock occurs.
|
|
#
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
begin;
|
|
insert into t1 values (1);
|
|
#
|
|
# Switching to connection 'deadlock_con2'.
|
|
begin;
|
|
insert into t2 values (1);
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Send:
|
|
rename table t2 to t0, t3 to t2, t0 to t3;;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Wait until the above RENAME TABLE is blocked because it has to wait
|
|
# for 'deadlock_con2' which holds shared metadata lock on 't2'.
|
|
# The below statement should wait for exclusive metadata lock
|
|
# on 't2' to go away and should not produce ER_LOCK_DEADLOCK
|
|
# as no deadlock is possible in this situation.
|
|
# Send:
|
|
select * from t2;;
|
|
#
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Wait until the above SELECT * FROM t2 is starts waiting
|
|
# for an exclusive metadata lock to go away.
|
|
#
|
|
# Unblock RENAME TABLE by releasing shared metadata lock on t2.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap RENAME TABLE.
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Reap SELECT.
|
|
k
|
|
#
|
|
# Switching to connection 'default'.
|
|
#
|
|
# Let us check that in the process of waiting for conflicting lock
|
|
# on table 't2' to go away transaction in connection 'deadlock_con1'
|
|
# has not released metadata lock on table 't1'.
|
|
# Send:
|
|
rename table t1 to t0, t3 to t1, t0 to t3;;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Wait until the above RENAME TABLE is blocked because it has to wait
|
|
# for 'deadlock_con1' which should still hold shared metadata lock on
|
|
# table 't1'.
|
|
# Commit transaction to unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap RENAME TABLE.
|
|
#
|
|
# Test for case when deadlock occurs and should be detected immediately.
|
|
#
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
begin;
|
|
insert into t2 values (2);
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Send:
|
|
rename table t2 to t0, t1 to t2, t0 to t1;;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Wait until the above RENAME TABLE is blocked because it has to wait
|
|
# for 'deadlock_con1' which holds shared metadata lock on 't2'.
|
|
#
|
|
# The below statement should not wait as doing so will cause deadlock.
|
|
# Instead it should fail and emit ER_LOCK_DEADLOCK statement.
|
|
select * from t1;
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
#
|
|
# Let us check that failure of the above statement has not released
|
|
# metadata lock on table 't1', i.e. that RENAME TABLE is still blocked.
|
|
# Commit transaction to unblock RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap RENAME TABLE.
|
|
#
|
|
# Test for the case in which deadlock also occurs but not immediately.
|
|
#
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
begin;
|
|
insert into t2 values (1);
|
|
#
|
|
# Switching to connection 'default'.
|
|
lock table t1 write;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# The below SELECT statement should wait for metadata lock
|
|
# on table 't1' and should not produce ER_LOCK_DEADLOCK
|
|
# immediately as no deadlock is possible at the moment.
|
|
select * from t1;;
|
|
#
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Wait until the above SELECT * FROM t1 is starts waiting
|
|
# for an UNRW metadata lock to go away.
|
|
# Send RENAME TABLE statement that will deadlock with the
|
|
# SELECT statement and thus should abort the latter.
|
|
rename table t1 to t0, t2 to t1, t0 to t2;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait till above RENAME TABLE is blocked while holding
|
|
# pending X lock on t1.
|
|
# Allow the above RENAME TABLE to acquire lock on t1 and
|
|
# create pending lock on t2 thus creating deadlock.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Since the latest RENAME TABLE entered in deadlock with SELECT
|
|
# statement the latter should be aborted and emit ER_LOCK_DEADLOCK
|
|
# error.
|
|
# Reap SELECT * FROM t1.
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
#
|
|
# Again let us check that failure of the SELECT statement has not
|
|
# released metadata lock on table 't2', i.e. that the latest RENAME
|
|
# is blocked.
|
|
# Commit transaction to unblock this RENAME TABLE.
|
|
commit;
|
|
#
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Reap RENAME TABLE ... .
|
|
#
|
|
# Switching to connection 'default'.
|
|
drop tables t1, t2, t3, t4;
|
|
#
|
|
# Now, test case which shows that deadlock detection empiric
|
|
# also takes into account requests for metadata lock upgrade.
|
|
#
|
|
create table t1 (i int);
|
|
insert into t1 values (1);
|
|
# Avoid race which occurs when SELECT in 'deadlock_con1' connection
|
|
# accesses table before the above INSERT unlocks the table and thus
|
|
# its result becomes visible to other connections.
|
|
select * from t1;
|
|
i
|
|
1
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
begin;
|
|
select * from t1;
|
|
i
|
|
1
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Send:
|
|
alter table t1 add column j int, rename to t2;;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Wait until the above ALTER TABLE ... RENAME acquires exclusive
|
|
# metadata lock on 't2' and starts waiting for connection
|
|
# 'deadlock_con1' which holds shared lock on 't1'.
|
|
# The below statement should not wait as it will cause deadlock.
|
|
# An appropriate error should be reported instead.
|
|
select * from t2;
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
# Again let us check that failure of the above statement has not
|
|
# released all metadata locks in connection 'deadlock_con1' and
|
|
# so ALTER TABLE ... RENAME is still blocked.
|
|
# Commit transaction to unblock ALTER TABLE ... RENAME.
|
|
commit;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap ALTER TABLE ... RENAME.
|
|
drop table t2;
|
|
#
|
|
# Test that in situation when MDL subsystem detects a deadlock
|
|
# but it turns out that it can be resolved by backing-off locks
|
|
# acquired by one of participating transactions (which is
|
|
# possible when one of transactions consists only of currently
|
|
# executed statement, e.g. in autocommit mode) no error is
|
|
# reported.
|
|
#
|
|
create table t1 (i int);
|
|
create table t2 (j int);
|
|
# Ensure that the below SELECT stops once it has acquired metadata
|
|
# lock on table 't2'.
|
|
set debug_sync= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
# Sending:
|
|
select * from t2, t1;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Wait till SELECT acquires MDL on 't2' and starts waiting for signal.
|
|
set debug_sync= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
lock tables t1 write, t2 write;
|
|
#
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Wait until LOCK TABLES acquires SNRW lock on 't1' and is blocked
|
|
# while trying to acquire SNRW lock on 't1'.
|
|
# Resume SELECT execution, this should eventually unblock LOCK TABLES.
|
|
set debug_sync= 'now SIGNAL finish';
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Reaping LOCK TABLES.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping SELECT. It succeed and not report ER_LOCK_DEADLOCK error.
|
|
j i
|
|
drop tables t1, t2;
|
|
#
|
|
# Test coverage for situation in which a race has happened
|
|
# during deadlock detection process which led to unwarranted
|
|
# ER_LOCK_DEADLOCK error.
|
|
#
|
|
create table t1 (i int);
|
|
# Ensure that ALTER waits once it has acquired SNW lock.
|
|
set debug_sync='after_open_table_mdl_shared SIGNAL parked1 WAIT_FOR go1';
|
|
# Sending:
|
|
alter table t1 add column j int;
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Wait till ALTER acquires SNW lock and stops.
|
|
set debug_sync='now WAIT_FOR parked1';
|
|
# Ensure that INSERT is paused once it detects that there is
|
|
# a conflicting metadata lock so it has to wait, but before
|
|
# deadlock detection is run.
|
|
set debug_sync='mdl_acquire_lock_wait SIGNAL parked2 WAIT_FOR go2';
|
|
# Sending:
|
|
insert into t1 values ();
|
|
#
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Wait till INSERT is paused.
|
|
set debug_sync='now WAIT_FOR parked2';
|
|
# Resume ALTER execution. Eventually it will release its
|
|
# metadata lock and INSERT's request for SW lock will be
|
|
# satisified.
|
|
set debug_sync='now SIGNAL go1';
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping ALTER TABLE.
|
|
# Add a new request for SNW lock to waiting graph.
|
|
# Sending:
|
|
alter table t1 drop column j;
|
|
#
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Wait until ALTER is blocked.
|
|
# Resume INSERT so it can start deadlock detection.
|
|
#
|
|
# At this point there is a discrepancy between the fact that INSERT's
|
|
# SW lock is already satisfied, but INSERT's connection is still
|
|
# marked as waiting for it. Looking for a loop in waiters graph
|
|
# without additional checks has detected a deadlock (INSERT waits
|
|
# for SW lock; which is not granted because of pending SNW lock from
|
|
# ALTER; which waits for active SW lock from INSERT). Since requests
|
|
# for SW and SNW locks have same weight ALTER was selected as a victim
|
|
# and ended with ER_LOCK_DEADLOCK error.
|
|
set debug_sync='now SIGNAL go2';
|
|
#
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Reaping INSERT.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reaping ALTER. It should succeed and not produce ER_LOCK_DEADLOCK.
|
|
drop table t1;
|
|
#
|
|
# Now, test for a situation in which deadlock involves waiting not
|
|
# only in MDL subsystem but also for TDC. Such deadlocks should be
|
|
# successfully detected. If possible, they should be resolved without
|
|
# resorting to ER_LOCK_DEADLOCK error.
|
|
#
|
|
create table t1(i int);
|
|
create table t2(j int);
|
|
#
|
|
# First, let us check how we handle a simple scenario involving
|
|
# waits in MDL and TDC.
|
|
#
|
|
set debug_sync= 'RESET';
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Start a statement, which will acquire SR metadata lock on t1, open it
|
|
# and then stop, before trying to acquire SW lock on t2 and opening it.
|
|
set debug_sync='open_tables_after_open_and_process_table SIGNAL parked WAIT_FOR go';
|
|
# Sending:
|
|
select * from t1 where i in (select j from t2 for update);
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Wait till the above SELECT stops.
|
|
set debug_sync='now WAIT_FOR parked';
|
|
# The below FLUSH TABLES WITH READ LOCK should acquire
|
|
# SNW locks on t1 and t2 and wait till SELECT closes t1.
|
|
# Sending:
|
|
flush tables t1, t2 with read lock;
|
|
# Switching to connection 'deadlock_con3'.
|
|
# Wait until FLUSH TABLES WITH t1, t2 READ LOCK starts waiting
|
|
# for SELECT to close t1.
|
|
# Resume SELECT, so it tries to acquire SW lock on t1 and blocks,
|
|
# creating a deadlock. This deadlock should be detected and resolved
|
|
# by backing-off SELECT. As a result FTWRL should be able to finish.
|
|
set debug_sync='now SIGNAL go';
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Reap FLUSH TABLES WITH READ LOCK.
|
|
unlock tables;
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Reap SELECT.
|
|
i
|
|
#
|
|
# The same scenario with a slightly different order of events
|
|
# which emphasizes that setting correct deadlock detector weights
|
|
# for flush waits is important.
|
|
#
|
|
set debug_sync= 'RESET';
|
|
# Switching to connection 'deadlock_con2'.
|
|
set debug_sync='flush_tables_with_read_lock_after_acquire_locks SIGNAL parked WAIT_FOR go';
|
|
# The below FLUSH TABLES WITH READ LOCK should acquire
|
|
# SNW locks on t1 and t2 and wait on debug sync point.
|
|
# Sending:
|
|
flush tables t1, t2 with read lock;
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Wait till FLUSH TABLE WITH READ LOCK stops.
|
|
set debug_sync='now WAIT_FOR parked';
|
|
# Start statement which will acquire SR metadata lock on t1, open
|
|
# it and then will block while trying to acquire SW lock on t2.
|
|
# Sending:
|
|
select * from t1 where i in (select j from t2 for update);
|
|
# Switching to connection 'deadlock_con3'.
|
|
# Wait till the above SELECT blocks.
|
|
# Resume FLUSH TABLES, so it tries to flush t1, thus creating
|
|
# a deadlock. This deadlock should be detected and resolved by
|
|
# backing-off SELECT. As a result FTWRL should be able to finish.
|
|
set debug_sync='now SIGNAL go';
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Reap FLUSH TABLES WITH READ LOCK.
|
|
unlock tables;
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Reap SELECT.
|
|
i
|
|
#
|
|
# Now a more complex scenario involving two connections
|
|
# waiting for MDL and one for TDC.
|
|
#
|
|
set debug_sync= 'RESET';
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Start a statement which will acquire SR metadata lock on t2, open it
|
|
# and then stop, before trying to acquire SR on t1 and opening it.
|
|
set debug_sync='open_tables_after_open_and_process_table SIGNAL parked WAIT_FOR go';
|
|
# Sending:
|
|
select * from t2, t1;
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Wait till the above SELECT stops.
|
|
set debug_sync='now WAIT_FOR parked';
|
|
# The below FLUSH TABLES WITH READ LOCK should acquire
|
|
# SNW locks on t2 and wait till SELECT closes t2.
|
|
# Sending:
|
|
flush tables t2 with read lock;
|
|
# Switching to connection 'deadlock_con3'.
|
|
# Wait until FLUSH TABLES WITH READ LOCK starts waiting
|
|
# for SELECT to close t2.
|
|
# The below DROP TABLES should acquire X lock on t1 and start
|
|
# waiting for X lock on t2.
|
|
# Sending:
|
|
drop tables t1, t2;
|
|
# Switching to connection 'default'.
|
|
# Wait until DROP TABLES starts waiting for X lock on t2.
|
|
# Resume SELECT, so it tries to acquire SR lock on t1 and blocks,
|
|
# creating a deadlock. This deadlock should be detected and resolved
|
|
# by backing-off SELECT. As a result, FTWRL should be able to finish.
|
|
set debug_sync='now SIGNAL go';
|
|
# Switching to connection 'deadlock_con2'.
|
|
# Reap FLUSH TABLES WITH READ LOCK.
|
|
# Unblock DROP TABLES.
|
|
unlock tables;
|
|
# Switching to connection 'deadlock_con3'.
|
|
# Reap DROP TABLES.
|
|
# Switching to connection 'deadlock_con1'.
|
|
# Reap SELECT. It should emit error about missing table.
|
|
ERROR 42S02: Table 'test.t2' doesn't exist
|
|
# Switching to connection 'default'.
|
|
set debug_sync= 'RESET';
|
|
#
|
|
# Test for a scenario in which FLUSH TABLES <list> WITH READ LOCK
|
|
# used to erroneously release metadata locks.
|
|
#
|
|
drop tables if exists t1, t2;
|
|
set debug_sync= 'RESET';
|
|
create table t1(i int);
|
|
create table t2(j int);
|
|
# Switching to connection 'con2'.
|
|
set debug_sync='open_tables_after_open_and_process_table SIGNAL parked WAIT_FOR go';
|
|
# The below FLUSH TABLES <list> WITH READ LOCK should acquire
|
|
# SNW locks on t1 and t2, open table t1 and block on the debug
|
|
# sync point.
|
|
# Sending:
|
|
flush tables t1, t2 with read lock;
|
|
# Switching to connection 'con1'.
|
|
# Wait till FLUSH TABLES <list> WITH READ LOCK stops.
|
|
set debug_sync='now WAIT_FOR parked';
|
|
# Start a statement which will flush all tables and thus
|
|
# invalidate table t1 open by FLUSH TABLES <list> WITH READ LOCK.
|
|
# Sending:
|
|
flush tables;
|
|
# Switching to connection 'default'.
|
|
# Wait till the above FLUSH TABLES blocks.
|
|
# Resume FLUSH TABLES <list> WITH READ LOCK, so it tries to open t2
|
|
# discovers that its t1 is obsolete and tries to reopen all tables.
|
|
# Such reopen should not cause releasing of SNW metadata locks
|
|
# which would result in assertion failures.
|
|
set debug_sync='now SIGNAL go';
|
|
# Switching to connection 'con2'.
|
|
# Reap FLUSH TABLES <list> WITH READ LOCK.
|
|
unlock tables;
|
|
# Switching to connection 'con1'.
|
|
# Reap FLUSH TABLES.
|
|
# Clean-up.
|
|
# Switching to connection 'default'.
|
|
drop tables t1, t2;
|
|
set debug_sync= 'RESET';
|
|
#
|
|
# Test for bug #46748 "Assertion in MDL_context::wait_for_locks()
|
|
# on INSERT + CREATE TRIGGER".
|
|
#
|
|
drop tables if exists t1, t2, t3, t4, t5;
|
|
# Let us simulate scenario in which we open some tables from extended
|
|
# part of prelocking set but then encounter conflicting metadata lock,
|
|
# so have to back-off and wait for it to go away.
|
|
create table t1 (i int);
|
|
create table t2 (j int);
|
|
create table t3 (k int);
|
|
create table t4 (l int);
|
|
create trigger t1_bi before insert on t1 for each row
|
|
insert into t2 values (new.i);
|
|
create trigger t2_bi before insert on t2 for each row
|
|
insert into t3 values (new.j);
|
|
#
|
|
# Switching to connection 'con1root'.
|
|
lock tables t4 read;
|
|
#
|
|
# Switching to connection 'con2root'.
|
|
# Send :
|
|
rename table t3 to t5, t4 to t3;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Wait until the above RENAME TABLE adds pending requests for exclusive
|
|
# metadata lock on its tables and blocks due to 't4' being used by LOCK
|
|
# TABLES.
|
|
# Send :
|
|
insert into t1 values (1);;
|
|
#
|
|
# Switching to connection 'con1root'.
|
|
# Wait until INSERT statement waits due to encountering pending
|
|
# exclusive metadata lock on 't3'.
|
|
unlock tables;
|
|
#
|
|
# Switching to connection 'con2root'.
|
|
# Reap RENAME TABLE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Reap INSERT.
|
|
# Clean-up.
|
|
drop tables t1, t2, t3, t5;
|
|
#
|
|
# Bug#42546 - Backup: RESTORE fails, thinking it finds an existing table
|
|
#
|
|
DROP TABLE IF EXISTS t1;
|
|
set @save_log_output=@@global.log_output;
|
|
set global log_output=file;
|
|
#
|
|
# Test 1: CREATE TABLE
|
|
#
|
|
# Connection 2
|
|
# Start insert on the not-yet existing table
|
|
# Wait after taking the MDL lock
|
|
SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
INSERT INTO t1 VALUES(1,"def");
|
|
# Connection 1
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Now INSERT has a MDL on the non-existent table t1.
|
|
#
|
|
# Continue the INSERT once CREATE waits for exclusive lock
|
|
SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL finish';
|
|
# Try to create that table.
|
|
CREATE TABLE t1 (c1 INT, c2 VARCHAR(100), KEY(c1));
|
|
# Connection 2
|
|
# Insert fails
|
|
ERROR 42S02: Table 'test.t1' doesn't exist
|
|
# Connection 1
|
|
SET DEBUG_SYNC= 'RESET';
|
|
SHOW TABLES;
|
|
Tables_in_test
|
|
t1
|
|
DROP TABLE IF EXISTS t1;
|
|
#
|
|
# Test 2: CREATE TABLE LIKE
|
|
#
|
|
CREATE TABLE t2 (c1 INT, c2 VARCHAR(100), KEY(c1));
|
|
# Connection 2
|
|
# Start insert on the not-yet existing table
|
|
# Wait after taking the MDL
|
|
SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL locked WAIT_FOR finish';
|
|
INSERT INTO t1 VALUES(1,"def");
|
|
# Connection 1
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Now INSERT has a MDL on the non-existent table t1.
|
|
#
|
|
# Continue the INSERT once CREATE waits for exclusive lock
|
|
SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL finish';
|
|
# Try to create that table.
|
|
CREATE TABLE t1 LIKE t2;
|
|
# Connection 2
|
|
# Insert fails
|
|
ERROR 42S02: Table 'test.t1' doesn't exist
|
|
# Connection 1
|
|
SET DEBUG_SYNC= 'RESET';
|
|
SHOW TABLES;
|
|
Tables_in_test
|
|
t1
|
|
t2
|
|
DROP TABLE t2;
|
|
DROP TABLE IF EXISTS t1;
|
|
set global log_output=@save_log_output;
|
|
#
|
|
# Bug #46044 "MDL deadlock on LOCK TABLE + CREATE TABLE HIGH_PRIORITY
|
|
# FOR UPDATE"
|
|
#
|
|
drop tables if exists t1, t2;
|
|
create table t1 (i int);
|
|
# Let us check that we won't deadlock if during filling
|
|
# of I_S table we encounter conflicting metadata lock
|
|
# which owner is in its turn waiting for our connection.
|
|
lock tables t1 read;
|
|
# Switching to connection 'con46044'.
|
|
# Sending:
|
|
create table t2 select * from t1 for update;;
|
|
# Switching to connection 'default'.
|
|
# Waiting until CREATE TABLE ... SELECT ... is blocked.
|
|
# First let us check that SHOW FIELDS/DESCRIBE doesn't
|
|
# gets blocked and emits and error.
|
|
show fields from t2;
|
|
ERROR HY000: Table 'test'.'t2' was skipped since its definition is being modified by concurrent DDL statement
|
|
# Now test for I_S query which reads only .FRMs.
|
|
#
|
|
# Query below should only emit a warning.
|
|
select column_name from information_schema.columns
|
|
where table_schema='test' and table_name='t2';
|
|
column_name
|
|
Warnings:
|
|
Warning 1684 Table 'test'.'t2' was skipped since its definition is being modified by concurrent DDL statement
|
|
# Finally, test for I_S query which does full-blown table open.
|
|
#
|
|
# Query below should not be blocked. Warning message should be
|
|
# stored in the 'table_comment' column.
|
|
select table_name, table_type, auto_increment, table_comment
|
|
from information_schema.tables where table_schema='test' and table_name='t2';
|
|
table_name table_type auto_increment table_comment
|
|
t2 BASE TABLE NULL Table 'test'.'t2' was skipped since its definition is being modified by concurrent DDL statement
|
|
# Switching to connection 'default'.
|
|
unlock tables;
|
|
# Switching to connection 'con46044'.
|
|
# Reaping CREATE TABLE ... SELECT ... .
|
|
drop table t2;
|
|
#
|
|
# Let us also check that queries to I_S wait for conflicting metadata
|
|
# locks to go away instead of skipping table with a warning in cases
|
|
# when deadlock is not possible. This is a nice thing from compatibility
|
|
# and ease of use points of view.
|
|
#
|
|
# We check same three queries to I_S in this new situation.
|
|
# Switching to connection 'con46044_2'.
|
|
lock tables t1 read;
|
|
# Switching to connection 'con46044'.
|
|
# Sending:
|
|
create table t2 select * from t1 for update;;
|
|
# Switching to connection 'default'.
|
|
# Waiting until CREATE TABLE ... SELECT ... is blocked.
|
|
# Let us check that SHOW FIELDS/DESCRIBE gets blocked.
|
|
# Sending:
|
|
show fields from t2;;
|
|
# Switching to connection 'con46044_2'.
|
|
# Wait until SHOW FIELDS gets blocked.
|
|
unlock tables;
|
|
# Switching to connection 'con46044'.
|
|
# Reaping CREATE TABLE ... SELECT ... .
|
|
# Switching to connection 'default'.
|
|
# Reaping SHOW FIELDS ...
|
|
Field Type Null Key Default Extra
|
|
i int(11) YES NULL
|
|
drop table t2;
|
|
# Switching to connection 'con46044_2'.
|
|
lock tables t1 read;
|
|
# Switching to connection 'con46044'.
|
|
# Sending:
|
|
create table t2 select * from t1 for update;;
|
|
# Switching to connection 'default'.
|
|
# Waiting until CREATE TABLE ... SELECT ... is blocked.
|
|
# Check that I_S query which reads only .FRMs gets blocked.
|
|
# Sending:
|
|
select column_name from information_schema.columns where table_schema='test' and table_name='t2';;
|
|
# Switching to connection 'con46044_2'.
|
|
# Wait until SELECT COLUMN_NAME FROM I_S.COLUMNS gets blocked.
|
|
unlock tables;
|
|
# Switching to connection 'con46044'.
|
|
# Reaping CREATE TABLE ... SELECT ... .
|
|
# Switching to connection 'default'.
|
|
# Reaping SELECT COLUMN_NAME FROM I_S.COLUMNS
|
|
column_name
|
|
i
|
|
drop table t2;
|
|
# Switching to connection 'con46044_2'.
|
|
lock tables t1 read;
|
|
# Switching to connection 'con46044'.
|
|
# Sending:
|
|
create table t2 select * from t1 for update;;
|
|
# Switching to connection 'default'.
|
|
# Waiting until CREATE TABLE ... SELECT ... is blocked.
|
|
# Finally, check that I_S query which does full-blown table open
|
|
# also gets blocked.
|
|
# Sending:
|
|
select table_name, table_type, auto_increment, table_comment from information_schema.tables where table_schema='test' and table_name='t2';;
|
|
# Switching to connection 'con46044_2'.
|
|
# Wait until SELECT ... FROM I_S.TABLES gets blocked.
|
|
unlock tables;
|
|
# Switching to connection 'con46044'.
|
|
# Reaping CREATE TABLE ... SELECT ... .
|
|
# Switching to connection 'default'.
|
|
# Reaping SELECT ... FROM I_S.TABLES
|
|
table_name table_type auto_increment table_comment
|
|
t2 BASE TABLE NULL
|
|
drop table t2;
|
|
# Switching to connection 'default'.
|
|
# Clean-up.
|
|
drop table t1;
|
|
#
|
|
# Test for bug #46273 "MySQL 5.4.4 new MDL: Bug#989 is not fully fixed
|
|
# in case of ALTER".
|
|
#
|
|
drop table if exists t1;
|
|
set debug_sync= 'RESET';
|
|
create table t1 (c1 int primary key, c2 int, c3 int);
|
|
insert into t1 values (1,1,0),(2,2,0),(3,3,0),(4,4,0),(5,5,0);
|
|
begin;
|
|
select * from t1 where c2 = 3;
|
|
c1 c2 c3
|
|
3 3 0
|
|
#
|
|
# Switching to connection 'con46273'.
|
|
set debug_sync='after_lock_tables_takes_lock SIGNAL alter_table_locked WAIT_FOR alter_go';
|
|
alter table t1 add column e int, rename to t2;;
|
|
#
|
|
# Switching to connection 'default'.
|
|
set debug_sync='now WAIT_FOR alter_table_locked';
|
|
set debug_sync='mdl_acquire_lock_wait SIGNAL alter_go';
|
|
# The below statement should get ER_LOCK_DEADLOCK error
|
|
# (i.e. it should not allow ALTER to proceed, and then
|
|
# fail due to 't1' changing its name to 't2').
|
|
update t1 set c3=c3+1 where c2 = 3;
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
#
|
|
# Let us check that failure of the above statement has not released
|
|
# metadata lock on table 't1', i.e. that ALTER TABLE is still blocked.
|
|
# Unblock ALTER TABLE by commiting transaction and thus releasing
|
|
# metadata lock on 't1'.
|
|
commit;
|
|
#
|
|
# Switching to connection 'con46273'.
|
|
# Reap ALTER TABLE.
|
|
#
|
|
# Switching to connection 'default'.
|
|
# Clean-up.
|
|
set debug_sync= 'RESET';
|
|
drop table t2;
|
|
#
|
|
# Test for bug #46673 "Deadlock between FLUSH TABLES WITH READ LOCK
|
|
# and DML".
|
|
#
|
|
drop tables if exists t1;
|
|
create table t1 (i int);
|
|
# Switching to connection 'con46673'.
|
|
begin;
|
|
insert into t1 values (1);
|
|
# Switching to connection 'default'.
|
|
# Statement below should not get blocked. And if after some
|
|
# changes to code it is there should not be a deadlock between
|
|
# it and transaction from connection 'con46673'.
|
|
flush tables with read lock;
|
|
unlock tables;
|
|
# Switching to connection 'con46673'.
|
|
delete from t1 where i = 1;
|
|
commit;
|
|
# Switching to connection 'default'.
|
|
# Clean-up
|
|
drop table t1;
|
|
#
|
|
# Bug#48210 FLUSH TABLES WITH READ LOCK deadlocks
|
|
# against concurrent CREATE PROCEDURE
|
|
#
|
|
# Test 1: CREATE PROCEDURE
|
|
# Connection 1
|
|
# Start CREATE PROCEDURE and open mysql.proc
|
|
SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL table_opened WAIT_FOR grlwait';
|
|
CREATE PROCEDURE p1() SELECT 1;
|
|
# Connection 2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
|
|
# Check that FLUSH must wait to get the GRL
|
|
# and let CREATE PROCEDURE continue
|
|
SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
|
|
FLUSH TABLES WITH READ LOCK;
|
|
# Connection 1
|
|
# Connection 2
|
|
UNLOCK TABLES;
|
|
# Connection 1
|
|
SET DEBUG_SYNC= 'RESET';
|
|
# Test 2: DROP PROCEDURE
|
|
# Start DROP PROCEDURE and open tables
|
|
SET DEBUG_SYNC= 'after_open_table_mdl_shared SIGNAL table_opened WAIT_FOR grlwait';
|
|
DROP PROCEDURE p1;
|
|
# Connection 2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR table_opened';
|
|
# Check that FLUSH must wait to get the GRL
|
|
# and let DROP PROCEDURE continue
|
|
SET DEBUG_SYNC= 'mdl_acquire_lock_wait SIGNAL grlwait';
|
|
FLUSH TABLES WITH READ LOCK;
|
|
# Connection 1
|
|
# Once FLUSH TABLES WITH READ LOCK starts waiting
|
|
# DROP PROCEDURE will be waked up and will drop
|
|
# procedure. Global read lock will be granted after
|
|
# this statement ends.
|
|
#
|
|
# Reaping DROP PROCEDURE.
|
|
# Connection 2
|
|
# Reaping FTWRL.
|
|
UNLOCK TABLES;
|
|
# Connection 1
|
|
SET DEBUG_SYNC= 'RESET';
|
|
#
|
|
# Bug#50786 Assertion `thd->mdl_context.trans_sentinel() == __null'
|
|
# failed in open_ltable()
|
|
#
|
|
# Supress warnings written to the log file
|
|
call mtr.add_suppression("Wait on a lock was aborted due to a pending exclusive lock");
|
|
DROP TABLE IF EXISTS t1, t2;
|
|
CREATE TABLE t1 (i INT);
|
|
CREATE TABLE t2 (i INT);
|
|
SET @old_general_log= @@global.general_log;
|
|
SET @@global.general_log= 1;
|
|
SET @old_log_output= @@global.log_output;
|
|
SET @@global.log_output= 'TABLE';
|
|
SET @old_sql_log_off= @@session.sql_log_off;
|
|
SET @@session.sql_log_off= 1;
|
|
# connection: con1
|
|
HANDLER t1 OPEN;
|
|
# connection: con3
|
|
SET @@session.sql_log_off= 1;
|
|
# connection: con2
|
|
SET DEBUG_SYNC= 'thr_multi_lock_after_thr_lock SIGNAL parked WAIT_FOR go';
|
|
# Sending:
|
|
SELECT 1;
|
|
# connection: con3
|
|
SET DEBUG_SYNC= 'now WAIT_FOR parked';
|
|
# connection: con1
|
|
# Sending:
|
|
SELECT 1;
|
|
# connection: con3
|
|
ALTER TABLE t1 ADD COLUMN j INT;
|
|
# connection: default
|
|
SET DEBUG_SYNC= 'now SIGNAL go';
|
|
# connection: con1
|
|
# Reaping SELECT 1
|
|
1
|
|
1
|
|
HANDLER t1 CLOSE;
|
|
# connection: con2
|
|
# Reaping SELECT 1
|
|
1
|
|
1
|
|
# connection: default
|
|
DROP TABLE t1, t2;
|
|
SET DEBUG_SYNC= 'RESET';
|
|
SET @@global.general_log= @old_general_log;
|
|
SET @@global.log_output= @old_log_output;
|
|
SET @@session.sql_log_off= @old_sql_log_off;
|
|
#
|
|
# Additional coverage for bug #50913 "Deadlock between
|
|
# open_and_lock_tables_derived and MDL". The main test
|
|
# case is in lock_multi.test
|
|
#
|
|
drop table if exists t1;
|
|
set debug_sync= 'RESET';
|
|
create table t1 (i int) engine=InnoDB;
|
|
# Switching to connection 'con50913_1'.
|
|
set debug_sync= 'thr_multi_lock_after_thr_lock SIGNAL parked WAIT_FOR go';
|
|
# Sending:
|
|
alter table t1 add column j int;
|
|
# Switching to connection 'default'.
|
|
# Wait until ALTER TABLE gets blocked on a sync point after
|
|
# acquiring thr_lock.c lock.
|
|
set debug_sync= 'now WAIT_FOR parked';
|
|
# The below statement should wait on MDL lock and not deadlock on
|
|
# thr_lock.c lock.
|
|
# Sending:
|
|
truncate table t1;
|
|
# Switching to connection 'con50913_2'.
|
|
# Wait until TRUNCATE TABLE is blocked on MDL lock.
|
|
# Unblock ALTER TABLE.
|
|
set debug_sync= 'now SIGNAL go';
|
|
# Switching to connection 'con50913_1'.
|
|
# Reaping ALTER TABLE.
|
|
# Switching to connection 'default'.
|
|
# Reaping TRUNCATE TABLE.
|
|
set debug_sync= 'RESET';
|
|
drop table t1;
|
|
#
|
|
# Test for bug #50998 "Deadlock in MDL code during test
|
|
# rqg_mdl_stability".
|
|
# Also provides coverage for the case when addition of
|
|
# waiting statement adds several loops in the waiters
|
|
# graph and therefore several searches for deadlock
|
|
# should be performed.
|
|
drop table if exists t1;
|
|
set debug_sync= 'RESET';
|
|
create table t1 (i int);
|
|
# Switching to connection 'con1'.
|
|
begin;
|
|
select * from t1;
|
|
i
|
|
# Switching to connection 'con2'.
|
|
begin;
|
|
select * from t1;
|
|
i
|
|
# Switching to connection 'default'.
|
|
# Start ALTER TABLE which will acquire SNW lock and
|
|
# table lock and get blocked on sync point.
|
|
set debug_sync= 'thr_multi_lock_after_thr_lock SIGNAL parked WAIT_FOR go';
|
|
# Sending:
|
|
alter table t1 add column j int;
|
|
# Switching to connection 'con1'.
|
|
# Wait until ALTER TABLE gets blocked on a sync point.
|
|
set debug_sync= 'now WAIT_FOR parked';
|
|
# Sending:
|
|
insert into t1 values (1);
|
|
# Switching to connection 'con2'.
|
|
# Sending:
|
|
insert into t1 values (1);
|
|
# Switching to connection 'con3'.
|
|
# Wait until both 'con1' and 'con2' are blocked trying to acquire
|
|
# SW lock on the table.
|
|
# Unblock ALTER TABLE. Since it will try to upgrade SNW to X lock
|
|
# deadlock with two loops in waiting graph will occur. Both loops
|
|
# should be found and DML statements in both 'con1' and 'con2'
|
|
# should be aborted with ER_LOCK_DEADLOCK errors.
|
|
set debug_sync= 'now SIGNAL go';
|
|
# Switching to connection 'con1'.
|
|
# Reaping INSERT. It should end with ER_LOCK_DEADLOCK error and
|
|
# not wait indefinitely (as it happened before the bugfix).
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
commit;
|
|
# Switching to connection 'con2'.
|
|
# Reaping INSERT.
|
|
ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
|
|
commit;
|
|
# Switching to connection 'default'.
|
|
# Reap ALTER TABLE.
|
|
set debug_sync= 'RESET';
|
|
drop table t1;
|
|
#
|
|
# Bug#42643: InnoDB does not support replication of TRUNCATE TABLE
|
|
#
|
|
# Ensure that a acquired lock is not given up due to a conflict.
|
|
#
|
|
DROP TABLE IF EXISTS t1;
|
|
CREATE TABLE t1 (a INT) ENGINE=InnoDB;
|
|
INSERT INTO t1 VALUES (1),(2),(3);
|
|
# Connection: con1
|
|
LOCK TABLES t1 WRITE;
|
|
SET debug_sync='upgrade_lock_for_truncate SIGNAL parked_truncate WAIT_FOR go_truncate';
|
|
TRUNCATE TABLE t1;
|
|
# Connection: default
|
|
SET debug_sync='now WAIT_FOR parked_truncate';
|
|
# Connection: con2
|
|
SET debug_sync='after_open_table_ignore_flush SIGNAL parked_show WAIT_FOR go_show';
|
|
SHOW FIELDS FROM t1;
|
|
# Connection: default
|
|
SET debug_sync='now WAIT_FOR parked_show';
|
|
# Connection: con3
|
|
SET debug_sync='after_flush_unlock SIGNAL parked_flush WAIT_FOR go_flush';
|
|
FLUSH TABLES t1;
|
|
# Connection: default
|
|
SET debug_sync='now WAIT_FOR parked_flush';
|
|
SET debug_sync='now SIGNAL go_truncate';
|
|
# Ensure that truncate waits for a exclusive lock
|
|
SET debug_sync= 'now SIGNAL go_show';
|
|
# Connection: con1 (TRUNCATE)
|
|
# Reaping...
|
|
UNLOCK TABLES;
|
|
# Connection: con2 (SHOW FIELDS FROM t1)
|
|
# Reaping...
|
|
Field Type Null Key Default Extra
|
|
a int(11) YES NULL
|
|
# Connection: default
|
|
SET debug_sync= 'now SIGNAL go_flush';
|
|
# Connection: con3 (FLUSH TABLES t1)
|
|
# Reaping...
|
|
# Connection: default
|
|
SET debug_sync= 'RESET';
|
|
DROP TABLE t1;
|
|
#
|
|
# Bug#52856 concurrent show columns or show full columns causes a crash!!!
|
|
#
|
|
CREATE TABLE t1(a CHAR(255));
|
|
SET DEBUG_SYNC= "get_schema_column SIGNAL waiting WAIT_FOR completed";
|
|
SHOW FULL COLUMNS FROM t1;
|
|
SET DEBUG_SYNC= "now WAIT_FOR waiting";
|
|
SHOW FULL COLUMNS FROM t1;
|
|
Field Type Collation Null Key Default Extra Privileges Comment
|
|
a char(255) latin1_swedish_ci YES NULL #
|
|
SET DEBUG_SYNC= "now SIGNAL completed";
|
|
Field Type Collation Null Key Default Extra Privileges Comment
|
|
a char(255) latin1_swedish_ci YES NULL #
|
|
DROP TABLE t1;
|
|
#
|
|
# Tests for schema-scope locks
|
|
#
|
|
DROP DATABASE IF EXISTS db1;
|
|
DROP DATABASE IF EXISTS db2;
|
|
# Test 1:
|
|
# CREATE DATABASE blocks database DDL on the same database, but
|
|
# not database DDL on different databases. Tests X vs X lock.
|
|
#
|
|
# Connection default
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
CREATE DATABASE db1;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
CREATE DATABASE db1;
|
|
# Connection con3
|
|
CREATE DATABASE db2;
|
|
ALTER DATABASE db2 DEFAULT CHARACTER SET utf8;
|
|
DROP DATABASE db2;
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: CREATE DATABASE db1
|
|
# Connection con2
|
|
# Reaping: CREATE DATABASE db1
|
|
ERROR HY000: Can't create database 'db1'; database exists
|
|
# Test 2:
|
|
# ALTER DATABASE blocks database DDL on the same database, but
|
|
# not database DDL on different databases. Tests X vs X lock.
|
|
#
|
|
# Connection default
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
ALTER DATABASE db1 DEFAULT CHARACTER SET utf8;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
ALTER DATABASE db1 DEFAULT CHARACTER SET utf8;
|
|
# Connection con3
|
|
CREATE DATABASE db2;
|
|
ALTER DATABASE db2 DEFAULT CHARACTER SET utf8;
|
|
DROP DATABASE db2;
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: ALTER DATABASE db1 DEFAULT CHARACTER SET utf8
|
|
# Connection con2
|
|
# Reaping: ALTER DATABASE db1 DEFAULT CHARACTER SET utf8
|
|
# Connection default
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
ALTER DATABASE db1 DEFAULT CHARACTER SET utf8;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con3
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: ALTER DATABASE db1 DEFAULT CHARACTER SET utf8
|
|
# Connection con2
|
|
# Reaping: DROP DATABASE db1
|
|
CREATE DATABASE db1;
|
|
# Test 3:
|
|
# Two ALTER..UPGRADE of the same database are mutually exclusive, but
|
|
# two ALTER..UPGRADE of different databases are not. Tests X vs X lock.
|
|
#
|
|
# Connection default
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
ALTER DATABASE `#mysql50#a-b-c` UPGRADE DATA DIRECTORY NAME;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
ALTER DATABASE `#mysql50#a-b-c` UPGRADE DATA DIRECTORY NAME;
|
|
# Connection con3
|
|
ALTER DATABASE `#mysql50#a-b-c-d` UPGRADE DATA DIRECTORY NAME;
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: ALTER DATABASE '#mysql50#a-b-c' UPGRADE DATA DIRECTORY NAME
|
|
# Connection con2
|
|
# Reaping: ALTER DATABASE '#mysql50#a-b-c' UPGRADE DATA DIRECTORY NAME
|
|
ERROR 42000: Unknown database '#mysql50#a-b-c'
|
|
DROP DATABASE `a-b-c`;
|
|
DROP DATABASE `a-b-c-d`;
|
|
# Test 4:
|
|
# DROP DATABASE blocks database DDL on the same database, but
|
|
# not database DDL on different databases. Tests X vs X lock.
|
|
#
|
|
# Connection default
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con3
|
|
CREATE DATABASE db2;
|
|
ALTER DATABASE db2 DEFAULT CHARACTER SET utf8;
|
|
DROP DATABASE db2;
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: DROP DATABASE db1
|
|
# Connection con2
|
|
# Reaping: DROP DATABASE db1
|
|
ERROR HY000: Can't drop database 'db1'; database doesn't exist
|
|
# Connection default
|
|
CREATE DATABASE db1;
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
ALTER DATABASE db1 DEFAULT CHARACTER SET utf8;
|
|
# Connection con3
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: DROP DATABASE db1
|
|
# Connection con2
|
|
# Reaping: ALTER DATABASE db1 DEFAULT CHARACTER SET utf8
|
|
Got one of the listed errors
|
|
# Test 5:
|
|
# Locked database name prevents CREATE of tables in that database.
|
|
# Tests X vs IX lock.
|
|
#
|
|
# Connection default
|
|
CREATE DATABASE db1;
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
CREATE TABLE db1.t1 (a INT);
|
|
# Connection con3
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: DROP DATABASE db1
|
|
# Connection con2
|
|
# Reaping: CREATE TABLE db1.t1 (a INT)
|
|
ERROR 42000: Unknown database 'db1'
|
|
# Test 6:
|
|
# Locked database name prevents RENAME of tables to/from that database.
|
|
# Tests X vs IX lock.
|
|
#
|
|
# Connection default
|
|
CREATE DATABASE db1;
|
|
CREATE TABLE db1.t1 (a INT);
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
RENAME TABLE db1.t1 TO test.t1;
|
|
# Connection con3
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: DROP DATABASE db1
|
|
# Connection con2
|
|
# Reaping: RENAME TABLE db1.t1 TO test.t1
|
|
Got one of the listed errors
|
|
# Connection default
|
|
CREATE DATABASE db1;
|
|
CREATE TABLE test.t2 (a INT);
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
RENAME TABLE test.t2 TO db1.t2;
|
|
# Connection con3
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: DROP DATABASE db1
|
|
# Connection con2
|
|
# Reaping: RENAME TABLE test.t2 TO db1.t2
|
|
Got one of the listed errors
|
|
DROP TABLE test.t2;
|
|
# Test 7:
|
|
# Locked database name prevents DROP of tables in that database.
|
|
# Tests X vs IX lock.
|
|
#
|
|
# Connection default
|
|
CREATE DATABASE db1;
|
|
CREATE TABLE db1.t1 (a INT);
|
|
SET DEBUG_SYNC= 'after_wait_locked_schema_name SIGNAL locked WAIT_FOR blocked';
|
|
# Sending:
|
|
DROP DATABASE db1;
|
|
# Connection con2
|
|
SET DEBUG_SYNC= 'now WAIT_FOR locked';
|
|
# Sending:
|
|
DROP TABLE db1.t1;
|
|
# Connection con3
|
|
SET DEBUG_SYNC= 'now SIGNAL blocked';
|
|
# Connection default
|
|
# Reaping: DROP DATABASE db1
|
|
# Connection con2
|
|
# Reaping: DROP TABLE db1.t1
|
|
ERROR 42S02: Unknown table 't1'
|
|
# Connection default
|
|
SET DEBUG_SYNC= 'RESET';
|
|
#
|
|
# End of tests for schema-scope locks
|
|
#
|
|
#
|
|
# Tests of granted global S lock (FLUSH TABLE WITH READ LOCK)
|
|
#
|
|
CREATE DATABASE db1;
|
|
CREATE TABLE db1.t1(a INT);
|
|
# Connection default
|
|
FLUSH TABLE WITH READ LOCK;
|
|
# Connection con2
|
|
CREATE TABLE db1.t2(a INT);
|
|
# Connection default
|
|
UNLOCK TABLES;
|
|
# Connection con2
|
|
# Reaping CREATE TABLE db1.t2(a INT)
|
|
# Connection default
|
|
FLUSH TABLE WITH READ LOCK;
|
|
# Connection con2
|
|
ALTER DATABASE db1 DEFAULT CHARACTER SET utf8;
|
|
# Connection default
|
|
UNLOCK TABLES;
|
|
# Connection con2
|
|
# Reaping ALTER DATABASE db1 DEFAULT CHARACTER SET utf8
|
|
# Connection default
|
|
FLUSH TABLE WITH READ LOCK;
|
|
# Connection con2
|
|
FLUSH TABLE WITH READ LOCK;
|
|
UNLOCK TABLES;
|
|
# Connection default
|
|
UNLOCK TABLES;
|
|
DROP DATABASE db1;
|
|
#
|
|
# Bug#56292 Deadlock with ALTER TABLE and MERGE tables
|
|
#
|
|
DROP TABLE IF EXISTS t1, t2, m1;
|
|
CREATE TABLE t1(a INT) engine=MyISAM;
|
|
CREATE TABLE t2(a INT) engine=MyISAM;
|
|
CREATE TABLE m1(a INT) engine=MERGE UNION=(t1, t2);
|
|
INSERT INTO t1 VALUES (1), (2);
|
|
INSERT INTO t2 VALUES (3), (4);
|
|
# Connection con1
|
|
SET DEBUG_SYNC= 'mdl_upgrade_shared_lock_to_exclusive SIGNAL upgrade WAIT_FOR continue';
|
|
# Sending:
|
|
ALTER TABLE m1 engine=MERGE UNION=(t2, t1);
|
|
# Connection con2
|
|
# Waiting for ALTER TABLE to try lock upgrade
|
|
SET DEBUG_SYNC= 'now WAIT_FOR upgrade';
|
|
# Sending:
|
|
DELETE FROM t2 WHERE a = 3;
|
|
# Connection default
|
|
# Check that DELETE is waiting on a metadata lock and not a table lock.
|
|
# Now that DELETE blocks on a metadata lock, we should be able to do
|
|
# SELECT * FROM m1 here. SELECT used to be blocked by a DELETE table
|
|
# lock request.
|
|
SELECT * FROM m1;
|
|
a
|
|
1
|
|
2
|
|
3
|
|
4
|
|
# Resuming ALTER TABLE
|
|
SET DEBUG_SYNC= 'now SIGNAL continue';
|
|
# Connection con1
|
|
# Reaping: ALTER TABLE m1 engine=MERGE UNION=(t2, t1)
|
|
# Connection con2
|
|
# Reaping: DELETE FROM t2 WHERE a = 3
|
|
# Connection default
|
|
DROP TABLE m1, t1, t2;
|
|
SET DEBUG_SYNC= 'RESET';
|