Erreurs fréquentes des débutants

Basé sur mon expérience de formateur, voici les erreurs les plus courantes :

• Oublier GROUP BY après SELECT avec agrégation
• Confondre JOIN et WHERE pour les conditions de jointure
• Utiliser COUNT(*) au lieu de COUNT(colonne) pour compter les valeurs non-nulles
• Oublier DISTINCT dans les sous-requêtes avec EXISTS

Pièges spécifiques aux débutants en entretien

D'après les retours de 150+ recruteurs, voici les erreurs éliminatoires :

• Confusion sur les NULL : ne pas comprendre que WHERE colonne != 'valeur' exclut les NULL
• Mauvaise syntaxe des agrégations : écrire SELECT nom, COUNT(*) sans GROUP BY
• Confondre les types de JOIN : utiliser INNER JOIN quand on veut toutes les lignes de la table principale
• Ne pas tester mentalement sur un petit jeu de données avant de donner la réponse

Validation des bases - questions bonus

Pour vous auto-évaluer sur le niveau débutant :

• Différence entre NULL et chaîne vide : NULL signifie "valeur inconnue", '' est une chaîne de longueur zéro
• Ordre d'exécution SQL : FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY
• Utilisation de DISTINCT : élimine les doublons sur l'ensemble des colonnes sélectionnées

Niveau intermédiaire

Question 6 : Comment trouver le N-ième salaire le plus élevé ?

Réponse attendue :

-- Avec DENSE_RANK (gère les doublons)
WITH salaires_classes AS (
    SELECT salaire, DENSE_RANK() OVER (ORDER BY salaire DESC) AS rang
    FROM employes
)
SELECT DISTINCT salaire FROM salaires_classes WHERE rang = 2;

Approche alternative avec LIMIT/OFFSET (moins robuste) :

SELECT DISTINCT salaire FROM employes
ORDER BY salaire DESC
LIMIT 1 OFFSET 1; -- 2ème salaire

Voir notre article RANK, DENSE_RANK et ROW_NUMBER.

Question 7 : Comment fonctionne une sous-requête corrélée ?

Réponse attendue :

Une sous-requête corrélée fait référence à une colonne de la requête externe et est exécutée une fois pour chaque ligne de la requête externe.

-- Employés gagnant plus que la moyenne de leur département
SELECT e.nom, e.salaire
FROM employes e
WHERE e.salaire > (
    SELECT AVG(e2.salaire) FROM employes e2
    WHERE e2.departement_id = e.departement_id
);

Alternative plus performante avec window function :

WITH avg_dept AS (
    SELECT nom, salaire,
           AVG(salaire) OVER (PARTITION BY departement_id) AS avg_dept_salaire
    FROM employes
)
SELECT nom, salaire FROM avg_dept WHERE salaire > avg_dept_salaire;

Voir notre article sur les sous-requêtes SQL.

Question 8 : Quelle est la différence entre UNION et UNION ALL ?

Réponse attendue :

• UNION : combine les résultats et supprime les doublons (tri implicite)
• UNION ALL : combine les résultats et garde les doublons (pas de tri)

-- UNION : 3 lignes si des doublons existent
SELECT nom FROM clients_france
UNION
SELECT nom FROM clients_belgique;

-- UNION ALL : toutes les lignes, doublons inclus
SELECT nom FROM clients_france
UNION ALL
SELECT nom FROM clients_belgique;

Question 9 : Comment écrire un CASE WHEN avec agrégation ?

Réponse attendue :

SELECT
    departement,
    COUNT(CASE WHEN genre = 'F' THEN 1 END) AS nb_femmes,
    COUNT(CASE WHEN genre = 'M' THEN 1 END) AS nb_hommes,
    ROUND(
        100.0 * COUNT(CASE WHEN genre = 'F' THEN 1 END) / COUNT(*), 1
    ) AS pct_femmes
FROM employes
GROUP BY departement;

Pattern avancé pour les métriques métier :

SELECT
    DATE_TRUNC('month', date_commande) AS mois,
    COUNT(*) AS total_commandes,
    COUNT(CASE WHEN montant > 100 THEN 1 END) AS commandes_premium,
    SUM(CASE WHEN statut = 'remboursee' THEN montant ELSE 0 END) AS ca_rembourse,
    AVG(CASE WHEN canal = 'web' THEN montant END) AS panier_moyen_web
