Database Internals learning path: everything to study, topic by topic

The role of a storage engine within a DBMS, the separation of storage from query processing, and the fundamental distinction between in-place update (B-Tree) and append-only (LSM) engines

How records are organized into fixed-size pages aligned to disk blocks, page headers, fixed vs variable-length records, and why the page is the fundamental unit of I/O

The slotted page organization that stores a slot directory of offsets at the page start and variable-length cells growing from the end, enabling in-place deletes, updates, and compaction

How database files encode cells, keys, values, and pointers; binary encoding, byte order, magic numbers, versioning, and checksums that make a format readable and durable

The balanced, high-fanout search tree at the heart of most databases: occupancy invariants, logarithmic height, why high fanout minimizes disk seeks, and key search within a node

The B+Tree variant that stores values only in leaves and links leaves into a sequential chain, optimizing range scans and separating routing keys in internal nodes from data in leaf nodes

How B-Trees stay balanced on insert and delete: splitting full nodes and propagating the separator up, merging or rebalancing underfull nodes, and the cost of structural modifications

Practical B-Tree optimizations: copy-on-write B-Trees, lazy B-Trees and deferred writes, Bw-Trees with delta chains, sibling pointers (B-link trees), and fractional cascading ideas

How indexes map keys to data: clustered (primary) indexes that store rows in key order vs non-clustered secondary indexes that store references, and the cost of maintaining multiple indexes

The log-structured merge-tree: buffering writes in memory, flushing immutable sorted runs to disk, and merging them in the background to trade read cost for write throughput

The in-memory sorted structure (often a skip list or balanced tree) that absorbs writes before they are flushed to an SSTable, the active/flushing memtable lifecycle, and its WAL pairing

Sorted String Tables: immutable on-disk files of sorted key-value pairs with a data block section, sparse index, and footer, enabling efficient lookups and merges across runs

Background merging of SSTables to reclaim space and bound read cost: size-tiered vs leveled compaction, their write/space amplification trade-offs, and tombstone garbage collection

Probabilistic membership filters used to skip SSTables that cannot contain a key: how multiple hash functions set bits, the meaning of false positives, and sizing for a target false-positive rate

The three amplification factors that govern storage-engine trade-offs and the RUM conjecture: how B-Trees and LSM variants sit at different points on the read/write/space surface

The in-memory cache of pages that mediates all disk access: page tables, pinning and reference counts, dirty page tracking, and the latching that keeps concurrent access safe

Choosing which page to evict when the buffer pool is full: LRU and its scan-resistance problems, CLOCK/second-chance, LRU-K and LFU variants, and interactions with prefetching

The durability mechanism that records changes to a sequential log before applying them to pages: the WAL invariant, log records and LSNs, force/steal policies, and group commit

The ARIES crash-recovery algorithm and its three phases — analysis, redo, and undo — with repeating history, compensation log records, checkpoints, and the dirty page table

What a transaction guarantees and how a storage engine implements ACID: atomicity via logging, consistency, isolation via concurrency control, and durability via WAL and fsync

The SQL isolation levels and the read/write anomalies they permit: dirty reads, non-repeatable reads, phantoms, write skew, and the gap between serializability and snapshot isolation

Pessimistic concurrency control with locks: shared/exclusive lock modes, two-phase locking and strict 2PL for serializability, lock granularity, deadlock detection, and lock escalation

MVCC: keeping multiple versions of each row so readers never block writers, version visibility via transaction timestamps/snapshots, garbage collection of old versions, and optimistic validation

Detecting node failures in a distributed store: heartbeats and timeouts, the impossibility of perfectly distinguishing slow from dead, phi-accrual detectors, and gossip-based dissemination

Keeping copies of data consistent: leader-based vs leaderless replication, synchronous vs asynchronous propagation, read/write quorums, and anti-entropy via Merkle trees and read repair

Agreeing on a single value or log order across nodes despite failures: the safety/liveness goals of consensus, the core ideas of Paxos, and how Raft structures leader election and log replication