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


Pourquoi ce guide existe

"Il faut maßtriser SQL." C'est écrit dans 9 offres data sur 10. Mais personne ne te dit ce que "maßtriser" veut dire pour un poste junior.

Résultat, deux profils se plantent en entretien :

  • Celui qui s'est arrĂȘtĂ© trop tĂŽt : il connaĂźt SELECT, WHERE, GROUP BY
 et bloque dĂšs qu'on lui demande "le dernier achat de chaque client".

  • Celui qui a appris trop large : il a passĂ© 3 semaines sur les index, les procĂ©dures stockĂ©es et les triggers
 et ne sait pas expliquer pourquoi son LEFT JOIN renvoie des doublons.

La vérité : le niveau attendu pour un premier poste (Data Analyst, BI, Analytics Engineer junior) est précis, borné et atteignable. Ce guide te donne la carte exacte.

Ce que tu vas trouver :

  • Les 5 blocs de compĂ©tences SQL rĂ©ellement Ă©valuĂ©s en entretien junior

  • Pour chaque bloc : l'erreur typique du dĂ©butant ❌ et le rĂ©flexe attendu ✅

  • Des cas business concrets avec donnĂ©es chiffrĂ©es (e-commerce, SaaS, finance, RH)

  • Ce qu'on n'attend pas de toi (pour arrĂȘter de perdre du temps)

  • Un prompt Claude pour auditer tes propres requĂȘtes

  • Une checklist finale : "suis-je prĂȘt Ă  postuler ?"


đŸ§Ș Calibre ton niveau avant de commencer

Tu sais écrire un GROUP BY, mais saurais-tu sortir le top 3 des produits par catégorie sans te tromper sur les ex Êquo ? C'est exactement la frontiÚre entre "je connais SQL" et "je suis employable".

Fais le test en 5 minutes.

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

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


La grille en un coup d'Ɠil

Avant d'entrer dans le détail, voici le niveau attendu pour un premier poste, bloc par bloc :

Bloc

Niveau attendu en junior

Poids en entretien

Socle (SELECT, WHERE, GROUP BY, HAVING, NULL)

Maßtrise totale, zéro hésitation

Éliminatoire

Jointures

INNER / LEFT sans erreur de cardinalité

Éliminatoire

CTE & sous-requĂȘtes

Découper un problÚme en étapes lisibles

TrĂšs fort

Fonctions de fenĂȘtre

ROW_NUMBER, RANK, LAG, SUM OVER

Le différenciateur

Dates & CASE WHEN

Cohortes, périodes, segmentation

Fort

Optimisation avancée, index, procédures

Notions seulement

Faible

Les deux premiĂšres lignes te font passer le premier filtre. Les fenĂȘtres te font sortir du lot.


PARTIE 1 — Le socle : lĂ  oĂč 50 % des candidats perdent des points bĂȘtement

On pense que le socle est "acquis". En rĂ©alitĂ©, c'est lĂ  que les recruteurs repĂšrent les profils fragiles, parce que les erreurs y sont silencieuses : la requĂȘte tourne, le chiffre est faux.

Trois mécanismes à comprendre (pas juste la syntaxe) :

  1. L'ordre d'exĂ©cution logique : FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY. C'est pour ça que tu ne peux pas filtrer un agrĂ©gat dans le WHERE : au moment du WHERE, l'agrĂ©gat n'existe pas encore.

  2. COUNT(*) vs COUNT(colonne) : COUNT(*) compte les lignes, COUNT(col) ignore les NULL.

  3. NULL n'est Ă©gal Ă  rien, pas mĂȘme Ă  NULL. statut <> 'annulĂ©' exclut aussi les lignes oĂč statut est NULL.

❌ Ce que fait le dĂ©butant

-- Objectif : rĂ©gions avec plus de 10 000 € de CA sur les commandes non annulĂ©es
SELECT region, SUM(montant) AS ca
FROM orders
WHERE statut <> 'annulĂ©' -- ⚠ exclut silencieusement les statuts NULL
AND SUM(montant) > -- ❌ erreur : agrĂ©gat interdit dans WHERE
GROUP BY region;
 
-- Et pour compter les clients ayant laissé un avis :
SELECT COUNT(*) AS nb_avis -- ❌ compte toutes les lignes, avis vide ou non
FROM orders;
niveau-sql-premier-emploi · 01

Données d'exemple dans orders :

order_id | region | montant | statut | avis
---------|--------|---------|----------|------
1 | IDF | 6 000 | livré | 5
2 | IDF | 5 500 | NULL | NULL ← commande en cours, statut pas encore renseignĂ©
3 | Sud | 4 000 | annulé | NULL
4 | Sud | 7 000 | livré | 4
niveau-sql-premier-emploi · 02

Avec statut <> 'annulĂ©', la commande 2 disparaĂźt → IDF tombe Ă  6 000 € et sort du rĂ©sultat. Faux.

✅ Ce qu'on attend d'un junior

