Multi-Version Concurrency Control (MVCC) is a complex technique for enhancing database performance in a multi-user environment. In contrast to most other database systems which use locks for concurrency control, Daffodil DB preserves uniformity of data by using a Multi-Version model.

MVCC ensures that each transaction obtains a snapshot of data as per the last consistent state of the database. This shields transactions from viewing inconsistent data caused by concurrent updates on the same data by other transactions.

The main difference between Multi-Version and lock models is that in MVCC locks attained for reading data do not conflict with locks acquired for writing data. This ensures that reading never blocks writing and vice versa, thereby providing transaction isolation for each database session.

Transaction Isolation Levels

The ANSI/ISO SQL standard characterizes four level of transaction isolation based upon three incidences that must be prevented between concurrent transactions. These undesirable incidences are:

1. Dirty / Inconsistent reads
In this, the result of a query includes data written by a concurrent uncommitted transaction.

2. Non-repeatable reads

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).

3. 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 transaction isolation levels have been categorized in following four forms,

1. Read uncommitted
2. Read committed
3. Repeatable read
4. Serializable

Daffodil DB supports all isolation levels. Let us have a detailed look at all of them.

1. Read Uncommitted Isolation Level

The Read Uncommitted Isolation Level allows a transaction to access uncommitted changes that have been made by other transactions. A transaction using the Read Uncommitted Isolation Level cannot prevent other transactions from modifying the row of data being read. Therefore, transactions are not isolated from each other. If the Read Uncommitted Isolation Level is being used by a transaction that is working with a data source (which supports other transaction isolation levels), the data source ignores the mechanism used to implement those levels.

(Note: Read Uncommitted Isolation Level is typically used by read-only transactions.)

2. Read Committed Isolation Level

Read Committed is the default isolation level in Daffodil DB. When a transaction runs on this isolation level, a SELECT query is able to extract the data committed before the query began and does not get a view of changes (uncommitted or committed) during query execution by concurrent transactions.)

(Note: Two successive SELECT can see different data, even though they are within a single transaction, when other transactions commit changes during execution of the first SELECT.)

The partial transaction isolation provided by Read Committed Level is adequate for many applications, and this level is fast and simple to use. However, for applications that do complex queries and updates, it may be necessary to guarantee a more rigorous and consistent view of the database.

3. Repeatable Read Isolation Level

The Repeatable Read Isolation Level permits a transaction to obtain read locks on all rows of data it returns to an application, and write locks on all rows of data it inserts, updates, or deletes.

By using the Repeatable Read isolation level, SELECT statements issued multiple times within the same transaction will always yield the same result. A transaction using the Repeatable Read isolation level can retrieve and manipulate the same rows of data as many times as needed until it completes its task.

However, other transactions can insert, update, or delete a row of data that would affect the result table being accessed until the isolating transaction releases its locks.

4. Serializable Isolation Level

Serializable provides the highest transaction isolation. This level follows serial transaction execution, as if transactions had been executed one after another, serially, rather than concurrently. However, applications using this level must be prepared to retry transactions due to serialization failures.
When a transaction is on the serializable level, a SELECT query sees the data committed before the transaction began and does not get a view of either uncommitted data or changes committed during transaction execution by concurrent transactions. (Note: This is different from Read Committed in the sense that SELECT sees a snapshot as of the start of the transaction, not as of the start of the current query within the transaction.)

Users should keep in view that serializable transactions cannot modify rows changed by other transactions after the serializable transaction began.
Transaction isolation levels do not affect a transaction's ability to see its own changes; transactions can always see any changes they make. For example, a transaction might consist of two UPDATE statements, but this succeeds as a single transaction only because the second UPDATE statement can see the results of the first.

In case you need to know more about Transaction Isolation levels, please feel free to contact us at

Join other professional developers at Daffodil DB Online Community.

Visit us at .