Guide pratique · Data, Produit, Marketing, Finance, RH · Lecture : ~18 min Teste ton niveau sur modai-lab.com/test-sql/


Pourquoi ce guide existe

« Le SQL, c'est pour les data analysts. » C'est faux, et c'est sans doute la croyance qui coûte le plus cher en début de carrière.

Dans les faits, le SQL est devenu la langue commune de toute personne qui doit répondre à une question avec des données sans attendre qu'un autre le fasse à sa place. Le product manager qui veut comprendre pourquoi son funnel fuit, le contrôleur de gestion qui rapproche factures et paiements, la HR business partner qui calcule un turnover : tous finissent devant une table.

Le problème, c'est que chaque métier utilise le SQL différemment, et commet ses propres erreurs. Un data scientist ne se trompe pas comme un contrôleur de gestion. Les tutos génériques ne te disent jamais ça.

Ce guide couvre :

  • Les 6 grandes familles de métiers qui écrivent du SQL au quotidien

  • Pour chacune : à quoi sert le SQL concrètement, avec une requête type

  • L'erreur classique de chaque métier (❌) et la version senior (✅)

  • Un cas business chiffré par métier : e-commerce, SaaS, finance, RH

  • Un tableau des niveaux attendus pour savoir où tu dois en être selon ton poste visé

  • Un prompt Claude pour auditer tes requêtes avec l'œil du métier que tu vises

Les exemples sont écrits en SQL standard (syntaxe PostgreSQL). Ils se transposent sans effort sur BigQuery, Snowflake ou SQL Server.


🧪 Calibre ton niveau avant de commencer

Tu vises un poste de data analyst, de PM ou de contrôleur de gestion ? Avant de lire ce que chaque métier attend, regarde où tu en es vraiment : jointures, agrégations, fonctions de fenêtre, CTE. 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 — Data Analyst & BI : le SQL comme outil principal

Ce que fait le SQL dans ce métier

Pour un data analyst ou un développeur BI, le SQL n'est pas une compétence parmi d'autres : c'est 80 % du temps de travail. Il sert à :

  • construire les KPI des dashboards (CA, panier moyen, taux de conversion)

  • répondre aux questions ad hoc du business (« combien de clients ont commandé deux fois en octobre ? »)

  • préparer les jeux de données qui alimentent Looker, Power BI, Tableau ou Metabase

  • vérifier qu'un chiffre affiché est juste quand quelqu'un le conteste

Ce qui distingue un analyste junior d'un senior, ce n'est pas la syntaxe. C'est la fiabilité du chiffre. Le senior sait qu'une jointure peut dupliquer des lignes, qu'une commande annulée ne fait pas de CA, et qu'un COUNT(*) ne compte pas toujours ce que tu crois.

L'erreur classique de l'analyste : le chiffre gonflé par la jointure

-- ❌ VERSION PROBLÉMATIQUE
-- Objectif : panier moyen et nombre de commandes par région en octobre
 
-- Tables :
-- orders (order_id, user_id, created_at, montant, statut)
-- order_items (order_id, product_id, quantite) -- plusieurs lignes par commande
 
SELECT
u.region,
COUNT(*) AS nb_commandes, -- compte des LIGNES d'articles, pas des commandes
AVG(o.montant) AS panier_moyen -- chaque commande pèse autant de fois qu'elle a d'articles
FROM orders o
JOIN users u ON u.user_id = o.user_id
JOIN order_items oi ON oi.order_id = o.order_id -- la jointure multiplie les lignes
WHERE o.created_at >= '2026-10-01'
AND o.created_at < '2026-11-01'
-- aucune exclusion des commandes annulées ou remboursées
GROUP BY u.region;
 
-- Exemple pour une commande de 120 € avec 3 articles :
-- order_id | montant | product_id
-- 5012 | 120.00 | P01
-- 5012 | 120.00 | P07
-- 5012 | 120.00 | P11
-- → comptée 3 fois dans nb_commandes, et pondérée x3 dans le panier moyen
metiers-sql · 01

Résultat : les grosses commandes multi-articles pèsent plus lourd, le panier moyen est faux, et le nombre de commandes est surévalué. Personne ne s'en rend compte… jusqu'au jour où la finance compare avec son propre chiffre.

-- ✅ VERSION CORRIGÉE
-- On ne joint que ce dont on a besoin, on compte des commandes distinctes,
-- et on exclut explicitement les statuts qui ne sont pas du CA.
 
SELECT
u.region,
COUNT(DISTINCT o.order_id) AS nb_commandes,
ROUND(SUM(o.montant) / COUNT(DISTINCT o.order_id), ) AS panier_moyen,
SUM(o.montant) AS ca_total
FROM orders o
JOIN users u ON u.user_id = o.user_id -- jointure 1-1 côté commande : aucune duplication
WHERE o.created_at >= '2026-10-01'
AND o.created_at < '2026-11-01' -- borne haute exclusive : pas de souci d'heure
AND o.statut IN ('payee', 'livree') -- on définit ce qu'est une commande "valide"
GROUP BY u.region
ORDER BY ca_total DESC;
 