FROM commandes
GROUP BY DATE_TRUNC('month', date_commande);

Voir CASE WHEN en SQL.

Question 10 : Qu'est-ce qu'une CTE et quand l'utiliser ?

Réponse attendue :

Une CTE (Common Table Expression) est une requête nommée temporaire définie avec WITH. Elle améliore la lisibilité et peut être référencée plusieurs fois.

WITH ventes_mensuelles AS (
    SELECT
        DATE_TRUNC('month', date_vente) AS mois,
        SUM(montant) AS total
    FROM ventes GROUP BY 1
)
SELECT mois, total,
    LAG(total) OVER (ORDER BY mois) AS mois_precedent,
    ROUND(100.0 * (total - LAG(total) OVER (ORDER BY mois)) / LAG(total) OVER (ORDER BY mois), 1) AS croissance_pct
FROM ventes_mensuelles;

Avantages des CTE :

• Lisibilité améliorée vs sous-requêtes imbriquées
• Réutilisation possible dans la même requête
• Facilite le debug étape par étape

Voir notre guide des CTE.

Question 11 : Comment trouver les clients sans commande ?

Réponse attendue — trois approches :

-- 1. LEFT JOIN + IS NULL (anti-join) - souvent le plus rapide
SELECT c.nom FROM clients c
LEFT JOIN commandes co ON c.id = co.client_id
WHERE co.id IS NULL;

-- 2. NOT EXISTS - performant sur gros volumes
SELECT c.nom FROM clients c
WHERE NOT EXISTS (SELECT 1 FROM commandes co WHERE co.client_id = c.id);

-- 3. NOT IN (attention aux NULL !)
SELECT nom FROM clients
WHERE id NOT IN (SELECT client_id FROM commandes WHERE client_id IS NOT NULL);

Cas d'usage réel : identifier les prospects inactifs pour les campagnes de relance.

Question 12 : Comment calculer un cumul (running total) ?

Réponse attendue :