-- Le filtre sur les lignes va dans WHERE, le filtre sur l'agrégat dans HAVING
SELECT
region,
SUM(montant) AS ca
FROM orders
WHERE statut IS DISTINCT FROM 'annulé' -- garde les NULL (ou : COALESCE(statut, '') <> 'annulé')
GROUP BY region
HAVING SUM(montant) > ; -- filtre APRÈS agrégation
 
-- Résultat :
-- region | ca
-- IDF | 11 500 ✅ la commande 2 est bien comptĂ©e
 
-- Compter ce qu'on veut vraiment compter
SELECT
COUNT(*) AS nb_commandes, -- 4
COUNT(avis) AS nb_avis -- 2 → COUNT(col) ignore les NULL
FROM orders;
niveau-sql-premier-emploi · 03

Le gain : tu ne "fais pas tourner" une requĂȘte, tu raisonnes sur ce qu'elle renvoie. C'est exactement ce que le recruteur cherche.

Cas business — E-commerce : panier moyen par canal

Le manager marketing veut le panier moyen par canal d'acquisition sur octobre, uniquement pour les canaux ayant généré au moins 200 commandes.

SELECT
canal,
COUNT(*) AS nb_commandes,
ROUND(SUM(montant), ) AS ca,
ROUND(AVG(montant), ) AS panier_moyen
FROM orders
WHERE created_at >= '2026-10-01'
AND created_at < '2026-11-01' -- borne exclusive : pas de souci d'heures
AND statut IS DISTINCT FROM 'annulé'
GROUP BY canal
HAVING COUNT(*) >=
ORDER BY ca DESC;
 
-- canal | nb_commandes | ca | panier_moyen
-- SEA | 1 840 | 112 240 | 61.00
-- Organique | 1 210 | 84 700 | 70.00
-- Email | 430 | 36 120 | 84.00
-- (Affiliation : 140 commandes → exclue par HAVING)
niveau-sql-premier-emploi · 04

Remarque le filtre de dates avec borne exclusive < '2026-11-01' : BETWEEN '2026-10-01' AND '2026-10-31' raterait toute la journée du 31 si created_at est un timestamp. Petit détail, gros signal de rigueur.

đŸ§Ș Verrouille ton socle sur des vraies donnĂ©es

Sur Modai Lab, les exercices du socle sont construits autour de ces piÚges silencieux : NULL, HAVING, bornes de dates. Tu vois immédiatement si ton chiffre est juste, et pourquoi.

👉 Pratiquer sur modai-lab.com

_Datasets réalistes · Correction instantanée · Explications pas à pas_


PARTIE 2 — Les jointures : le vrai filtre Ă©liminatoire

Écrire un JOIN, tout le monde sait. Ce qui est Ă©valuĂ©, c'est la cardinalitĂ© : combien de lignes sortent de ta jointure, et pourquoi.

Deux mécanismes à maßtriser absolument :

  1. Le fan-out : joindre une table 1-N (un client, plusieurs commandes) multiplie les lignes. Si tu fais ensuite un SUM sur une colonne de la table "1", tu la comptes plusieurs fois.

  2. Le LEFT JOIN cassé par le WHERE : un filtre sur la table de droite placé dans le WHERE élimine les lignes NULL
 et transforme ton LEFT JOIN en INNER JOIN.

❌ Ce que fait le dĂ©butant

-- Objectif : tous les clients inscrits en 2026, avec leur nombre de commandes livrées
SELECT
u.user_id,
u.budget_marketing_alloue, -- colonne de la table "1"
COUNT(o.order_id) AS nb_commandes
FROM users u
LEFT JOIN orders o ON o.user_id = u.user_id
WHERE o.statut = 'livrĂ©' -- ❌ supprime les clients sans commande (o.statut est NULL)
AND u.created_at >= '2026-01-01'
GROUP BY u.user_id, u.budget_marketing_alloue;
 
-- Puis, pour le total :
SELECT SUM(u.budget_marketing_alloue) -- ❌ fan-out : comptĂ© une fois PAR commande
FROM users u
JOIN orders o ON o.user_id = u.user_id;
niveau-sql-premier-emploi · 05

Données d'exemple :

users orders
user_id | budget_marketing_alloue order_id | user_id | statut
--------|------------------------ ---------|---------|--------
A | 10 1 | A | livré
B | 10 2 | A | livré
C | 10 3 | A | livré
4 | B | annulé
niveau-sql-premier-emploi · 06
  • RequĂȘte 1 : B et C disparaissent (aucune commande livrĂ©e → ligne NULL filtrĂ©e).

  • RequĂȘte 2 : total = 40 au lieu de 30 (A comptĂ© 3 fois, B une fois, C zĂ©ro).

✅ Ce qu'on attend d'un junior

-- Le filtre sur la table de droite va DANS la condition de jointure
SELECT
u.user_id,
COUNT(o.order_id) AS nb_commandes_livrees -- COUNT(col) → 0 pour les clients sans commande
FROM users u
LEFT JOIN orders o
ON o.user_id = u.user_id
AND o.statut = 'livrĂ©' -- ✅ prĂ©serve le LEFT JOIN
WHERE u.created_at >= '2026-01-01' -- filtre sur la table de gauche : OK dans WHERE
GROUP BY u.user_id;
 