-- Gain : 1 ligne = 1 commande. Le panier moyen est le vrai panier moyen,
-- et le chiffre est réconciliable avec la finance.
metiers-sql · 02

Le réflexe senior : avant toute agrégation, se demander « quel est le grain de ma table après les jointures ? » Si la réponse n'est pas « une ligne par commande », le AVG et le COUNT(*) mentent.

Cas business — E-commerce : le reporting mensuel du lundi

Une boutique en ligne de mobilier (≈ 4 200 commandes par mois) veut un tableau qui compare chaque région au mois précédent.

-- CA mensuel par région, avec évolution vs mois précédent
WITH ventes_mensuelles AS (
SELECT
DATE_TRUNC('month', o.created_at)::date AS mois,
u.region,
COUNT(DISTINCT o.order_id) AS nb_commandes,
SUM(o.montant) AS ca
FROM orders o
JOIN users u ON u.user_id = o.user_id
WHERE o.statut IN ('payee', 'livree')
AND o.created_at >= '2026-01-01'
GROUP BY ,
)
SELECT
mois,
region,
nb_commandes,
ca,
ROUND(ca / nb_commandes, ) AS panier_moyen,
LAG(ca) OVER (PARTITION BY region ORDER BY mois) AS ca_mois_precedent,
ROUND(. * (ca - LAG(ca) OVER (PARTITION BY region ORDER BY mois))
/ NULLIF(LAG(ca) OVER (PARTITION BY region ORDER BY mois), ), ) AS evolution_pct
FROM ventes_mensuelles
ORDER BY region, mois;
 
-- Extrait du résultat :
-- mois | region | nb_commandes | ca | panier_moyen | ca_mois_precedent | evolution_pct
-- 2026-09-01 | Île-de-France | 1 480 | 287 120 | 194.00 | 263 900 | 8.8
-- 2026-10-01 | Île-de-France | 1 562 | 305 840 | 195.80 | 287 120 | 6.5
-- 2026-10-01 | Occitanie | 612 | 102 210 | 167.01 | 109 480 | -6.6
metiers-sql · 03

Les compétences mobilisées ici sont exactement celles qu'on attend en entretien analyste : CTE, DATE_TRUNC, COUNT(DISTINCT), LAG, et NULLIF pour éviter la division par zéro.

🧪 Entraîne-toi sur des KPI e-commerce réels

Sur Modai Lab, tu construis des reportings comme celui-ci à partir de datasets de production : commandes, retours, remboursements, avec les pièges de grain qui vont avec.

👉 Pratiquer sur modai-lab.com

_Datasets réalistes · Correction ligne par ligne · Niveau analyste confirmé_


PARTIE 2 — Analytics Engineer & Data Engineer : le SQL qui construit les fondations

Ce que fait le SQL dans ce métier

L'analyste consomme des tables. L'analytics engineer et le data engineer les fabriquent. Leur SQL ne répond pas à une question ponctuelle : il tourne tous les jours, en production, et des dizaines de dashboards en dépendent.

Concrètement :

  • écrire les modèles de transformation (souvent avec dbt) : staging → intermediate → marts

  • garantir le grain de chaque table (une ligne par client, par jour, par abonnement…)

  • écrire des tests de qualité en SQL (unicité, non-nullité, cohérence entre tables)

  • optimiser les coûts et la performance sur BigQuery, Snowflake ou Redshift

Ici, l'exigence n'est plus seulement « le chiffre est juste aujourd'hui ». C'est « le chiffre restera juste quand les données changeront ».

L'erreur classique de l'engineer junior : la requête monolithe

-- ❌ VERSION PROBLÉMATIQUE
-- Calcul du MRR par mois, écrit d'un seul bloc, logique métier dupliquée
 
SELECT
DATE_TRUNC('month', s.start_date) AS mois,
SUM(CASE WHEN s.periodicite = 'annuel' THEN s.prix / ELSE s.prix END) AS mrr
FROM subscriptions s
WHERE s.statut != 'annule' -- un abonnement annulé en novembre a pourtant
-- généré du MRR de janvier à octobre
GROUP BY ;
 
-- Problèmes :
-- 1. Le MRR est rattaché au mois de DÉBUT, pas aux mois où l'abonnement est actif
-- 2. Les abonnements annulés disparaissent de tout l'historique
-- 3. La règle "annuel / 12" sera recopiée dans 5 autres requêtes,
-- et le jour où elle change, 4 sur 5 seront oubliées
-- 4. Aucun test : si subscriptions contient des doublons, personne ne le voit
metiers-sql · 04
-- ✅ VERSION CORRIGÉE
-- Logique découpée en étapes nommées, grain explicite à chaque étape.
 