SELECT
    date_vente,
    montant,
    SUM(montant) OVER (ORDER BY date_vente) AS cumul,
    SUM(montant) OVER (ORDER BY date_vente ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumul_explicite
FROM ventes;

Pour un cumul par groupe (ex: par vendeur) :

SELECT
    vendeur,
    date_vente,
    montant,
    SUM(montant) OVER (PARTITION BY vendeur ORDER BY date_vente) AS cumul_vendeur
FROM ventes;

La fenêtre par défaut avec ORDER BY est ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW, ce qui produit un cumul.

Validation des acquis - métriques métier courantes

Pour maîtriser le niveau intermédiaire, sachez calculer :

• Taux de conversion : COUNT(CASE WHEN achat THEN 1 END) * 100.0 / COUNT(*)
• Panier moyen : SUM(montant) / COUNT(DISTINCT commande_id)
• Évolution période : (valeur_actuelle - valeur_precedente) * 100.0 / valeur_precedente
• Top N par groupe : ROW_NUMBER() OVER (PARTITION BY groupe ORDER BY metrique DESC) <= 3

Spécificités par secteur d'activité

D'après mon expérience avec différents clients :

E-commerce : Focus sur les analyses de cohortes, calculs de panier moyen, taux de conversion par canal

Finance : Emphasis sur les window functions, calculs de volatilité, gestion des données temporelles

SaaS : Questions sur la rétention, MRR (Monthly Recurring Revenue), analyses de funnel

Santé : Requêtes sur les données longitudinales, respect des contraintes RGPD, anonymisation

Niveau avancé

Question 13 : Expliquez ROW_NUMBER, RANK et DENSE_RANK

Réponse attendue :

Les trois attribuent un numéro de classement, mais diffèrent pour les ex æquo :

• ROW_NUMBER : numéro unique, pas d'ex æquo
• RANK : même rang pour les ex æquo, avec saut (1, 2, 2, 4)
• DENSE_RANK : même rang pour les ex æquo, sans saut (1, 2, 2, 3)

SELECT
    nom,
    salaire,
    ROW_NUMBER() OVER (ORDER BY salaire DESC) AS row_num,
    RANK() OVER (ORDER BY salaire DESC) AS rank_val,
    DENSE_RANK() OVER (ORDER BY salaire DESC) AS dense_rank_val
FROM employes;

Cas d'usage concrets :

• ROW_NUMBER : pagination, numérotation unique
• RANK : classement sportif (1er, 2e ex æquo, 4e)
• DENSE_RANK : répartition en quintiles sans trous

Voir RANK, DENSE_RANK et ROW_NUMBER.

Question 14 : Comment calculer un taux de rétention mois par mois ?

Réponse attendue :

WITH premiere_activite AS (
    SELECT
        utilisateur_id,
        DATE_TRUNC('month', MIN(date_activite)) AS mois_inscription
    FROM activites
    GROUP BY utilisateur_id
),
activite_mensuelle AS (
    SELECT
        utilisateur_id,
        DATE_TRUNC('month', date_activite) AS mois_activite
    FROM activites
    GROUP BY utilisateur_id, DATE_TRUNC('month', date_activite)
),
cohorte_retention AS (
    SELECT
        p.mois_inscription,
        a.mois_activite,
        EXTRACT(EPOCH FROM a.mois_activite - p.mois_inscription) / (30.44 * 24 * 3600) AS mois_depuis_inscription,
        COUNT(DISTINCT a.utilisateur_id) AS utilisateurs_actifs,
        (SELECT COUNT(DISTINCT utilisateur_id) FROM premiere_activite WHERE mois_inscription = p.mois_inscription) AS cohorte_taille
    FROM premiere_activite p
    INNER JOIN activite_mensuelle a ON p.utilisateur_id = a.utilisateur_id
    GROUP BY p.mois_inscription, a.mois_activite
)
SELECT
    mois_inscription,
    ROUND(mois_depuis_inscription) AS mois_N,
    utilisateurs_actifs,
    cohorte_taille,
    ROUND(100.0 * utilisateurs_actifs / cohorte_taille, 1) AS taux_retention
FROM cohorte_retention
ORDER BY mois_inscription, mois_depuis_inscription;

Pour un exercice complet, voir Exercice SQL : calculer un taux de rétention.

Question 15 : Comment optimiser une requête lente ?

Réponse attendue :

Méthode systématique :

1. Analyser le plan d'exécution : EXPLAIN ANALYZE
2. Identifier les goulots : Seq Scan, Hash Join coûteux, tris lents
3. Optimiser par ordre de priorité :
   • Index sur les colonnes de WHERE et JOIN
   • Réécrire les sous-requêtes corrélées
   • Limiter les colonnes sélectionnées
   • Utiliser les statistiques à jour

-- Avant : requête lente
SELECT *
FROM commandes c, clients cl
WHERE c.client_id = cl.id
  AND YEAR(c.date_commande) = 2024
  AND UPPER(cl.pays) = 'FRANCE';

-- Après : optimisé
SELECT c.id, c.montant, cl.nom
FROM commandes c
INNER JOIN clients cl ON c.client_id = cl.id
WHERE c.date_commande >= '2024-01-01'
  AND c.date_commande < '2025-01-01'
  AND cl.pays = 'france';

-- Index suggérés :
-- CREATE INDEX idx_commandes_date_client ON commandes(date_commande, client_id);
-- CREATE INDEX idx_clients_pays ON clients(pays);

Outils de diagnostic :

• PostgreSQL : EXPLAIN (ANALYZE, BUFFERS)
• MySQL : EXPLAIN FORMAT=JSON
• SQL Server : SET STATISTICS IO ON

Voir nos 10 techniques d'optimisation SQL.

Question 16 : Qu'est-ce qu'une CTE récursive ?

Réponse attendue :

Une CTE récursive se référence elle-même pour traverser des structures hiérarchiques (arbre managérial, catégories imbriquées, graphes).

Structure : partie d'ancrage (non récursive) + partie récursive + condition d'arrêt.

WITH RECURSIVE hierarchie AS (
    -- Partie d'ancrage : nœuds racine
    SELECT id, nom, manager_id, 0 AS niveau, ARRAY[id] AS chemin
    FROM employes WHERE manager_id IS NULL
    
    UNION ALL
    
    -- Partie récursive
    SELECT e.id, e.nom, e.manager_id, h.niveau + 1, h.chemin || e.id
    FROM employes e 
    INNER JOIN hierarchie h ON e.manager_id = h.id
    WHERE e.id != ALL(h.chemin) -- Évite les cycles
      AND h.niveau < 10 -- Limite de profondeur
)
SELECT niveau, REPEAT('  ', niveau) || nom AS nom_indente, chemin
FROM hierarchie 
ORDER BY chemin;

Cas d'usage :

• Organigrammes d'entreprise
• Arborescences de catégories e-commerce
• Calcul de plus courts chemins
• Déploiement de droits par héritage

Question 17 : Comment faire un pivot en SQL ?

Réponse attendue :

-- Pivot manuel avec CASE WHEN (le plus compatible)
SELECT
    vendeur,
    SUM(CASE WHEN trimestre = 'Q1' THEN montant ELSE 0 END) AS q1,
    SUM(CASE WHEN trimestre = 'Q2' THEN montant ELSE 0 END) AS q2,
    SUM(CASE WHEN trimestre = 'Q3' THEN montant ELSE 0 END) AS q3,
    SUM(CASE WHEN trimestre = 'Q4' THEN montant ELSE 0 END) AS q4,
    SUM(montant) AS total_annuel
FROM ventes
GROUP BY vendeur;

Pivot dynamique (PostgreSQL avec crosstab) :

-- Nécessite l'extension tablefunc
CREATE EXTENSION IF NOT EXISTS tablefunc;

SELECT * FROM crosstab(
    'SELECT vendeur, trimestre, SUM(montant) FROM ventes GROUP BY 1, 2 ORDER BY 1, 2',
    'VALUES (''Q1''), (''Q2''), (''Q3''), (''Q4'')'
) AS pivot(vendeur text, Q1 numeric, Q2 numeric, Q3 numeric, Q4 numeric);

Anti-pivot (UNPIVOT) :

-- Transformer colonnes en lignes
SELECT vendeur, trimestre, montant
FROM (
    SELECT vendeur, 'Q1' AS trimestre, q1 AS montant FROM ventes_pivot
    UNION ALL
    SELECT vendeur, 'Q2', q2 FROM ventes_pivot
    UNION ALL  
    SELECT vendeur, 'Q3', q3 FROM ventes_pivot
    UNION ALL
    SELECT vendeur, 'Q4', q4 FROM ventes_pivot
) unpivot
WHERE montant IS NOT NULL;

C'est le pattern CASE WHEN + SUM + GROUP BY — le plus polyvalent et compatible avec tous les SGBD.

Question 18 : Quelle est la différence entre une vue et une vue matérialisée ?

Réponse attendue :

-- Création
CREATE MATERIALIZED VIEW ventes_mensuelles AS
SELECT 
    DATE_TRUNC('month', date_vente) AS mois,
    SUM(montant) AS total,
    COUNT(*) AS nb_transactions
FROM ventes
GROUP BY DATE_TRUNC('month', date_vente);

-- Index sur la vue matérialisée
CREATE INDEX idx_vm_mois ON ventes_mensuelles(mois);

-- Rafraîchissement
REFRESH MATERIALIZED VIEW ventes_mensuelles;

-- Rafraîchissement sans bloquer les lectures
REFRESH MATERIALIZED VIEW CONCURRENTLY ventes_mensuelles;

-- Transaction basique
BEGIN;
UPDATE comptes SET solde = solde - 100 WHERE id = 1;
UPDATE comptes SET solde = solde + 100 WHERE id = 2;
COMMIT; -- Ou ROLLBACK en cas d'erreur

-- Niveaux d'isolation (PostgreSQL)
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;   -- Lecture sale
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;     -- Par défaut
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;    -- Lecture répétable
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;       -- Sérialisation complète

-- Verrous explicites
BEGIN;
SELECT * FROM comptes WHERE id = 1 FOR UPDATE; -- Lock exclusif
-- ... opérations ...
COMMIT;

-- Déterminer le shard
SELECT shard_id = (client_id % 4) + 1;

-- Partitionnement natif (PostgreSQL 11+)
CREATE TABLE clients (
    id BIGINT,
    nom TEXT,
    email TEXT
) PARTITION BY RANGE (id);

CREATE TABLE clients_shard1 PARTITION OF clients
    FOR VALUES FROM (1) TO (25000001);
CREATE TABLE clients_shard2 PARTITION OF clients
    FOR VALUES FROM (25000001) TO (50000001);
-- ... etc