What are common examiner traps in Transactions and Concurrency Control?

Confusing Read-Read operations as conflicts (Read-Read is non-conflicting). Assuming 2PL prevents deadlocks (Basic 2PL guarantees conflict serializability but NOT deadlock freedom). Assuming a schedule is non-recoverable just because it has dirty reads; it becomes non-recoverable ONLY if the dirty reader commits BEFORE the writer commits. Confusing 'Cascadeless' with 'Strict' (Strict requires write-write to also wait for commit/abort; cascadeless only restricts write-read). Overlooking disconnected nodes in the precedence graph when listing all conflict-equivalent serial schedules in MSQs (unconstrained nodes can be placed anywhere relative to others). Mixing up Wound-Wait (preemptive, older wounds younger) with Wait-Die (non-preemptive, older waits, younger dies). Assuming lost updates violate only Atomicity rather than Isolation and Consistency.

GATE CSE Transactions and Concurrency Control PYQs

Medium yield22.7% of Databases

Across 2012–2026, Transactions and Concurrency Control in GATE CS is heavily weighted towards testing precedence (serialization) graphs for conflict serializabi… Read the guide

Take topic test

Questions: 25
Asked: since 2012
Total marks: 40
Marks / paper: 1.5

25 GATE CSE Transactions and Concurrency Control PYQs with solutions, from Databases. Browse all GATE CSE PYQs.

Questions

Every official paper that asked this topic, newest first.

What GATE tests in Transactions and Concurrency Control

Concepts, patterns, formulas and traps distilled from past papers.

Across 2012–2026, Transactions and Concurrency Control in GATE CS is heavily weighted towards testing precedence (serialization) graphs for conflict serializability, schedule classification (recoverable, cascadeless, strict), and locking/timestamping protocol mechanics. Questions frequently present interleaved schedules and require students to identify conflict edges, count valid topological orders, or detect recovery anomalies such as dirty reads and cascading rollbacks. Recent exams (2021–2025) feature multiple MSQs testing theoretical invariants of Two-Phase Locking (2PL), deadlock prevention protocols (Wait-Die, Wound-Wait), and real-world ACID violations.

Core concepts

Conflict operations (R-W, W-R, W-W on the same variable by distinct transactions)
Precedence (serialization) graph construction and cycle detection
Topological sorting to obtain conflict-equivalent serial schedules
Hierarchy of schedules: Strict ⊂ Cascadeless ⊂ Recoverable ⊂ All schedules
Dirty read anomaly and cascading rollbacks upon abort
Two-Phase Locking (Basic 2PL, Strict 2PL, Rigorous 2PL, Conservative 2PL)
Deadlock prevention schemes: Wait-Die vs Wound-Wait timestamp ordering
Thomas' Write Rule and View Serializability
ACID properties (Atomicity, Consistency, Isolation, Durability) and anomaly mappings (Lost Update, Inconsistent Analysis)
Idempotency of Redo and Undo operations in log-based crash recovery

Recurring question patterns

Precedence Graph Cycle Detection & Equivalent Serial Order
CommonMCQ2 marks2025, 2024, 2022, 2021
Given one or more transaction schedules with interleaved $r_i(X)$ and $w_i(X)$ operations, determine conflict serializability by constructing the precedence graph and/or find the conflict equivalent serial schedule(s) via topological sorting.
Schedule Recoverability and Cascading Aborts Analysis
CommonMCQ2 marks2025, 2021, 2016, 2015
Given an execution sequence with commit/abort events, analyze whether dirty reads occur ( $W_i(X) \to R_j(X)$ without commit), determine if the schedule is recoverable ( $T_i$ commits before $T_j$ ), cascadeless, or strict, and identify required cascading rollbacks.
Properties of Concurrency Control Protocols (2PL & Timestamps)
CommonMSQ1 marks2024, 2019, 2017, 2016
Conceptual evaluation (often in MSQ or 2-statement format) of 2PL variants (Basic, Strict, Rigorous, Conservative), address-ordered locking for deadlock freedom, Thomas' Write Rule generating view serializable schedules, or Wait-Die / Wound-Wait schemes.
ACID Properties & Concurrency Anomalies
OccasionalMCQ1 marks2025, 2024, 2016, 2015
Application scenarios (e.g., banking transfers, lost updates, uncommitted reads) mapping anomalies to specific ACID property violations (Atomicity, Consistency, Isolation, Durability).
Combinatorial Interleaving & Serializability Counting
RareNAT2 marks2017
Counting the total number of conflict serializable schedules out of all possible interleavings $\binom{n_1 + n_2}{n_1}$ by finding cycle-inducing relative orders.
Log-Based Recovery & Crash Semantics
RareMSQ1 marks2021
Analyzing behavior of DBMS crash recovery, idempotency of undo/redo actions, and state preservation when crashes occur during recovery without checkpoints.

