Domain
Database Design & Operations
A learning path that builds the ability to design and operate robust, scalable data foundations — covering SQL fundamentals, relational model theory, normalization, physical design, transactions, NoSQL/distributed databases, and operational schema evolution. Travel between logical (set theory, predicate logic) and physical (disk I/O, concurrency) spaces along the way.
The Terrain of This Field
The terrain of databases can be read as a continent you climb from the "plains of SQL" at the foot, across the plateau of theory, and up to the underground of physics and the mountains of distribution. On the first plains you shed procedural thinking and shift your footing to "thinking in sets" — the entrance everyone steps through first, the starting point of every route up.
Overlooking the plains spreads the plateau of "theory and design." On the bedrock of the relational model rest the continents of normalization, logical design, and business modeling. Only once theory truly lands do your design decisions gain a backbone; by learning the right way and the anti-patterns (the failures) as two sides of one coin, you grow the ability to capture real business domains.
Beneath the plateau run the tunnels of indexes and storage engines, and beyond them rise the mountains of distributed data systems. From B-Tree to LSM-Tree — only by understanding the internals of a single node do the highest peaks of distributed consistency become solid underfoot. The key to surveying this field is the constant travel between logical and physical space.
Follow the arrows to read in order / solid = required, dashed = recommended
Share this map
Grouping
Difficulty
Difficulty
Dependencies
Computing layout...
Books in this domain
18 books
SQL 第2版
ゼロからはじめるデータベース操作
ミック
達人に学ぶDB設計徹底指南書 第2版
ミック
PostgreSQL徹底入門 第4版
インストールから機能・仕組み、アプリ作り、管理・運用まで
近藤雄太, 正野裕大, 坂井潔, 鳥越淳, 笠原辰仁, 石井達夫
失敗から学ぶRDBの正しい歩き方
曽根壮大
リレーショナルデータベース入門 第3版
データモデル・SQL・管理システム・NoSQL
増永良文
SQLアンチパターン 第2版
データベースプログラミングで陥りがちな失敗とその対策
Bill Karwin
達人に学ぶSQL徹底指南書 第2版
初級者で終わりたくないあなたへ
ミック
SQL実践入門
高速でわかりやすいクエリの書き方
ミック
理論から学ぶデータベース実践入門
リレーショナルモデルによる効率的なSQL
奥野幹也
事業分析・データ設計のためのモデル作成技術入門
佐藤正美
システム開発・刷新のためのデータモデル大全
渡辺幸三
データ指向プログラミング
ソフトウェアがもつ複雑さの軽減に向けて
Yehonathan Sharvit
詳説 データベース
ストレージエンジンと分散データシステムの仕組み
Alex Petrov
データベースリライアビリティエンジニアリング
回復力のあるデータベースシステムの設計と運用
Laine Campbell, Charity Majors
データ指向アプリケーションデザイン
信頼性、拡張性、保守性の高い分散システム設計の原理
Martin Kleppmann
データベース・リファクタリング
データベースの体質改善テクニック
Scott W. Ambler, Pramod J. Sadalage
プログラマのためのSQL 第4版
すべてを知り尽くしたいあなたに
Joe Celko
SQLパフォーマンス詳解
開発者のためのSQLパフォーマンスのすべて
Markus Winand
Dependencies
Reason: Once you have the basics of SELECT, the natural next step is set-oriented techniques—CASE expressions, window functions, set operations—that teach you to think in sets rather than procedurally. Both are Japanese SQL books by the same author (Mick), so the vocabulary carries over smoothly from introduction to application.
Reason: After you can write correct SQL, the next lens is reading the execution plan (EXPLAIN) to understand why a query is slow. This book starts tuning from the execution plan, so reading it right after the basics grows you from 'can write SQL' to 'can write fast SQL'.
Reason: After the applied set operations, advance to Joe Celko's set-theory-based advanced idioms and the nested-set model for hierarchical data. Including declarative hierarchical queries such as recursive CTEs, it is the capstone of the set-theoretic mindset—shedding procedural thinking entirely.
Reason: With a tuning foundation grounded in execution plans, Celko's advanced idioms land more deeply—you grasp not just the syntax but why a given form performs well. A supplementary path for re-examining declarative complex queries such as recursive CTEs from both expressiveness and performance.
Reason: Once you study query tuning and index design, you see that many performance problems trace back to early schema and operational decisions. This Japanese book on RDB pitfalls (失敗から学ぶRDBの正しい歩き方) covers operational anti-patterns—soft deletes, caching, idempotency—lifting your view above optimizing individual SQL statements.
Sources
Reason: Even when you can write applied SQL fluently, the RDB-specific pitfalls you meet in production are a separate body of knowledge. Adding the operational perspective from this Japanese book (失敗から学ぶRDBの正しい歩き方) balances the ability to write SQL with the ability to operate the database.
Sources
Reason: After you can make SQL 'run', the next goal is to internalize why tables are split this way and why we normalize—grounded in relational theory. This Japanese book (理論から学ぶデータベース実践入門) reconstructs Codd's relational model in practitioner's terms, giving your syntax knowledge a theoretical backbone.
Reason: A branch for those who want the relational model systematically and academically. Masunaga's textbook (リレーショナルデータベース入門) covers relational algebra, normal forms, and concurrency control in textbook fashion, tracing the academic lineage descending from Codd's original paper—complementing the more practice-oriented Okuno book.
Reason: Grasping relational theory first makes the set operations and window functions in the 達人 guide land as the logical necessity of 'why think in sets'. Reading theory → implementation lets you derive each advanced SQL technique from first principles rather than memorizing it ad hoc.
Reason: After learning academic relational algebra and normalization theory, this path lets you verify how it is expressed in actual SQL via the 達人 guide. It grounds the abstractions you gained in theory into concrete query forms, converting knowledge into something usable in practice.
Sources
Reason: Once you have internalized relational and normalization theory, the next stage is translating it into real table design. This Japanese book (達人に学ぶDB設計徹底指南書) concretizes theory—normalization, primary keys, foreign keys—into the practical steps of logical and physical design, bridging theory and practice. Hence it is placed as a required prerequisite.
Sources
Reason: After learning the correct design procedure, the next step is learning what not to do from cautionary examples. Bill Karwin's 'SQL Antipatterns' systematizes classic failures—missing foreign keys (Keyless Entry), EAV, comma-separated lists—reinforcing from the flip side why enforcing integrity with constraints matters.
Reason: After mastering the basic DB design procedure, advance to the higher skill of mapping a real business domain into data structures. This Japanese book on business analysis and data modeling (事業分析・データ設計のためのモデル作成技術入門) teaches techniques for extracting entities from business analysis, cultivating the judgment of 'what to model' that lies beyond technical normalization.
Reason: After grasping general design guidelines, move to a catalog of modeling patterns specific to business systems. This Japanese data-model compendium (データモデル大全) covers proven patterns for standard domains—ordering, inventory, accounting—expanding your repertoire of reusable, battle-tested structures instead of designing from scratch each time.
Reason: Where Karwin's 'SQL Antipatterns' addresses failures at the logical-design and SQL level, the Japanese book '失敗から学ぶRDBの正しい歩き方' addresses RDB pitfalls that surface in production operation. Extending from design-time anti-patterns to operation-time ones gives a full panorama of failure patterns from design through operation.
Sources
Reason: After learning the 'how to think' of deriving entities from business analysis, you can consult many concrete model examples in the data-model compendium (データモデル大全) as its output. Moving back and forth between abstract modeling technique and concrete per-domain table structures makes your design repertoire three-dimensional—a parallel-reference relationship.
Reason: Once you master business modeling on a single RDB, you hit the question of how design changes when data becomes distributed and large-scale. Kleppmann's 'Designing Data-Intensive Applications' covers replication, partitioning, and consistency models across the board, serving as the starting point for extending modeling knowledge into distributed environments.
Reason: Once you can write applied SQL, you want to understand why a query is fast or slow from the internal structure of indexes. Markus Winand's 'SQL Performance Explained' builds index design up from how B-Trees work, connecting the way you write SQL with how fast it runs.
Reason: After learning to read execution plans in the practical intro, dig deeper into the internal structure of indexes themselves with Winand's 'SQL Performance Explained'. Understanding index structure clarifies why a plan chooses a given access path, raising the resolution of your tuning.
Reason: After grasping RDBMS-agnostic index theory in 'SQL Performance Explained', verify how it is implemented in a concrete product via the Japanese PostgreSQL book (PostgreSQL徹底入門). Touching PostgreSQL-specific index types—B-Tree, GiST, GIN, BRIN—and transaction mechanisms lands the abstract theory onto a concrete implementation.
Reason: After learning normalization-centric logical design, this is a supplementary path to understanding how that design rebounds on physical performance. Reading Winand's 'SQL Performance Explained' reveals how table design and key choices govern index efficiency, giving physical grounding to your logical-design decisions.
Reason: Once you understand operating and transactions on a single RDBMS (PostgreSQL), step into the distributed world of what breaks when you scale to multiple nodes. Kleppmann's 'Designing Data-Intensive Applications' covers replication and consistency trade-offs, bridging single-node operational knowledge into distributed design.
Reason: After understanding the internals of B-Tree indexes in 'SQL Performance Explained', broaden your view with Alex Petrov's 'Database Internals' to the LSM-Trees and various storage engines beyond the B-Tree. Comparing data structures with different read/write characteristics cultivates judgment for choosing a database engine.
Reason: Once you understand one concrete RDBMS implementation (PostgreSQL), you want a map to put it in perspective. Petrov's 'Database Internals' systematizes storage engines and distributed implementations across products, letting you grasp where 'this PostgreSQL mechanism' sits in the general picture.
Sources
Reason: Only after understanding single-node storage-engine internals do discussions of consistency, replication, and partitioning across multiple nodes become grounded. Kleppmann's 'Designing Data-Intensive Applications' is the capstone that systematizes the principles of distributed data systems, placing internals knowledge as a required prerequisite.
Reason: Studying RDB table design naturally extends interest to how data is represented on the application side. Yehonathan Sharvit's 'Data-Oriented Programming' advocates treating data as immutable generic structures, offering a view that connects the database's normalization mindset with application-side data modeling.
Sources
Reason: The mindset of treating data as immutable connects deeply with how distributed systems handle consistency and event history. Kleppmann's 'Designing Data-Intensive Applications' covers log-centric architectures and event sourcing, extending the immutable-data idea into the context of distributed infrastructure.
Reason: After covering the operational basics of PostgreSQL—backups, monitoring, transactions—the next stage is elevating them into organized, systematic operational discipline. 'Database Reliability Engineering' (by Laine Campbell and Charity Majors) applies the SRE principles systematized by Google to database operations, moving you from ad-hoc operations to SLO-based reliability design.
Reason: Understanding the internals of storage engines and replication lets you predict, from structure, what to monitor and what can break in production. 'Database Reliability Engineering' bridges that internal knowledge into operational design—capacity planning, incident response, data integrity.
Reason: Database design is not build-once-and-done; it must evolve continuously as the application changes. Ambler & Sadalage's 'Refactoring Databases' systematizes techniques for safely changing schemas, connecting initial-design knowledge to evolutionary design that keeps fixing the schema while in operation.
Reason: Once Karwin's 'SQL Antipatterns' lets you spot bad designs already baked in, you next need a safe way to fix them. 'Refactoring Databases' offers a catalog of patterns for incrementally improving a schema while preserving production data, joining the discovery of anti-patterns to their remediation end to end.
Reason: After learning the principles of 'don't break it' operations in 'Database Reliability Engineering', the question becomes how to uphold them when you actually change the schema. The zero-downtime migration techniques in 'Refactoring Databases' form a parallel reference that translates SRE-style reliability goals into concrete schema-change procedures.
Reason: After understanding the theoretical trade-offs of distributed systems in Kleppmann's 'Designing Data-Intensive Applications', step into the reality of keeping them running. Based on Google's SRE principles, 'Database Reliability Engineering' (by Laine Campbell and Charity Majors) provides concrete practices for operating distributed data infrastructure reliably in production.
Reason: Understanding the relational model and normalization theory lets you read each failure in Karwin's 'SQL Antipatterns' through the lens of 'which theoretical principle it violates'. Knowing the theory lets you judge why an anti-pattern is bad from first principles, turning it into transferable knowledge rather than memorization.
Sources
Reason: Pushing Celko's set-theoretic advanced SQL to its limits sparks interest in how those declarative queries are executed and stored internally. Learning storage engines and index implementations in Petrov's 'Database Internals' bridges the gap between SQL's declarations and their physical execution.
Sources
Reason: After grasping relational algebra and normal forms academically in Masunaga's textbook (リレーショナルデータベース入門), verify in Okuno's book (理論から学ぶデータベース実践入門) how that theory informs real SQL and design decisions. It connects academic rigor with field practicality, turning theory into 'usable knowledge'.
Sources