🎯 Programme SQL : Du niveau débutant à intermédiaire · Modai Lab

Guide structuré · Apprendre dans le bon ordre · Lecture : ~20 min Teste ton niveau actuel avec le test SQL

Pourquoi ce guide existe

La plupart des gens copient des requêtes SQL générées par une IA. Ils ne comprennent pas ce qu’ils font. Et ça se voit dès que le problème change d’une ligne.

L’IA ne remplace pas les bases. Elle les accélère. Mais encore faut-il savoir lire ce qu’elle produit — et repérer quand elle se trompe.

Ce guide est fait pour toi si :

Tu sais écrire une requête basique mais tu ne sais pas vraiment pourquoi elle fonctionne
Tu copies des requêtes sans pouvoir les adapter
Tu veux un programme structuré, dans le bon ordre, avec des outils concrets

Ce que tu reçois :

Un programme complet du niveau débutant à intermédiaire
Les concepts clés à maîtriser dans le bon ordre
Des prompts pour t’entraîner avec l’IA à chaque étape
La plateforme recommandée pour passer au niveau supérieur

🧪 Où en es-tu vraiment ? Avant de commencer ce programme, mesure ton niveau actuel. Le test prend 5 minutes et te dit exactement où démarrer. 👉 Faire le test de niveau Résultat en direct · Niveau calibré · Programme personnalisé

Comment utiliser ce programme

Ce programme est découpé en 4 niveaux, chacun avec :

Les concepts à maîtriser (dans l’ordre)
Les exercices pratiques pour valider la compréhension
Un prompt IA pour s’entraîner sans avoir de dataset
Le signal de passage au niveau suivant

Durée estimée par niveau :

Niveau	Concepts	Durée estimée	Prérequis
Niveau 1 — Fondations	SELECT, WHERE, ORDER BY	1 à 2 jours	Aucun
Niveau 2 — Agrégations	GROUP BY, fonctions d’agrégation	2 à 3 jours	Niveau 1
Niveau 3 — Relations	JOIN, sous-requêtes	3 à 5 jours	Niveau 2
Niveau 4 — Analyse	Fenêtres, CTE, NULL	5 à 7 jours	Niveau 3

NIVEAU 1 — Les fondations (débutant)

Objectif : comprendre comment SQL lit et filtre les données

Concept 1.1 — L’ordre d’exécution SQL

Pourquoi c’est fondamental

La plupart des bugs de débutants viennent d’une incompréhension de l’ordre dans lequel SQL exécute les clauses. Ce n’est pas l’ordre dans lequel tu écris.

Ordre d'écriture : SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY

Ordre d'exécution : FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY

programme-sql-debutant-intermediaire · 01

Ce que ça change concrètement :

-- ❌ Erreur classique de débutant

SELECT montant * . AS montant_remise

FROM orders

WHERE montant_remise > ; -- erreur : montant_remise n'existe pas encore

-- SELECT est exécuté APRÈS WHERE → l'alias n'est pas encore défini

-- ✅ Correction

SELECT montant * . AS montant_remise

FROM orders

WHERE montant * . > ; -- répéter le calcul dans WHERE

-- ou utiliser une sous-requête

programme-sql-debutant-intermediaire · 02 · Ce que ça change concrètement :

Concept 1.2 — SELECT : choisir ses colonnes

-- Sélectionner des colonnes spécifiques

SELECT nom, email, created_at FROM users;

-- Renommer avec un alias

SELECT nom AS client, email AS contact FROM users;

-- Calculer à la volée

SELECT

nom,

prix,

quantite,

prix * quantite AS total_ligne

FROM order_lines;

-- Sélectionner tout (uniquement pour explorer, jamais en production)

SELECT * FROM users LIMIT ;

programme-sql-debutant-intermediaire · 03

Concept 1.3 — WHERE : filtrer les lignes

-- Filtres simples

SELECT * FROM users WHERE pays = 'France';

SELECT * FROM orders WHERE montant > ;

SELECT * FROM users WHERE created_at >= '2024-01-01';

-- Opérateurs logiques

SELECT * FROM orders

WHERE montant >

AND statut = 'livré';

SELECT * FROM users

WHERE pays = 'France'

OR pays = 'Belgique';

-- IN : liste de valeurs

SELECT * FROM users WHERE pays IN ('France', 'Belgique', 'Suisse');

