Skip to content
Related Articles

Related Articles

Equivalent Serial Schedule of Conflict Serializable Schedule in DBMS
  • Difficulty Level : Hard
  • Last Updated : 12 Mar, 2021

Prerequisite: Conflict Serializability, Precedence Graph

Conflict Serializable Schedule: A schedule is called conflict serializable if it can be transformed into a serial schedule by swapping non-conflicting operations. The serial schedule of the Conflict Serializable Schedule can be found by applying topological Sorting on the Precedence Graph of the Conflict Serializable Schedule.

Note: Precedence Graph of Conflict Serial Schedule is always directed acyclic graph.

Approach: Follow to below steps to find topological sorting of Precedence Graph:

  • Find the indegree of all nodes for the given Precedence Graph and store it in an auxiliary array.
  • Now For each node having indegree 0 perform the following:
    • Print the current node T as the order of the topological sort.
    • Let the node T be the node with in-degree 0.
    • Remove T and all edges connecting to T from the graph.
    • Update indegree of all nodes after the above steps.
  • After the above steps, the topological sort of the given precedence graph can be calculated.

Below is the illustration of the above approach:



Let, the Conflict Serial Schedule be S: R2(A) W2(A) R3(C) W2(B) W3(A) W3(C) R1(A) R2(B) W1(A) W2(B)

  • Here node T2 has indegree 0.
  • So, select T2 and remove T2 and all edges connecting from it.
  • Now T3 has indegree 0. So, select T3 and remove the edge T3→T1.
  • At the end select T3. So the topological Sorting is T2, T3, T1.
  • Hence, the equivalent serial schedule of given conflict serializable schedule is T2→T3→T1, i.e., S2: R2(A) W2(A) W2(B) R3(C) W3(A) W3(C) R1(A) R2(B) W1(A) W1(B).

There may be more than one equivalent serial schedule of the conflict serializable schedule.

Below is the implementation to get the Serial Schedule of CSS using Topological Sorting:

C++




// C++ program to print serial schedule
// of CSS using Topological sorting
#include <bits/stdc++.h>
using namespace std;
  
class PrecedenceGraph {
  
    // No. of vertices
    int V;
  
    // Pointer to an array containing
    // adjacency vector
    vector<int>* adj;
  
    // Vector to store SerialSchedule
    vector<int> serialSchedule;
  
    // Function  declarations
    void computeIndegree(int* indegree);
    int findZeroIndegree(int* indegree,
                         bool* visited);
  
public:
    // Constructor
    PrecedenceGraph(int V);
  
    // Function declarations
    void addEdge(int v, int w);
    void topologicalSort();
    void printSchedule();
};
  
// Function to create the precedence
// graph
PrecedenceGraph::PrecedenceGraph(int V)
{
    this->V = V;
    adj = new vector<int>[V];
}
  
// Function to add the edge to the
// precedence graph
void PrecedenceGraph::addEdge(int v,
                              int w)
{
    adj[v].push_back(w);
}
  
// Funciton to compute indegree of nodes
void PrecedenceGraph::computeIndegree(
    int* indegree)
{
    for (int i = 1; i < V; i++) {
  
        // Traverse the adjacency list
        // of node i
        for (int j = 0;
             j < adj[i].size(); j++) {
            int node = adj[i][j];
  
            // Update the indegree
            // of node
            indegree[node]++;
        }
    }
}
  
// Function to find node with
// zero indegree
int PrecedenceGraph::findZeroIndegree(
    int* indegree, bool* visited)
{
    for (int i = 1; i < V; i++) {
  
        // If node is not visited
        // and have indegree 0
        if (!visited[i]
            && indegree[i] == 0) {
  
            // Mark node visited
            visited[i] = true;
  
            // Return node
            return i;
        }
    }
  
    // All nodes are visited
    return -1;
}
  
// Function to find the topological
// Sorting of the given graph
void PrecedenceGraph::topologicalSort()
{
    // Create and initialize
    // visited array
    bool* visited = new bool[V]();
  
    // Create and initialize
    // indegree array
    int* indegree = new int[V]();
  
    computeIndegree(indegree);
  
    // Check if the node with
    // indegree 0 is available
    int node = findZeroIndegree(
        indegree, visited);
  
    bool nodeAvailable = false;
  
    if (node != -1) {
        nodeAvailable = true;
    }
    while (nodeAvailable) {
  
        // Add node to serial schedule
        serialSchedule.push_back(node);
  
        for (int i = 0;
             i < adj[node].size(); i++) {
  
            // Delete all edges of current
            // node and update indegree
            indegree[adj[node][i]]--;
        }
  
        // Find next node with indegree 0
        node = findZeroIndegree(indegree,
                                visited);
  
        if (node == -1) {
  
            // Node with zero indegree
            // not available
            nodeAvailable = false;
        }
    }
}
  
// Function to print the serial schedule
void PrecedenceGraph::printSchedule()
{
    for (int i : serialSchedule) {
        cout << "T" << i << " ";
    }
}
  
// Driver Code
int main()
{
    // Create a precedence graph
    // given in the above diagram
    PrecedenceGraph graph(4);
    graph.addEdge(2, 1);
    graph.addEdge(2, 3);
    graph.addEdge(3, 1);
  
    // Find topological ordereing
    graph.topologicalSort();
  
    // Print Schedule
    cout << "Equivalent Serial"
         << " Schedule is :";
    graph.printSchedule();
}
Output:
Equivalent Serial Schedule is :T2 T3 T1

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :