Transaction Processing

Definition

Transaction processing is the method of executing a series of operations as one complete logical unit in such a way that the system ensures correctness, consistency, isolation, and durability of data.

A transaction is a set of database operations that must be treated as a single unit. A transaction is considered successful only when all its operations are completed properly; if any operation fails, the system must undo the changes or recover to a safe state. This process ensures that the database remains accurate even during errors, power failures, system crashes, or concurrent access by multiple users.

In database systems, transaction processing is often explained using the ACID properties:

Atomicity

: All operations in the transaction happen completely or not at all.

Consistency

: The transaction takes the database from one valid state to another valid state.

Isolation

: Transactions do not interfere with each other while running.

Durability

: Once a transaction is committed, its results are permanent.

For example, in an online shopping system, if a customer places an order and payment is deducted, the stock should also be updated. If payment succeeds but stock update fails, the system should not leave the order in a broken state. Transaction processing prevents such inconsistencies.

Main Content

1. Transaction and ACID Properties

Atomicity and Consistency

Atomicity means a transaction behaves like an indivisible unit. Either every operation succeeds, or the entire transaction is rolled back. For instance, in a bank transfer from Account A to Account B, if money is deducted from A but cannot be credited to B, atomicity ensures the deduction is undone.
Consistency ensures that every transaction preserves database rules, constraints, and business logic. If a database rule says an account balance cannot become negative, a transaction violating that rule must be rejected.

Isolation and Durability

Isolation means multiple transactions can run at the same time without affecting one another’s intermediate results. This is especially important in systems with many concurrent users, such as ticket booking websites.
Durability guarantees that once a transaction is committed, the changes survive system failures. Even if power goes out immediately after saving, the committed data remains intact.

2. Transaction States

Active and Partially Committed

A transaction begins in the active state when its operations are being executed. During this stage, it may read or write data, perform calculations, and interact with the database.
Once all operations are completed but the changes are not yet permanently saved, the transaction enters the partially committed state. At this point, it is ready for final commitment.

Committed and Failed

A transaction becomes committed when all updates are successfully stored and made permanent.
If an error occurs, such as a system crash, constraint violation, or deadlock, the transaction moves to the failed state and must be rolled back.

Aborted and Terminated

In the aborted state, the system restores the database to its previous stable condition by undoing changes made during the transaction.
The terminated state means the transaction has fully ended after commit or rollback.

3. Concurrency Control and Recovery

Concurrency Control

Concurrency control manages multiple transactions executing at the same time. Without it, problems like lost updates, dirty reads, and inconsistent retrievals can occur.
Techniques such as locks, timestamps, and scheduling help ensure safe simultaneous access. For example, if two users try to book the last available seat, concurrency control ensures only one transaction succeeds.

Recovery Mechanisms

Recovery ensures that the database can return to a correct state after failures. It uses logs, checkpoints, backups, and undo/redo operations.
Example: if a transaction was halfway complete when the system crashed, the recovery system checks the log file to determine which changes should be undone and which should be redone.

Working / Process

1. Transaction Begins

The system receives a user request, such as transferring money, placing an order, or updating a record.
The DBMS creates a transaction context and marks the transaction as active.
Example: In an ATM withdrawal, the system begins by checking the account number and requested amount.

2. Operations Are Executed

The transaction performs all required database actions: reading records, modifying values, validating rules, and updating related tables.
The DBMS may lock resources or apply concurrency control techniques to prevent conflicts with other transactions.
Example: In a bank transfer, the system deducts money from the sender’s account and adds it to the receiver’s account.

3. Commit or Rollback

If every step is successful, the transaction is committed and the changes are permanently stored.
If any step fails, the system rolls back the transaction and restores the previous state using logs or undo records.
Example: If a purchase payment succeeds but inventory update fails, the transaction is rolled back so the order does not remain partially completed.

A simple transaction flow can be represented as:

Start
  |
  v
Read / Validate Data
  |
  v
Perform Updates
  |
  v
All Successful?
  |         \
 Yes          No
  |            \
  v             v
Commit       Rollback
  |             |
  v             v
End           End

This process ensures that data stays accurate even when many users access the system simultaneously or unexpected failures occur.

Advantages / Applications

Data Accuracy and Reliability

Transaction processing prevents partial updates and maintains correct records across all operations.
It reduces the chance of corruption, inconsistency, and human error in business data.
Example: A payment system always ensures that money is either transferred fully or not transferred at all.

Concurrency and Efficiency

It allows multiple users to work with the same database safely at the same time.
Businesses can handle a large number of requests quickly, which improves productivity and user satisfaction.
Example: Thousands of customers can book flights, order products, or pay bills simultaneously without crashing the system.

Wide Practical Use

Transaction processing is used in banking, e-commerce, stock trading, railway and airline reservations, payroll systems, and hospital management.
It is crucial in any environment where errors can lead to financial loss, legal issues, or service failure.
Example: In a hospital system, updating patient records, billing, and medicine inventory may all depend on transaction processing.

Summary

Transaction processing manages a set of database operations as one complete unit.
It uses ACID properties to protect data from errors and failures.
It is essential for safe updates, concurrency, and recovery in real-world systems.
Important terms to remember: transaction, ACID, commit, rollback, concurrency control, recovery, isolation, durability