The relational model and your first SELECT through joins, aggregation, subqueries, set operations, writing data, and constraints — every query run against PostgreSQL 18, NULL and three-valued logic given a chapter of its own.
What SQL is really about — tables, rows, columns, and the relationships between them — why you describe the answer instead of looping to it, and how to connect to the bookshop and run your first SELECT. Run against PostgreSQL 18.
The SELECT clause in full — picking columns, computing new ones, naming them, and paging through results. Run against PostgreSQL 18.
The WHERE clause in full — comparisons, AND/OR/NOT and their precedence, BETWEEN, IN, and LIKE/ILIKE pattern matching. Run against PostgreSQL 18.
Why NULL means unknown, how three-valued logic propagates it, and the operators built to handle it — IS NULL, COALESCE, NULLIF, and the aggregate gotcha. Run against PostgreSQL 18.
Sorting results with multiple keys and NULL placement, de-duplicating with DISTINCT and Postgres DISTINCT ON, and the join bug DISTINCT can hide. Run against PostgreSQL 18.
The types every column carries — integers and the overflow that errors, why money is numeric and never float, text and boolean, the date/timestamp/timestamptz split, casting with :: and CAST, and the integer-division surprise. Run against PostgreSQL 18.
How the relational model reassembles data split across tables — INNER JOIN on a key, table aliases and qualified columns, LEFT JOIN to keep unmatched rows, joining three tables at once, and the one-to-many fan-out that silently multiplies your totals. Run against PostgreSQL 18.
Beyond inner and left — RIGHT and FULL OUTER joins and why MySQL lacks one, CROSS JOIN and its cardinality explosion, self-joins that pair a table against itself, and the anti-join for finding rows with no match, two ways. Run against PostgreSQL 18.
Collapsing rows into summaries — count/sum/avg/min/max, the difference between count(*), count(col), and count(DISTINCT), GROUP BY and the error that enforces it, HAVING versus WHERE, and the FILTER clause for conditional aggregates. Run against PostgreSQL 18.
Scalar subqueries, derived tables, IN, EXISTS, and correlated subqueries — plus the one NULL that quietly makes NOT IN return nothing, and the NOT EXISTS that fixes it. Run against PostgreSQL 18.
Combining whole query results the way set theory says you should — UNION versus UNION ALL and why the dedup costs you, INTERSECT for the overlap, EXCEPT for the difference, and the column rules that make it all line up. Run against PostgreSQL 18.
The three verbs that change data — INSERT with RETURNING, UPDATE and DELETE with the WHERE that saves you, the missing WHERE that doesn't, and ON CONFLICT for a clean upsert. Everything demonstrated in a scratch schema. Run against PostgreSQL 18.
Designing the table itself — column types, PRIMARY KEY and identity columns, and the five constraints (NOT NULL, UNIQUE, CHECK, DEFAULT, FOREIGN KEY) that reject bad data at the door, each shown by triggering its real error. Run against PostgreSQL 18.
BEGIN, COMMIT, and ROLLBACK — atomicity shown with the classic transfer, how a single error aborts the whole transaction until you roll back, and SAVEPOINT in a sentence. The last idea in the series, and the one that makes a database trustworthy. Run against PostgreSQL 18.