-- BETWEEN : intervalle

SELECT * FROM orders WHERE montant BETWEEN AND ;

-- LIKE : recherche de pattern

SELECT * FROM users WHERE nom LIKE 'Du%'; -- commence par Du

SELECT * FROM users WHERE email LIKE '%@gmail.com'; -- finit par @gmail.com

-- IS NULL : valeur absente

SELECT * FROM users WHERE telephone IS NULL;

SELECT * FROM users WHERE telephone IS NOT NULL;

programme-sql-debutant-intermediaire · 04

Concept 1.4 — ORDER BY et LIMIT

-- Trier par ordre croissant (défaut)

SELECT * FROM orders ORDER BY created_at;

-- Trier par ordre décroissant

SELECT * FROM orders ORDER BY montant DESC;

-- Trier sur plusieurs colonnes

SELECT * FROM orders ORDER BY pays ASC, montant DESC;

-- Limiter le nombre de résultats

SELECT * FROM orders ORDER BY montant DESC LIMIT ;

-- Pagination

SELECT * FROM orders ORDER BY created_at DESC LIMIT OFFSET ;

-- Retourne les lignes 41 à 60

programme-sql-debutant-intermediaire · 05

🤖 Prompt IA pour pratiquer le Niveau 1

Tu es un professeur SQL. Génère 5 exercices progressifs sur les bases SQL

(SELECT, WHERE, ORDER BY, LIMIT) pour un débutant complet.

Pour chaque exercice :

1. Décris un contexte métier simple (e-commerce, app mobile, etc.)

2. Donne le schéma de la table (CREATE TABLE avec 4-5 colonnes)

3. Pose une question en français

4. Donne la solution commentée

5. Propose une variation légèrement plus difficile

Commence par le plus simple et augmente la difficulté progressivement.

programme-sql-debutant-intermediaire · 06

✅ Signal de passage au Niveau 2

Tu peux passer au niveau 2 quand tu sais :

☐ Écrire un SELECT avec des colonnes spécifiques et des alias
☐ Filtrer avec WHERE, AND, OR, IN, BETWEEN, LIKE, IS NULL
☐ Trier les résultats avec ORDER BY
☐ Limiter les résultats avec LIMIT et OFFSET
☐ Expliquer pourquoi WHERE alias = valeur ne fonctionne pas

🧪 Valide les fondations sur Modai Lab Les exercices du Niveau 1 sont directement disponibles sur Modai Lab. Pratique sur de vraies données, avec correction automatique. 👉 Pratiquer le Niveau 1 Exercices progressifs · Datasets réels · Feedback immédiat

NIVEAU 2 — Les agrégations (débutant+)

Objectif : transformer des lignes de données en métriques utiles

Concept 2.1 — GROUP BY : regrouper pour calculer

-- Compter les commandes par pays

SELECT pays, COUNT(*) AS nb_commandes

FROM orders

GROUP BY pays;

-- Sommer le CA par mois

SELECT

DATE_TRUNC('month', created_at) AS mois,

SUM(montant) AS ca_mensuel

FROM orders

GROUP BY DATE_TRUNC('month', created_at)

ORDER BY mois;

-- Grouper sur plusieurs colonnes

SELECT pays, statut, COUNT(*) AS nb

FROM orders

GROUP BY pays, statut

ORDER BY pays, nb DESC;

programme-sql-debutant-intermediaire · 07

La règle fondamentale de GROUP BY :

Toute colonne dans le SELECT qui n’est pas une fonction d’agrégation doit être dans le GROUP BY.

-- ❌ Erreur

SELECT pays, nom, COUNT(*) -- nom n'est pas agrégé ni dans GROUP BY

FROM orders

GROUP BY pays;

-- ✅ Correct

SELECT pays, COUNT(*) FROM orders GROUP BY pays;

SELECT pays, nom, COUNT(*) FROM orders GROUP BY pays, nom;

programme-sql-debutant-intermediaire · 08

Concept 2.2 — Les fonctions d’agrégation

SELECT

COUNT(*) AS total_lignes, -- compte toutes les lignes

COUNT(montant) AS lignes_avec_montant, -- ignore les NULL

COUNT(DISTINCT pays) AS pays_distincts, -- valeurs uniques

SUM(montant) AS ca_total,

