mirror of
https://github.com/MariaDB/server.git
synced 2025-02-01 11:31:51 +01:00
5e1dfa4c06
Bug#42546 Backup: RESTORE fails, thinking it finds an existing table The problem occured when a MDL locking conflict happened for a non-existent table between a CREATE and a INSERT statement. The code for CREATE interpreted this lock conflict to mean that the table existed, which meant that the statement failed when it should not have. The problem could occur for CREATE TABLE, CREATE TABLE LIKE and ALTER TABLE RENAME. This patch fixes the problem for CREATE TABLE and CREATE TABLE LIKE. It is based on code backported from the mysql-6.1-fk tree written by Dmitry Lenev. CREATE now uses normal open_and_lock_tables() code to acquire exclusive locks. This means that for the test case in the bug description, CREATE will wait until INSERT completes so that it can get the exclusive lock. This resolves the reported bug. The patch also prohibits CREATE TABLE and CREATE TABLE LIKE under LOCK TABLES. Note that this is an incompatible change and must be reflected in the documentation. Affected test cases have been updated. mdl_sync.test contains tests for CREATE TABLE and CREATE TABLE LIKE. Fixing the issue for ALTER TABLE RENAME is beyond the scope of this patch. ALTER TABLE cannot be prohibited from working under LOCK TABLES as this could seriously impact customers and a proper fix would require a significant rewrite.
727 lines
17 KiB
Text
727 lines
17 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 (reader,localhost,root,,);
|
|
connect (writer,localhost,root,,);
|
|
|
|
connection locker;
|
|
create table t1(n int);
|
|
insert into t1 values (1);
|
|
lock tables t1 write;
|
|
connection writer;
|
|
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 = "Table lock" and info = "update low_priority t1 set n = 4";
|
|
--source include/wait_condition.inc
|
|
send
|
|
select n from t1;
|
|
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 = "Table lock" and info = "select n from t1";
|
|
--source include/wait_condition.inc
|
|
unlock tables;
|
|
connection writer;
|
|
reap;
|
|
connection reader;
|
|
reap;
|
|
drop table t1;
|
|
|
|
connection locker;
|
|
create table t1(n int);
|
|
insert into t1 values (1);
|
|
lock tables t1 read;
|
|
connection writer;
|
|
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 = "Table lock" and info = "update low_priority t1 set n = 4";
|
|
--source include/wait_condition.inc
|
|
select n from t1;
|
|
connection locker;
|
|
unlock tables;
|
|
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 = "Table lock" and info = "insert t1 select * from t2";
|
|
--source include/wait_condition.inc
|
|
drop table t2;
|
|
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 = "Table lock" and info = "insert t1 select * from t2";
|
|
--source include/wait_condition.inc
|
|
drop table t2;
|
|
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 = "Table 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 table" 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 table" 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 release of readlock"
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for release of readlock"
|
|
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 = "Table 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 = "Table 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 table" 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 $show_statement= SHOW PROCESSLIST;
|
|
let $field= State;
|
|
let $condition= = 'Waiting for release of readlock';
|
|
--source include/wait_show_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 $show_statement= SHOW PROCESSLIST;
|
|
let $field= State;
|
|
let $condition= = 'Waiting for release of readlock';
|
|
--source include/wait_show_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 $show_statement= SHOW PROCESSLIST;
|
|
let $field= State;
|
|
let $condition= = 'Waiting for release of readlock';
|
|
--source include/wait_show_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 = "Table 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 = "Table lock" and info = "select * from t1";
|
|
--source include/wait_condition.inc
|
|
let $ID= `select id from information_schema.processlist where state = "Table 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 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 table";
|
|
--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 table";
|
|
--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 release of readlock";
|
|
--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 release of readlock";
|
|
--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 table";
|
|
--source include/wait_condition.inc
|
|
flush tables;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table";
|
|
--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 = "Table lock" and info = "insert into t1 values(1)";
|
|
--source include/wait_condition.inc
|
|
let $tlwb= `show status like 'Table_locks_waited'`;
|
|
unlock tables;
|
|
drop table t1;
|
|
disconnect waiter;
|
|
connection default;
|
|
--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 table";
|
|
--source include/wait_condition.inc
|
|
flush tables;
|
|
let $wait_condition=
|
|
select count(*) = 1 from information_schema.processlist
|
|
where state = "Waiting for table";
|
|
--source include/wait_condition.inc
|
|
drop table t1;
|
|
connection flush;
|
|
--reap
|
|
connection default;
|
|
disconnect flush;
|
|
|
|
|
|
--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 #
|
|
|
|
CREATE TABLE t1 ( f1 integer );
|
|
CREATE VIEW v1 AS SELECT f1 FROM t1 ;
|
|
|
|
--echo # Connection 2
|
|
connect (con2,localhost,root);
|
|
LOCK TABLES v1 WRITE, t1 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 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;
|
|
|
|
|
|
# Wait till all disconnects are completed
|
|
--source include/wait_until_count_sessions.inc
|