mirror of
https://github.com/MariaDB/server.git
synced 2025-02-01 19:41:47 +01:00
378cdc58c1
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.
1150 lines
28 KiB
Text
1150 lines
28 KiB
Text
# Save the initial number of concurrent sessions
|
|
--source include/count_sessions.inc
|
|
|
|
--disable_warnings
|
|
drop table if exists t1,t2;
|
|
--enable_warnings
|
|
|
|
# Test to see if select will get the lock ahead of low priority update
|
|
|
|
connect (locker,localhost,root,,);
|
|
connect (locker2,localhost,root,,);
|
|
connect (reader,localhost,root,,);
|
|
connect (writer,localhost,root,,);
|
|
|
|
connection locker;
|
|
create table t1(n int);
|
|
insert into t1 values (1);
|
|
connection locker2;
|
|
select get_lock("mysqltest_lock", 100);
|
|
connection locker;
|
|
send
|
|
update t1 set n = 2 and get_lock('mysqltest_lock', 100);
|
|
connection writer;
|
|
# Wait till above update gets blocked on a user lock.
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "User lock" and info = "update t1 set n = 2 and get_lock('mysqltest_lock', 100)";
|
|
--source include/wait_condition.inc
|
|
send
|
|
update low_priority t1 set n = 4;
|
|
connection reader;
|
|
# Sleep a bit till the update of connection writer is in work and hangs
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table level lock" and
|
|
info = "update low_priority t1 set n = 4";
|
|
--source include/wait_condition.inc
|
|
send
|
|
select n from t1;
|
|
connection locker2;
|
|
# Sleep a bit till the select of connection reader is in work and hangs
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table level lock" and
|
|
info = "select n from t1";
|
|
--source include/wait_condition.inc
|
|
select release_lock("mysqltest_lock");
|
|
connection locker;
|
|
reap;
|
|
select release_lock("mysqltest_lock");
|
|
connection writer;
|
|
reap;
|
|
connection reader;
|
|
reap;
|
|
drop table t1;
|
|
|
|
connection locker;
|
|
create table t1(n int);
|
|
insert into t1 values (1);
|
|
connection locker2;
|
|
select get_lock("mysqltest_lock", 100);
|
|
connection locker;
|
|
send
|
|
select n from t1 where get_lock('mysqltest_lock', 100);
|
|
connection writer;
|
|
# Wait till above select gets blocked on a user lock.
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "User lock" and info = "select n from t1 where get_lock('mysqltest_lock', 100)";
|
|
--source include/wait_condition.inc
|
|
send
|
|
update low_priority t1 set n = 4;
|
|
connection reader;
|
|
# Sleep a bit till the update of connection writer is in work and hangs
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table level lock" and
|
|
info = "update low_priority t1 set n = 4";
|
|
--source include/wait_condition.inc
|
|
select n from t1;
|
|
connection locker2;
|
|
select release_lock("mysqltest_lock");
|
|
connection locker;
|
|
reap;
|
|
select release_lock("mysqltest_lock");
|
|
connection writer;
|
|
reap;
|
|
drop table t1;
|
|
|
|
#
|
|
# Test problem when using locks with multi-updates
|
|
# It should not block when multi-update is reading on a read-locked table
|
|
#
|
|
|
|
connection locker;
|
|
create table t1 (a int, b int);
|
|
create table t2 (c int, d int);
|
|
insert into t1 values(1,1);
|
|
insert into t1 values(2,2);
|
|
insert into t2 values(1,2);
|
|
lock table t1 read;
|
|
connection writer;
|
|
update t1,t2 set c=a where b=d;
|
|
connection reader;
|
|
select c from t2;
|
|
connection locker;
|
|
unlock tables;
|
|
drop table t1;
|
|
drop table t2;
|
|
|
|
#
|
|
# Test problem when using locks on many tables and dropping a table that
|
|
# is to-be-locked by another thread
|
|
#
|
|
#
|
|
connection locker;
|
|
create table t1 (a int);
|
|
create table t2 (a int);
|
|
lock table t1 write, t2 write;
|
|
connection reader;
|
|
send
|
|
insert t1 select * from t2;
|
|
connection locker;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "insert t1 select * from t2";
|
|
--source include/wait_condition.inc
|
|
drop table t2;
|
|
unlock tables;
|
|
connection reader;
|
|
--error ER_NO_SUCH_TABLE
|
|
reap;
|
|
connection locker;
|
|
drop table t1;
|
|
|
|
#
|
|
# Same test as above, but with the dropped table locked twice
|
|
#
|
|
|
|
connection locker;
|
|
create table t1 (a int);
|
|
create table t2 (a int);
|
|
lock table t1 write, t2 write, t1 as t1_2 write, t2 as t2_2 write;
|
|
connection reader;
|
|
send
|
|
insert t1 select * from t2;
|
|
connection locker;
|
|
# Sleep a bit till the insert of connection reader is in work and hangs
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "insert t1 select * from t2";
|
|
--source include/wait_condition.inc
|
|
drop table t2;
|
|
unlock tables;
|
|
connection reader;
|
|
--error ER_NO_SUCH_TABLE
|
|
reap;
|
|
connection locker;
|
|
drop table t1;
|
|
|
|
|
|
--echo End of 4.1 tests
|
|
|
|
#
|
|
# Bug#9998 MySQL client hangs on USE "database"
|
|
#
|
|
create table t1(a int);
|
|
lock tables t1 write;
|
|
connection reader;
|
|
show columns from t1;
|
|
connection locker;
|
|
unlock tables;
|
|
drop table t1;
|
|
|
|
#
|
|
# Bug#16986 Deadlock condition with MyISAM tables
|
|
#
|
|
|
|
# Need a matching user in mysql.user for multi-table select
|
|
--source include/add_anonymous_users.inc
|
|
|
|
connection locker;
|
|
USE mysql;
|
|
LOCK TABLES columns_priv WRITE, db WRITE, host WRITE, user WRITE;
|
|
FLUSH TABLES;
|
|
#
|
|
connection reader;
|
|
USE mysql;
|
|
# Note: This must be a multi-table select, otherwise the deadlock will not occur
|
|
send
|
|
SELECT user.Select_priv FROM user, db WHERE user.user = db.user LIMIT 1;
|
|
#
|
|
connection locker;
|
|
# Sleep a bit till the select of connection reader is in work and hangs
|
|
let $wait_condition=
|
|
SELECT COUNT(*) = 1 FROM information_schema.processlist
|
|
WHERE state = "Waiting for table metadata lock" AND info =
|
|
"SELECT user.Select_priv FROM user, db WHERE user.user = db.user LIMIT 1";
|
|
--source include/wait_condition.inc
|
|
# Make test case independent from earlier grants.
|
|
--replace_result "Table is already up to date" "OK"
|
|
OPTIMIZE TABLES columns_priv, db, host, user;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection reader;
|
|
reap;
|
|
USE test;
|
|
#
|
|
connection locker;
|
|
use test;
|
|
#
|
|
connection default;
|
|
#
|
|
# Test if CREATE TABLE with LOCK TABLE deadlocks.
|
|
#
|
|
connection writer;
|
|
CREATE TABLE t1 (c1 int);
|
|
LOCK TABLE t1 WRITE;
|
|
#
|
|
# This waits until t1 is unlocked.
|
|
connection locker;
|
|
send
|
|
FLUSH TABLES WITH READ LOCK;
|
|
#
|
|
connection writer;
|
|
# Sleep a bit till the flush of connection locker is in work and hangs
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "FLUSH TABLES WITH READ LOCK";
|
|
--source include/wait_condition.inc
|
|
# This must not block.
|
|
--error ER_TABLE_NOT_LOCKED
|
|
CREATE TABLE t2 (c1 int);
|
|
UNLOCK TABLES;
|
|
#
|
|
# This awakes now.
|
|
connection locker;
|
|
reap;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection default;
|
|
DROP TABLE t1;
|
|
#
|
|
# Test if CREATE TABLE SELECT with LOCK TABLE deadlocks.
|
|
#
|
|
connection writer;
|
|
CREATE TABLE t1 (c1 int);
|
|
LOCK TABLE t1 WRITE;
|
|
#
|
|
# This waits until t1 is unlocked.
|
|
connection locker;
|
|
send
|
|
FLUSH TABLES WITH READ LOCK;
|
|
#
|
|
# This must not block.
|
|
connection writer;
|
|
# Sleep a bit till the flush of connection locker is in work and hangs
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "FLUSH TABLES WITH READ LOCK";
|
|
--source include/wait_condition.inc
|
|
--error ER_TABLE_NOT_LOCKED
|
|
CREATE TABLE t2 AS SELECT * FROM t1;
|
|
UNLOCK TABLES;
|
|
#
|
|
# This awakes now.
|
|
connection locker;
|
|
reap;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection default;
|
|
DROP TABLE t1;
|
|
|
|
--source include/delete_anonymous_users.inc
|
|
|
|
#
|
|
# Bug#19815 CREATE/RENAME/DROP DATABASE can deadlock on a global read lock
|
|
#
|
|
connect (con1,localhost,root,,);
|
|
connect (con2,localhost,root,,);
|
|
#
|
|
connection con1;
|
|
CREATE DATABASE mysqltest_1;
|
|
FLUSH TABLES WITH READ LOCK;
|
|
#
|
|
# With bug in place: acquire LOCK_mysql_create_table and
|
|
# wait in wait_if_global_read_lock().
|
|
connection con2;
|
|
send
|
|
DROP DATABASE mysqltest_1;
|
|
#
|
|
# With bug in place: try to acquire LOCK_mysql_create_table...
|
|
# When fixed: Reject dropping db because of the read lock.
|
|
connection con1;
|
|
# Wait a bit so that the session con2 is in state
|
|
# "Waiting for global read lock"
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock"
|
|
and info = "DROP DATABASE mysqltest_1";
|
|
--source include/wait_condition.inc
|
|
--error ER_CANT_UPDATE_WITH_READLOCK
|
|
DROP DATABASE mysqltest_1;
|
|
UNLOCK TABLES;
|
|
#
|
|
connection con2;
|
|
reap;
|
|
#
|
|
connection default;
|
|
disconnect con1;
|
|
disconnect con2;
|
|
# This must have been dropped by connection 2 already,
|
|
# which waited until the global read lock was released.
|
|
--error ER_DB_DROP_EXISTS
|
|
DROP DATABASE mysqltest_1;
|
|
|
|
#
|
|
# Bug#17264 MySQL Server freeze
|
|
#
|
|
connection locker;
|
|
# Disable warnings to allow test to run also without InnoDB
|
|
--disable_warnings
|
|
create table t1 (f1 int(12) unsigned not null auto_increment, primary key(f1)) engine=innodb;
|
|
--enable_warnings
|
|
lock tables t1 write;
|
|
connection writer;
|
|
send
|
|
alter table t1 auto_increment=0;
|
|
connection reader;
|
|
# Wait till connection writer is blocked
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "alter table t1 auto_increment=0";
|
|
--source include/wait_condition.inc
|
|
send
|
|
alter table t1 auto_increment=0;
|
|
connection locker;
|
|
# Wait till connection reader is blocked
|
|
let $wait_condition=
|
|
select count(*) = 2 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "alter table t1 auto_increment=0";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
connection writer;
|
|
reap;
|
|
connection reader;
|
|
reap;
|
|
connection locker;
|
|
drop table t1;
|
|
|
|
#
|
|
# Bug#43230: SELECT ... FOR UPDATE can hang with FLUSH TABLES WITH READ LOCK indefinitely
|
|
#
|
|
|
|
connect (con1,localhost,root,,);
|
|
connect (con2,localhost,root,,);
|
|
connect (con3,localhost,root,,);
|
|
connect (con4,localhost,root,,);
|
|
connect (con5,localhost,root,,);
|
|
|
|
create table t1 (a int);
|
|
create table t2 like t1;
|
|
|
|
connection con1;
|
|
--echo # con1
|
|
lock tables t1 write;
|
|
connection con2;
|
|
--echo # con2
|
|
send flush tables with read lock;
|
|
connection con5;
|
|
--echo # con5
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "flush tables with read lock";
|
|
--source include/wait_condition.inc
|
|
--echo # global read lock is taken
|
|
connection con3;
|
|
--echo # con3
|
|
send select * from t2 for update;
|
|
connection con5;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "select * from t2 for update";
|
|
--source include/wait_condition.inc
|
|
--echo # waiting for release of read lock
|
|
connection con4;
|
|
--echo # con4
|
|
--echo # would hang and later cause a deadlock
|
|
flush tables t2;
|
|
connection con1;
|
|
--echo # clean up
|
|
unlock tables;
|
|
connection con2;
|
|
--reap
|
|
unlock tables;
|
|
connection con3;
|
|
--reap
|
|
connection default;
|
|
disconnect con5;
|
|
disconnect con4;
|
|
disconnect con3;
|
|
disconnect con2;
|
|
disconnect con1;
|
|
|
|
drop table t1,t2;
|
|
|
|
--echo #
|
|
--echo # Lightweight version:
|
|
--echo # Ensure that the wait for a GRL is done before opening tables.
|
|
--echo #
|
|
|
|
connect (con1,localhost,root,,);
|
|
connect (con2,localhost,root,,);
|
|
|
|
create table t1 (a int);
|
|
create table t2 like t1;
|
|
|
|
--echo #
|
|
--echo # UPDATE
|
|
--echo #
|
|
|
|
connection default;
|
|
--echo # default
|
|
flush tables with read lock;
|
|
connection con1;
|
|
--echo # con1
|
|
send update t2 set a = 1;
|
|
connection default;
|
|
--echo # default
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "update t2 set a = 1";
|
|
--source include/wait_condition.inc
|
|
--echo # statement is waiting for release of read lock
|
|
connection con2;
|
|
--echo # con2
|
|
flush table t2;
|
|
connection default;
|
|
--echo # default
|
|
unlock tables;
|
|
connection con1;
|
|
--echo # con1
|
|
--reap
|
|
|
|
--echo #
|
|
--echo # LOCK TABLES .. WRITE
|
|
--echo #
|
|
|
|
connection default;
|
|
--echo # default
|
|
flush tables with read lock;
|
|
connection con1;
|
|
--echo # con1
|
|
send lock tables t2 write;
|
|
connection default;
|
|
--echo # default
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "lock tables t2 write";
|
|
--source include/wait_condition.inc
|
|
--echo # statement is waiting for release of read lock
|
|
connection con2;
|
|
--echo # con2
|
|
flush table t2;
|
|
connection default;
|
|
--echo # default
|
|
unlock tables;
|
|
connection con1;
|
|
--echo # con1
|
|
--reap
|
|
unlock tables;
|
|
|
|
connection default;
|
|
disconnect con2;
|
|
disconnect con1;
|
|
|
|
drop table t1,t2;
|
|
|
|
|
|
--echo End of 5.0 tests
|
|
|
|
|
|
#
|
|
# Bug#21281 Pending write lock is incorrectly removed when its
|
|
# statement being KILLed
|
|
#
|
|
create table t1 (i int);
|
|
connection locker;
|
|
lock table t1 read;
|
|
connection writer;
|
|
send
|
|
update t1 set i= 10;
|
|
connection reader;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table level lock" and
|
|
info = "update t1 set i= 10";
|
|
--source include/wait_condition.inc
|
|
send
|
|
select * from t1;
|
|
connection default;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table level lock" and
|
|
info = "select * from t1";
|
|
--source include/wait_condition.inc
|
|
let $ID= `select id from information_schema.processlist
|
|
where state = "Waiting for table level lock" and
|
|
info = "update t1 set i= 10"`;
|
|
--replace_result $ID ID
|
|
eval kill query $ID;
|
|
connection reader;
|
|
--reap
|
|
connection writer;
|
|
--error ER_QUERY_INTERRUPTED
|
|
--reap
|
|
connection locker;
|
|
unlock tables;
|
|
connection default;
|
|
drop table t1;
|
|
|
|
#
|
|
# Bug#25856 HANDLER table OPEN in one connection lock DROP TABLE in another one
|
|
#
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
create table t1 (a int) ENGINE=MEMORY;
|
|
--echo --> client 2
|
|
connection locker;
|
|
--error ER_ILLEGAL_HA
|
|
handler t1 open;
|
|
--echo --> client 1
|
|
connection default;
|
|
drop table t1;
|
|
|
|
|
|
# Disconnect sessions used in many subtests above
|
|
disconnect locker;
|
|
disconnect locker2;
|
|
disconnect reader;
|
|
disconnect writer;
|
|
|
|
|
|
#
|
|
# Bug#32395 Alter table under a impending global read lock causes a server crash
|
|
#
|
|
|
|
#
|
|
# Test ALTER TABLE under LOCK TABLES and FLUSH TABLES WITH READ LOCK
|
|
#
|
|
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
create table t1 (i int);
|
|
connect (flush,localhost,root,,test,,);
|
|
connection default;
|
|
--echo connection: default
|
|
lock tables t1 write;
|
|
connection flush;
|
|
--echo connection: flush
|
|
--send flush tables with read lock;
|
|
connection default;
|
|
--echo connection: default
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "flush tables with read lock";
|
|
--source include/wait_condition.inc
|
|
alter table t1 add column j int;
|
|
connect (insert,localhost,root,,test,,);
|
|
connection insert;
|
|
--echo connection: insert
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "flush tables with read lock";
|
|
--source include/wait_condition.inc
|
|
--send insert into t1 values (1,2);
|
|
--echo connection: default
|
|
connection default;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "insert into t1 values (1,2)";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
connection flush;
|
|
--echo connection: flush
|
|
--reap
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock" and
|
|
info = "insert into t1 values (1,2)";
|
|
--source include/wait_condition.inc
|
|
select * from t1;
|
|
unlock tables;
|
|
connection insert;
|
|
--reap
|
|
connection default;
|
|
let $wait_condition=
|
|
select count(*) = 1 from t1;
|
|
--source include/wait_condition.inc
|
|
select * from t1;
|
|
drop table t1;
|
|
disconnect flush;
|
|
disconnect insert;
|
|
|
|
#
|
|
# Test that FLUSH TABLES under LOCK TABLES protects write locked tables
|
|
# from a impending FLUSH TABLES WITH READ LOCK
|
|
#
|
|
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
create table t1 (i int);
|
|
connect (flush,localhost,root,,test,,);
|
|
connection default;
|
|
--echo connection: default
|
|
lock tables t1 write;
|
|
connection flush;
|
|
--echo connection: flush
|
|
--send flush tables with read lock;
|
|
connection default;
|
|
--echo connection: default
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock";
|
|
--source include/wait_condition.inc
|
|
flush tables;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
connection flush;
|
|
--reap
|
|
connection default;
|
|
disconnect flush;
|
|
drop table t1;
|
|
|
|
#
|
|
# Bug#30331 Table_locks_waited shows inaccurate values
|
|
#
|
|
|
|
--disable_warnings
|
|
drop table if exists t1,t2;
|
|
--enable_warnings
|
|
create table t1 (a int);
|
|
flush status;
|
|
lock tables t1 read;
|
|
let $tlwa= `show status like 'Table_locks_waited'`;
|
|
connect (waiter,localhost,root,,);
|
|
connection waiter;
|
|
send insert into t1 values(1);
|
|
connection default;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table level lock" and
|
|
info = "insert into t1 values(1)";
|
|
--source include/wait_condition.inc
|
|
let $tlwb= `show status like 'Table_locks_waited'`;
|
|
unlock tables;
|
|
connection waiter;
|
|
--reap
|
|
connection default;
|
|
drop table t1;
|
|
disconnect waiter;
|
|
--disable_query_log
|
|
eval SET @tlwa= SUBSTRING_INDEX('$tlwa', ' ', -1);
|
|
eval SET @tlwb= SUBSTRING_INDEX('$tlwb', ' ', -1);
|
|
--enable_query_log
|
|
select @tlwa < @tlwb;
|
|
|
|
--echo End of 5.1 tests
|
|
|
|
#
|
|
# Test that DROP TABLES does not wait for a impending FLUSH TABLES
|
|
# WITH READ LOCK
|
|
#
|
|
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
create table t1 (i int);
|
|
connect (flush,localhost,root,,test,,);
|
|
connection default;
|
|
--echo connection: default
|
|
lock tables t1 write;
|
|
connection flush;
|
|
--echo connection: flush
|
|
--send flush tables with read lock;
|
|
connection default;
|
|
--echo connection: default
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock";
|
|
--source include/wait_condition.inc
|
|
flush tables;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for global read lock";
|
|
--source include/wait_condition.inc
|
|
drop table t1;
|
|
connection flush;
|
|
--reap
|
|
connection default;
|
|
disconnect flush;
|
|
|
|
|
|
--echo #
|
|
--echo # Test for bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock".
|
|
--echo #
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
--enable_warnings
|
|
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;
|
|
update t1 set c3=c3+1 where c2=3;
|
|
|
|
--echo #
|
|
--echo # Switching to connection 'con46272'.
|
|
connect (con46272,localhost,root,,test,,);
|
|
connection con46272;
|
|
--echo # The below ALTER TABLE statement should wait till transaction
|
|
--echo # in connection 'default' is complete and then succeed.
|
|
--echo # It should not deadlock or fail with ER_LOCK_DEADLOCK error.
|
|
--echo # Sending:
|
|
--send alter table t1 add column c4 int;
|
|
|
|
--echo #
|
|
--echo # Switching to connection 'default'.
|
|
connection default;
|
|
--echo # Wait until the above ALTER TABLE gets blocked because this
|
|
--echo # connection holds SW metadata lock on table to be altered.
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "alter table t1 add column c4 int";
|
|
--source include/wait_condition.inc
|
|
|
|
--echo # The below statement should succeed. It should not
|
|
--echo # deadlock or end with ER_LOCK_DEADLOCK error.
|
|
update t1 set c3=c3+1 where c2=4;
|
|
|
|
--echo # Unblock ALTER TABLE by committing transaction.
|
|
commit;
|
|
|
|
--echo #
|
|
--echo # Switching to connection 'con46272'.
|
|
connection con46272;
|
|
--echo # Reaping ALTER TABLE.
|
|
--reap
|
|
|
|
--echo #
|
|
--echo # Switching to connection 'default'.
|
|
connection default;
|
|
disconnect con46272;
|
|
drop table t1;
|
|
|
|
|
|
--echo #
|
|
--echo # Bug#47249 assert in MDL_global_lock::is_lock_type_compatible
|
|
--echo #
|
|
|
|
--disable_warnings
|
|
DROP TABLE IF EXISTS t1;
|
|
DROP VIEW IF EXISTS v1;
|
|
--enable_warnings
|
|
|
|
--echo #
|
|
--echo # Test 1: LOCK TABLES v1 WRITE, t1 READ;
|
|
--echo #
|
|
--echo # Thanks to the fact that we no longer allow DDL on tables
|
|
--echo # which are locked for write implicitly, the exact scenario
|
|
--echo # in which assert was failing is no longer repeatable.
|
|
|
|
CREATE TABLE t1 ( f1 integer );
|
|
CREATE VIEW v1 AS SELECT f1 FROM t1 ;
|
|
|
|
LOCK TABLES v1 WRITE, t1 READ;
|
|
--error ER_TABLE_NOT_LOCKED_FOR_WRITE
|
|
FLUSH TABLE t1;
|
|
UNLOCK TABLES;
|
|
|
|
# Cleanup
|
|
DROP TABLE t1;
|
|
DROP VIEW v1;
|
|
|
|
--echo #
|
|
--echo # Test 2: LOCK TABLES t1 WRITE, v1 READ;
|
|
--echo #
|
|
|
|
CREATE TABLE t1 ( f1 integer );
|
|
CREATE VIEW v1 AS SELECT f1 FROM t1 ;
|
|
|
|
--echo # Connection 2
|
|
connect (con2,localhost,root);
|
|
LOCK TABLES t1 WRITE, v1 READ;
|
|
FLUSH TABLE t1;
|
|
disconnect con2;
|
|
--source include/wait_until_disconnected.inc
|
|
|
|
--echo # Connection 1
|
|
connection default;
|
|
LOCK TABLES t1 WRITE;
|
|
FLUSH TABLE t1; # Assertion happened here
|
|
|
|
# Cleanup
|
|
DROP TABLE t1;
|
|
DROP VIEW v1;
|
|
|
|
|
|
--echo #
|
|
--echo # Test for bug #50913 "Deadlock between open_and_lock_tables_derived
|
|
--echo # and MDL". Also see additional coverage in mdl_sync.test.
|
|
--echo #
|
|
--disable_warnings
|
|
drop table if exists t1;
|
|
drop view if exists v1;
|
|
--enable_warnings
|
|
connect (con50913,localhost,root);
|
|
connection default;
|
|
create table t1 (i int);
|
|
create view v1 as select i from t1;
|
|
begin;
|
|
select * from t1;
|
|
|
|
--echo # Switching to connection 'con50913'.
|
|
connection con50913;
|
|
--echo # Sending:
|
|
--send alter table t1 add column j int
|
|
|
|
--echo # Switching to connection 'default'.
|
|
connection default;
|
|
--echo # Wait until ALTER TABLE gets blocked.
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "alter table t1 add column j int";
|
|
--source include/wait_condition.inc
|
|
--echo # The below statement should try to acquire SW lock on 't1'
|
|
--echo # and therefore should get ER_LOCK_DEADLOCK error. Before
|
|
--echo # bug fix it acquired SR lock and hung on thr_lock.c lock.
|
|
--error ER_LOCK_DEADLOCK
|
|
delete a from t1 as a where i = 1;
|
|
--echo # Unblock ALTER TABLE.
|
|
commit;
|
|
|
|
--echo # Switching to connection 'con50913'.
|
|
connection con50913;
|
|
--echo # Reaping ALTER TABLE;
|
|
--reap
|
|
|
|
--echo # Switching to connection 'default'.
|
|
connection default;
|
|
begin;
|
|
select * from v1;
|
|
|
|
--echo # Switching to connection 'con50913'.
|
|
connection con50913;
|
|
--echo # Sending:
|
|
--send alter table t1 drop column j
|
|
|
|
--echo # Switching to connection 'default'.
|
|
connection default;
|
|
--echo # Wait until ALTER TABLE gets blocked.
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "alter table t1 drop column j";
|
|
--source include/wait_condition.inc
|
|
--echo # The below statement should try to acquire SW lock on 't1'
|
|
--echo # and therefore should get ER_LOCK_DEADLOCK error. Before
|
|
--echo # bug fix it acquired SR lock and hung on thr_lock.c lock.
|
|
--error ER_LOCK_DEADLOCK
|
|
insert into v1 values (1);
|
|
--echo # Unblock ALTER TABLE.
|
|
commit;
|
|
|
|
--echo # Switching to connection 'con50913'.
|
|
connection con50913;
|
|
--echo # Reaping ALTER TABLE;
|
|
--reap
|
|
|
|
--echo # Switching to connection 'default'.
|
|
connection default;
|
|
disconnect con50913;
|
|
drop view v1;
|
|
drop table t1;
|
|
|
|
|
|
--echo #
|
|
--echo # Bug#45225 Locking: hang if drop table with no timeout
|
|
--echo #
|
|
--echo # These tests also provide function coverage for the
|
|
--echo # lock_wait_timeout server variable.
|
|
--echo #
|
|
|
|
--disable_warnings
|
|
DROP TABLE IF EXISTS t1;
|
|
--enable_warnings
|
|
|
|
CREATE TABLE t1 (id int);
|
|
|
|
connect(con2, localhost, root,,);
|
|
SET SESSION lock_wait_timeout= 1;
|
|
|
|
--echo #
|
|
--echo # Test 1: acquire exclusive lock
|
|
--echo #
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
START TRANSACTION;
|
|
INSERT INTO t1 VALUES (1);
|
|
|
|
--echo # Connection 2
|
|
connection con2;
|
|
--error ER_LOCK_WAIT_TIMEOUT
|
|
DROP TABLE t1;
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
COMMIT;
|
|
|
|
--echo #
|
|
--echo # Test 2: upgrade shared lock
|
|
--echo #
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
START TRANSACTION;
|
|
SELECT * FROM t1;
|
|
|
|
--echo # Connection 2
|
|
connection con2;
|
|
--error ER_LOCK_WAIT_TIMEOUT
|
|
ALTER TABLE t1 RENAME TO t2;
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
COMMIT;
|
|
|
|
--echo #
|
|
--echo # Test 3: acquire shared lock
|
|
--echo #
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
LOCK TABLE t1 WRITE;
|
|
|
|
--echo # Connection 2
|
|
connection con2;
|
|
--error ER_LOCK_WAIT_TIMEOUT
|
|
INSERT INTO t1(id) VALUES (2);
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
UNLOCK TABLES;
|
|
|
|
--echo #
|
|
--echo # Test 4: table level locks
|
|
--echo #
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
LOCK TABLE t1 READ;
|
|
|
|
--echo # Connection 2
|
|
connection con2;
|
|
--error ER_LOCK_WAIT_TIMEOUT
|
|
INSERT INTO t1(id) VALUES(4);
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
UNLOCK TABLES;
|
|
|
|
--echo #
|
|
--echo # Test 5: Waiting on Table Definition Cache (TDC)
|
|
--echo #
|
|
|
|
connect(con3, localhost, root);
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
LOCK TABLE t1 READ;
|
|
|
|
--echo # Connection con3
|
|
connection con3;
|
|
--echo # Sending:
|
|
--send FLUSH TABLES
|
|
|
|
--echo # Connection con2
|
|
connection con2;
|
|
let $wait_condition=
|
|
SELECT COUNT(*) = 1 FROM information_schema.processlist
|
|
WHERE state = "Waiting for table flush" AND info = "FLUSH TABLES";
|
|
--source include/wait_condition.inc
|
|
--error ER_LOCK_WAIT_TIMEOUT
|
|
SELECT * FROM t1;
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
UNLOCK TABLES;
|
|
|
|
--echo # Connection con3
|
|
connection con3;
|
|
--echo # Reaping: FLUSH TABLES
|
|
--reap
|
|
|
|
--echo #
|
|
--echo # Test 6: Timeouts in I_S queries
|
|
--echo #
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
CREATE TABLE t2 (id INT);
|
|
LOCK TABLE t2 WRITE;
|
|
|
|
--echo # Connection con3
|
|
connection con3;
|
|
--echo # Sending:
|
|
--send DROP TABLE t1, t2
|
|
|
|
--echo # Connection con2
|
|
connection con2;
|
|
let $wait_condition=
|
|
SELECT COUNT(*) = 1 FROM information_schema.processlist
|
|
WHERE state = "Waiting for table metadata lock" AND
|
|
info = "DROP TABLE t1, t2";
|
|
--source include/wait_condition.inc
|
|
# Note: This query causes two timeouts.
|
|
# 1: try_acquire_high_prio_shared_mdl_lock on t1
|
|
# 2: recover_from_failed_open on t1
|
|
SELECT table_name, table_comment FROM information_schema.tables
|
|
WHERE table_schema= 'test' AND table_name= 't1';
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
UNLOCK TABLES;
|
|
|
|
--echo # Connection con3
|
|
connection con3;
|
|
--echo # Reaping: DROP TABLE t1, t2
|
|
--reap
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
--echo # Cleanup
|
|
disconnect con2;
|
|
disconnect con3;
|
|
|
|
|
|
--echo #
|
|
--echo # Test for bug #51134 "Crash in MDL_lock::destroy on a concurrent
|
|
--echo # DDL workload".
|
|
--echo #
|
|
--disable_warnings
|
|
drop tables if exists t1, t2, t3;
|
|
--enable_warnings
|
|
connect (con1, localhost, root, , );
|
|
connect (con2, localhost, root, , );
|
|
connection default;
|
|
create table t3 (i int);
|
|
|
|
--echo # Switching to connection 'con1'
|
|
connection con1;
|
|
--echo # Lock 't3' so upcoming RENAME is blocked.
|
|
lock table t3 read;
|
|
|
|
--echo # Switching to connection 'con2'
|
|
connection con2;
|
|
--echo # Remember ID for this connection.
|
|
let $ID= `select connection_id()`;
|
|
--echo # Start statement which will try to acquire two instances
|
|
--echo # of X metadata lock on the same object.
|
|
--echo # Sending:
|
|
--send rename tables t1 to t2, t2 to t3;
|
|
|
|
--echo # Switching to connection 'default'
|
|
connection default;
|
|
--echo # Wait until RENAME TABLE is blocked on table 't3'.
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table metadata lock" and
|
|
info = "rename tables t1 to t2, t2 to t3";
|
|
--source include/wait_condition.inc
|
|
--echo # Kill RENAME TABLE.
|
|
--replace_result $ID ID
|
|
eval kill query $ID;
|
|
|
|
--echo # Switching to connection 'con2'
|
|
connection con2;
|
|
--echo # RENAME TABLE should be aborted but should not crash.
|
|
--error ER_QUERY_INTERRUPTED
|
|
--reap
|
|
|
|
--echo # Switching to connection 'con1'
|
|
connection con1;
|
|
unlock tables;
|
|
|
|
--echo # Switching to connection 'default'
|
|
connection default;
|
|
disconnect con1;
|
|
disconnect con2;
|
|
drop table t3;
|
|
|
|
|
|
--echo #
|
|
--echo # Test for the bug where upgradable metadata locks was acquired
|
|
--echo # even if the table to altered was temporary.
|
|
--echo # Bug found while working on the related bug #51240.
|
|
--echo #
|
|
|
|
--disable_warnings
|
|
DROP TABLE IF EXISTS t1;
|
|
--enable_warnings
|
|
|
|
CREATE TABLE t1 (id INT);
|
|
LOCK TABLE t1 WRITE;
|
|
|
|
--echo # Connection con1
|
|
connect (con1, localhost, root);
|
|
CREATE TEMPORARY TABLE t1 (id INT);
|
|
# This alter should not block and timeout.
|
|
ALTER TABLE t1 ADD COLUMN j INT;
|
|
|
|
--echo # Connection default
|
|
connection default;
|
|
disconnect con1;
|
|
UNLOCK TABLES;
|
|
DROP TABLE t1;
|
|
|
|
|
|
# Wait till all disconnects are completed
|
|
--source include/wait_until_count_sessions.inc
|