AVG(montant) AS panier_moyen,

MIN(montant) AS plus_petit_achat,

MAX(montant) AS plus_grand_achat,

ROUND(AVG(montant), ) AS panier_moyen_arrondi

FROM orders;

programme-sql-debutant-intermediaire · 09

Concept 2.3 — HAVING : filtrer après agrégation

-- WHERE filtre avant agrégation, HAVING filtre après

-- Pays avec plus de 100 commandes

SELECT pays, COUNT(*) AS nb

FROM orders

GROUP BY pays

HAVING COUNT(*) >

ORDER BY nb DESC;

-- Clients avec un CA total supérieur à 500€

SELECT user_id, SUM(montant) AS ca_total

FROM orders

GROUP BY user_id

HAVING SUM(montant) > ;

-- Combiner WHERE et HAVING

SELECT pays, COUNT(*) AS nb_commandes_livrees

FROM orders

WHERE statut = 'livré' -- filtre les lignes d'abord

GROUP BY pays

HAVING COUNT(*) > -- filtre les groupes ensuite

ORDER BY nb_commandes_livrees DESC;

programme-sql-debutant-intermediaire · 10

Concept 2.4 — Agréger avec des conditions (CASE WHEN)

-- Compter les commandes par statut dans une seule ligne par pays

SELECT

pays,

COUNT(*) AS total,

COUNT(CASE WHEN statut = 'livré' THEN END) AS livrees,

COUNT(CASE WHEN statut = 'annulé' THEN END) AS annulees,

ROUND(

. * COUNT(CASE WHEN statut = 'livré' THEN END) / COUNT(*),

) AS taux_livraison_pct

FROM orders

GROUP BY pays;

programme-sql-debutant-intermediaire · 11

🤖 Prompt IA pour pratiquer le Niveau 2

Tu es un professeur SQL. Génère 5 exercices sur GROUP BY, les fonctions

d'agrégation et HAVING pour un débutant qui vient de comprendre SELECT/WHERE.

Contexte : une base e-commerce avec les tables suivantes :

- users (id, nom, email, pays, created_at)

- orders (id, user_id, montant, statut, created_at)

- order_lines (id, order_id, product_id, quantite, prix_unitaire)

- products (id, nom, categorie, prix)

Pour chaque exercice :

1. Une question métier réaliste ("quel est le CA par catégorie ?")

2. La requête correcte avec commentaires

3. Un piège courant à éviter (ex: oublier une colonne dans GROUP BY)

4. Une question de relance légèrement plus difficile

Inclure au moins un exercice avec HAVING et un avec CASE WHEN dans SELECT.

programme-sql-debutant-intermediaire · 12

✅ Signal de passage au Niveau 3

☐ Je comprends pourquoi toute colonne non agrégée doit être dans GROUP BY
☐ Je sais utiliser COUNT(*), COUNT(col), SUM(), AVG(), MIN(), MAX()
☐ Je sais faire la différence entre WHERE et HAVING
☐ Je peux compter des événements conditionnels avec CASE WHEN dans SELECT
☐ Je peux expliquer pourquoi AVG() ignore les NULL

🧪 Teste les agrégations GROUP BY et HAVING sont systématiquement testés en entretien data. Vérifie que tes réflexes sont bons avant de passer au niveau suivant. 👉 Tester les agrégations Score immédiat · Explication des erreurs · Niveau calibré

NIVEAU 3 — Les relations (intermédiaire)

Objectif : interroger plusieurs tables à la fois et comprendre les modèles de données

Concept 3.1 — Les JOIN : relier les tables

-- INNER JOIN : seulement les correspondances des deux côtés

SELECT u.nom, o.montant, o.created_at

FROM users u

INNER JOIN orders o ON u.id = o.user_id;

-- LEFT JOIN : tous les users, même sans commande

SELECT u.nom, COUNT(o.id) AS nb_commandes

FROM users u

LEFT JOIN orders o ON u.id = o.user_id

GROUP BY u.id, u.nom;

-- Jointure sur plusieurs tables

SELECT

u.nom AS client,

o.id AS order_id,

p.nom AS produit,

ol.quantite,

ol.prix_unitaire

FROM users u

JOIN orders o ON u.id = o.user_id

JOIN order_lines ol ON o.id = ol.order_id

JOIN products p ON ol.product_id = p.id

