Database Management Systems

If this were a book, this page is the table of contents. Each Part below is a chapter; each chapter links out to the concepts, designs, and platform notes that already exist elsewhere in this wiki instead of duplicating them. Unwritten chapters are listed as Planned rows, not empty files.

Parts

00 — Database Foundations

Why DBMSs replaced file-based storage, the three-schema architecture that gives them data independence, and the major data models (hierarchical, network, relational, object-oriented, NoSQL).

• 1 — Why Databases Exist — (stub)
• 2 — Database Architecture — (stub)
• 3 — Database Models — (stub)

01 — Relational Model

The formal vocabulary of the relational model — relations, keys, constraints — and the two equivalent query formalisms (relational algebra and relational calculus) that SQL is built on top of.

• 1 — Relational Model Fundamentals — (stub)
• 2 — Constraints — (stub)
• 3 — Relational Algebra — (stub)
• 4 — Relational Calculus — (stub)

02 — SQL Mastery

Practical SQL from basic DDL/DML through joins, aggregation, subqueries, CTEs, window functions, and the advanced object types (views, triggers, sequences) that show up in both production code and SQL coding interviews.

• 1 — SQL Basics — (stub)
• 2 — Querying Data — (stub)
• 3 — Joins — (stub)
• 4 — Aggregation — (stub)
• 5 — Subqueries — (stub)
• 6 — Common Table Expressions — (stub)
• 7 — Window Functions — (stub)
• 8 — Advanced SQL — (stub)

03 — Database Design

Modeling a domain as an ER diagram, mapping it into relational tables, and using functional dependencies to drive normalization — plus when denormalization is the right tradeoff instead.

• 1 — ER Modeling — (stub)
• 2 — Mapping ER to Relational Model — (stub)
• 3 — Functional Dependencies — (stub)
• 4 — Normalization — (stub)
• 5 — Denormalization — (stub)

04 — Storage Internals

How a DBMS physically lays out data on disk — pages, heap files, clustered storage — and the two index families (B-tree and hash) built on top of that layout.

• 1 — Physical Storage — (stub)
• 2 — Indexing — (stub)
• 3 — B-Trees — (stub)
• 4 — Hash Indexes — (stub)

05 — Query Processing

How a query moves from parsed text to an execution plan, the optimizer decisions (cost-based vs rule-based, pushdown) behind that plan, and the join algorithms the executor picks from.

• 1 — Query Execution — (stub)
• 2 — Query Optimization — (stub)
• 3 — Join Algorithms — (stub)

06 — Transactions

The transaction lifecycle and ACID guarantees, the concurrency anomalies that arise without control, and the three families of concurrency control (locking, timestamp ordering, optimistic) that isolation levels are built from.

• 1 — Transaction Fundamentals — (stub)
• 2 — ACID Properties — (stub)
• 3 — Concurrency Problems — (stub)
• 4 — Concurrency Control — (stub)
• 5 — Two-Phase Locking — (stub)
• 6 — Timestamp Protocols — (stub)
• 7 — Optimistic Concurrency Control — (stub)
• 8 — Isolation Levels — (stub)

07 — Recovery

Write-ahead logging as the foundation of crash recovery, and the checkpointing/ARIES machinery a DBMS uses to recover to a consistent state after a crash.

• 1 — Logging — (stub)
• 2 — Recovery Algorithms — (stub)

08 — Distributed Databases

Fragmentation and replication across nodes, the two-phase commit protocol for distributed transactions, and the consensus protocols (Paxos, Raft) that keep replicas agreeing. See also Consensus Algorithms and Consensus Patterns for the general distributed-systems treatment this Part specializes to databases.

• 1 — Distributed Databases — (stub)
• 2 — Two-Phase Commit — (stub)
• 3 — Consensus Basics — (stub)

09 — NoSQL Databases

The four major NoSQL categories — key-value, document, column-family, graph — and why each trades away parts of the relational model for a different scalability profile. See also Storage Engines for how Cassandra/Bigtable-style engines are built internally.

• 1 — NoSQL Overview — (stub)
• 2 — Key-Value Stores — (stub)
• 3 — Document Databases — (stub)
• 4 — Column Family Databases — (stub)
• 5 — Graph Databases — (stub)

10 — Scalability

Replication topologies, partitioning strategies, and the patterns (saga, outbox, eventual consistency) that replace distributed ACID transactions at scale, framed through CAP and PACELC. See also Partitioning and Sharding, CAP Theorem and PACELC, Saga, and Outbox.

• 1 — Replication — (stub)
• 2 — Partitioning — (stub)
• 3 — Distributed Transactions — (stub)
• 4 — CAP Theorem — (stub)
• 5 — PACELC — (stub)

11 — Database Performance

Reading EXPLAIN plans and diagnosing slow queries, the tuning knobs (connection pools, buffer pool, caching, vacuum/analyze), and the bottlenecks — lock contention, hot partitions, index bloat, deadlocks — that show up in production.

• 1 — Query Performance — (stub)
• 2 — Database Tuning — (stub)
• 3 — Common Bottlenecks — (stub)

12 — Database Security

Authentication/authorization via roles and RBAC, encryption at rest/in transit/TDE, and SQL injection prevention through prepared statements and safe ORM usage.

• 1 — Authentication & Authorization — (stub)
• 2 — Encryption — (stub)
• 3 — SQL Injection — (stub)

13 — DBMS in System Design

How database choice, data modeling, and scaling decisions actually show up inside a system design interview, worked through classic case studies. See also system-design/README.md for the broader system design book this Part specializes to the data layer, and Distributed Cache for the caching half of the scaling toolkit.

• 1 — Choosing the Right Database — (stub)
• 2 — Designing Data Models — (stub)
• 3 — Scaling Databases — (stub)
• 4 — Interview Case Studies — (stub)

14 — MAANG Interview Preparation

The recurring theory comparison questions, a SQL coding practice set, internals deep dives across the major engines, and full mock-interview problem sets.

• 1 — Frequently Asked Interview Questions — (stub)
• 2 — SQL Coding Interview — (stub)
• 3 — Internal Architecture Deep Dive — (stub)
• 4 — Mock Interview Problems — (stub)

15 — Appendix

Quick-reference cheat sheets, decision matrices, and a glossary — the material you skim the night before an interview rather than read start to finish.

• 1 — SQL Cheat Sheet — (stub)
• 2 — Relational Algebra Cheat Sheet — (stub)
• 3 — Normalization Cheat Sheet — (stub)
• 4 — Isolation Levels Matrix — (stub)
• 5 — Lock Compatibility Matrix — (stub)
• 6 — Join Algorithms Comparison — (stub)
• 7 — Index Selection Guide — (stub)
• 8 — Database Selection Decision Matrix — (stub)
• 9 — PostgreSQL EXPLAIN Cheat Sheet — (stub)
• 10 — MySQL EXPLAIN Cheat Sheet — (stub)
• 11 — Top 200 MAANG DBMS Interview Questions — (stub)
• 12 — DBMS Glossary — (stub)
• 13 — Further Reading — (stub)

Metadata

Author	Amit Singh
Scope	dbms