Recoverability, Cascadeless and Strict Schedule MCQs: 12 Solved Questions

The same operations can test cascadelessness, recoverability or strictness. A dirty read breaks cascadelessness; reversed dependent commit order breaks recoverability; reading or overwriting uncommitted data breaks strictness. For each schedule, identify writer-to-reader dependencies, compare commit order and check uncommitted access. Use the GATE CS Exam Preparation Courses & Test Series page to place this practice inside a wider study route.

The three-test method to use on every schedule

Start with the latest earlier write seen by each read and draw the read-from edge. Next, compare writer and reader commits, then check uncommitted access. Cascadeless schedules forbid reads of uncommitted writes; strict schedules forbid both reads and overwrites. The implication chain is strict => cascadeless => recoverable. Reverse implications fail, and strictness does not imply conflict serializability. See Transactions & Concurrency Control in DBMS for the broader framework.

For S*: w1(X); r2(X); w2(Y); c1; c2, record the read-from edge, commit order and uncommitted access:

MCQs 1-3: dirty reads, independent items and the implication chain

Question 1

Which of the following scenarios may lead to an irrecoverable error in a database system ?

• A. A transaction writes a data item after it is read by an uncommitted transaction

• B. A transaction reads a data item after it is read by an uncommitted transaction

• C. A transaction reads a data item after it is written by a committed transaction

• D. A transaction reads a data item after it is written by an uncommitted transaction

Correct answer: D.

w1(X); r2(X); c2; a1 gives T1 -> T2. The reader commits before the writer aborts, leaving a result based on an undone value. Option C uses a committed value. A and B contain no dirty read.

Question 2

Consider the following transactions with data items P,Q,R and S initialized to zero: T1: read (P); If P = 0 then p: = 2p + 5; Write (P); T2: read (Q); If Q = 0 then Q: = Q + 5; Write (Q); T3: read (R); If R = 0 then R: = R + 10; Write (R); T4: read (S); If S = 0 then S: = S + 1; Write (S); Any non-serial interleaving of T1, T2, T3 and T4 for concurrent execution leads to

• A. An Irrecoverable serializable schedule

• B. A schedule that is not conflict serializable

• C. A conflict serializable schedule

• D. A deadlock present schedule

Correct answer: C.

Each transaction accesses its own item: P, Q, R or S. The precedence graph has four vertices and zero edges, so every interleaving is conflict-equivalent to a serial execution. No shared-item conflict exists to cause deadlock or a recovery dependency.

Question 3

Let S be the following schedule of operations of three transactions $T_1, \ T_2$ and $T_3$ in a relational database system: $R_2(Y), R_1(X), R_3(Z), R_1(Y), W_1(X), R_2(Z), W_2(Y), R_3(X), W_3(Z)$ Consider the statements $P$ and $Q$ below: $P$: $S$ is conflict-serializable. $Q$: If $T_3$ commits before $T_1$ finishes, then $S$ is recoverable. Which one of the following choices is correct?

• A. Both $P$ and $Q$ are true

• B. $P$ is true and $Q$ is false

• C. $P$ is false and $Q$ is true

• D. Both $P$ and $Q$ are false

Correct answer: B.

For P, T1 -> T2 on Y, T1 -> T3 on X, and T2 -> T3 on Z form an acyclic graph. For Q, R3(X) reads from W1(X), so committing T3 first violates recoverability.

MCQs 4-6: decide recoverability from read-from edges and commit order

Question 4

Let S be the following schedule of operations of three transactions T1, T2 and T3 in a relational database system: S: r1(X); r3(Y); r2(Y); r3(X); r1(Z);r2(Z); w3(Y); w1(X); w2(Z); w1(Z) Consider the statements S1 and S2 below: S1: S is conflict-serializable. S2: If T2 commits before T1 finishes, then S is recoverable. Which one of the following choices is correct?

• A. Both S1 and S2 are true

• B. S1 is true and S2 is false

• C. Both S1 and S2 are false

• D. S1 is false and S2 is true

Correct answer: D.

The edges include T3 -> T1 on X, T2 -> T3 on Y, and T1 <-> T2 on Z. The cycle makes S1 false. Transaction T2 reads only the initial values of Y and Z, so committing it before T1 finishes violates no writer-before-reader dependency. S2 is true.

Question 5

Consider the two schedules: S 1 : r1(x),r2(x),w2(x),r3(x),w1(x), w2(y),r3(y), c2,w3(x), c1, c3 S 2 : r2(x),r1(x),w1(x),w2(x),w2(y),r3(x),w3(x),r3(y), c1, c3, c2 Which of the schedules is recoverable?

• A. Only S2

• B. Only S1

• C. None of them

• D. Both S1 and S2

Correct answer: B.

In S1, T3 reads x and y from T2, and c2 < c3, so it is recoverable. In S2, the same dependency has c3 < c2. The reader commits first, so S2 is not recoverable.

Question 6

Consider the following schedules: S1: R1(x) W1(x) R1(y) R2(x) W2(x) C2, C1; S2: R2(x) W2(x) R1(y) R1(x) W2(x) C2, C1; Which of the following is true?

• A. Both S1 and S2 are recoverable

• B. S1 is recoverable but S2 is not

• C. S2 is recoverable but S1 is not

• D. Both schedule are not Recoverable

Correct answer: C.

In S1, R2(x) sees W1(x), but C2 < C1, so the reader commits first. In S2, R1(x) sees W2(x) and C2 < C1, writer-before-reader order. Only S2 is recoverable.