WHERE o.created_at >= '2024-01-01';

programme-sql-debutant-intermediaire · 13

Les 4 types de JOIN en une image :

JOIN	Ce qu’il retourne
`INNER JOIN`	Lignes avec correspondance des deux côtés
`LEFT JOIN`	Toutes les lignes de gauche + correspondances de droite
`RIGHT JOIN`	Correspondances de gauche + toutes les lignes de droite
`FULL OUTER JOIN`	Toutes les lignes des deux tables

Concept 3.2 — Le piège du LEFT JOIN silencieux

-- ❌ WHERE sur la table de droite transforme LEFT JOIN en INNER JOIN

SELECT u.nom, o.montant

FROM users u

LEFT JOIN orders o ON u.id = o.user_id

WHERE o.statut = 'livré'; -- élimine les NULL → INNER JOIN déguisé

-- ✅ Filtre dans le ON pour préserver le LEFT JOIN

SELECT u.nom, o.montant

FROM users u

LEFT JOIN orders o

ON u.id = o.user_id

AND o.statut = 'livré';

programme-sql-debutant-intermediaire · 14

Concept 3.3 — Les sous-requêtes

-- Sous-requête dans WHERE

SELECT nom, montant

FROM orders

WHERE montant > (SELECT AVG(montant) FROM orders);

-- Sous-requête dans FROM (table dérivée)

SELECT u.nom, stats.nb_commandes

FROM users u

JOIN (

SELECT user_id, COUNT(*) AS nb_commandes

FROM orders

GROUP BY user_id

) stats ON u.id = stats.user_id;

-- EXISTS : tester la présence

SELECT nom

FROM users u

WHERE EXISTS (

SELECT FROM orders o WHERE o.user_id = u.id

);

-- NOT EXISTS : tester l'absence

SELECT nom

FROM users u

WHERE NOT EXISTS (

SELECT FROM orders o WHERE o.user_id = u.id

);

programme-sql-debutant-intermediaire · 15

Concept 3.4 — Lire un modèle de données

Avant d’écrire une requête sur plusieurs tables, pose-toi ces questions :

1. Quelle est la granularité de chaque table ?

→ Une ligne par user ? Par commande ? Par événement ?

2. Quelles sont les clés de jointure ?

→ orders.user_id → users.id

→ order_lines.order_id → orders.id

3. Quelle est la cardinalité ?

→ 1 user peut avoir N commandes (1:N)

→ 1 commande peut avoir N lignes (1:N)

→ Si je join sans agréger, j'aurai N × M lignes

programme-sql-debutant-intermediaire · 16

🤖 Prompt IA pour pratiquer le Niveau 3

Tu es un expert SQL data analytics. Crée 5 exercices progressifs sur les

jointures SQL pour quelqu'un qui maîtrise SELECT/WHERE/GROUP BY.

Base de données :

- users (id, nom, email, pays, segment, created_at)

- orders (id, user_id, montant, statut, created_at)

- order_lines (id, order_id, product_id, quantite, prix_unitaire)

- products (id, nom, categorie, prix_achat, prix_vente)

- campaigns (id, nom, canal, budget)

- user_events (id, user_id, campaign_id, event_type, created_at)

Exercice 1 : INNER JOIN simple (2 tables)

Exercice 2 : LEFT JOIN avec compréhension du résultat NULL

Exercice 3 : JOIN sur 3 tables

Exercice 4 : Piège du LEFT JOIN silencieux (WHERE sur table de droite)

Exercice 5 : Sous-requête dans FROM pour éviter le fan-out

Pour chaque exercice : contexte métier, question, requête fausse courante,

requête correcte commentée, explication du piège.

programme-sql-debutant-intermediaire · 17

✅ Signal de passage au Niveau 4

☐ Je sais faire un INNER, LEFT, et FULL OUTER JOIN
☐ Je comprends pourquoi un LEFT JOIN + WHERE peut se transformer en INNER JOIN
☐ Je peux joindre 3 tables sans créer de doublons involontaires
☐ Je comprends ce qu’est un fan-out et comment le détecter
☐ Je sais utiliser EXISTS et NOT EXISTS à la place d’un JOIN + IS NULL

