Try a preview of AI-powered search below!

• YSQL

YugabyteDB supports three isolation levels in the transactional layer:

• Serializable
• Snapshot
• Read committed TP

The default isolation level for the YSQL API is effectively Snapshot (that is, the same as PostgreSQL's REPEATABLE READ) because, by default, Read committed, which is the YSQL API and PostgreSQL syntactic default, maps to Snapshot isolation.

To enable Read committed (currently in Tech Preview), you must set the YB-TServer flag yb_enable_read_committed_isolation to true. By default this flag is false and the Read committed isolation level of the YugabyteDB transactional layer falls back to the stricter Snapshot isolation (in which case READ COMMITTED and READ UNCOMMITTED of YSQL also in turn use Snapshot isolation).

To set the transaction isolation level of a transaction, use the command SET TRANSACTION.

Isolation levels in PostgreSQL and YSQL

PostgreSQL (and the SQL standard) has four isolation levels: Serializable, Repeatable read, Read committed, and Read uncommitted.

The following table shows the mapping between the PostgreSQL isolation levels in YSQL, along with transaction anomalies that can occur at each isolation level:

The strictest isolation level is Serializable, which requires that any concurrent execution of a set of Serializable transactions is guaranteed to produce the same effect as running them in some serial order (one transaction at a time).

The other levels are defined by which anomalies (none of which are possible with serializable) must not occur as a result of interactions between concurrent transactions.

Serializable isolation

The Serializable isolation level provides the strictest transaction isolation. This level emulates serial transaction execution for all committed transactions, as if transactions had been executed one after another, serially rather than concurrently. Serializable isolation can detect read-write conflicts in addition to write-write conflicts. This is accomplished by writing provisional records for read operations as well.

The Serializable isolation can be demonstrated by a bank overdraft protection example.

The hypothetical case is that there is a bank which allows depositors to withdraw money up to the total of what they have in all accounts. The bank later automatically transfers funds as needed to close the day with a positive balance in each account. In a single transaction, they check that the total of all accounts exceeds the amount requested.

Suppose someone tries to withdraw $900 from two of their accounts simultaneously, each with $500 balances. At the REPEATABLE READ transaction isolation level, that could work, but if the SERIALIZABLE transaction isolation level is used, a read-write conflict is detected and one of the transactions is rejected.

Set up the example with the following statements:

create table account
  (
    name text not null,
    type text not null,
    balance money not null default '0.00'::money,
    primary key (name, type)
  );
insert into account values
  ('kevin','saving', 500),
  ('kevin','checking', 500);

Next, connect to the universe using two independent ysqlsh instances, referred to as session #1 and session #2.

begin isolation level serializable;
select type, balance from account
  where name = 'kevin';

   type   | balance
----------+---------
 saving   | $500.00
 checking | $500.00
(2 rows)

begin isolation level serializable;
select type, balance from account
  where name = 'kevin';

   type   | balance
----------+---------
 saving   | $500.00
 checking | $500.00
(2 rows)

update account
  set balance = balance - 900::money
  where name = 'kevin' and type = 'saving';

update account
  set balance = balance - 900::money
  where name = 'kevin' and type = 'checking';

ERROR:  40001: Operation failed.
  Try again.: Transaction aborted: XXXX

commit;
select type, balance from account
  where name = 'kevin';

   type   | balance
----------+----------
 checking |  $500.00
 saving   | -$400.00
(2 rows)

Snapshot isolation

The Snapshot isolation level is only aware of data committed before the transaction began (in other words, it works on a snapshot of the table). Transactions running under Snapshot isolation are not aware of either uncommitted data or changes committed during transaction execution by other concurrently running transactions. Note that the query is aware of the effects of previous updates executed in its own transaction, even though they are not yet committed. This is a stronger guarantee than is required by the SQL standard for the REPEATABLE READ isolation level.

Snapshot isolation detects only write-write conflicts; it does not detect read-write conflicts. That is:

• INSERT, UPDATE, and DELETE commands behave in the same way as SELECT in terms of searching for target rows. They can only find target rows that were committed as of the transaction start time.
• If such a target row might have already been updated, deleted, or locked by another concurrent transaction by the time it is found. This is called a transaction conflict, where the current transaction conflicts with the transaction that made or is attempting to make an update. In such cases, one of the two transactions is aborted, depending on priority.

Applications using this level must be prepared to retry transactions due to serialization failures.

Consider an example of transactions' behavior under the Snapshot isolation level (mapped to PostgreSQL's Repeatable Read level).

Create a table with sample data, as follows:

CREATE TABLE IF NOT EXISTS example (k INT PRIMARY KEY);
TRUNCATE TABLE example;

Next, connect to the universe using two independent ysqlsh instances, referred to as session #1 and session #2:

BEGIN TRANSACTION;

INSERT INTO example VALUES (1);
SELECT * FROM example;

 k
---
 1
(1 row)

INSERT INTO example VALUES (2);
SELECT * FROM example;

 k
---
 2
(1 row)

SELECT * FROM example;

 k
---
 1
(1 row)

COMMIT;
SELECT * FROM example;

 k
---
 1
 2
(2 rows)

Read committed isolation

Read committed isolation is the same as Snapshot isolation, except that every statement in the transaction is aware of all data that has been committed before it has been issued (this implicitly means that the statement will see a consistent snapshot). In other words, each statement works on a new snapshot of the database that includes everything that has been committed before the statement is issued. Conflict detection is the same as in Snapshot isolation.

Consider an example of transactions' behavior under the Read committed isolation level.

Create a table, as follows:

CREATE TABLE test (k int PRIMARY KEY, v int);
INSERT INTO test VALUES (1, 2);

Connect to the universe using two independent ysqlsh instances, referred to as session #1 and session #2:

BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED;
SELECT * FROM test;

 k | v
---+---
 1 | 2
(1 row)

INSERT INTO test VALUES (2, 3);

SELECT * FROM test;
COMMIT;

 k | v
---+---
 1 | 2
(1 row)

BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED;
SELECT * FROM test;

 k | v
---+---
 1 | 2
 2 | 3
(2 rows)

INSERT INTO test VALUES (3, 4);

SELECT * FROM test;

 k | v
---+---
 1 | 2
 2 | 3
 3 | 4
(3 rows)