Pick the columns you need, rename them for clearer output, sort results, and limit long answers. These small skills make query results usable right away.

See how the relational model, early database systems, the SQL standard, and vendor dialects shaped the language people use today. This explains why SQL feels consistent across databases but never exactly identical.

Build the set-based mindset behind SQL: describe the rows you want, not a step-by-step loop over each record. You will connect predicates, relations, and result tables to everyday questions.

Use WHERE to keep only the rows that match clear conditions. You will work with comparisons, ranges, lists, patterns, and careful parentheses.

Handle NULL without getting fooled by missing or unknown values. This chapter covers IS NULL, COALESCE, three-valued logic, and common mistakes in filters and joins.

Create new output columns using arithmetic, string operations, CASE expressions, and type casts. You will turn raw fields into labels, categories, and calculated measures.

Read SQL in the logical order a database applies it: FROM, WHERE, GROUP BY, HAVING, SELECT, ORDER BY, and LIMIT. This gives you a reliable way to debug confusing query behavior.

Connect rows from two tables using matching keys. You will practice inner joins on realistic data and see how table aliases keep queries readable.

Use left, right, and full outer joins when unmatched rows still matter. You will learn how filter placement can accidentally turn an outer join into an inner join.

Spot many-to-many joins, duplicate keys, and accidental row multiplication before they corrupt your answer. You will use row counts and small checks to prove joins are doing what you think.

Use COUNT, SUM, AVG, MIN, and MAX to turn many rows into clear summaries. You will group by categories, dates, and combinations of fields.

Use HAVING, grouped CASE expressions, and conditional aggregates to answer sharper questions. You will compare groups, count only certain rows, and build simple business metrics.

Combine results with UNION, UNION ALL, INTERSECT, and EXCEPT. This chapter teaches when you are stacking similar answers, finding overlap, or removing one set from another.

Place one query inside another to filter, compare, or calculate from a smaller result. You will use scalar, IN, EXISTS, and correlated subqueries where they make the main query clearer.

Use common table expressions to break a hard query into named steps. You will practice writing SQL that another person can read, test, and safely change.

Use temporary tables when intermediate results need to be reused, inspected, or indexed. This chapter shows how staged SQL work differs from one long query.

Use window functions to rank rows, calculate running totals, compare with previous rows, and compute percentages without collapsing the result. These patterns are essential for analytics work.

Filter, group, and calculate with dates, times, time zones, intervals, and calendars. You will handle common reporting questions like month-to-date, rolling windows, and late events.

Clean practical data problems with trimming, splitting, replacing, rounding, casting, and safe conversion. You will make messy text and numbers ready for joins, reports, and checks.

Use INSERT, UPDATE, DELETE, MERGE, and upsert patterns without damaging data. You will practice previewing changes, using transactions, and writing reversible work.

Move data between files and tables using imports, exports, staging tables, and validation checks. This chapter covers CSV-style workflows that show up in many entry-level SQL jobs.

Create tables with data types that match the real values they will hold. You will choose between text, numbers, dates, booleans, identifiers, and database-specific types.

Protect data quality with primary keys, foreign keys, unique rules, NOT NULL rules, checks, and defaults. These constraints turn business rules into database guarantees.

Model one-to-one, one-to-many, and many-to-many relationships without repeating the same facts everywhere. You will use normalization to reduce update mistakes while still keeping queries practical.

Change table structures safely as an application or dataset grows. This chapter covers ALTER statements, migration files, rollback plans, and the risks of changing live data.

Use transactions to group related changes so they all succeed or all roll back. You will practice COMMIT, ROLLBACK, savepoints, and safe habits for production work.

Handle cases where many people or jobs read and write the same data at once. This chapter covers locks, isolation levels, deadlocks, and when stale reads can cause real problems.

Use indexes to speed up lookups, joins, sorting, and uniqueness checks. You will learn what indexes help, what they cost, and why not every column should be indexed.

Read execution plans to see how the database is actually running your query. You will tune slow SQL by checking scans, joins, filters, estimates, and index use.

Package repeated query logic into views and materialized views. You will see when a view improves clarity, when a materialized view improves speed, and how refresh rules matter.

Write database-side functions, stored procedures, and triggers for work that belongs close to the data. This chapter also covers the tradeoffs: hidden behavior, portability, testing, and maintenance.

Grant the right access with users, roles, schemas, row-level rules, masking, and audit trails. You will practice limiting damage while still letting people do their jobs.

Send SQL from application code using parameters, connection pools, transactions, and prepared statements. You will also see where ORMs help, where raw SQL is better, and how SQL injection happens.

Compare SQL features across PostgreSQL, MySQL, SQL Server, Oracle, SQLite, DuckDB, and analytical warehouses. This chapter builds the habit of checking standards, dialect notes, and portability risks.

Shape data for reports with metrics, pivots, date buckets, cohorts, and dashboard-friendly tables. You will build queries that produce numbers people can explain and trust.

Query event logs, sensor data, financial ticks, and other time-ordered records. You will use gaps, sessionization, rolling metrics, and retention patterns.

Use recursive CTEs to walk parent-child structures such as folders, org charts, bills of materials, and dependency trees. You will also learn the safety checks that keep recursion from running forever.

Store and query semi-structured data with JSON columns and JSON functions. You will extract fields, index common paths, and decide when JSON belongs in a relational table.

Work with points, lines, polygons, distances, and containment queries in spatial databases. This chapter covers practical location questions such as nearest stores, delivery zones, and regional counts.

Use cloud warehouse patterns such as column storage, separation of compute and storage, partitioning, clustering, and pay-per-query costs. You will tune SQL with both speed and budget in mind.

Query open table formats and large files through lakehouse engines. This chapter covers Parquet-style data, catalogs, partitions, schema evolution, and when lakehouse SQL differs from warehouse SQL.

Use streaming SQL to compute results as events arrive instead of after a batch finishes. You will work with windows, late data, watermarks, and live operational metrics.

Use embeddings and vector indexes from SQL to support similarity search and retrieval workflows. You will combine structured filters with nearest-neighbor search and check the limits of approximate matches.

Use AI tools to draft, explain, and refactor SQL while still checking correctness yourself. This chapter covers prompt patterns, schema context, test queries, privacy risks, and hallucinated results.

Test SQL with expected row counts, edge cases, sample fixtures, code review, comments, and documentation. You will build habits that prevent silent wrong answers.

Follow a realistic workflow from stakeholder question to source discovery, data checks, query design, performance tuning, validation, and delivery. You will produce a final dataset and explain the choices behind it.

Map SQL skills to roles in data analysis, analytics engineering, backend development, data engineering, database administration, and BI. You will plan portfolio projects, practice tasks, useful certifications, and ways to stay current as SQL tools evolve.