🧪 Valide les jointures sur Modai Lab Les JOIN sont le thème le plus fréquent en entretien data. Modai Lab propose des exercices spécifiques avec détection des LEFT JOINs silencieux. 👉 Valider mes jointures Datasets réalistes · Pièges détectés · Feedback ligne par ligne

NIVEAU 4 — L’analyse avancée (intermédiaire)

Objectif : écrire des requêtes analytiques que les seniors utilisent en production

Concept 4.1 — Les CTE : structurer et lire sa logique

-- Sans CTE : une requête imbriquée difficile à lire

SELECT u.nom, stats.ca, stats.nb

FROM users u

JOIN (

SELECT user_id, SUM(montant) AS ca, COUNT(*) AS nb

FROM orders

WHERE created_at > '2024-01-01'

GROUP BY user_id

) stats ON u.id = stats.user_id

WHERE stats.ca > ;

-- Avec CTE : lisible, maintenable, testable étape par étape

WITH

commandes_2024 AS (

SELECT user_id, SUM(montant) AS ca, COUNT(*) AS nb

FROM orders

WHERE created_at > '2024-01-01'

GROUP BY user_id

clients_premium AS (

SELECT user_id FROM commandes_2024 WHERE ca >

)

SELECT u.nom, c.ca, c.nb

FROM users u

JOIN commandes_2024 c ON u.id = c.user_id

WHERE u.id IN (SELECT user_id FROM clients_premium)

ORDER BY c.ca DESC;

programme-sql-debutant-intermediaire · 18

Concept 4.2 — Les fonctions de fenêtre (window functions)

-- ROW_NUMBER : numéroter les lignes dans un groupe

SELECT

user_id,

order_id,

montant,

created_at,

ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC) AS rang

FROM orders;

-- rang = 1 → la commande la plus récente de chaque user

-- Récupérer la dernière commande par user

SELECT *

FROM (

SELECT *,

ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC) AS rn

FROM orders

) t

WHERE rn = ;

-- LAG : comparer avec la valeur précédente

SELECT

mois,

ca,

LAG(ca) OVER (ORDER BY mois) AS ca_precedent,

ca - LAG(ca) OVER (ORDER BY mois) AS variation

FROM revenus_mensuels;

-- SUM cumulatif

SELECT

date_vente,

montant,

SUM(montant) OVER (ORDER BY date_vente) AS cumul

FROM ventes;

programme-sql-debutant-intermediaire · 19

Concept 4.3 — Maîtriser NULL (vraiment)

-- NULL ≠ zéro, NULL = valeur inconnue

-- Toute comparaison avec NULL retourne UNKNOWN

-- ❌ Ne fonctionne jamais

SELECT * FROM users WHERE telephone = NULL;

-- ✅ Toujours utiliser IS NULL / IS NOT NULL

SELECT * FROM users WHERE telephone IS NULL;

-- COALESCE : valeur par défaut si NULL

SELECT nom, COALESCE(telephone, 'Non renseigné') AS tel FROM users;

-- Attention aux agrégations

SELECT

COUNT(*) AS toutes_lignes, -- compte les NULL

COUNT(montant) AS lignes_renseignees, -- ignore les NULL

SUM(montant) AS ca, -- ignore les NULL

AVG(montant) AS moyenne -- ignore les NULL (dénominateur réduit)

FROM orders;

programme-sql-debutant-intermediaire · 20

Concept 4.4 — Penser en ensemble, pas en boucle

La différence de mentalité entre quelqu’un qui “code” du SQL et quelqu’un qui “pense” en SQL.

-- Mentalité boucle (approche non-SQL)

-- "Pour chaque utilisateur, je cherche sa dernière commande"

-- → sous-requête corrélée = 1 requête par ligne

-- Mentalité ensemble (approche SQL)

-- "Je prends toutes les commandes, je les classe par user et par date,

-- et je garde la première de chaque groupe"

-- → une seule opération sur l'ensemble complet

WITH derniere_commande AS (

SELECT *,

ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC) AS rn

FROM orders

)

SELECT * FROM derniere_commande WHERE rn = ;

-- Une seule passe sur toutes les données. Performant. Lisible.

programme-sql-debutant-intermediaire · 21

🤖 Prompt IA pour pratiquer le Niveau 4

Tu es un data analyst senior. Crée 5 exercices de niveau intermédiaire

sur les CTE et les window functions SQL.

Base de données e-commerce :

- users (id, nom, email, pays, segment, created_at)

