Pre-General Availability Draft: 2017-09-22
Transaction isolation is one of the foundations of database processing. Isolation is the I in the acronym ACID; the isolation level is the setting that fine-tunes the balance between performance and reliability, consistency, and reproducibility of results when multiple transactions are making changes and performing queries at the same time.
InnoDB offers all four transaction isolation
levels described by the SQL:1992 standard:
REPEATABLE READ, and
SERIALIZABLE. The default
isolation level for
A user can change the isolation level for a single session or
for all subsequent connections with the
TRANSACTION statement. To set the server's default
isolation level for all connections, use the
--transaction-isolation option on
the command line or in an option file. For detailed information
about isolation levels and level-setting syntax, see
Section 13.3.7, “SET TRANSACTION Syntax”.
InnoDB supports each of the transaction
isolation levels described here using different
locking strategies. You can
enforce a high degree of consistency with the default
REPEATABLE READ level, for
operations on crucial data where
ACID compliance is important.
Or you can relax the consistency rules with
READ COMMITTED or even
READ UNCOMMITTED, in
situations such as bulk reporting where precise consistency and
repeatable results are less important than minimizing the amount
of overhead for locking.
SERIALIZABLE enforces even
stricter rules than
READ, and is used mainly in specialized situations,
such as with XA transactions and
for troubleshooting issues with concurrency and
The following list describes how MySQL supports the different transaction levels. The list goes from the most commonly used level to the least used.
This is the default isolation level for
InnoDB. Consistent reads within the same transaction read the snapshot established by the first read. This means that if you issue several plain (nonlocking)
SELECTstatements within the same transaction, these
SELECTstatements are consistent also with respect to each other. See Section 18.104.22.168, “Consistent Nonlocking Reads”.
For locking reads (
DELETEstatements, locking depends on whether the statement uses a unique index with a unique search condition, or a range-type search condition.
For a unique index with a unique search condition,
InnoDBlocks only the index record found, not the gap before it.
For other search conditions,
InnoDBlocks the index range scanned, using gap locks or next-key locks to block insertions by other sessions into the gaps covered by the range. For information about gap locks and next-key locks, see Section 15.5.1, “InnoDB Locking”.
Each consistent read, even within the same transaction, sets and reads its own fresh snapshot. For information about consistent reads, see Section 22.214.171.124, “Consistent Nonlocking Reads”.
For locking reads (
InnoDBlocks only index records, not the gaps before them, and thus permits the free insertion of new records next to locked records. Gap locking is only used for foreign-key constraint checking and duplicate-key checking.
Because gap locking is disabled, phantom problems may occur, as other sessions can insert new rows into the gaps. For information about phantoms, see Section 15.5.4, “Phantom Rows”.
If you use
READ COMMITTED, you must use row-based binary logging.
READ COMMITTEDhas additional effects:
InnoDBholds locks only for rows that it updates or deletes. Record locks for nonmatching rows are released after MySQL has evaluated the
WHEREcondition. This greatly reduces the probability of deadlocks, but they can still happen.
UPDATEstatements, if a row is already locked,
InnoDBperforms a “semi-consistent” read, returning the latest committed version to MySQL so that MySQL can determine whether the row matches the
WHEREcondition of the
UPDATE. If the row matches (must be updated), MySQL reads the row again and this time
InnoDBeither locks it or waits for a lock on it.
Consider the following example, beginning with this table:
CREATE TABLE t (a INT NOT NULL, b INT) ENGINE = InnoDB; INSERT INTO t VALUES (1,2),(2,3),(3,2),(4,3),(5,2); COMMIT;
In this case, table has no indexes, so searches and index scans use the hidden clustered index for record locking (see Section 126.96.36.199, “Clustered and Secondary Indexes”).
Suppose that one client performs an
UPDATEusing these statements:
SET autocommit = 0; UPDATE t SET b = 5 WHERE b = 3;
Suppose also that a second client performs an
UPDATEby executing these statements following those of the first client:
SET autocommit = 0; UPDATE t SET b = 4 WHERE b = 2;
UPDATE, it first acquires an exclusive lock for each row, and then determines whether to modify it. If
InnoDBdoes not modify the row, it releases the lock. Otherwise,
InnoDBretains the lock until the end of the transaction. This affects transaction processing as follows.
When using the default
REPEATABLE READisolation level, the first
UPDATEacquires x-locks and does not release any of them:
x-lock(1,2); retain x-lock x-lock(2,3); update(2,3) to (2,5); retain x-lock x-lock(3,2); retain x-lock x-lock(4,3); update(4,3) to (4,5); retain x-lock x-lock(5,2); retain x-lock
x-lock(1,2); block and wait for first UPDATE to commit or roll back
READ COMMITTEDis used instead, the first
UPDATEacquires x-locks and releases those for rows that it does not modify:
x-lock(1,2); unlock(1,2) x-lock(2,3); update(2,3) to (2,5); retain x-lock x-lock(3,2); unlock(3,2) x-lock(4,3); update(4,3) to (4,5); retain x-lock x-lock(5,2); unlock(5,2)
For the second
InnoDBdoes a “semi-consistent” read, returning the latest committed version of each row to MySQL so that MySQL can determine whether the row matches the
WHEREcondition of the
x-lock(1,2); update(1,2) to (1,4); retain x-lock x-lock(2,3); unlock(2,3) x-lock(3,2); update(3,2) to (3,4); retain x-lock x-lock(4,3); unlock(4,3) x-lock(5,2); update(5,2) to (5,4); retain x-lock
SELECTstatements are performed in a nonlocking fashion, but a possible earlier version of a row might be used. Thus, using this isolation level, such reads are not consistent. This is also called a dirty read. Otherwise, this isolation level works like
This level is like
REPEATABLE READ, but
InnoDBimplicitly converts all plain
SELECT ... FOR SHAREif
autocommitis disabled. If
autocommitis enabled, the
SELECTis its own transaction. It therefore is known to be read only and can be serialized if performed as a consistent (nonlocking) read and need not block for other transactions. (To force a plain
SELECTto block if other transactions have modified the selected rows, disable