DBMS Topics
HubUnit 1 — Introduction to DBMS & Entity-Relationship ModelAdvantages and Disadvantages of DBMSAggregationCharacteristics of DBMSData IndependenceData ModelsDatabase Users and AdministratorsDBMS LanguagesER DiagramsEntity-Relationship ER ModelIntroduction to DBMSKeys in DBMSRelationships and CardinalitySchema and InstanceSpecialization and GeneralizationUnit 1 Summary — Introduction to DBMS & ER ModelThree-Level Architecture ANSI/SPARC ArchitectureWeak Entity SetUnit 2 — Relational Model & SQLConstraints in SQLCursorsDCL and TCL CommandsDDL CommandsDML CommandsDomain Relational Calculus DRCFunctions and Stored ProceduresJoins in SQLNested Queries SubqueriesRelational AlgebraRelational CalculusRelational ModelSQL IntroductionUnit 2 Summary — Relational Model & SQLTriggers in SQLTuple Relational Calculus TRCViews in SQLArmstrong's Axioms & Closure of AttributesBoyce-Codd Normal Form BCNFClosure of AttributesDependency PreservationFifth Normal Form 5NFFirst Normal Form 1NFFourth Normal Form 4NFFunctional DependencyLossless DecompositionMultivalued DependencyNormal Forms — OverviewNormalization — IntroductionSecond Normal Form 2NFUnit 3 Summary — NormalizationThird Normal Form 3NFUnit 4 — Transaction Management & Concurrency ControlACID PropertiesCheckpointsConcurrency Control & SerializabilityDeadlock in DBMSLock-Based Protocols & Two-Phase LockingLog-Based RecoveryRecovery SystemSerializabilityShadow PagingUnit 4 Summary — Transaction Management & Concurrency ControlTimestamp-Based ProtocolTransaction ManagementTransaction StatesTwo-Phase Locking 2PLUnit 5 — Storage & IndexingB+ TreeB-TreeCost EstimationDynamic HashingFile OrganizationHashing TechniquesIndexing — IntroductionMulti-Level IndexingQuery OptimizationQuery ProcessingSingle-Level IndexingStatic HashingUnit 5 Summary — Storage & IndexingUnit 6 — Advanced Topics in DBMSBig Data and DBMSCloud DatabaseData MiningData WarehouseDatabase SecurityDistributed DatabaseDistributed Query ProcessingDistributed DBMS Architecture, Fragmentation & ReplicationMongoDB — IntroductionNoSQL DatabaseReplication in Distributed DatabasesUnit 6 Summary — Advanced Topics in DBMSViva Voce — DBMSImportant Viva Questions — DBMSInterview Questions — DBMSViva Answers — DBMSDBMS Multiple Choice Questions MCQsDBMS Lab Programs
Transaction Management
Last Updated : 21 May, 2026
A transaction is a logical unit of work consisting of one or more database operations reads/writes that must be executed as a single indivisible unit. Either ALL operatio
Unit 4212 words12 headingsTables includedExamples included
What is a Transaction?
A transaction is a logical unit of work consisting of one or more database operations (reads/writes) that must be executed as a single indivisible unit. Either ALL operations complete successfully, or NONE of them are applied to the database.
Example — Bank Transfer of ₹5000 from Account A to Account B:
Transaction T:
1. Read(A)
2. A = A − 5000
3. Write(A)
4. Read(B)
5. B = B + 5000
6. Write(B)
Either ALL 6 steps complete → COMMIT
Or ANY step fails → ROLLBACK (all changes undone)
Why Transactions are Needed
Without transactions, two problems arise:
Problem 1 — Concurrent Access Anomalies
T1: Transfer A→B ₹5000
T2: Transfer A→C ₹3000 (simultaneously)
Without control:
T1 reads A = 10000
T2 reads A = 10000 ← both read before either writes
T1 writes A = 5000
T2 writes A = 7000 ← overwrites T1's update! ₹5000 lost!
Problem 2 — System Failure Mid-Operation
| T: Transfer A | B ₹5000 |
| Step 1 | A = A − 5000 (written to disk) |
| Step 2 | B = B + 5000 (never executed) |
Transactions with ACID properties solve both problems.
ACID Properties (Overview)
| Property | Meaning |
|---|---|
| Atomicity | All-or-nothing execution |
| Consistency | DB goes from valid state to valid state |
| Isolation | Transactions don't interfere with each other |
| Durability | Committed changes survive failures |
(Detailed in the ACID Properties topic)
Transaction Operations
| Operation | Notation | Description |
|---|---|---|
| Read | read(X) | Read data item X from DB into memory |
| Write | write(X) | Write data item X from memory to DB buffer |
| Commit | commit | Transaction completed successfully; changes permanent |
| Abort/Rollback | abort | Transaction failed; all changes undone |
Transaction T1 — Transfer ₹1000 from A to B:
BEGIN TRANSACTION
read(A)
A := A − 1000
write(A)
read(B)
B := B + 1000
write(B)
COMMIT
If any step fails:
ROLLBACK ← system restores A and B to original values
Simple vs. Complex Transactions
Simple (single SQL statement)
UPDATE Accounts SET balance = balance − 1000 WHERE id = 'A';
← This is one transaction in autocommit mode
Complex (multiple statements)
BEGIN TRANSACTION;
UPDATE Accounts SET balance = balance − 1000 WHERE id = 'A';
UPDATE Accounts SET balance = balance + 1000 WHERE id = 'B';
INSERT INTO TransactionLog VALUES (...);
COMMIT;
← All three statements as one atomic unit
Concurrent Transactions — Problems Without Control
1. Lost Update Problem
T1 reads X = 100
T2 reads X = 100
T1 writes X = 150 (added 50)
T2 writes X = 80 (subtracted 20 from original 100, OVERWRITING T1's write)
Final X = 80 (T1's update of +50 is LOST)
2. Dirty Read (Temporary Update Problem)
T1 writes X = 200 (but hasn't committed yet)
T2 reads X = 200 (reads uncommitted data)
T1 ROLLBACK → X reverts to original value
T2 has used dirty (invalid) data
3. Incorrect Summary Problem
T1 is summing account balances (reads A=100, B=200, ...)
T2 transfers 50 from C to A during T1's summation
T1 reads A after T2 writes (200), but reads C before T2 reads (100)
T1's sum includes both the new A and the old C → incorrect total
Transaction Manager Role in DBMS
| Transaction Manager | ||
|---|---|---|
| - Ensures ACID properties | ||
| - Coordinates with: | ||
| • Concurrency Control Manager | ||
| • Recovery Manager | ||
| • Buffer Manager |
The Transaction Manager is responsible for:
- Beginning and ending transactions
- Coordinating concurrency control (locking/timestamps)
- Coordinating recovery (logging)
- Ensuring durability via write-ahead logging
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Transaction Management.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this DBMS topic.
Search Terms
dbms, database management system, database notes, sql, unit, transaction, management, transaction management
Related DBMS Topics
Continue learning this concept
Unit 4Unit 4 — Transaction Management & Concurrency ControlThis unit covers how databases maintain data integrity when multiple operations execute simultaneously or when system failures occur. Transactions are the fundamental uniUnit 4Unit 4 Summary — Transaction Management & Concurrency ControlUnit 4Transaction StatesA transaction passes through a series of well-defined states during its lifetime. The DBMS tracks the state of every transaction to manage concurrency and recovery correcUnit 4ACID PropertiesACID is an acronym for the four key properties that every database transaction must satisfy to ensure data validity even in cases of errors, power failures, and concurrenUnit 4CheckpointsA checkpoint is a snapshot mechanism where the DBMS periodically writes all dirty modified buffer pages to disk and records the state of active transactions in the log.Unit 4Concurrency Control & SerializabilityConcurrency control is the mechanism that ensures correct results when multiple transactions execute simultaneously, without interfering with each other.