- orders (id, user_id, montant, statut, created_at)

Exercice 1 : CTE pour remplacer une sous-requête imbriquée

Exercice 2 : ROW_NUMBER pour le top 1 par groupe

Exercice 3 : LAG pour calculer une variation mois/mois

Exercice 4 : SUM cumulatif avec OVER (ORDER BY)

Exercice 5 : Combinaison CTE + window function (rapport complet)

Pour chaque exercice :

- La question métier (ex: "calcule la variation de CA mensuel")

- La version sans window function (sous-requête corrélée)

- La version avec window function (plus performante)

- L'explication de la clause OVER et PARTITION BY

programme-sql-debutant-intermediaire · 22

✅ Tu es au niveau intermédiaire quand :

☐ Je comprends et j’utilise les CTE (WITH ... AS (...))
☐ Je sais utiliser ROW_NUMBER, LAG, LEAD et SUM avec OVER
☐ Je comprends PARTITION BY et ORDER BY dans une window function
☐ Je gère NULL correctement dans mes agrégations et comparaisons
☐ Je pense en “ensemble” plutôt qu’en “boucle”
☐ Je peux expliquer mes requêtes à un collègue non-technique

🧪 Teste ton niveau intermédiaire Le test couvre les 4 niveaux de ce programme. Après l’avoir complété, tu sais exactement sur quoi travailler en priorité. 👉 Passer le test complet Test complet · Score par niveau · Plan de progression personnalisé

PARTIE 5 — Les prompts universels pour apprendre avec l’IA

Utilise ces prompts à tout moment de ton apprentissage.

Prompt “Explique-moi”

J'apprends SQL et je ne comprends pas [concept].

Explique-moi avec :

1. Une analogie du quotidien (pas de jargon)

2. Un exemple simple avec une table de 5 lignes

3. L'erreur classique que font les débutants avec ce concept

4. Un exercice pour vérifier que j'ai compris

Concept à expliquer : [GROUP BY / LEFT JOIN / NULL / window functions / etc.]

programme-sql-debutant-intermediaire · 23

Prompt “Génère un exercice”

Génère un exercice SQL de niveau [débutant / intermédiaire] sur [concept].

Contexte : une app SaaS avec :

- users (id, nom, email, plan, created_at, churned_at)

- events (id, user_id, type, created_at)

- invoices (id, user_id, montant, statut, created_at)

Format :

1. Question métier en français

2. Schéma des tables concernées

3. Résultat attendu (3-5 lignes exemple)

4. Solution commentée

5. Question bonus légèrement plus difficile

programme-sql-debutant-intermediaire · 24

Prompt “Audite ma requête”

Voici une requête SQL que j'ai écrite. Dis-moi :

1. Est-ce qu'elle est correcte pour répondre à la question ?

2. Y a-t-il des erreurs silencieuses (NULL ignorés, fan-out, LEFT JOIN transformé) ?

3. Comment l'améliorer en lisibilité et en performance ?

4. Quelle version un senior écrirait à ma place ?

Contexte : [décrire ce que tu veux calculer]

[coller ta requête]

programme-sql-debutant-intermediaire · 25

Prompt “Simule un entretien”

Simule un entretien data analyst sur SQL.

Niveau : [débutant / intermédiaire / senior]

Pose-moi 5 questions progressives, une à la fois.

Attends ma réponse avant de passer à la suivante.

À chaque réponse, dis-moi :

- Ce qui est correct

- Ce qui manque ou pourrait être mieux

- La réponse idéale qu'un recruteur attendrait

Commence par la première question.

programme-sql-debutant-intermediaire · 26

🧪 De l’IA à la pratique réelle Les prompts IA t’aident à comprendre. Modai Lab te met face à de vraies données, avec un feedback qui va au-delà de ce qu’une IA peut détecter. 👉 Passer à la pratique Environnement SQL réel · Datasets métiers · Progression mesurée

Récapitulatif — Le programme en une page

NIVEAU 1 — Fondations (1-2 jours)

├── SELECT, alias, calculs

├── WHERE : =, !=, >, <, IN, BETWEEN, LIKE, IS NULL

├── ORDER BY, LIMIT, OFFSET

└── Comprendre l'ordre d'exécution SQL

NIVEAU 2 — Agrégations (2-3 jours)

