SQL

The foundation of Relational Databases.

The four categories of SQL commands.

The unique identifier for a row.

Creating relationships between tables.

Rules that prevent garbage data from entering your database.

The billion-dollar mistake in database design.

Choosing the exact memory footprint for your data.

Summarizing massive amounts of data.

Retrieving data from the database.

Filtering rows based on conditions.

Smashing rows together based on common values.

The WHERE clause for aggregated data.

Sorting your results.

Removing duplicate rows from your results.

Fetching data in chunks.

If/Else logic directly inside the database.

Queries inside of queries.

The performance killer of SQL.

Making complex SQL readable.

Navigating trees and hierarchies in SQL.

Combining data across multiple tables.

The strict intersection.

Keep everything on the left, even if there's no match.

The mirrored opposite of a Left Join.

Return everything from everywhere.

The Cartesian Product.

When a table joins with itself.

How databases find data instantly.

The mathematical engine behind SQL.

How data is physically stored on the hard drive.

Indexing multiple columns simultaneously.

The holy grail of SQL query optimization.

Enforcing absolute data integrity at the storage layer.

Indexing only the data you care about.

Why the database sometimes ignores your index.

The uniqueness of your data.

The hidden costs of over-indexing.

The mathematical guarantee that your database won't lose money.

Grouping queries into atomic units of work.

Balancing data accuracy with concurrency.

Reading data that never existed.

When the ground shifts beneath your feet.

When the database summons ghosts.

When perfect snapshots aren't enough.

Assuming the worst and locking the door.

Assuming everything will be fine, and failing gracefully if it isn't.

The mathematical process of eliminating data duplication.

The rule of atomic values.

Eliminating partial dependencies.

Eliminating transitive dependencies.

Intentionally breaking the rules for performance.

Splitting a single entity across two tables.

The foundation of relational databases.

Resolving complex relationships with Junction Tables.

When a foreign key points to multiple tables.

How the database actually runs your code.

Reading the entire book to find one word.

The most common ORM performance killer.

Why serverless functions crush your database.

Caching complex queries as physical tables.

Why the fastest query is the one you never run.

Optimizing execution and stopping hackers.

The most famous vulnerability in computer history.

Why PostgreSQL requires a garbage collector.

Splitting massive tables into smaller chunks.

How databases prevent chaos during concurrent access.

The Mexican Standoff of databases.

Why readers never block writers.

How databases survive power failures.

The mechanics of Shared vs Exclusive access.

Precision locking for high concurrency.

The nuclear option of database concurrency.

Performing math across rows without squashing them.

The top N per group problem.

Time travel across rows.

Virtual tables for security and simplicity.

Event listeners inside the database.

Writing full programs inside the database.

Writing your own SQL keywords.

Blurring the line between SQL and NoSQL.

Building a search engine without Elasticsearch.

Handling conflicts elegantly.

Throwing money at the problem.

Dividing and conquering the traffic.

Scaling read-heavy applications.

Scaling write-heavy applications.

How to physically divide the data.

How to add a server without breaking everything.

The great database war of the 2010s.

Storing JSON directly on the hard drive.

The ultimate caching layer.

When the relationships are more important than the data.

Writing data at the speed of light.

Identifying dirty data.

Surgically removing clones.

The most famous SQL interview question.

Adding it up as we go.

Smoothing out the spikes.

Comparing the present to the past.

Figuring out who comes back.

Avoiding the Three-Valued Logic trap.

The hardest part of software engineering.

Who manages the manager's manager?

Turning rows into columns.

Grouping continuous numbers into discrete buckets.

The classic window function test.

The 30-Day Active User metric.

Finding sequential groupings.

The classic Self-Join test.

Finding three-in-a-row.

The multi-column join challenge.