Guide pratique · E-commerce · SaaS · Finance · RH · Lecture : ~15 min Teste ton niveau sur modai-lab.com/test-sql/


Pourquoi ce guide existe

Tu Ă©cris peut-ĂȘtre dĂ©jĂ  des SELECT * FROM ... tous les jours. Mais si on te demande ce qu'est vraiment une base de donnĂ©es, pourquoi on sĂ©pare les clients et les commandes dans deux tables, ou ce qui se passe quand tu lances ta requĂȘte
 c'est plus flou.

Ce flou coûte cher :

  • Tu fais des jointures qui dupliquent tes lignes sans t'en rendre compte

  • Tu calcules un chiffre d'affaires faux parce que tu ne connais pas la granularitĂ© de ta table

  • Tu confonds une base transactionnelle (l'app) et un entrepĂŽt analytique (BigQuery, Snowflake) et tu ne comprends pas pourquoi ta requĂȘte coĂ»te 40 €

  • En entretien, tu bloques sur « c'est quoi une clĂ© Ă©trangĂšre ? »

Ce guide couvre :

  • Ce qu'est une base de donnĂ©es relationnelle (et pourquoi ce n'est pas un gros Excel)

  • Tables, lignes, colonnes, types : le vocabulaire qui compte

  • ClĂ©s primaires, clĂ©s Ă©trangĂšres et relations entre tables

  • Le langage SQL : les 4 familles de commandes

  • Les moteurs (PostgreSQL, MySQL, BigQuery
) et la diffĂ©rence OLTP / OLAP

  • Comment une requĂȘte est rĂ©ellement exĂ©cutĂ©e

  • Les erreurs classiques des dĂ©butants, et ce que font les seniors Ă  la place


đŸ§Ș Calibre ton niveau avant de commencer

Sais-tu expliquer la différence entre une clé primaire et une clé étrangÚre, et prédire combien de lignes renvoie une jointure ? Si tu hésites, ce guide est fait pour toi. Fais le test en 5 minutes.

👉 Faire le test sur modai-lab.com/test-sql/

_Résultat en direct · Niveau calibré · Parcours personnalisé_


PARTIE 1 — Une base de donnĂ©es, ce n'est pas un gros fichier Excel

La définition simple

Une base de donnĂ©es est un ensemble organisĂ© de donnĂ©es, stockĂ© de maniĂšre Ă  pouvoir ĂȘtre lu, modifiĂ© et protĂ©gĂ© par plusieurs personnes ou applications en mĂȘme temps.

Une base de données SQL (ou relationnelle) organise ces données en tables reliées entre elles, et on l'interroge avec un langage standard : SQL (Structured Query Language).

Le logiciel qui gĂšre tout ça s'appelle un SGBD (SystĂšme de Gestion de Base de DonnĂ©es) : PostgreSQL, MySQL, SQL Server, Oracle, BigQuery, Snowflake, SQLite


Le vocabulaire de base

Terme

Équivalent Excel

Ce que c'est vraiment

Base de données

Le classeur

Un ensemble de tables (souvent regroupées en schémas)

Schéma / dataset

Un dossier de classeurs

Un espace de noms : finance.orders, crm.users

Table

Une feuille

Un ensemble de lignes qui décrivent un seul type d'objet

Ligne (row / enregistrement)

Une ligne

Une occurrence de l'objet : un client, une commande

Colonne (field / attribut)

Une colonne

Une propriété de l'objet, avec un type imposé

Type

Format de cellule (souvent ignoré)

INTEGER, NUMERIC, VARCHAR, DATE, TIMESTAMP, BOOLEAN

Ce qui change vraiment par rapport Ă  Excel

Sous le capot, un SGBD apporte 5 garanties qu'un tableur n'offre pas :

  1. Typage strict : une colonne DATE refuse "bientît". Une colonne NUMERIC refuse "12,5 €".

  2. Contraintes : unicité, valeurs obligatoires (NOT NULL), cohérence entre tables.

  3. AccĂšs concurrent : 10 000 utilisateurs peuvent Ă©crire en mĂȘme temps sans Ă©craser les donnĂ©es des autres.

  4. Transactions (ACID) : un virement débite ET crédite, ou rien du tout. Jamais à moitié.

  5. Volume : des milliards de lignes, interrogées en secondes grùce aux index et au moteur d'exécution.

❌ L'approche « tableur » : tout dans une seule table

-- Table "ventes" conçue comme un export Excel
-- Chaque ligne répÚte toutes les infos du client
--
-- | vente_id | client_nom | client_email | client_ville | produit | prix | date_vente |
-- |----------|------------|---------------------|--------------|-----------|-------|------------|
-- | 1 | Julie Martin | julie@mail.fr | Lyon | Clavier | 49.90 | 2026-10-02 |
-- | 2 | Julie Martin | julie@mail.fr | Lyon | Souris | 19.90 | 2026-10-05 |
-- | 3 | julie martin | julie.m@mail.fr | Lyon | Écran | 189.00| 2026-10-12 |
--
-- ProblĂšmes :
-- 1. Julie change d'email → il faut modifier N lignes (et on en oublie)
-- 2. "Julie Martin" vs "julie martin" : est-ce la mĂȘme cliente ? Impossible Ă  dire
-- 3. Combien de clientes uniques ? COUNT(DISTINCT client_nom) renvoie 2 au lieu de 1
-- 4. Le prix du produit est recopié à chaque vente : s'il change, l'historique devient incohérent
 