-- user_id | nb_commandes_livrees
-- A | 3
-- B | 0 ✅
-- C | 0 ✅
 
-- Contre le fan-out : agréger AVANT de joindre
WITH commandes_par_user AS (
SELECT user_id, COUNT(*) AS nb_commandes
FROM orders
GROUP BY user_id -- 1 ligne par user → plus de multiplication
)
SELECT
SUM(u.budget_marketing_alloue) AS budget_total, -- 30 ✅
SUM(c.nb_commandes) AS commandes_total -- 4
FROM users u
LEFT JOIN commandes_par_user c ON c.user_id = u.user_id;
niveau-sql-premier-emploi · 07

Le réflexe à avoir en entretien : dire à voix haute la granularité de chaque table ("orders, c'est une ligne par commande") avant d'écrire le JOIN. Les recruteurs adorent.

Cas business — SaaS : clients sans activitĂ©

Le Customer Success veut la liste des comptes payants qui n'ont eu aucune session sur les 30 derniers jours (risque de churn).

SELECT
s.account_id,
s.plan,
s.mrr
FROM subscriptions s
LEFT JOIN sessions se
ON se.account_id = s.account_id
AND se.started_at >= CURRENT_DATE - INTERVAL '30' DAY
WHERE s.statut = 'active'
AND s.mrr >
AND se.session_id IS NULL -- anti-jointure : aucune session trouvée
ORDER BY s.mrr DESC;
 
-- account_id | plan | mrr
-- ACC-0412 | Business | 890
-- ACC-1187 | Pro | 290
-- ACC-0903 | Pro | 290
-- → 37 comptes, 6 420 € de MRR à risque
niveau-sql-premier-emploi · 08

Le pattern LEFT JOIN 
 WHERE droite.id IS NULL (anti-jointure) tombe dans quasiment tous les tests techniques. Alternative tout aussi valide : WHERE NOT EXISTS (
).

đŸ§Ș VĂ©rifie que tes jointures tiennent la route

Les jointures sont le premier point de rupture en test technique. Mesure en quelques minutes si tu sais anticiper la cardinalité de tes résultats.

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

_PiÚges de cardinalité · Score détaillé · Recommandations ciblées_


PARTIE 3 — CTE et sous-requĂȘtes : montrer que tu sais raisonner

À partir d'un certain niveau de complexitĂ©, le recruteur ne regarde plus seulement si ta requĂȘte est juste, mais comment tu l'as construite. Une requĂȘte de 40 lignes imbriquĂ©es sur 4 niveaux est un signal nĂ©gatif, mĂȘme si elle fonctionne.

