Isolation

Definition

Isolation (the I in ACID) guarantees that concurrent transactions don't see each other's INTERMEDIATE, not-yet-committed state — from any one transaction's point of view, it appears as though it's running alone, even when others are executing at the same time.

How It Works

Without isolation, if T1 is mid-way through updating several rows, T2 could read some ALREADY-updated rows and some NOT-YET-updated rows — an inconsistent, confusing mixed view that never actually existed as a real, complete state. Isolation prevents this by controlling exactly what one transaction can see of another's in-progress work.

Edge Cases and Pitfalls

• Perfect isolation (as if every transaction ran one at a time, serially) is the theoretical ideal, but it sacrifices ALL the performance benefits of concurrency (23.1) — real databases offer configurable ISOLATION LEVELS (Chapter 25) that trade some isolation strength for better throughput, each preventing a different subset of the concurrency anomalies covered in Chapter 23 (dirty reads, non-repeatable reads, phantom reads).
• Isolation is specifically about transactions not observing EACH OTHER's uncommitted intermediate state — it's a distinct concern from Atomicity (which is about a single transaction's own all-or-nothing completion) and Consistency (about constraint validity), even though all three properties work together.
• The word "isolation" here should not be confused with process/container isolation in operating systems or virtualization — this is specifically about transaction visibility rules within the database.

Key Takeaways

• Isolation ensures each transaction appears to run alone, even when others execute concurrently — no seeing another transaction's half-finished work.
• Perfect isolation (fully serial execution) is the theoretical ideal but sacrifices concurrency performance — real systems use configurable isolation levels (Chapter 25) as a practical trade-off.
• Isolation specifically addresses inter-transaction visibility, distinct from Atomicity (intra-transaction completeness) and Consistency (constraint validity).