Postgresql Transaction isolation
Transaction isolation:
The SQL standard defines four levels of
transaction isolation. The most strict is Serializable, which is defined by the
standard in a paragraph which says that any concurrent execution of a set of
Serializable transactions is guaranteed to produce the same effect as running
them one at a time in some order. The other three levels are defined in terms
of phenomena, resulting from interaction between concurrent transactions, which
must not occur at each level. The standard notes that due to the definition of
Serializable, none of these phenomena are possible at that level. (This is hardly
surprising -- if the effect of the transactions must be consistent with having
been run one at a time, how could you see any phenomena caused by
interactions?)
The phenomena which are prohibited at various
levels are:
dirty read
A transaction reads data
written by a concurrent uncommitted transaction.
nonrepeatable read
A transaction re-reads data it has previously read and finds that
data has been modified by another transaction (that committed since the initial
read).
phantom read
A transaction re-executes a query returning a set of rows that
satisfy a search condition and finds that the set of rows satisfying the
condition has changed due to another recently-committed transaction.
The four transaction isolation levels and the corresponding behaviors
are described in below table
Standard SQL Transaction Isolation Levels:
Isolation
Level
|
Dirty
Read
|
Nonrepeatable
Read
|
Phantom
Read
|
Read uncommitted
|
Possible
|
Possible
|
Possible
|
Read committed
|
Not possible
|
Possible
|
Possible
|
Repeatable read
|
Not possible
|
Not possible
|
Possible
|
Serializable
|
Not possible
|
Not possible
|
Not possible
|
In PostgreSQL, you can
request any of the four standard transaction isolation levels. But internally,
there are only three distinct isolation levels, which correspond to the levels
Read Committed, Repeatable Read, and Serializable. When you select the level
Read Uncommitted you really get Read Committed, and phantom reads are not
possible in the PostgreSQL implementation
of Repeatable Read, so the actual isolation level might be stricter than what
you select. This is permitted by the SQL standard: the four isolation levels
only define which phenomena must not happen, they do not define which phenomena
must happen. The reason that PostgreSQL only
provides three isolation levels is that this is the only sensible way to map
the standard isolation levels to the multiversion concurrency control
architecture. The behavior of the available isolation levels is detailed in the
following subsections.
To
set the transaction isolation level of a transaction, use the command SET TRANSACTION.
SET
TRANSACTION:
Name
SET TRANSACTION -- set the characteristics of the current transaction
Synopsis
SET TRANSACTION transaction_mode [, ...]
SET TRANSACTION SNAPSHOT snapshot_id
SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode
[, ...]
where transaction_mode is one of:
ISOLATION LEVEL {
SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
READ WRITE | READ ONLY
[ NOT ] DEFERRABLE
Description
The SET TRANSACTION command sets the
characteristics of the current transaction. It has no effect on any subsequent
transactions. SET SESSION CHARACTERISTICS sets the default
transaction characteristics for subsequent transactions of a session. These
defaults can be overridden by SET TRANSACTION for an individual
transaction.The available transaction characteristics are the transaction
isolation level, the transaction access mode (read/write or read-only), and the
deferrable mode. In addition, a snapshot can be selected, though only for the
current transaction, not as a session default.
The isolation level of a transaction determines
what data the transaction can see when other transactions are running
concurrently:
READ COMMITTED
A statement can only see
rows committed before it began. This is the default.
REPEATABLE READ
All statements of the current transaction can only see rows
committed before the first query or data-modification statement was executed in
this transaction.
SERIALIZABLE
All statements of the current transaction can only see rows
committed before the first query or data-modification statement was executed in
this transaction. If a pattern of reads and writes among concurrent
serializable transactions would create a situation which could not have
occurred for any serial (one-at-a-time) execution of those transactions, one of
them will be rolled back with a serialization_failure error.
The SQL
standard defines one additional level, READ
UNCOMMITTED. In PostgreSQL READ UNCOMMITTED is
treated as READ
COMMITTED.
The
transaction isolation level cannot be changed after the first query or
data-modification statement (SELECT, INSERT, DELETE, UPDATE, FETCH, or COPY) of a transaction has been
executed
The
transaction access mode determines whether the transaction is read/write or
read-only. Read/write is the default.
When a transaction is read-only, the following
SQL commands are disallowed: INSERT, UPDATE, DELETE, and COPY FROM if the table
they would write to is not a temporary table; all CREATE, ALTER, and DROP commands; COMMENT, GRANT, REVOKE, TRUNCATE;and EXPLAINANALYZE and EXECUTE if the command
they would execute is among those listed. This is a high-level notion of
read-only that does not prevent all writes to disk.
The SET TRANSACTION SNAPSHOT command
allows a new transaction to run with the same snapshot as an
existing transaction. The pre-existing transaction must have exported its
snapshot with the pg_export_snapshot function
(see Section 9.26.5). That
function returns a snapshot identifier, which must be given to SET TRANSACTION SNAPSHOT to
specify which snapshot is to be imported. The identifier must be written as a
string literal in this command, for example '000003A1-1'. SET
TRANSACTION SNAPSHOT can only be executed at the start of a
transaction, before the first query or data-modification statement (SELECT, INSERT, DELETE, UPDATE, FETCH, or COPY) of the transaction.
Furthermore, the transaction must already be set to SERIALIZABLE or REPEATABLE READ isolation
level (otherwise, the snapshot would be discarded immediately, since READ COMMITTED mode takes
a new snapshot for each command). If the importing transaction uses SERIALIZABLE isolation
level, then the transaction that exported the snapshot must also use that
isolation level. Also, a non-read-only serializable transaction cannot import a
snapshot from a read-only transaction.
Notes:
If SET TRANSACTION is executed
without a prior START
TRANSACTION or BEGIN,
it will appear to have no effect, since the transaction will immediately end.It
is possible to dispense with SET
TRANSACTION by instead specifying the desired transaction_modes in BEGIN or START TRANSACTION. But that
option is not available for SET
TRANSACTION SNAPSHOT.
The session default
transaction modes can also be set by setting the configuration parameters default_transaction_isolation, default_transaction_read_only,
and default_transaction_deferrable. (In fact SET SESSION CHARACTERISTICS is
just a verbose equivalent for setting these variables with SET.) This means the defaults
can be set in the configuration file, via ALTER DATABASE, etc. Consult Chapter
18 for more information.
Examples
To begin a new transaction with the same snapshot as an already existing transaction, first export the snapshot from the existing transaction. That will return the snapshot identifier, for example:
BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
SELECT pg_export_snapshot();
pg_export_snapshot
000003A1-1
(1 row)
Then give the snapshot
identifier in a SET
TRANSACTION SNAPSHOT command at the beginning of the newly
opened transaction:
BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;
SET TRANSACTION SNAPSHOT '000003A1-1';
References:
Written BY :- Raghavan Rao
Comments
Post a Comment