SELECT COUNT(DISTINCT client_nom) AS nb_clients
FROM ventes;
-- RĂ©sultat : 2 ❌ (alors qu'il n'y a qu'une seule cliente)
base-de-donnees-sql · 01

✅ L'approche relationnelle : une table par objet

-- Une table "users" : une ligne = un client, identifié de façon unique
-- | user_id | nom | email | ville |
-- |---------|--------------|----------------|-------|
-- | 101 | Julie Martin | julie@mail.fr | Lyon |
 
-- Une table "products" : une ligne = un produit
-- | product_id | nom | prix_catalogue |
-- |------------|---------|----------------|
-- | 1 | Clavier | 49.90 |
-- | 2 | Souris | 19.90 |
-- | 3 | Écran | 189.00 |
 
-- Une table "orders" : une ligne = une commande, qui POINTE vers le client
-- | order_id | user_id | product_id | montant | created_at |
-- |----------|---------|------------|---------|------------|
-- | 1 | 101 | 1 | 49.90 | 2026-10-02 |
-- | 2 | 101 | 2 | 19.90 | 2026-10-05 |
-- | 3 | 101 | 3 | 189.00 | 2026-10-12 |
 
-- Gains :
-- 1. L'email de Julie est stockĂ© UNE fois → une seule mise Ă  jour
-- 2. Le client est identifié par un id, pas par un texte saisi à la main
-- 3. Le comptage est fiable :
SELECT COUNT(DISTINCT user_id) AS nb_clients
FROM orders;
-- RĂ©sultat : 1 ✅
base-de-donnees-sql · 02

Ce découpage s'appelle la normalisation : chaque information vit à un seul endroit, et les tables se référencent entre elles.

Cas business — E-commerce : crĂ©er les tables d'une boutique

-- Création des tables d'une boutique en ligne (syntaxe PostgreSQL)
 
CREATE TABLE users (
user_id INTEGER PRIMARY KEY,
email VARCHAR() NOT NULL UNIQUE, -- obligatoire et unique
nom VARCHAR(),
ville VARCHAR(),
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);
 
CREATE TABLE products (
product_id INTEGER PRIMARY KEY,
nom VARCHAR() NOT NULL,
categorie VARCHAR(),
prix_catalogue NUMERIC(, ) NOT NULL CHECK (prix_catalogue >= )
);
 
CREATE TABLE orders (
order_id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(user_id),
created_at TIMESTAMP NOT NULL,
statut VARCHAR() NOT NULL
CHECK (statut IN ('payee', 'expediee', 'livree', 'remboursee')),
montant NUMERIC(, ) NOT NULL
);
 
-- La base refusera désormais :
INSERT INTO users (user_id, email) VALUES (, NULL);
-- ❌ ERREUR : null value in column "email" violates not-null constraint
 
INSERT INTO orders (order_id, user_id, created_at, statut, montant)
VALUES (, , '2026-11-01', 'payee', .);
-- ❌ ERREUR : user 999 n'existe pas dans users (violation de clĂ© Ă©trangĂšre)
 
INSERT INTO orders (order_id, user_id, created_at, statut, montant)
VALUES (, , '2026-11-01', 'en_cours_peut_etre', .);
-- ❌ ERREUR : violates check constraint (statut non autorisĂ©)
base-de-donnees-sql · 03

C'est la grande diffĂ©rence avec un tableur : la base protĂšge la qualitĂ© de tes donnĂ©es avant mĂȘme que tu les analyses.

đŸ§Ș Apprends Ă  lire un schĂ©ma de base rĂ©el

Sur Modai Lab, chaque exercice démarre sur un vrai schéma métier (e-commerce, SaaS, finance) : tu apprends à repérer les tables, leurs grains et leurs liens avant d'écrire la moindre ligne.

👉 Pratiquer sur modai-lab.com

_Schémas réalistes · Données de production · Correction instantanée_


PARTIE 2 — ClĂ©s primaires, clĂ©s Ă©trangĂšres : comment les tables se parlent

La clé primaire (PRIMARY KEY)

C'est la colonne (ou le groupe de colonnes) qui identifie de maniĂšre unique chaque ligne d'une table.

  • Jamais NULL

  • Jamais en double

  • IdĂ©alement stable dans le temps (on ne change pas l'id d'un client)

user_id dans users, order_id dans orders.

La clé étrangÚre (FOREIGN KEY)

C'est une colonne qui pointe vers la clé primaire d'une autre table. Elle matérialise la relation.

orders.user_id → users.user_id signifie : « cette commande appartient Ă  ce client ».

Les 3 types de relations

Relation

Exemple

OĂč vit la clĂ© Ă©trangĂšre

1 → 1

Un salariĂ© ↔ un contrat de travail actif

Dans l'une des deux tables

1 → N

Un client → plusieurs commandes

Dans la table « N » (orders.user_id)

N → N

Des commandes ↔ des produits

Dans une table de liaison (order_items)

Le concept clé : la granularité (le « grain »)

Le grain d'une table, c'est ce que représente une ligne.

  • users : 1 ligne = 1 client

  • orders : 1 ligne = 1 commande

  • order_items : 1 ligne = 1 produit dans 1 commande

90 % des erreurs de chiffres viennent d'une jointure entre deux tables de grains différents.

❌ Joindre sans connaĂźtre le grain : le CA gonflĂ©

-- orders (grain : 1 ligne = 1 commande)
-- | order_id | user_id | montant |
-- |----------|---------|---------|
-- | 1 | 101 | 120.00 |
-- | 2 | 102 | 80.00 |
 
-- order_items (grain : 1 ligne = 1 produit dans une commande)
-- | order_id | product_id | quantite | prix_unitaire |
-- |----------|------------|----------|---------------|
-- | 1 | 10 | 1 | 70.00 |
-- | 1 | 11 | 2 | 25.00 |
-- | 2 | 12 | 1 | 80.00 |
 
SELECT SUM(o.montant) AS ca_total
FROM orders o
JOIN order_items oi ON oi.order_id = o.order_id;
 
-- La commande 1 a 2 lignes dans order_items → elle apparaüt 2 fois aprùs la jointure
-- Calcul : 120 + 120 + 80 = 320 ❌
-- Le vrai CA est 200. Tu viens de gonfler le chiffre de 60 %.
base-de-donnees-sql · 04

✅ AgrĂ©ger au bon grain

-- Option 1 : le CA se lit directement au grain commande, pas besoin de jointure
SELECT SUM(montant) AS ca_total
FROM orders;
-- RĂ©sultat : 200 ✅
 
-- Option 2 : si tu as besoin du détail produit, tu calcules depuis order_items
SELECT SUM(quantite * prix_unitaire) AS ca_total
FROM order_items;
-- RĂ©sultat : 70 + 50 + 80 = 200 ✅
 
-- RĂšgle senior : avant toute jointure, demande-toi
-- "combien de lignes de B correspondent Ă  UNE ligne de A ?"
-- Si la rĂ©ponse peut ĂȘtre > 1, toute somme sur une colonne de A sera multipliĂ©e.
base-de-donnees-sql · 05

Cas business — RH : salariĂ©s, dĂ©partements et managers

-- departments (grain : 1 ligne = 1 département)
-- | dept_id | nom_dept | budget_annuel |
-- |---------|------------|---------------|
-- | 1 | Data | 850000 |
-- | 2 | Produit | 1200000 |
-- | 3 | Commercial | 950000 |
 
-- employees (grain : 1 ligne = 1 salarié)
-- | employee_id | nom | dept_id | manager_id | salaire_annuel | date_entree |
-- |-------------|------------|---------|------------|----------------|-------------|
-- | 1 | Sarah L. | 1 | NULL | 78000 | 2021-03-01 |
-- | 2 | Karim B. | 1 | 1 | 52000 | 2023-09-15 |
-- | 3 | Léa D. | 1 | 1 | 48000 | 2025-01-06 |
-- | 4 | Thomas R. | 2 | NULL | 82000 | 2020-06-01 |
-- | 5 | InĂšs K. | 3 | NULL | 61000 | 2022-11-02 |
 
-- Deux clés étrangÚres :
-- employees.dept_id → departments.dept_id (relation 1 → N)
-- employees.manager_id → employees.employee_id (auto-rĂ©fĂ©rence : un salariĂ© a un manager)
 
-- Masse salariale et poids dans le budget, par département
SELECT
d.nom_dept,
COUNT(e.employee_id) AS effectif,
SUM(e.salaire_annuel) AS masse_salariale,
ROUND(. * SUM(e.salaire_annuel) / d.budget_annuel, ) AS pct_budget
FROM departments d
LEFT JOIN employees e ON e.dept_id = d.dept_id
GROUP BY d.nom_dept, d.budget_annuel
ORDER BY masse_salariale DESC;
 
-- | nom_dept | effectif | masse_salariale | pct_budget |
-- |------------|----------|-----------------|------------|
-- | Data | 3 | 178000 | 20.9 |
-- | Produit | 1 | 82000 | 6.8 |
-- | Commercial | 1 | 61000 | 6.4 |
 
-- Pourquoi c'est juste : on joint du grain "département" (1) vers "salarié" (N),
-- et on ne somme QUE des colonnes du cÎté N. budget_annuel est dans le GROUP BY,
-- donc il n'est jamais additionné plusieurs fois.
base-de-donnees-sql · 06

đŸ§Ș Teste ta maĂźtrise des jointures et du grain

Le piÚge du CA gonflé fait partie des questions du test Modai Lab. Vérifie en 5 minutes si tu le repÚres du premier coup.

👉 Faire le test sur modai-lab.com/test-sql/

_Questions sur cas réels · Diagnostic par thÚme · Gratuit_


PARTIE 3 — SQL, le langage : les 4 familles de commandes

SQL n'est pas un langage de programmation classique : il est dĂ©claratif. Tu dĂ©cris ce que tu veux (« le CA par mois »), pas comment l'obtenir (« ouvre le fichier, boucle sur les lignes
 »). C'est le moteur qui choisit la stratĂ©gie.

Les 4 familles

Famille

RĂŽle

Commandes

Qui l'utilise au quotidien

DQL (Query)

Lire les données

SELECT

Analystes, data scientists, métiers

DML (Manipulation)

Modifier le contenu

INSERT, UPDATE, DELETE, MERGE

Applications, pipelines, analytics engineers

DDL (Definition)

Définir la structure

CREATE, ALTER, DROP, TRUNCATE

Data engineers, développeurs

DCL / TCL (ContrĂŽle / Transactions)

Droits et transactions

GRANT, REVOKE, BEGIN, COMMIT, ROLLBACK

DBA, data engineers

En tant qu'analyste, tu passes 95 % de ton temps sur SELECT. Mais savoir que les autres existent t'évite des catastrophes.

La structure d'un SELECT

SELECT colonnes, calculs, agrégats -- ce que je veux voir
FROM table -- d'oĂč viennent les donnĂ©es
JOIN autre_table ON condition -- avec quoi je les relie
WHERE filtre sur les lignes -- quelles lignes je garde
GROUP BY colonnes de regroupement -- comment je regroupe
HAVING filtre sur les groupes -- quels groupes je garde
ORDER BY tri -- dans quel ordre
LIMIT n; -- combien de lignes
base-de-donnees-sql · 07

❌ Le UPDATE sans WHERE (l'erreur qui fait le tour de l'Ă©quipe)

-- Objectif : passer la commande 1042 au statut 'remboursee'
 
UPDATE orders
SET statut = 'remboursee';
 
-- RĂ©sultat : 184 302 rows updated ❌
-- TOUTES les commandes de la base sont maintenant remboursées.
-- Le dashboard du CA affiche 0 €. Le directeur financier appelle.
base-de-donnees-sql · 08

✅ La version sĂ©curisĂ©e

-- 1. On vĂ©rifie d'abord avec un SELECT ce qui va ĂȘtre touchĂ©
SELECT order_id, statut, montant
FROM orders
WHERE order_id = ;
-- | order_id | statut | montant |
-- | 1042 | livree | 89.90 | → 1 ligne, c'est bien elle
 
-- 2. On ouvre une transaction : rien n'est définitif tant qu'on n'a pas validé
BEGIN;
 
UPDATE orders
SET statut = 'remboursee'
WHERE order_id = ;
-- 1 row updated ✅ (si le nombre n'est pas celui attendu → ROLLBACK;)
 
COMMIT;
 
-- Gain : le SELECT préalable te montre le périmÚtre exact,
-- la transaction te laisse une porte de sortie (ROLLBACK) avant le COMMIT.
base-de-donnees-sql · 09

Cas business — SaaS : MRR par plan à partir des abonnements

-- subscriptions (grain : 1 ligne = 1 abonnement)
-- | subscription_id | user_id | plan | prix_mensuel | started_at | ended_at |
-- |-----------------|---------|----------|--------------|------------|------------|
-- | 1 | 201 | Starter | 29 | 2026-01-10 | NULL |
-- | 2 | 202 | Pro | 99 | 2026-03-02 | NULL |
-- | 3 | 203 | Pro | 99 | 2026-04-15 | 2026-09-30 |
-- | 4 | 204 | Business | 299 | 2026-05-20 | NULL |
-- | 5 | 205 | Starter | 29 | 2026-07-01 | NULL |
-- | 6 | 206 | Pro | 99 | 2026-08-12 | NULL |
 
-- MRR actuel par plan (abonnements non terminés)
SELECT
plan,
COUNT(*) AS abonnes_actifs,
SUM(prix_mensuel) AS mrr
FROM subscriptions
WHERE ended_at IS NULL -- WHERE filtre les LIGNES (abonnements actifs)
GROUP BY plan
HAVING SUM(prix_mensuel) >= -- HAVING filtre les GROUPES (plans significatifs)
ORDER BY mrr DESC;
 
-- | plan | abonnes_actifs | mrr |
-- |----------|----------------|-----|
-- | Business | 1 | 299 |
-- | Pro | 2 | 198 |
-- | Starter | 2 | 58 |
 
-- Note : on teste "ended_at IS NULL" et pas "ended_at = NULL"
-- (= NULL ne renvoie jamais vrai, on y revient en partie 6)
base-de-donnees-sql · 10

đŸ§Ș Écris tes premiĂšres requĂȘtes sur de vraies donnĂ©es

Sur Modai Lab, tu enchaĂźnes SELECT, WHERE, GROUP BY et HAVING sur des datasets SaaS et e-commerce, avec une IA qui corrige ta logique, pas seulement ta syntaxe.

👉 Pratiquer sur modai-lab.com

_Exercices progressifs · IA tuteur · Cas business réels_


PARTIE 4 — PostgreSQL, MySQL, BigQuery
 : quel moteur, pour quel usage ?

Un langage, plusieurs moteurs

SQL est une norme (ANSI/ISO). Chaque SGBD l'implémente avec ses variantes (« dialectes »). Un SELECT ... WHERE ... GROUP BY marche partout ; les fonctions de dates, elles, changent d'un moteur à l'autre.

Moteur

Type

Usage typique

PostgreSQL

OLTP (open source)

Back-end d'applications, trĂšs complet

MySQL / MariaDB

OLTP (open source)

Sites web, e-commerce

SQL Server

OLTP (Microsoft)

Entreprises, écosystÚme Microsoft

Oracle

OLTP (propriétaire)

Banque, assurance, grands comptes

SQLite

Embarqué

Applications mobiles, prototypes, fichiers locaux

BigQuery

OLAP (Google Cloud)

EntrepÎt analytique, facturé au volume scanné

Snowflake

OLAP (multi-cloud)

EntrepÎt analytique, facturé au temps de calcul

DuckDB

OLAP (embarqué)

Analyse locale rapide de fichiers Parquet/CSV

OLTP vs OLAP : la distinction que tout analyste doit connaĂźtre

OLTP (Online Transaction Processing) : la base de l'application.

  • Beaucoup de petites opĂ©rations : « crĂ©e cette commande », « mets Ă  jour ce panier »

  • Stockage orientĂ© ligne : lire une commande entiĂšre est ultra rapide

  • DonnĂ©es normalisĂ©es, Ă  jour Ă  la milliseconde

OLAP (Online Analytical Processing) : l'entrepÎt de données (data warehouse).

  • Peu de requĂȘtes, mais Ă©normes : « CA par rĂ©gion sur 3 ans »

  • Stockage orientĂ© colonne : lire 2 colonnes sur 80 ne charge que ces 2 colonnes

  • DonnĂ©es souvent copiĂ©es depuis l'OLTP (via un pipeline ETL/ELT, dbt
)

Les variations de syntaxe Ă  connaĂźtre

-- Tronquer une date au mois : mĂȘme intention, syntaxes diffĂ©rentes
 
-- PostgreSQL / Snowflake
SELECT DATE_TRUNC('month', created_at) AS mois FROM orders;
 
-- BigQuery
SELECT DATE_TRUNC(DATE(created_at), MONTH) AS mois FROM orders;
 
-- MySQL
SELECT DATE_FORMAT(created_at, '%Y-%m-01') AS mois FROM orders;
 
-- Limiter le résultat
SELECT * FROM orders LIMIT ; -- PostgreSQL, MySQL, BigQuery, Snowflake
SELECT TOP * FROM orders; -- SQL Server
SELECT * FROM orders FETCH FIRST ROWS ONLY; -- norme SQL, Oracle
base-de-donnees-sql · 11

❌ RequĂȘter un entrepĂŽt OLAP comme une base OLTP

-- Sur BigQuery, table events de 2 To, 60 colonnes, partitionnée par event_date
 
SELECT *
FROM analytics.events
LIMIT ;
 
-- Le LIMIT ne réduit PAS le volume scanné en stockage colonnaire :
-- BigQuery lit les 60 colonnes sur toute la table → 2 To facturĂ©s
-- À ~6 $ par To scannĂ© : environ 12 $ pour regarder 100 lignes ❌
-- Lancée 10 fois par jour par 5 analystes : environ 18 000 $ par mois
base-de-donnees-sql · 12

✅ Penser « colonnes » et « partitions »

-- Seulement les colonnes utiles + un filtre sur la colonne de partition
SELECT user_id, event_name, event_date
FROM analytics.events
WHERE event_date BETWEEN '2026-10-01' AND '2026-10-31'
LIMIT ;
 
-- Volume scannĂ© : 3 colonnes × 1 mois ≈ 12 Go au lieu de 2 To
-- CoĂ»t : quelques centimes au lieu d'environ 12 $ ✅
-- Astuce : pour juste "voir" une table, utilise l'onglet Aperçu (gratuit)
base-de-donnees-sql · 13

Cas business — Finance : soldes de comptes sur une base OLTP

-- Contexte : néobanque, base PostgreSQL de l'application
 
-- accounts (grain : 1 ligne = 1 compte)
-- | account_id | user_id | type | ouvert_le |
-- |------------|---------|----------|------------|
-- | A1 | 301 | courant | 2025-02-10 |
-- | A2 | 302 | courant | 2025-06-01 |
 
-- transactions (grain : 1 ligne = 1 mouvement)
-- | transaction_id | account_id | montant | sens | created_at |
-- |----------------|------------|----------|--------|---------------------|
-- | T1 | A1 | 2500.00 | credit | 2026-10-01 08:00:00 |
-- | T2 | A1 | 850.00 | debit | 2026-10-03 14:12:00 |
-- | T3 | A1 | 42.30 | debit | 2026-10-04 19:45:00 |
-- | T4 | A2 | 1800.00 | credit | 2026-10-01 08:00:00 |
-- | T5 | A2 | 1950.00 | debit | 2026-10-02 10:30:00 |
 
-- Virement de A1 vers A2 : les deux écritures passent ensemble, ou aucune
BEGIN;
INSERT INTO transactions (transaction_id, account_id, montant, sens, created_at)
VALUES ('T6', 'A1', ., 'debit', NOW());
INSERT INTO transactions (transaction_id, account_id, montant, sens, created_at)
VALUES ('T7', 'A2', ., 'credit', NOW());
COMMIT;
-- Si la 2e insertion échoue, ROLLBACK annule aussi la 1re : l'argent ne disparaßt jamais.
 
-- Solde par compte et détection des découverts
SELECT
account_id,
SUM(CASE WHEN sens = 'credit' THEN montant ELSE -montant END) AS solde
FROM transactions
GROUP BY account_id
HAVING SUM(CASE WHEN sens = 'credit' THEN montant ELSE -montant END) < ;
 
-- Avant le virement : A2 → 1800 - 1950 = -150 (dĂ©couvert)
-- Aprùs le virement : A1 → 2500 - 850 - 42.30 - 300 = 1307.70 ; A2 → -150 + 300 = 150
-- La requĂȘte ne renvoie plus aucune ligne ✅
base-de-donnees-sql · 14

đŸ§Ș VĂ©rifie si tu sais adapter tes requĂȘtes au moteur

Le test Modai Lab inclut des questions sur les rĂ©flexes « entrepĂŽt de donnĂ©es » : colonnes sĂ©lectionnĂ©es, partitions, coĂ»t des requĂȘtes.

👉 Faire le test sur modai-lab.com/test-sql/

_Questions OLTP & OLAP · Niveau calibré · Recommandations ciblées_


PARTIE 5 — Ce qui se passe quand tu lances une requĂȘte

Le parcours d'une requĂȘte

  1. Parsing : le moteur vérifie la syntaxe (« tu as oublié une virgule »)

  2. Résolution : il vérifie que les tables et colonnes existent, et que tu as les droits

  3. Optimisation : il choisit un plan d'exécution (quel index utiliser, dans quel ordre faire les jointures
)

  4. Exécution : il lit les données, filtre, joint, agrÚge

  5. Renvoi du résultat