MCQs 7-9: cascading rollback and dependency chains

Question 7

Consider the following database schedule with two transactions, $T_1$ and $T_2$. $S= r_{2}\left(X\right); r_{1}\left(X\right); r_{2} \left(Y\right); w_{1} \left(X\right); r_{1} \left(Y\right); w_{2} \left(X\right); a_{1}; a_{2}$ where $r_i(Z)$ denotes a read operation by transaction $T_i$ on a variable $Z$, $w_i(Z)$ denotes a write operation by transaction $T_i$ on a variable $Z$ and ai denotes an abort by transaction $T_i$ . Which one of the following statements about the above schedule is TRUE?

• A. $S$ is non-recoverable

• B. $S$ is recoverable, but has a cascading abort

• C. $S$ does not have a cascading abort

• D. $S$ is strict

Correct answer: C.

Every read precedes the other transaction's write, so no dirty-read dependency or cascading abort exists. However, w2(X) follows w1(X) before a1. This dirty write makes the schedule non-strict, separating strictness from cascading rollback.

Question 8

A schedule of three database transactions $𝑇_1, 𝑇_2$, and $𝑇_3$ is shown. $𝑅_𝑖(𝐴)$ and $𝑊_𝑖(𝐴)$ denote read and write of data item $𝐴$ by transaction $𝑇_𝑖 , 𝑖 = 1,2,3$. The transaction $𝑇_1$ aborts at the end. Which other transaction(s) will be required to be rolled back? $𝑅_1 (𝑋) 𝑊_1 (𝑌) 𝑅_2 (𝑋) 𝑅_2 (𝑌) 𝑅_3 (𝑌) 𝐴𝐵𝑂𝑅𝑇(𝑇_1 )$

• A. Only $𝑇_2$

• B. Only $𝑇_3$

• C. Both $𝑇_2$ and $𝑇_3$

• D. Neither $𝑇_2$ nor $𝑇_3$

Correct answer: C.

Both R2(Y) and R3(Y) follow W1(Y), giving T1 -> T2 and T1 -> T3. When T1 aborts, both readers roll back. R2(X) is irrelevant because T1 only reads X.

Question 9

For the schedule S given below, if transaction T1 aborts after the last operation of schedule S, then which of the following statements will be true? S: r1(x), r2 (z), w1(x), r3(x), r2(y), w2(y), w3(x), r3(y), r2(x)

• A. Only T3 will be rolled back.

• B. First T2 will be rolled back followed by T3 rollback.

• C. First T3 will be rolled back followed by T2 rollback.

• D. There will be no cascading rollbacks.

Correct answer: C.

r3(x) reads from w1(x), so T1 -> T3. The final r2(x) reads from the latest write, w3(x), so T3 -> T2. Aborting T1 therefore rolls back T3, then T2.

MCQs 10-12: strict, cascadeless and recoverable classification

Question 10

Consider the given schedule R1 (X), R2 (Z), R1 (Z), R3 (X), R3 (Y), W1 (X), Commit1, W3 (Y), Commit3, R2 (Y), W2 (Z), W2 (Y), Commit2. The given schedule is

• A. Recoverable only

• B. Cascadeless only

• C. Strict schedule

• D. None

Correct answer: C.

Other reads of X precede W1(X), then Commit1 follows immediately. Likewise, Commit3 follows W3(Y) before T2 accesses Y. No transaction accesses another's uncommitted write, so the schedule is strict, cascadeless and recoverable.

Question 11

Consider the following schedule ‘S’. S: r1(X); r2(Z); r3(X); r1(Z); r2(Y); r3(Y); w1(X); c1; w2(Z); w3(Y); w2(Y); c3; c2; The schedule ‘S’ is

• A. Recoverable

• B. Cascade less

• C. recoverable and cascade-less

• D. None

Correct answer: C.

All reads precede the relevant cross-transaction writes, so the schedule is cascadeless and recoverable. It is not strict because w2(Y) follows w3(Y) before c3, a dirty write. Thus C is the strongest listed choice.

Question 12

Consider the following schedule 'S' involving 3 Transactions T₁, T₂, and T₃: S: r₁(x); r₃(x); r₁(x); w₁(y); r₂(y); w₂(x); C₃; C₁; C₂ Which of the following is true regarding the above schedule?

• A. It is recoverable and also cascadeless

• B. It is recoverable but not cascadeless

• C. It is not recoverable

• D. It is a strict schedule, so it is both recoverable and cascadeless

Correct answer: B.

r₂(y) reads from w₁(y) before C₁, breaking cascadelessness. Recoverability holds because C₁ < C₂. Transaction T₃ reads x before w₂(x), adding no dependency. This disproves the implication from recoverable to cascadeless.

Final trap checklist and the next practice step

• Find the latest earlier writer for each read.

• Draw each writer-to-reader edge.

• For recoverability, require writer commit before reader commit.

• Reject cascadelessness when a read precedes writer commit.

• Reject strictness when a read or write precedes writer commit or abort.

w1(X); r2(X); c1; c2 is recoverable but not cascadeless. Delaying r2(X) until after c1 makes that dependency strict.

Next, solve DBMS Transaction MCQs: 12 Solved (ACID, Locking) and DBMS Normalization MCQs: 12 Solved (1NF to BCNF). Use GATE Guidance by Sanchit Sir for concept teaching and the GATE Test Series for timed practice.

Now solve the 12 again without explanations. Label every read-from edge before checking an option.