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 :
Typage strict : une colonne DATE refuse "bientĂŽt". Une colonne NUMERIC refuse "12,5 âŹ".
Contraintes : unicité, valeurs obligatoires (NOT NULL), cohérence entre tables.
AccĂšs concurrent : 10 000 utilisateurs peuvent Ă©crire en mĂȘme temps sans Ă©craser les donnĂ©es des autres.
Transactions (ACID) : un virement débite ET crédite, ou rien du tout. Jamais à moitié.
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_
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.
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 Parsing : le moteur vĂ©rifie la syntaxe (« tu as oubliĂ© une virgule »)
Résolution : il vérifie que les tables et colonnes existent, et que tu as les droits
Optimisation : il choisit un plan d'exĂ©cution (quel index utiliser, dans quel ordre faire les jointuresâŠ)
Exécution : il lit les données, filtre, joint, agrÚge
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 â»ïž_