SQL COURSE GUIDE

SQL Tutorial – Full Database Course for Beginners

A chapter-by-chapter readback of the free course by Mike Dane on freeCodeCamp.org.

Length4:20:36
Chapters24
Modules6

Most SQL courses teach syntax against toy one-table examples. This one builds a single company database — employees, branches, clients, suppliers — and keeps querying it for three hours, so joins and keys stop being abstract the moment they appear.

Who it's for
Read this guide if
  • You want SQL from zero with a real running database, not slides
  • You learn relational design best by building one schema and living in it
  • You need joins and nested queries to finally make sense
Skip ahead if
  • You already write joins comfortably — go straight to the ER diagram chapters
  • You need PostgreSQL-specific features — the course uses MySQL
  • You want NoSQL or analytics warehouses — this is classic relational SQL
In brief
  • 4h 20m total, 25 chapters, average chapter ~10 minutes
  • Taught by Mike Dane using MySQL (installation covered for Windows and Mac)
  • One running example throughout: a company database with four linked tables
  • Ends with ER diagram design — the part most beginner courses skip
  • Companion code for the company database is linked in the video description

The walkthrough

Each chapter below is our original written explanation of what happens at that moment in the video — a paraphrase, not a transcript. Click any timestamp to jump the player.

Databases, Tables & Keys

0:00

Introduction

The course map: what SQL is, what the 25 chapters cover, and the promise that by the end you will have designed a real database schema, not just memorized SELECT statements.

2:36

What is a Database?

A long, careful grounding: databases versus spreadsheets, what a DBMS actually does, and why applications route their data through one instead of files. The MySQL vs other systems landscape gets a quick tour.

23:10

Tables & Keys

The relational model in one chapter: tables as grids of rows and columns, and the three key types — primary, foreign and surrogate — that let tables reference each other without duplicating data.

Getting MySQL Running & First Tables

43:31

SQL Basics

First statements: CREATE DATABASE, USE, SHOW TABLES. He stresses that SQL keywords are case-insensitive but uppercase is convention — a style point that makes code review easier forever.

52:26

MySQL Windows Installation

Downloading MySQL Server and Workbench on Windows, setting the root password, and confirming the server responds. Skip this chapter if you installed on Mac.

1:01:59

MySQL Mac Installation

The Mac path via the MySQL community installer, plus opening Workbench and connecting. Same destination as the Windows chapter — one working server.

1:15:49

Creating Tables

CREATE TABLE walks through data types: INT, VARCHAR, DATE and friends. He shows how to inspect a table's structure and why choosing types now shapes what data you can store later.

1:31:05

Inserting Data

INSERT INTO with single and multiple rows, and the first peek at the SELECT that proves the data landed. The habit he drills: insert a little, check a lot.

Constraints & Changing Data

1:38:17

Constraints

Rules that keep bad data out: NOT NULL, UNIQUE, DEFAULT, AUTO_INCREMENT and the CHECK idea. He frames constraints as guards that fail loudly at write time instead of corrupting reports later.

1:48:11

Update & Delete

UPDATE and DELETE with WHERE — and the legendary warning: without WHERE you update or delete every row. He shows the mistake on purpose, on a disposable table.

1:56:11

Basic Queries

The SELECT toolkit begins: WHERE with comparison and logical operators, ORDER BY, LIMIT, and DISTINCT. Most day-to-day SQL is variations of what fits in this one chapter.

The Company Database & Advanced Queries

2:08:37

Company Database Intro

Meet the course's spine: a company with branches, employees, clients and suppliers. The schema sketch on screen shows how four tables will hang together with foreign keys.

2:14:05

Creating Company Database

Building the schema for real: branch, employee, client and works_with tables, with primary and foreign keys declared. This file gets reused in every remaining chapter.

2:26:24

Functions

Aggregate functions — AVG, SUM, COUNT, MAX, MIN — and how NULL values quietly skip them. Counting things turns out to be subtler than it looks.

2:30:27

More Basic Queries

Deeper WHERE patterns: BETWEEN, IN, IS NULL, and pattern matching with LIKE. These are the filters that appear in almost every real report.

2:45:13

Wildcards

LIKE's wildcard characters % and _ and when each matches. A short chapter, but mistaking one for the other produces famously wrong results.

2:53:53

Union

UNION and UNION ALL stack result sets from two queries into one. The difference — deduplication versus speed — is the kind of detail that separates knowing syntax from knowing the engine.

Joins & Programmability

3:01:36

Joins

The chapter everyone waits for: combining the company tables. Inner joins, the different outer joins, and a visual explanation of which rows survive each type. This is where the hours of schema setup pay off.

3:11:49

Nested Queries

Subqueries — a SELECT inside another SELECT — for questions one query cannot ask directly, like employees who earn more than their branch average. He shows both the subquery and the JOIN alternative.

3:21:52

On Delete

Foreign key behaviors when a parent row disappears: RESTRICT, CASCADE, SET NULL. Deleting a branch and watching employees cascade is the clearest demonstration in the course.

3:30:05

Triggers

Code that runs on insert, update or delete — a trigger that audits salary changes shows the idea. He notes triggers are powerful and easy to overuse, a judgment call most courses skip.

Designing Databases

3:42:12

ER Diagrams Intro

Entity-relationship diagrams as the blueprint language for schemas: entities, attributes, relationships, and the crow's-foot notation that shows one-to-many at a glance.

3:55:53

Designing an ER Diagram

The finale starts: translating a written business description into an ER diagram on a whiteboard. Identifying entities and their relationships is presented as the actual skill of database design.

4:15:14

Converting ER Diagrams to Schemas

The final step: turning the diagram into CREATE TABLE statements, choosing keys and placing foreign keys correctly. Watching the full pipeline close — words to diagram to working schema — is why this course beats syntax drills.

Moment by moment

TimeWhy it matters
23:10Tables & Keys — the mental model the whole course uses
1:56:11Basic Queries — the 80% of everyday SQL
3:01:36Joins — where the company database pays off
3:11:49Nested Queries — asking questions about aggregates
4:15:14ER to Schema — the design pipeline closes

Do this next

  1. Recreate the company database from memory, then check against the video
  2. Design an ER diagram for a library or a food-delivery service, then convert it
  3. Follow with a window-functions course — this one ends where analytics SQL begins

Common questions

MySQL, PostgreSQL or SQLite — does the course transfer?

Everything core (SELECT, JOIN, constraints, subqueries, ER design) is standard SQL that works across all three. MySQL-specific bits: the installation chapters and minor type names. PostgreSQL and SQLite users lose almost nothing.

Do I need to install MySQL to follow along?

No — any SQL runner works. The course's own companion files target MySQL, but DB Fiddle, SQLite in your browser, or a PostgreSQL sandbox run every query in the guide chapters.

Is the course practical or theoretical?

Both, deliberately: syntax chapters run against the one company database, and the final three chapters are pure design methodology (ER diagrams). It is closer to a semester course than a tutorial.

How current is the material?

Core SQL has been stable for decades — every statement shown still runs. Newer features like window functions and CTEs are not covered; treat those as the natural next course.

Spot a mistake?

Every summary on this page was written by a person watching the course, and we still miss things. If a chapter summary gets a concept wrong or a timestamp drifts, tell us at support@readcast.dev and we will check the video and fix it — usually within a day.

More course guides