SQL: Query, Model, and Analyze Data

Relational foundations

1. Databases, SQL, and the relational modelUnderstand what a database does, where SQL fits, and why relational data is organized into related tables.
   90 min
2. Tables, rows, columns, and schemasSee how a relational database stores records and why a schema gives those records a reliable shape.
   105 min
3. Data types and NULLChoose useful numeric, text, date, boolean, and binary types, then reason correctly about absent values.
   120 min
4. Primary keys, foreign keys, and relationshipsConnect related data with keys and explicit one-to-one, one-to-many, and many-to-many relationships.
   130 min

Reading and filtering data

5. Your first SELECT queryRead specific columns, give them useful aliases, and make a query easy for another developer to review.
   110 min
6. Conditions with WHEREFilter precisely with comparisons, AND, OR, NOT, IN, BETWEEN, and parentheses that make the logic unambiguous.
   125 min
7. Sorting, limiting, and distinct valuesControl result order, return a useful page of data, and remove duplicates only when that answers the real question.
   120 min
8. Text, dates, patterns, and conditional resultsWork with strings, date ranges, LIKE patterns, CASE expressions, and portable functions without losing query clarity.
   130 min

Reports, aggregation, and analytics

9. Aggregate functionsSummarize data with COUNT, SUM, AVG, MIN, and MAX while recognizing what each result really represents.
   125 min
10. GROUP BY and HAVINGBuild grouped reports, filter those groups correctly, and avoid common aggregation mistakes.
    130 min
11. Window functionsCalculate rankings, running totals, moving values, and per-group comparisons without collapsing the result set.
    135 min
12. Common table expressionsBreak a complicated reporting query into named, reviewable steps with CTEs and recursive queries.
    135 min

Combining related data

13. INNER, LEFT, RIGHT, and FULL joinsChoose the join that matches the question and predict which rows remain when a relationship is missing.
    13 · Planned
14. Self joins and many-to-many dataModel hierarchies and bridge tables without duplicating records or losing the meaning of a relationship.
    14 · Planned
15. Subqueries and correlated subqueriesUse nested queries when they express the problem clearly, and recognize when a join or CTE is safer.
    15 · Planned
16. UNION, INTERSECT, and EXCEPTCombine compatible result sets and understand how each set operation handles duplicates.
    16 · Planned

Designing reliable schemas

17. CREATE TABLE and schema designTurn an application requirement into tables, columns, and names that stay understandable as the system grows.
    17 · Planned
18. Constraints and data integrityUse NOT NULL, UNIQUE, CHECK, DEFAULT, and foreign keys so invalid data is rejected at the right boundary.
    18 · Planned
19. Normalization and intentional denormalizationReduce duplication and update anomalies, then identify the rare cases where a denormalized shape is justified.
    19 · Planned
20. Views and materialized viewsCreate reusable, safe interfaces to complex data and know when a stored result needs refreshing.
    20 · Planned

Writing and protecting data

21. INSERT, UPDATE, and DELETEChange records intentionally, target the right rows, and preview a data change before it reaches production.
    21 · Planned
22. Upserts and conflict handlingInsert or update safely when a row may already exist, without relying on fragile application-side checks.
    22 · Planned
23. Transactions and savepointsGroup related changes into all-or-nothing work and recover safely when one step cannot succeed.
    23 · Planned
24. Isolation, locks, and concurrencyUnderstand simultaneous access, deadlocks, and the trade-offs that protect correctness under load.
    24 · Planned

Performance and administration

25. Indexes and access pathsChoose indexes that help real queries while understanding their storage and write-time costs.
    25 · Planned
26. EXPLAIN and query plansRead a query plan, find expensive work, and verify whether an optimization actually changes execution.
    26 · Planned
27. Query tuning patternsAvoid unnecessary scans, repeated work, accidental Cartesian products, and inefficient pagination.
    27 · Planned
28. Backups, restores, and migrationsMove schema changes safely and plan recovery before data loss turns into an emergency.
    28 · Planned

Security and production workflow

29. Users, roles, and least privilegeGive people and applications only the permissions they need, then audit those access boundaries.
    29 · Planned
30. Preventing SQL injectionUse parameterized queries and clear ownership boundaries instead of building executable SQL from user input.
    30 · Planned
31. Stored procedures, functions, and triggersDecide when database-side behavior belongs in a reusable function, a trigger, or the application layer.
    31 · Planned
32. Production data projectApply the complete path by modeling a small application, querying it, protecting changes, and reviewing performance.
    32 · Planned