Formulas GATE uses

Total Interleavings of Two Transactions

\text{Total Schedules} = \binom{n_1 + n_2}{n_1} = \frac{(n_1 + n_2)!}{n_1! \, n_2!}

Used when counting total possible concurrent schedules formed by two transactions of length $n_1$ and $n_2$ operations preserving intra-transaction order.

Conflict Condition Definition

(O_i(X), O_j(X)) \text{ is in conflict iff } T_i \neq T_j \land (O_i = \text{Write} \lor O_j = \text{Write})

Used to add directed edges $T_i \to T_j$ in a precedence graph whenever $O_i(X)$ appears before $O_j(X)$ in schedule $S$ .

Recoverability Rule

\forall T_i, T_j \; [W_i(X) <_S R_j(X) \implies C_i <_S C_j]

Used to check whether a schedule is recoverable by verifying that the writer transaction $T_i$ commits before the reader transaction $T_j$ commits.

Cascadelessness Rule (Avoids Cascading Aborts)

\forall T_i, T_j \; [W_i(X) <_S R_j(X) \implies C_i <_S R_j(X)]

Used to verify that every read operation only reads committed data (no dirty reads).

Strict Schedule Rule

\forall T_i, T_j \; [W_i(X) <_S O_j(X) \implies (C_i <_S O_j(X) \lor A_i <_S O_j(X))] \text{ where } O_j \in \{R_j, W_j\}

Used to verify that no transaction reads or overwrites uncommitted written data.

Examiner traps in Transactions and Concurrency Control

Confusing Read-Read operations as conflicts (Read-Read is non-conflicting).
Assuming 2PL prevents deadlocks (Basic 2PL guarantees conflict serializability but NOT deadlock freedom).
Assuming a schedule is non-recoverable just because it has dirty reads; it becomes non-recoverable ONLY if the dirty reader commits BEFORE the writer commits.
Confusing 'Cascadeless' with 'Strict' (Strict requires write-write to also wait for commit/abort; cascadeless only restricts write-read).
Overlooking disconnected nodes in the precedence graph when listing all conflict-equivalent serial schedules in MSQs (unconstrained nodes can be placed anywhere relative to others).
Mixing up Wound-Wait (preemptive, older wounds younger) with Wait-Die (non-preemptive, older waits, younger dies).
Assuming lost updates violate only Atomicity rather than Isolation and Consistency.

How questions are asked

Given a schedule string, determine if it is conflict serializable and/or recoverable
Select all conflict-equivalent serial orders from a given set (MCQ/MSQ)
Match locking/timestamping protocols to their guarantees (serializability, deadlock-freedom, starvation-freedom)
Count the number of conflict serializable schedules using combinatorics (NAT)
Identify which transactions must cascade-abort when a specific transaction fails
Scenario-based identification of violated ACID properties upon a concurrent failure

Paper trends

Shift from single-answer MCQs identifying a unique serial order to MSQs where multiple serial orders are valid due to disconnected DAG components or independent transactions.
2024, 2022
Increased focus on multi-concept MSQs combining 2PL phase rules, deadlock possibilities, and transaction abort ripple effects (cascading rollbacks).
2025, 2024
Contextual scenario-based questions (e.g., banking system audit logs) testing nuanced distinctions between Isolation and Consistency violations rather than pure rote definitions.
2025, 2015

Difficulty notes

Easy: Direct definition matching of ACID properties, identifying conflict pairs ( $R-W, W-R, W-W$ ), or checking 2-node precedence graphs for cycles. Medium: Multi-transaction (3 or 4 transactions) precedence graphs with branching topological orders, classifying schedules across the hierarchy (Strict vs Cascadeless vs Recoverable), or evaluating 2PL / Wound-Wait protocol claims in MSQ format. Hard: Combinatorial enumeration (NAT) of non-serializable interleavings against total permutations $\binom{\sum n_i}{n_1, n_2, \dots}$ or subtle view serializability edge cases involving blind writes.