Conflict Serializability in DBMS

Conflict Serializability ensures that a concurrent schedule produces the same result as some serial execution by reordering non-conflicting operations. It maintains data consistency and is stricter than View Serializability, which allows more flexibility but still preserves correctness.

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

Testing Conflict Serializability

A Precedence Graph or Serialization Graph is used commonly to test the Conflict Serializability of a schedule. It is a directed Graph (V, E) consisting of a set of nodes V = {T₁, T₂, T₃..........T_n} and a set of directed edges E = {e₁, e₂, e₃..................e_m}.

The graph contains one node for each Transaction T_i. An edge e_i is of the form T_j --> T_k where T_j is the starting node of e_i and T_k is the ending node of e_i. An edge e_i​ is drawn from node T_j to node T_k if a conflicting operation in T_j occurs before the corresponding conflicting operation in T_k​ in the schedule. The Algorithm can be written as:

• Create a node T in the graph for each participating transaction in the schedule.
• For the conflicting operation read_item(X) and write_item(X) - If a Transaction T_j executes a read_item (X) after T_i executes a write_item (X), draw an edge from T_i to T_j in the graph.
• For the conflicting operation write_item(X) and read_item(X) - If a Transaction T_j executes a write_item (X) after T_i executes a read_item (X), draw an edge from T_i to T_j in the graph.
• For the conflicting operation write_item(X) and write_item(X) - If a Transaction T_j executes a write_item (X) after T_i executes a write_item (X), draw an edge from T_i to T_j in the graph.
• Schedule S is serializable if there is no cycle in the precedence graph.

If there is no cycle in the precedence graph, it means we can construct a serial schedule S' which is conflict equivalent to schedule S. The serial schedule S' can be found by Topological Sorting of the acyclic precedence graph. Such schedules can be more than 1. For example, Consider the schedule S:

S: r1(x) r1(y) w2(x) w1(x) r2(y)

Creating Precedence Graph

Step 1: Make two nodes corresponding to Transaction T₁ and T₂.

Step 2: For the conflicting pair r1(x) w2(x), where r1(x) happens before w2(x), draw an edge from T₁ to T₂.

Step 3: For the conflicting pair w2(x) w1(x), where w2(x) happens before w1(x), draw an edge from T₂ to T₁.

Since the graph is cyclic, we can conclude that it is not conflict serializable to any schedule serial schedule. Let us try to infer a serial schedule from this graph using topological ordering.

The edge T₁-->T₂ tells that T₁ should come before T₂ in the linear ordering. The edge T₂ --> T₁ tells that T₂ should come before T₁ in the linear ordering. So, we can not predict any particular order (when the graph is cyclic). Therefore, no serial schedule can be obtained from this graph. 
Consider another schedule S1:

S1: r1(x) r3(y) w1(x) w2(y) r3(x) w2(x)

The graph for this schedule is: Since the graph is acyclic, the schedule is conflict serializable. Performing Topological Sort on this graph would give us a possible serial schedule that is conflict equivalent to schedule S1. In Topological Sort, we first select the node with in-degree 0, which is T1. This would be followed by T3 and T2. So, S1 is conflict serializable since it is conflict equivalent to the serial schedule T1 T3 T2.

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.

Conflict Serializability in DBMS

Visit Course

Conflict Serializability in DBMS

Transaction and Concurrency Control | Conflict Serializable Schedule in DBMS