WITH abonnements_normalises AS (
-- Étape 1 : une ligne par abonnement, prix ramené au mois (règle définie UNE fois)
SELECT
subscription_id,
user_id,
start_date,
COALESCE(end_date, DATE '2099-12-31') AS end_date, -- abonnement en cours = pas de fin
CASE WHEN periodicite = 'annuel' THEN prix / . ELSE prix END AS prix_mensuel
FROM subscriptions
),
calendrier AS (
-- Étape 2 : un mois par ligne
SELECT generate_series(DATE '2026-01-01', DATE '2026-10-01', INTERVAL '1 month')::date AS mois
),
mrr_par_abonnement_mois AS (
-- Étape 3 : grain = 1 ligne par (abonnement, mois où il est actif)
SELECT c.mois, a.subscription_id, a.prix_mensuel
FROM calendrier c
JOIN abonnements_normalises a
ON a.start_date <= c.mois
AND a.end_date > c.mois
)
SELECT
mois,
COUNT(*) AS nb_abonnements_actifs,
SUM(prix_mensuel) AS mrr
FROM mrr_par_abonnement_mois
GROUP BY mois
ORDER BY mois;
 
-- Gain : un abonnement annulé en novembre compte bien dans le MRR
-- de janvier à octobre. Chaque étape est testable séparément,
-- et dans dbt chacune deviendrait un modèle réutilisable.
metiers-sql · 05

Et le test qui va avec, à faire tourner à chaque exécution :

-- Test d'unicité : doit retourner 0 ligne
SELECT subscription_id, COUNT(*) AS nb
FROM subscriptions
GROUP BY subscription_id
HAVING COUNT(*) > ;
metiers-sql · 06

Cas business — SaaS : la table `fct_mrr` qui alimente le board

Un éditeur SaaS B2B (≈ 1 850 abonnements actifs, offres mensuelles à 49 € et annuelles à 470 €) présente chaque mois son MRR au board. Avec la version monolithe, le MRR d'avril affichait 58 300 €. Avec la version corrigée, qui garde dans l'historique les abonnements résiliés depuis, il remonte à 64 900 €.

L'écart de 6 600 € venait uniquement des clients résiliés après avril, effacés rétroactivement de l'historique. C'est exactement le type de bug qu'un analytics engineer est payé pour empêcher.

🧪 Teste tes réflexes de modélisation

Grain, CTE, generate_series, tests d'unicité : le test Modai Lab te dit si tu as le niveau pour écrire du SQL de production ou si tu restes sur du requêtage ad hoc.

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

_5 minutes · Niveau de modélisation évalué · Points faibles identifiés_


PARTIE 3 — Data Scientist : le SQL avant le modèle

Ce que fait le SQL dans ce métier

On imagine le data scientist dans des notebooks Python. En réalité, la moitié de son travail se fait en SQL, avant même d'ouvrir pandas :

  • extraire et filtrer les données de l'entrepôt (impossible de charger 2 milliards de lignes dans un notebook)

  • construire les features : nombre de connexions sur 30 jours, montant moyen, ancienneté…

  • définir la cible (le client a-t-il churné dans les 60 jours ?)

  • préparer des jeux d'entraînement et de test propres

Le piège numéro un du data scientist en SQL n'est pas syntaxique. C'est la fuite de données (data leakage) : utiliser, pour prédire un événement, des informations qui n'existaient pas encore au moment de la prédiction.

L'erreur classique du data scientist : les features qui voient le futur

-- ❌ VERSION PROBLÉMATIQUE
-- Objectif : prédire si un client va churner après le 1er septembre 2026
 
SELECT
u.user_id,
COUNT(s.session_id) AS nb_sessions, -- TOUTES les sessions, y compris
-- celles d'octobre et novembre
MAX(s.created_at) AS derniere_session, -- un client churné a forcément une
-- dernière session ancienne → la feature
-- "contient" déjà la réponse
CASE WHEN sub.end_date IS NOT NULL THEN ELSE END AS a_churne
FROM users u
LEFT JOIN sessions s ON s.user_id = u.user_id
LEFT JOIN subscriptions sub ON sub.user_id = u.user_id
GROUP BY u.user_id, sub.end_date;
 
-- Le modèle obtiendra 0.97 d'AUC à l'entraînement…
-- et sera inutilisable en production.
metiers-sql · 07
-- ✅ VERSION CORRIGÉE
-- Une date de snapshot. Les features ne regardent QUE le passé,
-- la cible ne regarde QUE le futur.
 
WITH params AS (
SELECT DATE '2026-09-01' AS snapshot_date
),
clients_actifs AS (
-- Population : clients avec un abonnement actif au snapshot
SELECT sub.user_id, sub.end_date
FROM subscriptions sub, params p
WHERE sub.start_date <= p.snapshot_date
AND (sub.end_date IS NULL OR sub.end_date > p.snapshot_date)
),
features AS (
SELECT
c.user_id,
COUNT(s.session_id) FILTER (
WHERE s.created_at >= p.snapshot_date - INTERVAL '30 days'
) AS nb_sessions_30j,
COUNT(s.session_id) FILTER (
WHERE s.created_at >= p.snapshot_date - INTERVAL '90 days'
) AS nb_sessions_90j,
p.snapshot_date - MAX(s.created_at)::date AS jours_depuis_derniere_session
FROM clients_actifs c
CROSS JOIN params p
LEFT JOIN sessions s
ON s.user_id = c.user_id
AND s.created_at < p.snapshot_date -- ⚠️ la ligne qui change tout
GROUP BY c.user_id, p.snapshot_date
)
SELECT
f.*,
CASE
WHEN c.end_date IS NOT NULL
AND c.end_date <= (SELECT snapshot_date FROM params) + INTERVAL '60 days'
THEN ELSE
END AS churn_60j -- cible : uniquement le futur
FROM features f
JOIN clients_actifs c ON c.user_id = f.user_id;
 