La CTE (WITH 
 AS) te permet de dĂ©couper un problĂšme en Ă©tapes nommĂ©es, testables une par une. C'est exactement comme ça qu'on travaille en entreprise (et c'est la base de dbt).

❌ Ce que fait le dĂ©butant

-- Objectif : part des clients ayant recommandé dans les 60 jours aprÚs leur 1er achat
SELECT
COUNT(DISTINCT CASE WHEN o2.created_at <= DATE_ADD(f.premier_achat, INTERVAL DAY)
THEN f.user_id END) * .
/ COUNT(DISTINCT f.user_id)
FROM (SELECT user_id, MIN(created_at) AS premier_achat
FROM orders
GROUP BY user_id) f
LEFT JOIN orders o2
ON o2.user_id = f.user_id
AND o2.created_at > f.premier_achat;
-- ❌ illisible, impossible Ă  dĂ©bugger Ă©tape par Ă©tape,
-- ❌ et le recruteur ne peut pas suivre ton raisonnement
niveau-sql-premier-emploi · 09

✅ Ce qu'on attend d'un junior

WITH premier_achat AS (
-- Étape 1 : date du premier achat par client
SELECT user_id, MIN(created_at) AS date_premier_achat
FROM orders
WHERE statut = 'livré'
GROUP BY user_id
),
 
rachat_60j AS (
-- Étape 2 : clients ayant une 2e commande dans les 60 jours
SELECT DISTINCT p.user_id
FROM premier_achat p
JOIN orders o
ON o.user_id = p.user_id
AND o.statut = 'livré'
AND o.created_at > p.date_premier_achat
AND o.created_at <= DATE_ADD(p.date_premier_achat, INTERVAL DAY)
)
 
-- Étape 3 : le KPI final
SELECT
COUNT(*) AS nb_nouveaux_clients, -- 4 200
COUNT(r.user_id) AS nb_rachats_60j, -- 1 134
ROUND(COUNT(r.user_id) * . / COUNT(*), ) AS taux_rachat_60j_pct -- 27.0
FROM premier_achat p
LEFT JOIN rachat_60j r ON r.user_id = p.user_id;
niveau-sql-premier-emploi · 10

Le gain : chaque CTE a un nom mĂ©tier et une seule responsabilitĂ©. Tu peux faire SELECT * FROM premier_achat pour vĂ©rifier l'Ă©tape 1 avant de passer Ă  la suite. En entretien, tu commentes en mĂȘme temps que tu Ă©cris : c'est ton raisonnement qui est notĂ©.

Cas business — RH : turnover par dĂ©partement

La DRH veut le taux de départ 2026 par département, rapporté à l'effectif moyen.

WITH effectif_debut AS (
SELECT departement, COUNT(*) AS nb_debut
FROM employes
WHERE date_entree < '2026-01-01'
AND (date_sortie IS NULL OR date_sortie >= '2026-01-01')
GROUP BY departement
),
 
effectif_fin AS (
SELECT departement, COUNT(*) AS nb_fin
FROM employes
WHERE date_entree <= '2026-10-31'
AND (date_sortie IS NULL OR date_sortie > '2026-10-31')
GROUP BY departement
),
 
departs AS (
SELECT departement, COUNT(*) AS nb_departs
FROM employes
WHERE date_sortie BETWEEN '2026-01-01' AND '2026-10-31' -- colonne DATE : BETWEEN est sûr ici
GROUP BY departement
)
 
SELECT
d.departement,
d.nb_debut,
f.nb_fin,
COALESCE(dp.nb_departs, ) AS nb_departs,
ROUND(COALESCE(dp.nb_departs, ) * . / ((d.nb_debut + f.nb_fin) / .), ) AS turnover_pct
FROM effectif_debut d
JOIN effectif_fin f ON f.departement = d.departement
LEFT JOIN departs dp ON dp.departement = d.departement
ORDER BY turnover_pct DESC;
 
-- departement | nb_debut | nb_fin | nb_departs | turnover_pct
-- Sales | 48 | 52 | 11 | 22.0
-- Support | 30 | 28 | 5 | 17.2
-- Tech | 65 | 74 | 6 | 8.6
niveau-sql-premier-emploi · 11

đŸ§Ș EntraĂźne-toi Ă  structurer, pas juste Ă  Ă©crire

Sur Modai Lab, les cas complexes sont pensĂ©s pour ĂȘtre dĂ©coupĂ©s en Ă©tapes. Le feedback porte autant sur la lisibilitĂ© de ta requĂȘte que sur le rĂ©sultat.

👉 Pratiquer sur modai-lab.com

_Cas multi-étapes · Feedback sur la structure · Réflexes dbt-ready_


PARTIE 4 — Les fonctions de fenĂȘtre : le vrai diffĂ©renciateur

Si tu ne devais retenir qu'une partie de ce guide, c'est celle-ci.

Pour un premier poste, les fonctions de fenĂȘtre font la diffĂ©rence entre "profil junior moyen" et "profil qu'on veut recruter". Pourquoi ? Parce qu'elles rĂ©solvent les questions mĂ©tier les plus frĂ©quentes : dernier Ă©vĂ©nement par client, classement, Ă©volution d'une pĂ©riode Ă  l'autre, cumul.

Le mĂ©canisme clĂ© : contrairement Ă  GROUP BY, une fonction de fenĂȘtre ne rĂ©duit pas le nombre de lignes. Elle calcule une valeur pour chaque ligne en regardant un groupe de lignes voisines (PARTITION BY) dans un certain ordre (ORDER BY).

Les 5 Ă  connaĂźtre pour un premier poste :

Fonction

Usage typique

ROW_NUMBER()

Dédoublonner, garder la derniÚre ligne par entité

RANK() / DENSE_RANK()

Top N avec gestion des ex ĂŠquo

LAG() / LEAD()

Comparer à la période précédente / suivante

SUM() OVER (ORDER BY 
)

Cumul, running total

AVG() OVER (ROWS BETWEEN 
)

Moyenne mobile

❌ Ce que fait le dĂ©butant

-- Objectif : la derniĂšre commande de chaque client (montant inclus)
SELECT user_id, MAX(created_at) AS derniere_date, montant
FROM orders
GROUP BY user_id;
-- ❌ erreur : montant n'est ni agrĂ©gĂ© ni dans le GROUP BY
-- (et sur certains moteurs permissifs, renvoie un montant au hasard !)
 
-- Tentative de correction par auto-jointure :
SELECT o.user_id, o.created_at, o.montant
FROM orders o
JOIN (SELECT user_id, MAX(created_at) AS max_date
FROM orders GROUP BY user_id) m
ON m.user_id = o.user_id AND m.max_date = o.created_at;
-- ⚠ fonctionne, mais doublons si deux commandes ont le mĂȘme timestamp
-- et la requĂȘte devient lourde dĂšs qu'on ajoute des critĂšres
niveau-sql-premier-emploi · 12

✅ Ce qu'on attend d'un junior

WITH commandes_classees AS (
SELECT
user_id,
order_id,
created_at,
montant,
ROW_NUMBER() OVER (
PARTITION BY user_id -- une numérotation par client
ORDER BY created_at DESC, order_id DESC -- la plus récente = 1 (order_id départage les égalités)
) AS rang
FROM orders
)
SELECT user_id, order_id, created_at, montant
FROM commandes_classees
WHERE rang = ;
 
-- Avant (orders) AprĂšs
-- user_id | created_at | montant user_id | created_at | montant
-- A | 2026-09-02 10:00 | 45 A | 2026-10-15 18:20 | 120
-- A | 2026-10-15 18:20 | 120 B | 2026-10-01 09:05 | 60
-- B | 2026-10-01 09:05 | 60
niveau-sql-premier-emploi · 13

Et sur BigQuery, la version raccourcie que tu peux citer en bonus :

SELECT user_id, order_id, created_at, montant
FROM orders
QUALIFY ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC, order_id DESC) = ;
niveau-sql-premier-emploi · 14