Tu peux voir le plan choisi avec EXPLAIN (PostgreSQL, MySQL) ou dans l'onglet Détails d'exécution sur BigQuery.

L'ordre d'exĂ©cution logique (≠ ordre d'Ă©criture)

Tu écris SELECT en premier, mais le moteur le traite presque en dernier :

Ordre d'écriture

Ordre d'exécution logique

1. SELECT

1. FROM / JOIN

2. FROM

2. WHERE

3. JOIN

3. GROUP BY

4. WHERE

4. HAVING

5. GROUP BY

5. SELECT

6. HAVING

6. DISTINCT

7. ORDER BY

7. ORDER BY

8. LIMIT

8. LIMIT

Cet ordre explique la majorité des messages d'erreur « incompréhensibles ».

❌ Utiliser un alias du SELECT dans le WHERE

SELECT
order_id,
montant * . AS montant_ttc
FROM orders
WHERE montant_ttc > ;
 
-- ERREUR : column "montant_ttc" does not exist ❌
-- Pourquoi ? WHERE est exécuté AVANT SELECT : l'alias n'existe pas encore.
base-de-donnees-sql · 15

✅ RĂ©pĂ©ter le calcul ou passer par une CTE

-- Option 1 : répéter l'expression dans le WHERE
SELECT
order_id,
montant * . AS montant_ttc
FROM orders
WHERE montant * . > ;
 
-- Option 2 : CTE, plus lisible quand le calcul est complexe
WITH orders_ttc AS (
SELECT order_id, montant * . AS montant_ttc
FROM orders
)
SELECT *
FROM orders_ttc
WHERE montant_ttc > ; -- ✅ ici l'alias existe, il a Ă©tĂ© créé dans la CTE
 
-- Bonus : ORDER BY montant_ttc fonctionne directement,
-- car ORDER BY est exécuté APRÈS SELECT.
base-de-donnees-sql · 16

Le rĂŽle des index (OLTP)

Un index est comme l'index d'un livre : au lieu de lire toutes les pages, le moteur saute directement Ă  la bonne.

-- Sans index sur orders.user_id, chercher les commandes d'un client
-- oblige Ă  lire les 5 millions de lignes (Seq Scan)
EXPLAIN SELECT * FROM orders WHERE user_id = ;
-- Seq Scan on orders (cost=0.00..98500.00 rows=12)
 
CREATE INDEX idx_orders_user_id ON orders(user_id);
 
EXPLAIN SELECT * FROM orders WHERE user_id = ;
-- Index Scan using idx_orders_user_id on orders (cost=0.43..52.10 rows=12)
-- Le coĂ»t estimĂ© est divisĂ© par ~1 900 ✅
 
-- Contrepartie : chaque INSERT/UPDATE doit aussi mettre l'index Ă  jour.
-- On indexe les colonnes souvent filtrées ou jointes, pas toutes les colonnes.
-- (Dans BigQuery/Snowflake, on raisonne plutĂŽt en partitions et clustering.)
base-de-donnees-sql · 17

Cas business — E-commerce : panier moyen mensuel, Ă©crit dans le bon ordre

-- orders (extrait, octobre-novembre 2026)
-- | order_id | user_id | statut | montant | created_at |
-- |----------|---------|------------|---------|------------|
-- | 1 | 101 | livree | 64.00 | 2026-10-03 |
-- | 2 | 102 | livree | 120.00 | 2026-10-09 |
-- | 3 | 103 | remboursee | 45.00 | 2026-10-15 |
-- | 4 | 101 | livree | 88.00 | 2026-10-28 |
-- | 5 | 104 | expediee | 150.00 | 2026-11-02 |
-- | 6 | 102 | livree | 72.00 | 2026-11-04 |
 
SELECT
DATE_TRUNC('month', created_at) AS mois, -- 5. calculé aprÚs le GROUP BY
COUNT(*) AS nb_commandes,
ROUND(AVG(montant), ) AS panier_moyen
FROM orders -- 1. on lit la table
WHERE statut <> 'remboursee' -- 2. on exclut les remboursements
GROUP BY DATE_TRUNC('month', created_at) -- 3. un groupe par mois
HAVING COUNT(*) >= -- 4. mois avec au moins 2 commandes
ORDER BY mois; -- 6. tri final (alias autorisé ici)
 
-- | mois | nb_commandes | panier_moyen |
-- |------------|--------------|--------------|
-- | 2026-10-01 | 3 | 90.67 |
-- | 2026-11-01 | 2 | 111.00 |
base-de-donnees-sql · 18

đŸ§Ș EntraĂźne-toi Ă  penser comme le moteur

Les exercices Modai Lab te font lire des requĂȘtes avant de les Ă©crire : prĂ©dire le rĂ©sultat, repĂ©rer l'Ă©tape qui pose problĂšme, puis corriger.

👉 Pratiquer sur modai-lab.com

_Lecture de requĂȘtes · DĂ©bogage guidĂ© · Feedback immĂ©diat_


PARTIE 6 — Les erreurs classiques des dĂ©butants

Erreur 1 : comparer avec NULL en utilisant `=`

-- ❌ Junior : "les clients sans ville"
SELECT * FROM users WHERE ville = NULL;
-- Résultat : 0 ligne, toujours. NULL signifie "inconnu" :
-- "inconnu = inconnu" n'est ni vrai ni faux, donc la ligne est écartée.
 
-- ✅ Senior
SELECT * FROM users WHERE ville IS NULL;
base-de-donnees-sql · 19

Erreur 2 : croire que `COUNT(colonne)` compte toutes les lignes

-- users : 1 000 lignes, dont 180 sans téléphone (telephone IS NULL)
 
-- ❌ Junior
SELECT COUNT(telephone) AS nb_users FROM users;
-- Résultat : 820. COUNT(colonne) ignore les NULL.
 
-- ✅ Senior : choisir consciemment
SELECT
COUNT(*) AS nb_users, -- 1000 : toutes les lignes
COUNT(telephone) AS nb_avec_tel, -- 820 : valeurs non nulles
COUNT(DISTINCT telephone) AS nb_tel_uniques -- valeurs distinctes non nulles
FROM users;
base-de-donnees-sql · 20

Erreur 3 : le `SELECT *` en production

-- ❌ Junior : dans un dashboard ou un modùle dbt
SELECT * FROM orders;
-- ProblÚmes : coût élevé en OLAP, colonnes inutiles transférées,
-- et le jour oĂč quelqu'un ajoute une colonne, le dashboard casse.
 
-- ✅ Senior : colonnes explicites
SELECT order_id, user_id, statut, montant, created_at
FROM orders;
base-de-donnees-sql · 21

Erreur 4 : une colonne non agrégée absente du GROUP BY

-- ❌ Junior
SELECT region, user_id, SUM(montant)
FROM orders
GROUP BY region;
-- ERREUR (PostgreSQL, BigQuery) : user_id must appear in the GROUP BY clause
-- Sur certains MySQL permissifs : pas d'erreur, mais un user_id pris au hasard ❌
 
-- ✅ Senior : toute colonne du SELECT est soit agrĂ©gĂ©e, soit dans le GROUP BY
SELECT region, COUNT(DISTINCT user_id) AS nb_clients, SUM(montant) AS ca
FROM orders
GROUP BY region;
base-de-donnees-sql · 22

Erreur 5 : diviser deux entiers

-- 37 commandes remboursées sur 412
 
-- ❌ Junior (PostgreSQL, SQL Server)
SELECT / AS taux_remboursement;
-- Résultat : 0. Division entiÚre, la partie décimale est tronquée.
 
-- ✅ Senior
SELECT ROUND(. * / , ) AS taux_remboursement_pct;
-- Résultat : 9.0
-- Le 100.0 force un calcul décimal. Sur BigQuery, préfÚre SAFE_DIVIDE(a, b)
-- qui évite aussi l'erreur de division par zéro.
base-de-donnees-sql · 23

Erreur 6 : `LEFT JOIN` annulé par un WHERE

-- Objectif : tous les clients, avec leurs commandes livrées s'ils en ont
 
-- ❌ Junior
SELECT u.user_id, o.order_id
FROM users u
LEFT JOIN orders o ON o.user_id = u.user_id
WHERE o.statut = 'livree';
-- Les clients sans commande ont o.statut = NULL → Ă©liminĂ©s par le WHERE.
-- Ton LEFT JOIN est devenu un INNER JOIN sans que tu le voies.
 
-- ✅ Senior : la condition sur la table de droite va dans le ON
SELECT u.user_id, o.order_id
FROM users u
LEFT JOIN orders o
ON o.user_id = u.user_id
AND o.statut = 'livree';
-- Tous les clients sont conservés, order_id est NULL pour ceux sans commande livrée.
base-de-donnees-sql · 24

đŸ§Ș Mesure combien de ces piĂšges tu Ă©vites dĂ©jĂ 

Ces 6 erreurs sont toutes couvertes par le test Modai Lab. Tu sauras en 5 minutes lesquelles te concernent encore.

👉 Faire le test sur modai-lab.com/test-sql/

_6 piÚges classiques · Explications détaillées · Plan de progression_


Prompt Claude pour auditer tes requĂȘtes

Copie-colle ce prompt dans Claude, puis colle ta requĂȘte et (si possible) la description de tes tables Ă  la suite.

Tu es un analytics engineer senior qui relit le SQL d'un analyste junior.
Je vais te donner une requĂȘte SQL et, si je l'ai, la structure des tables utilisĂ©es.
 
Moteur utilisé : [PostgreSQL / MySQL / BigQuery / Snowflake / SQL Server]
 
Analyse la requĂȘte selon cette grille, point par point :
 
1. GRAIN DES TABLES
- Pour chaque table, indique ce que représente une ligne (ou demande-le-moi si c'est ambigu).
- Pour chaque jointure, indique si elle est 1-1, 1-N ou N-N.
- Signale tout risque de duplication de lignes et toute somme qui serait gonflée.
 
2. CLÉS ET JOINTURES
- Les conditions de jointure portent-elles bien sur des clĂ©s (primaire ↔ Ă©trangĂšre) ?
- Un LEFT JOIN est-il annulé par une condition dans le WHERE ?
- Une jointure manquante produit-elle un produit cartésien ?
 
3. GESTION DES NULL
- Comparaisons "= NULL" ou "<> NULL" au lieu de IS NULL / IS NOT NULL.
- COUNT(colonne) utilisé à la place de COUNT(*) sans que ce soit voulu.
- Agrégats ou calculs qui deviennent NULL à cause d'une valeur manquante.
 
4. ORDRE D'EXÉCUTION
- Alias du SELECT utilisés dans WHERE ou GROUP BY (selon le moteur).
- Filtres placĂ©s dans HAVING alors qu'ils devraient ĂȘtre dans WHERE (ou l'inverse).
- Colonnes non agrégées absentes du GROUP BY.
 
5. CALCULS
- Divisions entiÚres, divisions par zéro possibles.
- Arrondis appliqués trop tÎt.
- Fonctions de date non adaptées au moteur indiqué.
 
6. PERFORMANCE ET COÛT
- SELECT * Ă  remplacer par des colonnes explicites.
- En OLAP (BigQuery, Snowflake) : filtre sur la colonne de partition, colonnes inutiles scannées.
- En OLTP (PostgreSQL, MySQL) : colonnes filtrées ou jointes qui mériteraient un index.
 
7. SÉCURITÉ (si la requĂȘte modifie des donnĂ©es)
- UPDATE ou DELETE sans WHERE, ou avec un WHERE trop large.
- Absence de transaction (BEGIN / COMMIT / ROLLBACK) pour des modifications liées.
 
Pour chaque problÚme trouvé, donne :
- la ligne concernée,
- pourquoi c'est un problÚme, avec un mini-exemple de données qui montre le mauvais résultat,
- la gravité (bloquant / résultat faux / performance / lisibilité).
 
Termine par :
- la version corrigĂ©e complĂšte de la requĂȘte, commentĂ©e ligne par ligne,
- un rĂ©sumĂ© en 3 points de ce que je dois retenir pour mes prochaines requĂȘtes.
 
Voici ma requĂȘte :
[COLLE TA REQUÊTE ICI]
 
Voici la structure de mes tables (optionnel) :
[COLLE TES CREATE TABLE OU LA LISTE DES COLONNES ICI]
base-de-donnees-sql · 25

📋 RĂ©capitulatif

Notion

À retenir

PiÚge à éviter

Base de données relationnelle

Données en tables reliées, gérées par un SGBD

La traiter comme un gros fichier Excel

Table / ligne / colonne

1 table = 1 type d'objet, 1 ligne = 1 occurrence, colonnes typées

Mélanger plusieurs objets dans une seule table

Normalisation

Chaque information est stockée à un seul endroit

Dupliquer l'email ou le prix dans chaque ligne

Clé primaire

Identifiant unique et non nul d'une ligne

Identifier un client par son nom

Clé étrangÚre

Colonne qui pointe vers la clé primaire d'une autre table

Joindre sur des colonnes texte approximatives

Grain

Ce que représente une ligne de la table

Sommer aprÚs une jointure 1-N (CA gonflé)

SQL déclaratif

Tu décris le résultat, le moteur choisit comment

Penser en boucles ligne par ligne

DQL / DML / DDL / DCL

SELECT / INSERT-UPDATE-DELETE / CREATE-ALTER / GRANT-COMMIT

UPDATE ou DELETE sans WHERE

Transactions

Tout ou rien (BEGIN, COMMIT, ROLLBACK)

Modifier des données liées sans transaction

OLTP vs OLAP

Application (lignes) vs entrepĂŽt analytique (colonnes)

SELECT * LIMIT 10 sur BigQuery

Ordre d'exécution

FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY

Alias du SELECT dans le WHERE

Index / partitions

AccélÚrent la lecture des colonnes filtrées

Tout indexer, ou ne jamais filtrer la partition

NULL

Valeur inconnue, se teste avec IS NULL

= NULL, COUNT(colonne) mal compris


✅ Checklist « Je comprends ma base de donnĂ©es »

  • ☐ Je sais expliquer la diffĂ©rence entre une base de donnĂ©es, une table, une ligne et une colonne

  • ☐ Je connais le grain (ce que reprĂ©sente une ligne) de chaque table que j'utilise

  • ☐ Je sais identifier la clĂ© primaire de chaque table

  • ☐ Je sais vers quelle table pointe chaque clĂ© Ă©trangĂšre

  • ☐ Avant une jointure, je sais dire si elle est 1-1, 1-N ou N-N

  • ☐ Je vĂ©rifie le nombre de lignes avant et aprĂšs chaque jointure

  • ☐ Je sais si je travaille sur une base OLTP ou un entrepĂŽt OLAP

  • ☐ Je connais le dialecte SQL de mon moteur (fonctions de dates, LIMIT/TOP)

  • ☐ Je sĂ©lectionne des colonnes explicites plutĂŽt que SELECT *

  • ☐ Sur un entrepĂŽt, je filtre sur la colonne de partition

  • ☐ Je teste les valeurs manquantes avec IS NULL / IS NOT NULL

  • ☐ Je fais un SELECT de contrĂŽle avant tout UPDATE ou DELETE

  • ☐ J'utilise une transaction pour les modifications qui doivent passer ensemble

  • ☐ Je connais l'ordre d'exĂ©cution logique d'une requĂȘte

  • ☐ Je fais auditer mes requĂȘtes importantes (relecture d'un pair ou prompt Claude ci-dessus)


🚀 Passe de « je lance des requĂȘtes » Ă  « je comprends ma base »

ConnaĂźtre les tables, les clĂ©s et le grain, c'est ce qui sĂ©pare l'analyste qui copie des requĂȘtes de celui Ă  qui on confie les chiffres du comitĂ© de direction. Le plus rapide pour ancrer ces rĂ©flexes : les pratiquer sur de vrais schĂ©mas mĂ©tiers.

👉 modai-lab.com/test-sql/ — Exercices calibrĂ©s · Cas business rĂ©els · Feedback senior


_Guide offert suite au post LinkedIn · EntraĂźnez-vous sur modai-lab.com/test-sql/ · Partagez librement ♻_