SQL & Databases

Every column has a type — numbers, text, true/false, dates. Choosing well prevents bugs forever.

What it means when a cell has no value at all — and why NULL is not zero or empty text.

Every row needs a unique, permanent ID. That's the primary key — the anchor of every table.

How a column in one table points at rows in another — the 'relational' in relational databases.

No new concepts — realistic reps over tables, types, NULL, and keys.

Choosing exactly which columns you want — the foundation of every query.

Doing math in SELECT and renaming output columns with AS.

Keep only the rows that match a condition — the single most important clause in SQL.

Why WHERE phone = NULL finds nothing, and the right way to filter missing values.

Rows come back in arbitrary order unless you say otherwise. ORDER BY is how you say otherwise.

Top-N lists, pagination, and collapsing duplicate values.

No new concepts — realistic query-reading reps over everything in Module 2.

Combining multiple conditions in one WHERE clause.

What happens when AND and OR mix — and the one rule that prevents the classic filtering bug.

Searching text with wildcards — the SQL behind every search box.

Range filters for numbers and dates — and the date-range pattern professionals actually use.

Matching against a list of values — and the NOT IN + NULL trap every developer hits once.

No new concepts — combined filtering reps: logic, patterns, ranges, lists, and the NULL traps.

LOWER, UPPER, LENGTH, TRIM, and friends — cleaning and shaping text inside queries.

ROUND and friends, the integer division surprise, and converting between types with ::

NOW, INTERVAL arithmetic, EXTRACT, and DATE_TRUNC — the four tools behind every time-based report.

Finally, the tools that FIX NULLs: fallback values with COALESCE, and NULLIF for divide-by-zero armor.

No new concepts — text, numbers, dates, and NULL-taming combined into realistic report expressions.

Collapsing many rows into one answer: totals, averages, and extremes.

COUNT(*) vs COUNT(column) vs COUNT(DISTINCT …) — and how every aggregate quietly skips NULLs.

One aggregate per category instead of one for the whole table — the most important reporting tool in SQL.

One bucket per combination — the pattern behind pivot-style business reports.

WHERE filters rows before grouping; HAVING filters the groups after — and the full execution order.

No new concepts — realistic report-building reps with COUNT, SUM, AVG, GROUP BY, and HAVING.

Your data is split across tables on purpose — joins are how you put it back together.

The default join: only rows with a match on both sides survive — plus chaining three or more tables.

Keep every row from the left table, matched or not — the join for 'ALL customers, with orders if any'.

LEFT JOIN + IS NULL = find rows with NO match: customers who never bought, products that never sold.

Keeping unmatched rows from BOTH sides, and joining a table to itself for hierarchies.

Order counts per customer, revenue per product — Modules 5 and 6 combined, plus the COUNT(*) vs COUNT(col) payoff.

No new concepts — join-type choices, anti-joins, and join+group pipelines on a realistic schema.

Building your own tables at last — columns, types, and the rules that guard your data.

Adding rows — one, many, or straight from a query — and getting the new id back.

Changing and removing rows, the missing-WHERE catastrophe, and the SELECT-first safety ritual.

Insert-or-update in one atomic statement — no race conditions, no check-then-write dance.

All-or-nothing groups of statements — the guarantee that makes databases trustworthy with money.

No new concepts — DDL reading, safe writes, upserts, and transaction judgment calls.

Every schema is built from three relationship shapes — here are the first two, and where the FK goes.

When both sides are 'many', no FK fits either table — the junction table solves it.

When a parent row dies, what happens to its children? You decide — per foreign key.

Every fact in exactly one place — the principle behind 'store the id, not a copy', formalized.

The full method, start to finish: requirements → entities → relationships → constraints, on a real blog schema.

No new concepts — you design a food-delivery schema decision by decision.

A query inside a query — when the filter itself needs computing first.

Name your subqueries and read complex SQL top-to-bottom like a recipe.

Conditional logic in queries — labels, buckets, and the mighty conditional-aggregation pattern.

Stacking and comparing whole result sets — SQL's Venn-diagram operators.

The 'is there at least one?' test — correlated subqueries, and the NULL-proof answer to NOT IN.

Aggregates that DON'T collapse rows — every row keeps its identity and gains a group statistic.

Numbering and ranking rows — and the top-N-per-group pattern, SQL interview question #1.

Peeking at neighboring rows and accumulating as you go — growth rates and cumulative charts.

No new concepts — subqueries, CTEs, CASE, EXISTS, and windows, combined like production analytics.

Why a 10-million-row lookup takes milliseconds — and why you can't just index everything.

Multi-column indexes and the leftmost-prefix rule, plus indexing expressions and subsets.

Read the database's own execution plan, then fix the classic slow-query patterns.

No new concepts — you're on call, and four slow queries just paged you.

Name a query once, use it like a table forever — plus materialized views for expensive reports.

The most famous attack in software — how it works, the one true defense, and locking down access.

pg_dump, point-in-time recovery, and the rule that an untested backup doesn't exist.

Connection strings, pooling, ORMs vs raw SQL, and migrations — the bridge to backend development.

Revenue reports, customer lifetime value, and growth rates — the queries every analytics job runs daily.

Followers, mutuals, and activity feeds — graph problems in relational clothing.

Rolling averages, running totals, and cohort retention — the three patterns behind every BI dashboard.

One final build — schema, integrity, queries, performance, and analytics for a whole product. Then: what's next.