Cas business — Finance : Ă©volution mensuelle du CA et cumul annuel

Le contrÎle de gestion veut, pour chaque mois de 2026 : le CA, la variation vs mois précédent, et le cumul depuis janvier.

WITH ca_mensuel AS (
SELECT
DATE_TRUNC(created_at, MONTH) AS mois,
SUM(montant) AS ca
FROM orders
WHERE statut = 'livré'
AND created_at >= '2026-01-01'
GROUP BY mois
)
SELECT
mois,
ca,
LAG(ca) OVER (ORDER BY mois) AS ca_mois_prec,
ROUND((ca - LAG(ca) OVER (ORDER BY mois)) * .
/ LAG(ca) OVER (ORDER BY mois), ) AS variation_pct,
SUM(ca) OVER (ORDER BY mois
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS ca_cumule
FROM ca_mensuel
ORDER BY mois;
 
-- mois | ca | ca_mois_prec | variation_pct | ca_cumule
-- 2026-01-01 | 182 000 | NULL | NULL | 182 000
-- 2026-02-01 | 168 500 | 182 000 | -7.4 | 350 500
-- 2026-03-01 | 201 300 | 168 500 | 19.5 | 551 800
-- 2026-04-01 | 214 900 | 201 300 | 6.8 | 766 700
niveau-sql-premier-emploi · 15

Bonus entretien : explique pourquoi la premiÚre ligne a une variation NULL (pas de mois précédent) et comment tu la gérerais (laisser NULL plutÎt que mettre 0, qui serait faux).

đŸ§Ș Mesure ton niveau sur les fonctions de fenĂȘtre

C'est la compĂ©tence qui sĂ©pare le plus nettement les candidats. Le test Modai Lab inclut des questions de fenĂȘtres calibrĂ©es sur ce qu'on demande vraiment en entretien junior.

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

_ROW_NUMBER, LAG, cumuls · Niveau situé · Plan de progression_


PARTIE 5 — Dates et CASE WHEN : parler le langage du mĂ©tier

Les managers ne te demanderont jamais "fais-moi un GROUP BY". Ils te demanderont : "combien de clients actifs par cohorte ?", "quelle part de gros paniers ?", "le CA de cette semaine vs la mĂȘme semaine l'an dernier ?".

Pour traduire ces questions, deux outils reviennent en permanence :

  • Les fonctions de dates : DATE_TRUNC, DATE_DIFF, DATE_ADD, EXTRACT (la syntaxe varie selon le moteur, le raisonnement non)

  • CASE WHEN : pour segmenter, crĂ©er des catĂ©gories, et faire des agrĂ©gations conditionnelles

❌ Ce que fait le dĂ©butant

-- Objectif : répartition des commandes par tranche de panier, par mois
SELECT DATE_TRUNC(created_at, MONTH) AS mois, 'petit' AS tranche, COUNT(*) AS nb
FROM orders WHERE montant < GROUP BY mois
UNION ALL
SELECT DATE_TRUNC(created_at, MONTH), 'moyen', COUNT(*)
FROM orders WHERE montant BETWEEN AND GROUP BY
UNION ALL
SELECT DATE_TRUNC(created_at, MONTH), 'gros', COUNT(*)
FROM orders WHERE montant > GROUP BY ;
-- ❌ 3 lectures de la table au lieu d'une (coĂ»t x3 sur BigQuery)
-- ❌ tranches fragiles : un montant NULL n'apparaüt nulle part, et personne ne s'en rend compte
-- ❌ format long difficile à lire pour un manager
niveau-sql-premier-emploi · 16

✅ Ce qu'on attend d'un junior

SELECT
DATE_TRUNC(created_at, MONTH) AS mois,
COUNT(*) AS nb_total,
COUNTIF(montant < ) AS nb_petit, -- BigQuery
COUNTIF(montant >= AND montant <= ) AS nb_moyen,
COUNTIF(montant > ) AS nb_gros,
SUM(CASE WHEN montant > THEN montant ELSE END) AS ca_gros, -- version portable
COUNTIF(montant IS NULL) AS nb_sans_montant -- on contrĂŽle les trous
FROM orders
GROUP BY mois
ORDER BY mois;
 
-- mois | nb_total | nb_petit | nb_moyen | nb_gros | ca_gros | nb_sans_montant
-- 2026-09-01 | 3 120 | 1 410 | 1 380 | 322 | 68 900 | 8
-- 2026-10-01 | 3 480 | 1 520 | 1 560 | 397 | 86 200 | 3
niveau-sql-premier-emploi · 17

Une seule lecture de table, un tableau lisible directement par le mĂ©tier, et un contrĂŽle explicite des NULL. Trois signaux de sĂ©nioritĂ© en une requĂȘte.

Cas business — SaaS : rĂ©tention par cohorte d'inscription

Le Head of Growth veut savoir, pour chaque cohorte mensuelle d'inscription, quel pourcentage d'utilisateurs est encore actif 1, 2 et 3 mois aprĂšs.

WITH cohortes AS (
SELECT
user_id,
DATE_TRUNC(created_at, MONTH) AS mois_cohorte
FROM users
WHERE created_at >= '2026-04-01'
),
 
activite AS (
SELECT DISTINCT
user_id,
DATE_TRUNC(started_at, MONTH) AS mois_activite
FROM sessions
),
 
cohorte_activite AS (
SELECT
c.mois_cohorte,
c.user_id,
DATE_DIFF(a.mois_activite, c.mois_cohorte, MONTH) AS mois_ecoule
FROM cohortes c
LEFT JOIN activite a ON a.user_id = c.user_id
)
 
SELECT
mois_cohorte,
COUNT(DISTINCT user_id) AS taille_cohorte,
ROUND(COUNT(DISTINCT CASE WHEN mois_ecoule = THEN user_id END) * .
/ COUNT(DISTINCT user_id), ) AS retention_m1_pct,
ROUND(COUNT(DISTINCT CASE WHEN mois_ecoule = THEN user_id END) * .
/ COUNT(DISTINCT user_id), ) AS retention_m2_pct,
ROUND(COUNT(DISTINCT CASE WHEN mois_ecoule = THEN user_id END) * .
/ COUNT(DISTINCT user_id), ) AS retention_m3_pct
FROM cohorte_activite
GROUP BY mois_cohorte
ORDER BY mois_cohorte;
 
-- mois_cohorte | taille_cohorte | retention_m1_pct | retention_m2_pct | retention_m3_pct
-- 2026-04-01 | 1 250 | 42.4 | 31.2 | 26.8
-- 2026-05-01 | 1 410 | 45.1 | 33.0 | 28.3
-- 2026-06-01 | 1 380 | 47.9 | 35.6 | 30.1
niveau-sql-premier-emploi · 18

Si tu sais Ă©crire et expliquer cette requĂȘte, tu as le niveau attendu d'un Data Analyst junior dans une startup SaaS. Point.

đŸ§Ș Pratique les analyses que les managers demandent vraiment

Cohortes, segmentation, comparaisons de périodes : sur Modai Lab, chaque exercice part d'une question métier, pas d'une consigne technique.

👉 Pratiquer sur modai-lab.com

_Questions de managers réels · Données de production · Feedback senior_


PARTIE 6 — Ce que les entretiens testent vraiment (et ce qu'ils ne testent pas)

Les 3 formats que tu vas rencontrer

  1. Le test en ligne chronomĂ©trĂ© (45-90 min, plateforme type HackerRank / CoderPad ou interne) : 4 Ă  8 questions de difficultĂ© croissante. Les premiĂšres vĂ©rifient le socle, les derniĂšres les fenĂȘtres et les CTE.

  2. Le live coding (30-45 min avec un data de l'Ă©quipe) : on te donne un schĂ©ma de 3-4 tables et une question mĂ©tier. On Ă©value ton raisonnement Ă  voix haute autant que ta requĂȘte.

  3. Le take-home (cas à rendre sous 3-7 jours) : un dataset, une question ouverte, une restitution. On évalue SQL + capacité à tirer une conclusion business.

Ce qui fait la différence en live coding

  • Clarifier avant d'Ă©crire : "Une commande annulĂ©e compte-t-elle ? Je prends la date de crĂ©ation ou de livraison ?"

  • Annoncer la granularitĂ© : "Je veux une ligne par client et par mois."

  • Construire par Ă©tapes : une CTE, on vĂ©rifie, la suivante.

  • ContrĂŽler le rĂ©sultat : "Je m'attends Ă  environ X lignes, vĂ©rifions."

  • Admettre une syntaxe oubliĂ©e : "Je ne me souviens plus si c'est DATE_DIFF ou DATEDIFF ici, mais l'idĂ©e est
" Ça passe trĂšs bien. Bloquer en silence, beaucoup moins.

❌ Ce que le junior croit devoir maütriser (et qu'on ne lui demande quasiment jamais)

-- Création d'index, plans d'exécution détaillés
CREATE INDEX idx_orders_user ON orders(user_id);
 
-- Procédures stockées et triggers
CREATE PROCEDURE maj_stats() ...
 
-- Récursivité avancée
WITH RECURSIVE hierarchie AS (...)
 
-- Tuning de partitions, clustering, gestion des transactions
niveau-sql-premier-emploi · 19

Ces sujets ont leur place plus tard dans ta carriÚre (ou pour des postes Data Engineer). Pour un premier poste Data Analyst / BI, une notion suffit ("je sais que l'index accélÚre les recherches sur une colonne"), pas une maßtrise.

✅ Ce que le junior doit vraiment maütriser en plus du SQL pur

-- 1. Penser coût sur un data warehouse (BigQuery facture au volume scanné)
SELECT user_id, montant, created_at -- ✅ colonnes nĂ©cessaires uniquement, pas de SELECT *
FROM orders
WHERE created_at >= '2026-10-01'; -- ✅ filtre sur la colonne de partition
 
-- 2. Vérifier l'unicité d'une clé avant de joindre
SELECT user_id, COUNT(*) AS nb
FROM users
GROUP BY user_id
HAVING COUNT(*) > ; -- ✅ 0 ligne attendue, sinon la jointure va dupliquer
 
-- 3. Réconcilier un chiffre avec une source connue
SELECT
COUNT(*) AS nb_commandes, -- comparer au chiffre du back-office
SUM(montant) AS ca -- comparer au chiffre de la compta
FROM orders
WHERE created_at >= '2026-10-01' AND created_at < '2026-11-01';
niveau-sql-premier-emploi · 20

Ces trois réflexes (coût, unicité, réconciliation) sont rarement enseignés et pourtant systématiquement appréciés. Ils montrent que tu as déjà pensé comme quelqu'un qui livre des chiffres en production.

Cas business — E-commerce : le cas type de live coding

Voici un énoncé trÚs proche de ce qu'on donne réellement en entretien junior :

_"On a les tables users, orders et products. Donne-moi, pour chaque catégorie de produit, les 3 clients qui ont le plus dépensé en 2026, avec leur montant total et leur rang."_

WITH depenses AS (
-- Étape 1 : granularitĂ© = 1 ligne par (catĂ©gorie, client)
SELECT
p.categorie,
o.user_id,
SUM(o.montant) AS total_depense
FROM orders o
JOIN products p ON p.product_id = o.product_id
WHERE o.statut = 'livré'
AND o.created_at >= '2026-01-01'
GROUP BY p.categorie, o.user_id
),
 
classement AS (
-- Étape 2 : rang par catĂ©gorie (DENSE_RANK → les ex ĂŠquo partagent le rang)
SELECT
categorie,
user_id,
total_depense,
DENSE_RANK() OVER (PARTITION BY categorie ORDER BY total_depense DESC) AS rang
FROM depenses
)
 
-- Étape 3 : on garde le top 3
SELECT categorie, rang, user_id, total_depense
FROM classement
WHERE rang <=
ORDER BY categorie, rang;
 
-- categorie | rang | user_id | total_depense
-- Maison | 1 | U-2231 | 3 840
-- Maison | 2 | U-0918 | 2 910
-- Maison | 2 | U-4470 | 2 910 ← ex ĂŠquo, mĂȘme rang
-- Maison | 3 | U-1102 | 2 455
-- Sport | 1 | U-3307 | 4 120
-- ...
niveau-sql-premier-emploi · 21

La question piĂšge qui suit presque toujours : _"Pourquoi DENSE_RANK et pas ROW_NUMBER ou RANK ?"_

  • ROW_NUMBER : exclut arbitrairement un des ex ĂŠquo (1, 2, 3, 4)

  • RANK : saute un rang aprĂšs une Ă©galitĂ© (1, 2, 2, 4) → le client Ă  2 455 € disparaĂźtrait du top 3

  • DENSE_RANK : ne saute pas (1, 2, 2, 3) → tous les "top 3 montants" sont prĂ©sents

Savoir justifier ce choix, c'est exactement le niveau attendu.

đŸ§Ș Simule ton entretien avant le vrai

Le test Modai Lab reproduit la progression d'un test technique junior : socle, jointures, fenĂȘtres. Tu sais en 5 minutes oĂč tu en es, et ce qu'il te reste Ă  travailler avant de postuler.

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

_Format entretien · Niveau junior calibré · Points faibles identifiés_


Prompt Claude pour auditer tes requĂȘtes

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

Tu es un Lead Data Analyst qui fait passer des entretiens techniques SQL
pour des postes de Data Analyst junior. Je vais te donner une requĂȘte SQL
que j'ai écrite, avec la question métier qu'elle doit résoudre.
 
Ta mission : Ă©valuer ma requĂȘte comme tu le ferais en entretien.
 
1. VÉRIFICATIONS DE JUSTESSE
- Ordre logique : y a-t-il un agrégat filtré dans WHERE au lieu de HAVING ?
- NULL : un filtre (<>, NOT IN, =) exclut-il des lignes NULL sans le vouloir ?
- COUNT : COUNT(*) vs COUNT(colonne) vs COUNT(DISTINCT) est-il le bon choix ?
- Jointures : y a-t-il un risque de fan-out (doublons) ? Un LEFT JOIN
transformé en INNER JOIN par un filtre dans le WHERE ?
- Dates : les bornes sont-elles correctes (BETWEEN sur un timestamp,
borne de fin incluse/exclue) ?
- FenĂȘtres : PARTITION BY et ORDER BY sont-ils corrects ? Le choix
ROW_NUMBER / RANK / DENSE_RANK est-il justifié vis-à-vis des ex Êquo ?
- Divisions : risque de division par zéro ou de division entiÚre ?
 
2. VÉRIFICATIONS DE QUALITÉ
- La requĂȘte est-elle dĂ©coupĂ©e en CTE lisibles avec des noms mĂ©tier ?
- Y a-t-il des SELECT * ou des lectures de table répétées inutiles ?
- La granularité du résultat final est-elle claire ?
 
3. VERDICT ENTRETIEN
- Donne une note sur 10 et dis-moi si cette requĂȘte me ferait passer
un test technique de Data Analyst junior.
- Liste les 3 questions de relance qu'un recruteur me poserait
sur cette requĂȘte.
 
4. VERSION CORRIGÉE
- Réécris la requĂȘte en version "senior" avec des commentaires SQL
expliquant chaque correction.
- Pour chaque correction, montre un mini-exemple de données (3-4 lignes)
oĂč ma version donnait un rĂ©sultat faux.
 
Sois direct et précis. Ne me félicite pas pour ce qui est basique.
 
Question métier :
[colle ici la question]
 
Schéma des tables (si disponible) :
[colle ici les tables et colonnes]
 
Ma requĂȘte :
[colle ici ta requĂȘte]
niveau-sql-premier-emploi · 22

📋 RĂ©capitulatif : le niveau SQL attendu pour un premier poste data

Bloc

Tu dois savoir


PiÚge n°1 à éviter

RequĂȘte-test

Socle

WHERE vs HAVING, COUNT, NULL, ORDER BY

<> qui exclut les NULL

CA par rĂ©gion > 10 k€

Jointures

INNER, LEFT, anti-jointure, granularité

Filtre de droite dans le WHERE

Comptes payants sans session

CTE

Découper en étapes nommées

Sous-requĂȘtes imbriquĂ©es illisibles

Taux de rachat Ă  60 jours

FenĂȘtres

ROW_NUMBER, DENSE_RANK, LAG, SUM OVER

GROUP BY pour "la derniĂšre ligne"

DerniĂšre commande par client

Dates & CASE

DATE_TRUNC, DATE_DIFF, agrégats conditionnels

BETWEEN sur un timestamp

Rétention par cohorte

Réflexes pro

Coût, unicité des clés, réconciliation

SELECT * sur une table partitionnée

ContrÎle de doublons sur une clé

Hors scope junior

Index, procédures, triggers, tuning

Y passer des semaines

—


✅ Checklist : suis-je prĂȘt Ă  postuler ?

  • ☐ Je sais expliquer l'ordre d'exĂ©cution logique d'une requĂȘte (FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY)

  • ☐ Je ne mets jamais un agrĂ©gat dans un WHERE

  • ☐ Je sais pourquoi statut <> 'annulĂ©' peut exclure des lignes que je voulais garder

  • ☐ Je connais la diffĂ©rence entre COUNT(*), COUNT(col) et COUNT(DISTINCT col)

  • ☐ J'annonce la granularitĂ© de chaque table avant d'Ă©crire un JOIN

  • ☐ Je sais pourquoi un filtre sur la table de droite d'un LEFT JOIN va dans le ON

  • ☐ Je sais Ă©crire une anti-jointure (LEFT JOIN 
 IS NULL ou NOT EXISTS)

  • ☐ Je sais dĂ©tecter et Ă©viter un fan-out (agrĂ©ger avant de joindre)

  • ☐ Je dĂ©coupe spontanĂ©ment une requĂȘte complexe en CTE nommĂ©es

  • ☐ Je sais sortir la derniĂšre ligne par entitĂ© avec ROW_NUMBER()

  • ☐ Je sais justifier le choix entre ROW_NUMBER, RANK et DENSE_RANK

  • ☐ Je sais calculer une variation vs pĂ©riode prĂ©cĂ©dente avec LAG()

  • ☐ Je sais calculer un cumul avec SUM() OVER (ORDER BY 
)

  • ☐ Je sais construire une analyse de cohorte de rĂ©tention

  • ☐ Je sais faire un agrĂ©gat conditionnel avec CASE WHEN dans un SUM / COUNT

  • ☐ Je n'utilise pas BETWEEN sur un timestamp sans rĂ©flĂ©chir Ă  la borne de fin

  • ☐ Je vĂ©rifie l'unicitĂ© d'une clĂ© avant de m'en servir pour joindre

  • ☐ Je contrĂŽle mes rĂ©sultats (nombre de lignes, rĂ©conciliation avec un chiffre connu)

  • ☐ Je sais rĂ©flĂ©chir Ă  voix haute en Ă©crivant une requĂȘte

  • ☐ Je ne perds plus de temps sur les index et les procĂ©dures stockĂ©es avant mon premier poste

Si tu coches 16 cases ou plus : tu as le niveau SQL d'un premier poste data. Postule.


🚀 Passe de "je connais SQL" à "je suis recrutable"

Le niveau attendu pour un premier poste n'est pas flou : c'est le socle sans faille, des jointures maĂźtrisĂ©es et les fonctions de fenĂȘtre. Le plus court chemin pour l'atteindre, c'est de pratiquer sur des cas business rĂ©els avec un feedback qui te dit exactement oĂč tu bloques.

👉 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 ♻_