├── GROUP BY + règle des colonnes non agrégées

├── COUNT(*) vs COUNT(col), SUM, AVG, MIN, MAX

├── HAVING vs WHERE

└── Agrégations conditionnelles avec CASE WHEN

NIVEAU 3 — Relations (3-5 jours)

├── INNER JOIN, LEFT JOIN, FULL OUTER JOIN

├── Piège du LEFT JOIN silencieux

├── Jointures sur 3+ tables, gestion du fan-out

└── Sous-requêtes : WHERE, FROM, EXISTS, NOT EXISTS

NIVEAU 4 — Analyse avancée (5-7 jours)

├── CTE (WITH ... AS) pour structurer la logique

├── ROW_NUMBER, RANK, LAG, LEAD, SUM cumulatif

├── NULL : IS NULL, COALESCE, impact sur agrégations

└── Penser en ensemble, pas en boucle

programme-sql-debutant-intermediaire · 27

✅ Checklist finale — Suis-je vraiment intermédiaire ?

☐ Je peux expliquer pourquoi WHERE alias = valeur ne fonctionne pas
☐ Je sais quand utiliser GROUP BY vs DISTINCT
☐ Je comprends la différence entre INNER JOIN et LEFT JOIN et je la justifie
☐ Je détecte un fan-out avant même de lancer la requête
☐ Je comprends pourquoi COUNT(col) ≠ COUNT(*) avec des NULL
☐ Je peux écrire une requête avec CTE et window function
☐ Je peux lire une requête que je n’ai pas écrite et expliquer ce qu’elle fait

🚀 La plateforme recommandée pour passer au niveau supérieur

La théorie, c’est ici. La pratique qui ancre vraiment, c’est sur des vraies données.

Modai Lab est la plateforme que je recommande pour ce programme :

Des exercices calibrés sur chacun des 4 niveaux
Un feedback immédiat qui explique chaque erreur
Des datasets réalistes issus de cas métiers réels
Un test de niveau pour savoir exactement où tu en es

👉 Commencer le test SQL — puis continue avec les exercices du niveau correspondant.

Entraîne-toi sur les exercices interactifs · Partagez librement ♻️

Pourquoi ce guide existe

Comment utiliser ce programme

NIVEAU 1 — Les fondations (débutant)

Concept 1.1 — L’ordre d’exécution SQL

Concept 1.2 — SELECT : choisir ses colonnes

Concept 1.3 — WHERE : filtrer les lignes

Concept 1.4 — ORDER BY et LIMIT

🤖 Prompt IA pour pratiquer le Niveau 1

✅ Signal de passage au Niveau 2

NIVEAU 2 — Les agrégations (débutant+)

Concept 2.1 — GROUP BY : regrouper pour calculer

Concept 2.2 — Les fonctions d’agrégation

Concept 2.3 — HAVING : filtrer après agrégation

Concept 2.4 — Agréger avec des conditions (CASE WHEN)

🤖 Prompt IA pour pratiquer le Niveau 2

✅ Signal de passage au Niveau 3

NIVEAU 3 — Les relations (intermédiaire)

Concept 3.1 — Les JOIN : relier les tables

Concept 3.2 — Le piège du LEFT JOIN silencieux

Concept 3.3 — Les sous-requêtes

Concept 3.4 — Lire un modèle de données

🤖 Prompt IA pour pratiquer le Niveau 3

✅ Signal de passage au Niveau 4

NIVEAU 4 — L’analyse avancée (intermédiaire)

Concept 4.1 — Les CTE : structurer et lire sa logique

Concept 4.2 — Les fonctions de fenêtre (window functions)

Concept 4.3 — Maîtriser NULL (vraiment)

Concept 4.4 — Penser en ensemble, pas en boucle

🤖 Prompt IA pour pratiquer le Niveau 4

✅ Tu es au niveau intermédiaire quand :

PARTIE 5 — Les prompts universels pour apprendre avec l’IA

Prompt “Explique-moi”

Prompt “Génère un exercice”

Prompt “Audite ma requête”

Prompt “Simule un entretien”

Récapitulatif — Le programme en une page

✅ Checklist finale — Suis-je vraiment intermédiaire ?

🚀 La plateforme recommandée pour passer au niveau supérieur

La théorie c’est bien. La pratique sur des cas concrets, c’est mieux.