2008-12-16 12:44:18 +01:00
|
|
|
drop table if exists t1;
|
2016-03-25 17:51:22 +01:00
|
|
|
connect a,localhost,root,,;
|
|
|
|
connect b,localhost,root,,;
|
|
|
|
connection a;
|
2008-12-16 12:44:18 +01:00
|
|
|
set binlog_format=mixed;
|
2009-01-13 23:12:16 +01:00
|
|
|
set session transaction isolation level repeatable read;
|
2008-12-16 12:44:18 +01:00
|
|
|
create table t1(a int not null)
|
|
|
|
engine=innodb
|
|
|
|
DEFAULT CHARSET=latin1
|
|
|
|
PARTITION BY RANGE(a)
|
|
|
|
(PARTITION p0 VALUES LESS THAN (20),
|
|
|
|
PARTITION p1 VALUES LESS THAN MAXVALUE);
|
|
|
|
insert into t1 values (1),(2),(3),(4),(5),(6),(7);
|
|
|
|
set autocommit=0;
|
|
|
|
select * from t1 where a=3 lock in share mode;
|
|
|
|
a
|
|
|
|
3
|
2016-03-25 17:51:22 +01:00
|
|
|
connection b;
|
2008-12-16 12:44:18 +01:00
|
|
|
set binlog_format=mixed;
|
2009-01-13 23:12:16 +01:00
|
|
|
set session transaction isolation level repeatable read;
|
2008-12-16 12:44:18 +01:00
|
|
|
set autocommit=0;
|
|
|
|
update t1 set a=10 where a=5;
|
|
|
|
ERROR HY000: Lock wait timeout exceeded; try restarting transaction
|
|
|
|
commit;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection a;
|
Draft patch that fixes and a sketches test cases for:
Bug#20837 Apparent change of isolation level during transaction,
Bug#46527 COMMIT AND CHAIN RELEASE does not make sense,
Bug#53343 completion_type=1, COMMIT/ROLLBACK AND CHAIN don't
preserve the isolation level
Bug#53346 completion_type has strange effect in a stored
procedure/prepared statement
Make thd->tx_isolation mean strictly "current transaction
isolation level"
Make thd->variables.tx_isolation mean "current session isolation
level".
The current transaction isolation level is now established
at transaction start. If there was a SET TRANSACTION
ISOLATION LEVEL statement, the value is taken from it.
Otherwise, the session value is used.
A change in a session value, made while a transaction is active,
whereas still allowed, no longer has any effect on the
current transaction isolation level. This is an incompatible
change.
A change in a session isolation level, made while there is
no active transaction, overrides SET TRANSACTION statement,
if there was any.
Changed the impelmentation to not look at @@session.completion_type
in the parser, and thus fixed Bug#53346.
Changed the parser to not allow AND NO CHAIN RELEASE,
and thus fixed Bug#46527.
Changed the transaction API to take the current transaction
isolation level into account:
- BEGIN/COMMIT now do preserve the current transaction
isolation level if chaining is on.
- implicit commit, XA COMMIT or XA ROLLBACK or autocommit don't.
2010-05-07 18:28:59 +02:00
|
|
|
commit;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection b;
|
2009-01-13 23:12:16 +01:00
|
|
|
set session transaction isolation level read committed;
|
2008-12-16 12:44:18 +01:00
|
|
|
update t1 set a=10 where a=5;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection a;
|
2008-12-16 12:44:18 +01:00
|
|
|
select * from t1 where a=2 for update;
|
|
|
|
ERROR HY000: Lock wait timeout exceeded; try restarting transaction
|
|
|
|
select * from t1 where a=2 limit 1 for update;
|
|
|
|
a
|
|
|
|
2
|
2016-03-25 17:51:22 +01:00
|
|
|
connection b;
|
2008-12-16 12:44:18 +01:00
|
|
|
update t1 set a=11 where a=6;
|
|
|
|
update t1 set a=12 where a=2;
|
|
|
|
ERROR HY000: Lock wait timeout exceeded; try restarting transaction
|
|
|
|
update t1 set a=13 where a=1;
|
|
|
|
ERROR HY000: Lock wait timeout exceeded; try restarting transaction
|
2016-03-25 17:51:22 +01:00
|
|
|
connection a;
|
2008-12-16 12:44:18 +01:00
|
|
|
commit;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection b;
|
2008-12-16 12:44:18 +01:00
|
|
|
update t1 set a=14 where a=1;
|
|
|
|
commit;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection a;
|
2008-12-16 12:44:18 +01:00
|
|
|
select * from t1;
|
|
|
|
a
|
|
|
|
10
|
|
|
|
11
|
|
|
|
14
|
|
|
|
2
|
|
|
|
3
|
|
|
|
4
|
|
|
|
7
|
|
|
|
drop table t1;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection default;
|
|
|
|
disconnect a;
|
|
|
|
disconnect b;
|
|
|
|
connect con1,localhost,root,,;
|
|
|
|
connect con2,localhost,root,,;
|
2008-12-16 12:44:18 +01:00
|
|
|
SET SESSION AUTOCOMMIT = 0;
|
|
|
|
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
|
|
|
|
set binlog_format=mixed;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con1;
|
2008-12-16 12:44:18 +01:00
|
|
|
CREATE TABLE t1 (a INT PRIMARY KEY, b VARCHAR(256))
|
|
|
|
ENGINE = InnoDB
|
|
|
|
PARTITION BY RANGE (a)
|
|
|
|
(PARTITION p0 VALUES LESS THAN (300),
|
|
|
|
PARTITION p1 VALUES LESS THAN MAXVALUE);
|
|
|
|
INSERT INTO t1 VALUES (1,2);
|
|
|
|
# 1. test for locking:
|
|
|
|
BEGIN;
|
|
|
|
UPDATE t1 SET b = 12 WHERE a = 1;
|
|
|
|
affected rows: 1
|
|
|
|
info: Rows matched: 1 Changed: 1 Warnings: 0
|
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
1 12
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con2;
|
2008-12-16 12:44:18 +01:00
|
|
|
UPDATE t1 SET b = 21 WHERE a = 1;
|
|
|
|
ERROR HY000: Lock wait timeout exceeded; try restarting transaction
|
2010-05-25 22:01:38 +02:00
|
|
|
ROLLBACK;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con1;
|
2008-12-16 12:44:18 +01:00
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
1 12
|
|
|
|
ROLLBACK;
|
|
|
|
# 2. test for serialized update:
|
|
|
|
CREATE TABLE t2 (a INT);
|
|
|
|
TRUNCATE t1;
|
|
|
|
INSERT INTO t1 VALUES (1,'init');
|
|
|
|
CREATE PROCEDURE p1()
|
|
|
|
BEGIN
|
2010-12-08 14:34:08 +01:00
|
|
|
# retry the UPDATE in case it times out the lock before con1 has time
|
|
|
|
# to COMMIT.
|
|
|
|
DECLARE do_retry INT DEFAULT 0;
|
|
|
|
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION SET do_retry = 1;
|
|
|
|
retry_loop:LOOP
|
2008-12-16 12:44:18 +01:00
|
|
|
UPDATE t1 SET b = CONCAT(b, '+con2') WHERE a = 1;
|
2010-12-08 14:34:08 +01:00
|
|
|
IF do_retry = 0 THEN
|
|
|
|
LEAVE retry_loop;
|
|
|
|
END IF;
|
|
|
|
SET do_retry = 0;
|
|
|
|
END LOOP;
|
2008-12-16 12:44:18 +01:00
|
|
|
INSERT INTO t2 VALUES ();
|
|
|
|
END|
|
|
|
|
BEGIN;
|
|
|
|
UPDATE t1 SET b = CONCAT(b, '+con1') WHERE a = 1;
|
|
|
|
affected rows: 1
|
|
|
|
info: Rows matched: 1 Changed: 1 Warnings: 0
|
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
1 init+con1
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con2;
|
2008-12-16 12:44:18 +01:00
|
|
|
CALL p1;;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con1;
|
2008-12-16 12:44:18 +01:00
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
1 init+con1
|
|
|
|
COMMIT;
|
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
1 init+con1
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con2;
|
2008-12-16 12:44:18 +01:00
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
1 init+con1+con2
|
2010-05-25 22:01:38 +02:00
|
|
|
COMMIT;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con1;
|
2008-12-16 12:44:18 +01:00
|
|
|
# 3. test for updated key column:
|
|
|
|
TRUNCATE t1;
|
Backport of revno ## 2617.31.1, 2617.31.3, 2617.31.4, 2617.31.5,
2617.31.12, 2617.31.15, 2617.31.15, 2617.31.16, 2617.43.1
- initial changeset that introduced the fix for
Bug#989 and follow up fixes for all test suite failures
introduced in the initial changeset.
------------------------------------------------------------
revno: 2617.31.1
committer: Davi Arnaut <Davi.Arnaut@Sun.COM>
branch nick: 4284-6.0
timestamp: Fri 2009-03-06 19:17:00 -0300
message:
Bug#989: If DROP TABLE while there's an active transaction, wrong binlog order
WL#4284: Transactional DDL locking
Currently the MySQL server does not keep metadata locks on
schema objects for the duration of a transaction, thus failing
to guarantee the integrity of the schema objects being used
during the transaction and to protect then from concurrent
DDL operations. This also poses a problem for replication as
a DDL operation might be replicated even thought there are
active transactions using the object being modified.
The solution is to defer the release of metadata locks until
a active transaction is either committed or rolled back. This
prevents other statements from modifying the table for the
entire duration of the transaction. This provides commitment
ordering for guaranteeing serializability across multiple
transactions.
- Incompatible change:
If MySQL's metadata locking system encounters a lock conflict,
the usual schema is to use the try and back-off technique to
avoid deadlocks -- this schema consists in releasing all locks
and trying to acquire them all in one go.
But in a transactional context this algorithm can't be utilized
as its not possible to release locks acquired during the course
of the transaction without breaking the transaction commitments.
To avoid deadlocks in this case, the ER_LOCK_DEADLOCK will be
returned if a lock conflict is encountered during a transaction.
Let's consider an example:
A transaction has two statements that modify table t1, then table
t2, and then commits. The first statement of the transaction will
acquire a shared metadata lock on table t1, and it will be kept
utill COMMIT to ensure serializability.
At the moment when the second statement attempts to acquire a
shared metadata lock on t2, a concurrent ALTER or DROP statement
might have locked t2 exclusively. The prescription of the current
locking protocol is that the acquirer of the shared lock backs off
-- gives up all his current locks and retries. This implies that
the entire multi-statement transaction has to be rolled back.
- Incompatible change:
FLUSH commands such as FLUSH PRIVILEGES and FLUSH TABLES WITH READ
LOCK won't cause locked tables to be implicitly unlocked anymore.
mysql-test/extra/binlog_tests/drop_table.test:
Add test case for Bug#989.
mysql-test/extra/binlog_tests/mix_innodb_myisam_binlog.test:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction.
mysql-test/include/mix1.inc:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction.
mysql-test/include/mix2.inc:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction.
mysql-test/r/flush_block_commit.result:
Update test case result (WL#4284).
mysql-test/r/flush_block_commit_notembedded.result:
Update test case result (WL#4284).
mysql-test/r/innodb.result:
Update test case result (WL#4284).
mysql-test/r/innodb_mysql.result:
Update test case result (WL#4284).
mysql-test/r/lock.result:
Add test case result for an effect of WL#4284/Bug#989
(all locks should be released when a connection terminates).
mysql-test/r/mix2_myisam.result:
Update test case result (effects of WL#4284/Bug#989).
mysql-test/r/not_embedded_server.result:
Update test case result (effects of WL#4284/Bug#989).
Add a test case for interaction of WL#4284 and FLUSH PRIVILEGES.
mysql-test/r/partition_innodb_semi_consistent.result:
Update test case result (effects of WL#4284/Bug#989).
mysql-test/r/partition_sync.result:
Temporarily disable the test case for Bug#43867,
which will be fixed by a subsequent backport.
mysql-test/r/ps.result:
Add a test case for effect of PREPARE on transactional
locks: we take a savepoint at beginning of PREAPRE
and release it at the end. Thus PREPARE does not
accumulate metadata locks (Bug#989/WL#4284).
mysql-test/r/read_only_innodb.result:
Update test case result (effects of WL#4284/Bug#989).
mysql-test/suite/binlog/r/binlog_row_drop_tbl.result:
Add a test case result (WL#4284/Bug#989).
mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result:
Update test case result (effects of WL#4284/Bug#989).
mysql-test/suite/binlog/r/binlog_stm_drop_tbl.result:
Add a test case result (WL#4284/Bug#989).
mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result:
Update test case result (effects of WL#4284/Bug#989).
mysql-test/suite/binlog/r/binlog_unsafe.result:
A side effect of Bug#989 -- slightly different table map ids.
mysql-test/suite/binlog/t/binlog_row_drop_tbl.test:
Add a test case for WL#4284/Bug#989.
mysql-test/suite/binlog/t/binlog_stm_drop_tbl.test:
Add a test case for WL#4284/Bug#989.
mysql-test/suite/binlog/t/binlog_stm_row.test:
Update to the new state name. This
is actually a follow up to another patch for WL#4284,
that changes Locked thread state to Table lock.
mysql-test/suite/ndb/r/ndb_index_ordered.result:
Remove result for disabled part of the test case.
mysql-test/suite/ndb/t/disabled.def:
Temporarily disable a test case (Bug#45621).
mysql-test/suite/ndb/t/ndb_index_ordered.test:
Disable a part of a test case (needs update to
reflect semantics of Bug#989).
mysql-test/suite/rpl/t/disabled.def:
Disable tests made meaningless by transactional metadata
locking.
mysql-test/suite/sys_vars/r/autocommit_func.result:
Add a commit (Bug#989).
mysql-test/suite/sys_vars/t/autocommit_func.test:
Add a commit (Bug#989).
mysql-test/t/flush_block_commit.test:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction.
mysql-test/t/flush_block_commit_notembedded.test:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction.
Add a test case for transaction-scope locks and the global
read lock (Bug#989/WL#4284).
mysql-test/t/innodb.test:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction
(effects of Bug#989/WL#4284).
mysql-test/t/lock.test:
Add a test case for Bug#989/WL#4284.
mysql-test/t/not_embedded_server.test:
Add a test case for Bug#989/WL#4284.
mysql-test/t/partition_innodb_semi_consistent.test:
Replace TRUNCATE with DELETE, to not issue
an implicit commit of a transaction, and not depend
on metadata locks.
mysql-test/t/partition_sync.test:
Temporarily disable the test case for Bug#43867,
which needs a fix to be backported from 6.0.
mysql-test/t/ps.test:
Add a test case for semantics of PREPARE and transaction-scope
locks: metadata locks on tables used in PREPARE are enclosed into a
temporary savepoint, taken at the beginning of PREPARE,
and released at the end. Thus PREPARE does not effect
what locks a transaction owns.
mysql-test/t/read_only_innodb.test:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction
(Bug#989/WL#4284).
Wait for the read_only statement to actually flush tables before
sending other concurrent statements that depend on its state.
mysql-test/t/xa.test:
Fix test case to reflect the fact that transactions now hold
metadata locks for the duration of a transaction
(Bug#989/WL#4284).
sql/ha_ndbcluster_binlog.cc:
Backport bits of changes of ha_ndbcluster_binlog.cc
from 6.0, to fix the failing binlog test suite with
WL#4284. WL#4284 implementation does not work
with 5.1 implementation of ndbcluster binlog index.
sql/log_event.cc:
Release metadata locks after issuing a commit.
sql/mdl.cc:
Style changes (WL#4284).
sql/mysql_priv.h:
Rename parameter to match the name used in the definition (WL#4284).
sql/rpl_injector.cc:
Release metadata locks on commit (WL#4284).
sql/rpl_rli.cc:
Remove assert made meaningless, metadata locks are released
at the end of the transaction.
sql/set_var.cc:
Close tables and release locks if autocommit mode is set.
sql/slave.cc:
Release metadata locks after a rollback.
sql/sql_acl.cc:
Don't implicitly unlock locked tables. Issue a implicit commit
at the end and unlock tables.
sql/sql_base.cc:
Defer the release of metadata locks when closing tables
if not required to.
Issue a deadlock error if the locking protocol requires
that a transaction re-acquire its locks.
Release metadata locks when closing tables for reopen.
sql/sql_class.cc:
Release metadata locks if the thread is killed.
sql/sql_parse.cc:
Release metadata locks after implicitly committing a active
transaction, or after explicit commits or rollbacks.
sql/sql_plugin.cc:
Allocate MDL request on the stack as the use of the table
is contained within the function. It will be removed from
the context once close_thread_tables is called at the end
of the function.
sql/sql_prepare.cc:
The problem is that the prepare phase of the CREATE TABLE
statement takes a exclusive metadata lock lock and this can
cause a self-deadlock the thread already holds a shared lock
on the table being that should be created.
The solution is to make the prepare phase take a shared
metadata lock when preparing a CREATE TABLE statement. The
execution of the statement will still acquire a exclusive
lock, but won't cause any problem as it issues a implicit
commit.
After some discussions with stakeholders it has been decided that
metadata locks acquired during a PREPARE statement must be released
once the statement is prepared even if it is prepared within a multi
statement transaction.
sql/sql_servers.cc:
Don't implicitly unlock locked tables. Issue a implicit commit
at the end and unlock tables.
sql/sql_table.cc:
Close table and release metadata locks after a admin operation.
sql/table.h:
The problem is that the prepare phase of the CREATE TABLE
statement takes a exclusive metadata lock lock and this can
cause a self-deadlock the thread already holds a shared lock
on the table being that should be created.
The solution is to make the prepare phase take a shared
metadata lock when preparing a CREATE TABLE statement. The
execution of the statement will still acquire a exclusive
lock, but won't cause any problem as it issues a implicit
commit.
sql/transaction.cc:
Release metadata locks after the implicitly committed due
to a new transaction being started. Also, release metadata
locks acquired after a savepoint if the transaction is rolled
back to the save point.
The problem is that in some cases transaction-long metadata locks
could be released before the transaction was committed. This could
happen when a active transaction was ended by a "START TRANSACTION"
or "BEGIN" statement, in which case the metadata locks would be
released before the actual commit of the active transaction.
The solution is to defer the release of metadata locks to after the
transaction has been implicitly committed. No test case is provided
as the effort to provide one is too disproportional to the size of
the fix.
2009-12-05 00:02:48 +01:00
|
|
|
DELETE FROM t2;
|
2008-12-16 12:44:18 +01:00
|
|
|
INSERT INTO t1 VALUES (1,'init');
|
|
|
|
BEGIN;
|
|
|
|
UPDATE t1 SET a = 2, b = CONCAT(b, '+con1') WHERE a = 1;
|
|
|
|
affected rows: 1
|
|
|
|
info: Rows matched: 1 Changed: 1 Warnings: 0
|
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
2 init+con1
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con2;
|
2008-12-16 12:44:18 +01:00
|
|
|
CALL p1;;
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con1;
|
2008-12-16 12:44:18 +01:00
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
2 init+con1
|
|
|
|
COMMIT;
|
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
2 init+con1
|
2016-03-25 17:51:22 +01:00
|
|
|
connection con2;
|
2008-12-16 12:44:18 +01:00
|
|
|
SELECT * FROM t1;
|
|
|
|
a b
|
|
|
|
2 init+con1
|
2016-03-25 17:51:22 +01:00
|
|
|
connection default;
|
|
|
|
disconnect con1;
|
|
|
|
disconnect con2;
|
2008-12-16 12:44:18 +01:00
|
|
|
DROP PROCEDURE p1;
|
|
|
|
DROP TABLE t1, t2;
|