Two transactions on one timeline. Switch from Read Uncommitted to Serializable and watch dirty reads, non-repeatable reads, phantoms and lost updates disappear.

Find the conflicting operations in a schedule, draw the precedence graph edge by edge, and read the equivalent serial order off it — unless there is a cycle.

Shared and exclusive locks in a lock table: a growing phase, a lock point, a shrinking phase — and the deadlocks and cascading aborts that strict 2PL deals with.

Every update writes a new version. Each transaction reads from its own snapshot, readers never block writers, and old versions wait for garbage collection.

Log records with LSNs are forced to disk before the pages they describe. Then the power fails, and recovery redoes history and undoes the losers.

A messy table, its functional dependencies and its update, insert and delete anomalies — then the table splitting apart through 1NF, 2NF, 3NF and BCNF.

Parser, logical plan, cost-based optimizer, full scan against index scan, and the iterator model that pulls rows up to the client.

Nested-loop, hash join and sort-merge join on the same two tables, counting every comparison to see which one wins and why.

Rows flowing through FROM, WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY and LIMIT in logical order — which is why a SELECT alias cannot appear in WHERE.

Selection, projection, join, union, difference and rename on small tables, evaluating an expression tree from the leaves up.

Writes land in a memtable, flush to immutable SSTables and compact into larger levels; reads check newest first and skip tables with Bloom filters.

The update-in-place index that LSM trees are measured against: wide nodes that split and promote keys to stay shallow.

The structure under almost every primary key: values live in linked leaves, so a range scan walks sideways.