-- Exemple de sortie :
-- user_id | nb_sessions_30j | nb_sessions_90j | jours_depuis_derniere_session | churn_60j
-- 10442 | 0 | 3 | 41 | 1
-- 10457 | 18 | 61 | 1 | 0
metiers-sql · 08

Gain : le dataset reproduit exactement la situation de production (« au 1er septembre, avec ce qu'on savait ce jour-là, ce client va-t-il partir ? »). Le score baisse à l'entraînement, mais il tient en conditions réelles.

Cas business — SaaS : le modèle de churn qui ne marchait pas

Une plateforme de facturation pour indépendants (≈ 12 000 abonnés) avait entraîné un modèle de churn à 0,94 d'AUC. En production, ses recommandations étaient à peine meilleures que le hasard. La cause : la feature derniere_session calculée sans borne temporelle. Après correction avec un snapshot, l'AUC d'entraînement est retombée à 0,78… et c'est devenu le premier modèle réellement utilisé par l'équipe Customer Success.

🧪 Construis des datasets d'entraînement propres

Les exercices Modai Lab orientés data science t'obligent à raisonner en dates de snapshot, FILTER, fenêtres glissantes : exactement ce qui sépare un dataset fiable d'un dataset qui fuit.

👉 Pratiquer sur modai-lab.com

_Cas churn réels · Pièges temporels · Feedback sur ta logique_


PARTIE 4 — Product Manager, Growth & Marketing : le SQL pour arrêter d'attendre

Ce que fait le SQL dans ce métier

C'est la famille de métiers où le SQL a le plus progressé ces dernières années. Un PM, un growth manager ou un responsable CRM qui sait écrire une requête :

  • n'attend plus 5 jours qu'un analyste soit disponible pour répondre à « combien d'utilisateurs ont utilisé la nouvelle feature ? »

  • analyse ses funnels de conversion et ses cohortes de rétention

  • mesure les résultats de ses A/B tests et de ses campagnes

  • construit ses propres segments pour l'emailing ou la pub

Le niveau attendu est plus modeste qu'en data, mais il y a un piège très spécifique : le funnel mal calculé.

L'erreur classique du PM : le funnel qui additionne des inconnus

-- ❌ VERSION PROBLÉMATIQUE
-- Objectif : funnel de conversion d'octobre
 
-- Table events (user_id, event_name, created_at)
 
SELECT event_name, COUNT(DISTINCT user_id) AS nb_users
FROM events
WHERE created_at >= '2026-10-01' AND created_at < '2026-11-01'
AND event_name IN ('view_product', 'add_to_cart', 'checkout', 'purchase')
GROUP BY event_name;
 
-- Résultat :
-- view_product | 48 200
-- add_to_cart | 9 150
-- checkout | 4 020
-- purchase | 3 310
--
-- Problème : chaque étape compte des utilisateurs INDÉPENDAMMENT.
-- Un client qui a acheté via un lien direct de relance email
-- (sans view_product ce mois-ci) est compté dans purchase,
-- mais pas dans les étapes précédentes.
-- Le "taux de conversion" calculé dessus n'a pas de sens.
metiers-sql · 09
-- ✅ VERSION CORRIGÉE
-- Funnel ordonné par utilisateur : on ne compte une étape
-- que si l'utilisateur a franchi la précédente AVANT.
 
WITH etapes AS (
SELECT
user_id,
MIN(created_at) FILTER (WHERE event_name = 'view_product') AS t_view,
MIN(created_at) FILTER (WHERE event_name = 'add_to_cart') AS t_cart,
MIN(created_at) FILTER (WHERE event_name = 'checkout') AS t_checkout,
MIN(created_at) FILTER (WHERE event_name = 'purchase') AS t_purchase
FROM events
WHERE created_at >= '2026-10-01' AND created_at < '2026-11-01'
GROUP BY user_id
),
funnel AS (
SELECT
COUNT(*) FILTER (WHERE t_view IS NOT NULL) AS n_view,
COUNT(*) FILTER (WHERE t_cart > t_view) AS n_cart,
COUNT(*) FILTER (WHERE t_checkout > t_cart AND t_cart > t_view) AS n_checkout,
COUNT(*) FILTER (WHERE t_purchase > t_checkout
AND t_checkout > t_cart AND t_cart > t_view) AS n_purchase
FROM etapes
)
SELECT
n_view, n_cart, n_checkout, n_purchase,
ROUND(. * n_cart / NULLIF(n_view, ), ) AS taux_view_cart,
ROUND(. * n_checkout / NULLIF(n_cart, ), ) AS taux_cart_checkout,
ROUND(. * n_purchase / NULLIF(n_checkout, ), ) AS taux_checkout_purchase
FROM funnel;
 
-- Résultat :
-- n_view | n_cart | n_checkout | n_purchase | taux_view_cart | taux_cart_checkout | taux_checkout_purchase
-- 48 200 | 8 640 | 3 710 | 2 870 | 17.9 | 42.9 | 77.4
--
-- Gain : chaque taux mesure vraiment un passage d'étape.
-- Les 440 achats "directs" sont exclus du funnel produit,
-- et peuvent être analysés à part (ils relèvent du CRM, pas du parcours).
metiers-sql · 10

Note : MIN(...) prend la première occurrence de chaque étape. C'est une simplification acceptable pour un funnel mensuel ; pour un parcours multi-sessions précis, on raisonne par session.

Cas business — E-commerce : la cohorte de rétention pour le comité produit

Le PM d'une marque de cosmétiques en ligne veut savoir si les clients acquis pendant les soldes d'été rachètent autant que les autres.

WITH premiere_commande AS (
SELECT user_id, DATE_TRUNC('month', MIN(created_at))::date AS cohorte
FROM orders
WHERE statut IN ('payee', 'livree')
GROUP BY user_id
),
activite AS (
SELECT DISTINCT o.user_id, DATE_TRUNC('month', o.created_at)::date AS mois_achat
FROM orders o
WHERE o.statut IN ('payee', 'livree')
)
SELECT
p.cohorte,
COUNT(DISTINCT p.user_id) AS taille_cohorte,
ROUND(. * COUNT(DISTINCT a.user_id) FILTER (
WHERE a.mois_achat = p.cohorte + INTERVAL '1 month')
/ COUNT(DISTINCT p.user_id), ) AS retention_m1,
ROUND(. * COUNT(DISTINCT a.user_id) FILTER (
WHERE a.mois_achat = p.cohorte + INTERVAL '3 months')
/ COUNT(DISTINCT p.user_id), ) AS retention_m3
FROM premiere_commande p
LEFT JOIN activite a ON a.user_id = p.user_id
WHERE p.cohorte BETWEEN '2026-05-01' AND '2026-07-01'
GROUP BY p.cohorte
ORDER BY p.cohorte;
 
-- cohorte | taille_cohorte | retention_m1 | retention_m3
-- 2026-05-01 | 3 120 | 14.2 | 9.8
-- 2026-06-01 | 3 480 | 13.7 | 9.1
-- 2026-07-01 | 6 950 | 7.9 | 4.6 ← cohorte soldes : volume x2, rétention /2
metiers-sql · 11

Conclusion actionnable en une requête : les soldes ont doublé l'acquisition, mais avec des clients deux fois moins fidèles. Le PM a de quoi arbitrer le budget de la prochaine opération, sans attendre personne.

🧪 Vérifie que tes funnels tiennent la route

Funnels ordonnés, cohortes, FILTER : le test Modai Lab contient des questions taillées pour les profils produit et growth qui veulent devenir autonomes sur leurs données.

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

_Adapté aux profils non-data · 5 minutes · Recommandations ciblées_


PARTIE 5 — Finance, contrôle de gestion & risque : le SQL qui doit tomber juste au centime

Ce que fait le SQL dans ce métier

Contrôleurs de gestion, analystes financiers, auditeurs, analystes risque ou conformité en banque et assurance : ils ont longtemps travaillé uniquement dans Excel. Aujourd'hui, les volumes (des millions de transactions) et l'exigence de traçabilité les poussent vers le SQL pour :

  • rapprocher factures, paiements et écritures comptables

  • produire des balances âgées (qui doit quoi, depuis combien de temps)

  • détecter des anomalies : doublons de paiement, montants atypiques

  • alimenter le reporting réglementaire ou les clôtures mensuelles

Ici, une erreur d'1 % n'est pas « une approximation ». C'est un écart de clôture que quelqu'un devra justifier. Le piège classique : la double jointure qui multiplie les montants (fan-out).

L'erreur classique du contrôleur : la somme qui double toute seule

-- ❌ VERSION PROBLÉMATIQUE
-- Objectif : reste à payer par client
 
-- invoices (invoice_id, client_id, montant_ttc, date_emission, date_echeance)
-- payments (payment_id, invoice_id, montant_paye, date_paiement) -- paiements partiels possibles
 
SELECT
i.client_id,
SUM(i.montant_ttc) AS total_facture, -- dupliqué si plusieurs paiements
SUM(p.montant_paye) AS total_paye, -- NULL si aucun paiement
SUM(i.montant_ttc) - SUM(p.montant_paye) AS reste_a_payer -- NULL pour les clients
-- qui n'ont jamais payé !
FROM invoices i
LEFT JOIN payments p ON p.invoice_id = i.invoice_id
GROUP BY i.client_id;
 
-- Exemple : facture F-2201 de 3 000 € payée en 3 fois (1 000 € x 3)
-- invoice_id | montant_ttc | montant_paye
-- F-2201 | 3 000 | 1 000
-- F-2201 | 3 000 | 1 000
-- F-2201 | 3 000 | 1 000
-- → total_facture = 9 000 € au lieu de 3 000 €
-- Et un client sans aucun paiement ressort avec reste_a_payer = NULL,
-- c'est-à-dire... invisible dans la balance.
metiers-sql · 12
-- ✅ VERSION CORRIGÉE
-- Règle d'or : AGRÉGER AVANT DE JOINDRE quand la relation est 1-N.
 
WITH paiements_par_facture AS (
SELECT invoice_id, SUM(montant_paye) AS total_paye
FROM payments
GROUP BY invoice_id -- grain ramené à 1 ligne par facture
)
SELECT
i.client_id,
SUM(i.montant_ttc) AS total_facture,
SUM(COALESCE(pf.total_paye, )) AS total_paye,
SUM(i.montant_ttc - COALESCE(pf.total_paye, )) AS reste_a_payer
FROM invoices i
LEFT JOIN paiements_par_facture pf ON pf.invoice_id = i.invoice_id
GROUP BY i.client_id
HAVING SUM(i.montant_ttc - COALESCE(pf.total_paye, )) >
ORDER BY reste_a_payer DESC;
 
-- Gain : F-2201 compte pour 3 000 € facturés, 3 000 € payés, 0 € restant.
-- Les clients sans aucun paiement apparaissent avec leur encours complet.
metiers-sql · 13

Point de vigilance supplémentaire : les montants doivent être stockés en NUMERIC(12,2) (ou en centimes entiers), jamais en FLOAT. Sur des millions de lignes, les arrondis binaires finissent par créer des écarts de quelques centimes impossibles à expliquer en clôture.

Cas business — Finance : la balance âgée de fin de mois

Une PME de services B2B (≈ 340 clients, 2 900 factures sur l'année) veut sa balance âgée au 31 octobre pour la réunion de trésorerie.

WITH paiements_par_facture AS (
SELECT invoice_id, SUM(montant_paye) AS total_paye
FROM payments
WHERE date_paiement <= DATE '2026-10-31'
GROUP BY invoice_id
),
encours AS (
SELECT
i.client_id,
i.invoice_id,
i.montant_ttc - COALESCE(pf.total_paye, ) AS restant,
DATE '2026-10-31' - i.date_echeance AS jours_retard
FROM invoices i
LEFT JOIN paiements_par_facture pf ON pf.invoice_id = i.invoice_id
WHERE i.date_emission <= DATE '2026-10-31'
)
SELECT
client_id,
SUM(restant) FILTER (WHERE jours_retard <= ) AS non_echu,
SUM(restant) FILTER (WHERE jours_retard BETWEEN AND ) AS retard_1_30j,
SUM(restant) FILTER (WHERE jours_retard BETWEEN AND ) AS retard_31_60j,
SUM(restant) FILTER (WHERE jours_retard > ) AS retard_plus_60j,
SUM(restant) AS total_du
FROM encours
WHERE restant >
GROUP BY client_id
ORDER BY retard_plus_60j DESC NULLS LAST;
 
-- client_id | non_echu | retard_1_30j | retard_31_60j | retard_plus_60j | total_du
-- C-0187 | 4 200 | 6 800 | 9 400 | 18 650 | 39 050
-- C-0042 | 12 300 | NULL | 2 100 | 7 900 | 22 300
metiers-sql · 14

La requête remplace un fichier Excel reconstruit à la main chaque mois, et elle est rejouable à n'importe quelle date : il suffit de changer 2026-10-31.

🧪 Pratique sur des données financières qui ne pardonnent pas

Rapprochements, paiements partiels, balances âgées : sur Modai Lab, les cas finance reproduisent les relations 1-N et les NULL qui piègent les contrôleurs en clôture.

👉 Pratiquer sur modai-lab.com

_Cas finance réels · Montants au centime · Pièges de fan-out_


PARTIE 6 — RH, People Analytics & Opérations : le SQL au service des décisions humaines

Ce que fait le SQL dans ce métier

Les équipes RH, people analytics, mais aussi supply chain, service client ou opérations utilisent de plus en plus le SQL pour piloter leur activité :

  • RH : turnover, effectifs, ancienneté, écarts de rémunération, absentéisme

  • Supply chain : ruptures de stock, délais fournisseurs, rotation des produits

  • Service client : volume de tickets, délai de première réponse, taux de résolution

  • Opérations : temps de traitement, charge par équipe, respect des SLA

Ces métiers ont deux points communs : des indicateurs dont la définition compte autant que le calcul, et, côté RH, des données personnelles et sensibles qui imposent des précautions dans la requête elle-même.

L'erreur classique en RH : le turnover au mauvais dénominateur

-- ❌ VERSION PROBLÉMATIQUE
-- Objectif : taux de turnover 2026 (janvier à octobre) par département
 
-- employees (employee_id, departement, date_entree, date_sortie)
 
SELECT
departement,
COUNT(*) FILTER (WHERE date_sortie >= '2026-01-01') AS nb_departs,
COUNT(*) FILTER (WHERE date_sortie IS NULL) AS effectif_actuel,
ROUND(. * COUNT(*) FILTER (WHERE date_sortie >= '2026-01-01')
/ COUNT(*) FILTER (WHERE date_sortie IS NULL), ) AS turnover_pct
FROM employees
GROUP BY departement;
 
-- Problèmes :
-- 1. Dénominateur = effectif d'AUJOURD'HUI. Un département qui a perdu
-- beaucoup de monde a un effectif réduit → turnover artificiellement gonflé.
-- 2. Les salariés entrés ET sortis en 2026 faussent la base.
-- 3. Un département de 3 personnes avec 1 départ affiche 33 %,
-- et on peut identifier qui est parti : problème de confidentialité.
metiers-sql · 15
-- ✅ VERSION CORRIGÉE
-- Dénominateur = effectif MOYEN de la période (moyenne début / fin),
-- et masquage des petits groupes.
 
WITH bornes AS (
SELECT DATE '2026-01-01' AS debut, DATE '2026-10-31' AS fin
),
stats AS (
SELECT
e.departement,
COUNT(*) FILTER (WHERE e.date_entree <= b.debut
AND (e.date_sortie IS NULL OR e.date_sortie > b.debut)) AS effectif_debut,
COUNT(*) FILTER (WHERE e.date_entree <= b.fin
AND (e.date_sortie IS NULL OR e.date_sortie > b.fin)) AS effectif_fin,
COUNT(*) FILTER (WHERE e.date_sortie BETWEEN b.debut AND b.fin) AS nb_departs
FROM employees e
CROSS JOIN bornes b
GROUP BY e.departement
)
SELECT
departement,
effectif_debut,
effectif_fin,
CASE WHEN (effectif_debut + effectif_fin) / . < THEN NULL
ELSE nb_departs END AS nb_departs,
CASE WHEN (effectif_debut + effectif_fin) / . < THEN NULL
ELSE ROUND(. * nb_departs
/ NULLIF((effectif_debut + effectif_fin) / ., ), )
END AS turnover_pct
FROM stats
ORDER BY turnover_pct DESC NULLS LAST;
 
-- Gain : le taux suit la convention RH usuelle (départs / effectif moyen),
-- et les équipes de moins de 10 personnes sont masquées (NULL)
-- pour ne pas rendre les départs individuels identifiables.
metiers-sql · 16

Cas business — RH : le comité de direction d'une ETI

Une ETI de 640 salariés présente son turnover au comité de direction. Avec la version ❌, l'équipe commerciale affichait 41 % de turnover (24 départs sur un effectif actuel de 58). Avec la version ✅ (effectif début 71, fin 58, moyenne 64,5), on obtient 37,2 %. Toujours élevé, mais le chiffre est défendable, et l'équipe juridique (6 personnes) n'apparaît plus avec un taux qui désignait nommément la personne partie.

Le même raisonnement s'applique en service client (délai de réponse médian plutôt que moyen, pour ne pas être écrasé par quelques tickets oubliés) ou en supply chain (taux de rupture calculé sur les jours ouvrés, pas calendaires) : définir l'indicateur avant d'écrire la requête.

🧪 Valide ta maîtrise des indicateurs métier

Effectifs moyens, bornes de période, masquage des petits groupes : le test Modai Lab te montre si tu sais traduire une définition métier en SQL exact.

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

_Indicateurs RH et ops · Calibrage en 5 minutes · Plan de progression_


Et les autres ? Les métiers qui utilisent aussi le SQL

Les six familles ci-dessus concentrent l'essentiel des usages, mais elles sont loin d'être les seules :

  • Développeur back-end / full-stack : écrit les requêtes de l'application, conçoit les schémas, gère les migrations et les index

  • DBA (administrateur de bases de données) : performance, sauvegardes, droits d'accès, réplication

  • Consultant data / ERP / CRM : interroge les bases de Salesforce, SAP ou HubSpot pour les audits et migrations

  • Chef de projet MOA / business analyst : vérifie les règles de gestion directement dans les données, rédige des spécifications avec des exemples SQL

  • Analyste fraude / conformité : détecte les schémas suspects dans les transactions

  • Chercheur, épidémiologiste, analyste en santé publique : exploite des bases de données médicales ou administratives

  • Journaliste data : interroge des jeux de données publics pour ses enquêtes

Le point commun : dès qu'une question touche des données qui ne tiennent plus dans un tableur, le SQL devient l'outil le plus direct pour y répondre.


Prompt Claude pour auditer tes requêtes

Copie ce prompt dans Claude, remplace les deux champs entre crochets, et colle ta requête à la fin.

Tu es un expert SQL senior qui a encadré des profils data, produit, finance et RH.
Je vise (ou j'occupe) le poste suivant : [ex. data analyst / product manager /
contrôleur de gestion / HR analyst / data scientist / analytics engineer].
Ma base est : [PostgreSQL / BigQuery / Snowflake / SQL Server / MySQL].
 
Audite la requête SQL ci-dessous avec l'œil d'un manager de ce métier.
 
Vérifie systématiquement :
1. Le GRAIN : quel est le grain de chaque table et le grain final après jointures ?
Y a-t-il un risque de duplication (fan-out) qui fausse un SUM, un AVG ou un COUNT(*) ?
2. Les NULL : un LEFT JOIN, un SUM ou une soustraction peut-il produire des NULL
qui font disparaître des lignes ou faussent un total ?
3. Les FILTRES MÉTIER : les statuts exclus (annulé, remboursé, test, interne)
sont-ils explicites ? Les bornes de dates sont-elles exclusives en haut ?
4. La DÉFINITION DE L'INDICATEUR : le calcul correspond-il à la définition
standard du métier (ex. turnover sur effectif moyen, MRR par mois actif,
funnel ordonné, encours après paiements partiels) ?
5. Les PIÈGES SPÉCIFIQUES À MON MÉTIER :
- data scientist : fuite de données (features calculées après la date de snapshot)
- finance : montants en FLOAT, agrégation après jointure 1-N
- RH : confidentialité des petits groupes, dénominateurs
- produit/growth : étapes de funnel comptées indépendamment
- analytics engineer : logique dupliquée, absence de tests d'unicité
6. La LISIBILITÉ : CTE nommées, alias explicites, commentaires utiles.
7. La PERFORMANCE : SELECT *, fonctions sur colonnes filtrées, jointures inutiles.
 
Pour chaque problème trouvé, donne :
- la ligne concernée
- pourquoi c'est un problème, avec un exemple chiffré de l'erreur produite
- la sévérité (bloquant / important / cosmétique)
 
Termine par :
- la version corrigée complète de la requête, commentée
- une note sur 10 de mon niveau pour le poste visé, avec les 3 notions
que je devrais travailler en priorité
 
Voici ma requête :
[colle ta requête ici]
metiers-sql · 17

Récapitulatif : le SQL métier par métier

Métier

Usage principal du SQL

Fonctions clés à maîtriser

Erreur typique

Niveau attendu

Data Analyst / BI

KPI, reporting, analyses ad hoc

GROUP BY, COUNT(DISTINCT), CTE, LAG, DATE_TRUNC

Chiffre gonflé par une jointure

Avancé

Analytics / Data Engineer

Modèles de données, pipelines, tests

CTE, generate_series, fenêtres, MERGE, dbt

Logique monolithe et dupliquée

Expert

Data Scientist

Extraction, features, cibles

FILTER, fenêtres glissantes, intervalles de dates

Fuite de données (features du futur)

Avancé

Product / Growth / Marketing

Funnels, cohortes, A/B tests, segments

MIN() FILTER, COUNT(DISTINCT), DATE_TRUNC

Funnel aux étapes indépendantes

Intermédiaire

Finance / Contrôle / Risque

Rapprochements, balances, anomalies

Agrégation avant jointure, COALESCE, NUMERIC

Fan-out sur relation 1-N, FLOAT

Intermédiaire à avancé

RH / Ops / Service client

Turnover, effectifs, SLA, stocks

Bornes de période, FILTER, médianes

Mauvais dénominateur, petits groupes exposés

Intermédiaire

Développeur / DBA

Requêtes applicatives, schémas, perf

Index, transactions, EXPLAIN, contraintes

Requêtes N+1, index manquants

Avancé à expert


✅ Checklist SQL métier

  • ☐ Je sais dire quel est le grain de chaque table que j'utilise

  • ☐ Je vérifie le grain après chaque jointure avant d'agréger

  • ☐ J'agrège les tables 1-N (paiements, articles, sessions) avant de les joindre

  • ☐ J'utilise COUNT(DISTINCT ...) quand je compte des entités, pas des lignes

  • ☐ J'exclus explicitement les statuts qui faussent l'indicateur (annulé, test, remboursé)

  • ☐ Mes bornes de dates sont du type >= début AND < fin

  • ☐ Je gère les NULL avec COALESCE dans les sommes et les soustractions

  • ☐ Je protège mes divisions avec NULLIF(..., 0)

  • ☐ Je connais la définition officielle de l'indicateur dans mon métier avant de le coder

  • ☐ (Data science) Mes features ne regardent que le passé par rapport au snapshot

  • ☐ (Finance) Mes montants sont en NUMERIC ou en centimes, jamais en FLOAT

  • ☐ (RH) Je masque les groupes trop petits pour être anonymes

  • ☐ (Produit) Mes étapes de funnel sont ordonnées par utilisateur

  • ☐ (Engineering) Chaque règle métier est écrite une seule fois et testée


🚀 Quel que soit ton métier, le SQL se travaille sur des vrais cas

Que tu sois analyste, PM, contrôleur de gestion ou HR analyst, la différence ne se fait pas sur la syntaxe mais sur les pièges propres à ton métier. Modai Lab te fait pratiquer sur des cas business réels, avec un feedback de niveau senior.

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