Conflict Serializability in DBMS

A schedule is a sequence in which operations (read, write, commit, abort) from multiple transactions are executed in a database. Serial or one by one execution of schedules has less resource utilization and low throughput. To improve it, two or more transactions are run concurrently.

• Conflict Serializability guarantees that even though transactions run concurrently, their outcome will be identical to the result achieved if the transactions were executed one by one in a specific order.
• It is a concept in concurrency control that determines whether a non-serial schedule can be rearranged to act like a serial schedule without conflicts.
• It ensures data consistency when multiple transactions are executed at the same time.
• There is another type of serializability called view serializability, which is less restrictive than conflict serializability.

Non-conflicting operations: Two operations are considered non-conflicting if they operate on separate data items, or if they involve the same data item but both are read operations.

Conflicting Operations

Two operations are said to be conflicting if all conditions are satisfied: 

• They belong to different transactions
• They operate on the same data item
• Atleast one of them is a write operation

Consider the following schedule: 

S1: R₁(A), W₁(A), R₂(A), W₂(A), R₁(B), W₁(B), R₂(B), W₂(B)

If O_i and O_j are two operations in a transaction and O_i< O_j (O_i is executed before O_j), same order will follow in the schedule as well. Using this property, we can get two transactions of schedule S1: 

T1: R₁(A), W₁(A), R₁(B), W₁(B)
T2: R₂(A), W₂(A), R₂(B), W₂(B)

Possible Serial Schedules are: T1->T2 or T2->T1 

-> Swapping non-conflicting operations R₂(A) and R₁(B) in S1, the schedule becomes, 

S11: R₁(A), W₁(A), R₁(B), W₂(A)_, R₂(A), W₁(B)_, R₂(B), W₂(B)

-> Similarly, swapping non-conflicting operations W₂(A) and W₁(B) in S11, the schedule becomes, 

S12: R₁(A), W₁(A), R₁(B), W₁(B), R₂(A), W₂(A), R₂(B), W₂(B)

S12 is a serial schedule in which all operations of T1 are performed before starting any operation of T2. Since S has been transformed into a serial schedule S12 by swapping non-conflicting operations of S1, S1 is conflict serializable.

Let us take another Schedule: 

S2: R₂(A), W₂(A), R₁(A), W₁(A), R₁(B), W₁(B), R₂(B), W₂(B)

Two transactions will be:  

T1: R₁(A), W₁(A), R₁(B), W₁(B)
T2: R₂(A), W₂(A), R₂(B), W₂(B)

Possible Serial Schedules are: T1->T2 or T2->T1 

Original Schedule is as:  

S2: R₂(A), W₂(A), R₁(A)_, W₁(A), R₁(B), W₁(B), R₂(B)_, W₂(B)

Swapping non-conflicting operations R₁(A) and R₂(B) in S2, the schedule becomes, 

S21: R₂(A), W₂(A), R₂(B), W₁(A)_, R₁(B), W₁(B), R₁(A), W₂(B)

Similarly, swapping non-conflicting operations W₁(A) and W₂(B) in S21, the schedule becomes,  

S22: R₂(A), W₂(A), R₂(B), W₂(B), R₁(B), W₁(B), R₁(A), W₁(A)

In schedule S22, all operations of T2 are performed first, but operations of T1 are not in order (order should be R₁(A), W₁(A), R₁(B), W₁(B)). So S2 is not conflict serializable.

Conflict Equivalent

If a schedule S can be transformed into a schedule S´ by a series of swaps of non-conflicting instructions, we say that S and S´ are conflict equivalent. We say that a schedule S is conflict serializable if it is conflict equivalent to a serial schedule.

Note 1: In the above example, Although S2 is not conflict serializable, still it is conflict equivalent to S21 and S22 because S2 can be converted to S21 and S22 by swapping non-conflicting operations.

Note 2: The schedule which is conflict serializable is always conflict equivalent to one of the serial schedule. S1 schedule discussed above (which is conflict serializable) is equivalent to the serial schedule (T1->T2).

Read more about Equivalent Serial Schedule of Conflict Serializable Schedule in DBMS.

Gate Question-2007

Testing Conflict Serializability

To test whether a schedule is conflict-serializable, you can use the precedence graph (or conflict graph). The process involves the following steps:

• Identify Conflicting Operations: Conflicts occur when two transactions access the same data item, and at least one of them is a write operation. Common conflicts are:
  • Write-Read (WR): A transaction writes a data item, and another transaction reads it.
  • Read-Write (RW): A transaction reads a data item, and another transaction writes to it.
  • Write-Write (WW): Two transactions write to the same data item.
• Construct the Precedence Graph:
  • Create a node for each transaction in the schedule.
  • Draw a directed edge from transaction Ti to transaction Tj if Ti performs a conflicting operation before Tj.
• Check for Cycles:
  • If the precedence graph has no cycles, the schedule is conflict-serializable.
  • If there are cycles, the schedule is not conflict-serializable.

Read more about Precedence Graph for Testing Conflict Serializability in DBMS here.

Advantages of Conflict Serializability

• Consistency: Conflict serializability guarantees that the transactions' outcomes correspond to the sequence in which they were carried out.
• Correctness: Regardless of the order in which transactions were submitted, conflict serializability guarantees that transactions are executed correctly.
• Decreased Overhead: By doing away with pointless locking and other conflict resolution techniques, conflict serializability lowers overhead.
• Enhanced Concurrency: By enabling concurrent execution of operations without causing conflicts, conflict serializability enhances concurrency.

Disadvantages of Conflict Serializability

• Complexity: Conflict serializability can be complex to implement, especially in large and complex databases.
• Reduced Performance: Conflict serializability can reduce performance by introducing delays and overhead due to locking and other conflict resolution mechanisms.
• Limited Concurrency: Conflict serializability can limit the degree of concurrency in the system because it may delay some transactions to avoid conflicts.
• Increased Overhead: Conflict serializability requires additional overhead to maintain the order of the transactions and ensure that they do not conflict with each other.