Ce QCM s'adresse aux développeurs, data analysts et candidats qui passent un test SQL de recrutement sur SkillValue, CodinGame ou HackerRank. Vous y trouverez 12 questions de niveau mêlé avec des tables explicites, la réponse et surtout l'explication détaillée de chaque piège.
En bref
Les tests SQL de recrutement tournent autour d'un petit nombre de thèmes : le nombre de lignes renvoyées par un INNER, LEFT ou FULL JOIN, la différence entre WHERE et HAVING, le comportement de NULL (comparaisons, COUNT, NOT IN), les sous-requêtes avec EXISTS et les fonctions de fenêtrage comme ROW_NUMBER, RANK et DENSE_RANK. Viennent ensuite des questions plus conceptuelles sur les index, l'ordre d'exécution d'une requête et les propriétés ACID des transactions. La plupart des questions donnent une ou deux petites tables et demandent le résultat exact d'une requête : il faut savoir dérouler la requête à la main, ligne par ligne.
Les thèmes qui tombent le plus
Jointures : INNER, LEFT, RIGHT, FULLOn vous donne deux tables de 3 ou 4 lignes et on vous demande combien de lignes renvoie la jointure. Le piège classique : oublier les lignes sans correspondance et les lignes dont la clé de jointure est NULL.
GROUP BY, HAVING et WHEREWHERE filtre les lignes avant l'agrégation, HAVING filtre les groupes après. Les questions mélangent les deux clauses dans la même requête pour vérifier que vous les appliquez dans le bon ordre.
NULL et logique à trois valeursUne comparaison avec NULL ne vaut ni vrai ni faux mais UNKNOWN. D'où les pièges sur col = NULL, COUNT(col) contre COUNT(*) et surtout NOT IN quand la sous-requête contient un NULL.
Sous-requêtes et EXISTSLes tests vérifient que vous savez choisir entre IN, EXISTS et une jointure, et que vous connaissez la différence de comportement de NOT IN et NOT EXISTS face aux NULL.
Fonctions de fenêtrageROW_NUMBER, RANK et DENSE_RANK se distinguent uniquement sur les ex aequo. Les questions portent presque toujours sur une table avec un doublon de valeur pour voir si vous connaissez la numérotation de la ligne suivante.
Index, performance et transactionsSavoir quand un index est utilisable (pas de fonction appliquée à la colonne, pas de LIKE commençant par %) et connaître les quatre propriétés ACID suffit pour la plupart des questions de ce type.
Entraînez-vous : 12 questions corrigées
Choisissez une réponse pour voir l'explication.
Soit les deux tables suivantes :
employees departments
id | name | dept_id id | name
---+-------+-------- ---+------
1 | Ana | 10 10 | IT
2 | Bob | 20 20 | HR
3 | Chloe | NULL 40 | Legal
4 | Dan | 30
Combien de lignes renvoie cette requête ?
SELECT e.name, d.name
FROM employees e
INNER JOIN departments d ON e.dept_id = d.id;
Un INNER JOIN ne conserve que les paires dont la condition est vraie. Seuls Ana (10 → IT) et Bob (20 → HR) trouvent un département : 2 lignes. Chloe a un dept_id NULL (aucune comparaison avec NULL n'est vraie), Dan pointe vers le département 30 qui n'existe pas, et Legal n'a aucun employé. 4 serait le résultat d'un LEFT JOIN depuis employees, 5 celui d'un FULL OUTER JOIN.
Toujours avec la table employees ci-dessus, combien de lignes renvoie cette requête ?
SELECT name FROM employees WHERE dept_id = NULL;
En SQL, toute comparaison avec NULL via = ou <> renvoie UNKNOWN, jamais TRUE. Le WHERE ne garde que les lignes évaluées à TRUE, donc aucune ligne ne passe : 0. La syntaxe est valide, c'est le résultat qui surprend. Pour trouver Chloe il faut écrire WHERE dept_id IS NULL.
SELECT DISTINCT category
FROM products
ORDER BY category
LIMIT 2;
DISTINCT réduit d'abord les catégories à trois valeurs : book, pen, lamp. ORDER BY les trie alphabétiquement : book, lamp, pen. LIMIT 2 garde les deux premières : book et lamp. L'ordre logique est toujours DISTINCT puis ORDER BY puis LIMIT, quel que soit l'ordre d'écriture. « book, book » oublie le DISTINCT, « book, pen » oublie le tri.
Une transaction effectue un virement de 100 € :
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;
Le serveur tombe en panne juste après le premier UPDATE, avant le COMMIT. Quel est l'état des comptes après redémarrage de la base ?
C'est l'atomicité (le A de ACID) : une transaction est tout ou rien. Tant que le COMMIT n'a pas été enregistré, la base annule au redémarrage toutes les modifications partielles grâce à son journal (undo/redo log). Le premier choix décrit exactement ce que l'atomicité empêche. Le niveau d'isolation concerne la visibilité entre transactions concurrentes, pas la reprise après panne.
Avec les tables employees et departments du début (PostgreSQL ou SQL Server), combien de lignes renvoie cette requête ?
SELECT e.name, d.name
FROM employees e
FULL OUTER JOIN departments d ON e.dept_id = d.id;
Un FULL OUTER JOIN renvoie les lignes appariées plus les lignes orphelines des deux côtés. Appariées : Ana-IT, Bob-HR (2). Employés sans département : Chloe (dept_id NULL) et Dan (dept 30 inexistant) avec d.name NULL (2). Département sans employé : Legal avec e.name NULL (1). Total 5. Le résultat 4 correspond au LEFT JOIN, 7 à la somme naïve des deux tables sans tenir compte des correspondances.
Soit la table orders :
id | customer | amount
---+----------+-------
1 | A | 100
2 | A | 50
3 | B | 200
4 | C | 30
5 | B | 20
Quelles lignes renvoie cette requête ?
SELECT customer, SUM(amount) AS total
FROM orders
WHERE amount > 40
GROUP BY customer
HAVING SUM(amount) > 100;
Le WHERE s'applique d'abord, ligne par ligne : il ne reste que les commandes 1 (A, 100), 2 (A, 50) et 3 (B, 200). Le GROUP BY donne alors A = 150 et B = 200 ; C disparaît avant même l'agrégation. Le HAVING garde les groupes dont la somme dépasse 100 : A et B. La réponse « B (220) » suppose à tort que le WHERE est ignoré, et « B (200) seulement » oublie que 150 est supérieur à 100.
Avec la table employees du début, qu'affiche cette requête ?
SELECT COUNT(*), COUNT(dept_id), COUNT(DISTINCT dept_id)
FROM employees;
COUNT(*) compte toutes les lignes : 4. COUNT(dept_id) ignore les NULL : 10, 20 et 30 soit 3. COUNT(DISTINCT dept_id) compte les valeurs distinctes non NULL : 10, 20, 30 soit 3 également. Le NULL de Chloe n'est jamais compté comme une valeur, ni dans COUNT(col) ni dans COUNT(DISTINCT col), ce qui exclut « 4, 4, 3 » et « 4, 3, 4 ».
Avec les tables employees et departments du début, que renvoie cette requête ?
SELECT d.name
FROM departments d
WHERE NOT EXISTS (
SELECT 1 FROM employees e WHERE e.dept_id = d.id
);
NOT EXISTS renvoie vrai quand la sous-requête corrélée ne trouve aucune ligne. Pour IT (10) et HR (20) il existe un employé, donc elles sont exclues. Pour Legal (40), aucun employé n'a dept_id = 40 : la sous-requête est vide et Legal est renvoyé. Le dept_id NULL de Chloe ne perturbe rien : NULL = 40 est UNKNOWN, donc cette ligne n'est tout simplement pas trouvée. C'est précisément ce qui distingue NOT EXISTS de NOT IN (voir la question suivante).
Soit la table scores :
name | score
------+------
Ana | 90
Bob | 85
Chloe | 85
Dan | 70
On exécute :
SELECT name,
ROW_NUMBER() OVER (ORDER BY score DESC) AS rn,
RANK() OVER (ORDER BY score DESC) AS rk,
DENSE_RANK() OVER (ORDER BY score DESC) AS drk
FROM scores;
Quelles valeurs (rn, rk, drk) obtient Dan ?
Ana est première. Bob et Chloe sont ex aequo à 85 : RANK et DENSE_RANK leur donnent 2 à tous les deux, ROW_NUMBER leur donne 2 et 3 dans un ordre arbitraire. Pour Dan, ROW_NUMBER continue la numérotation : 4. RANK saute les positions occupées par les ex aequo : 4 également. DENSE_RANK ne laisse pas de trou : 3. D'où (4, 4, 3). Si les trois fonctions donnaient le même résultat, c'est qu'il n'y aurait aucun ex aequo.
Avec les tables employees et departments du début, que renvoie cette requête ?
SELECT name
FROM departments
WHERE id NOT IN (SELECT dept_id FROM employees);
La sous-requête renvoie {10, 20, NULL, 30}. id NOT IN (...) équivaut à id <> 10 AND id <> 20 AND id <> NULL AND id <> 30. Pour Legal (40), les trois premières comparaisons sont vraies mais 40 <> NULL vaut UNKNOWN, donc tout le AND vaut UNKNOWN et la ligne est rejetée. Aucune ligne n'est renvoyée, sans erreur. C'est le piège le plus fréquent des tests SQL : dès qu'une sous-requête peut contenir un NULL, utilisez NOT EXISTS ou ajoutez WHERE dept_id IS NOT NULL dans la sous-requête.
Avec les tables employees et departments du début, combien de lignes renvoient respectivement les requêtes A et B ?
-- A
SELECT e.name FROM employees e
LEFT JOIN departments d ON e.dept_id = d.id
WHERE d.name = 'IT';
-- B
SELECT e.name FROM employees e
LEFT JOIN departments d ON e.dept_id = d.id AND d.name = 'IT';
Dans A, le LEFT JOIN produit d'abord 4 lignes (toutes celles d'employees), puis le WHERE d.name = 'IT' élimine les trois lignes où d.name est HR ou NULL : il ne reste qu'Ana, soit 1 ligne. Le LEFT JOIN se comporte alors comme un INNER JOIN. Dans B, la condition fait partie du ON : elle décide seulement quelles lignes de departments sont appariées. Tous les employés sont conservés (c'est la définition du LEFT JOIN), seule Ana a un d.name non NULL : 4 lignes. Placer un filtre sur la table de droite dans WHERE ou dans ON ne donne pas le même résultat.
La table orders contient 50 millions de lignes et possède un index B-tree classique sur la colonne created_at (type DATETIME). Laquelle de ces clauses WHERE permet au moteur d'utiliser cet index pour un parcours de plage (range scan) ?
Un index B-tree est trié sur les valeurs brutes de la colonne. Dès qu'on applique une fonction à la colonne (YEAR, DATE, CAST), le moteur doit calculer cette fonction pour chaque ligne : la condition n'est plus « sargable » et l'index sur created_at est ignoré au profit d'un parcours complet. Seule la comparaison directe de created_at à des bornes permet de se positionner dans l'index et de lire uniquement la plage concernée. Pour les autres formulations, il faudrait créer un index fonctionnel ou une colonne calculée indexée.
Score0 / 12
Le jour du test
Avant de répondre à une question de jointure, listez les lignes de chaque table et barrez celles qui n'ont pas de correspondance : le nombre de lignes se lit alors directement.
Dès qu'un énoncé contient un NULL, cherchez le piège : = NULL, NOT IN, COUNT(col) et les agrégats ignorent ou cassent les NULL de façon différente.
Récitez l'ordre logique d'exécution : FROM et JOIN, WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY, LIMIT. La plupart des questions se résolvent en l'appliquant pas à pas.
Sur les fonctions de fenêtrage, repérez les ex aequo dans la table : c'est le seul endroit où ROW_NUMBER, RANK et DENSE_RANK divergent.
Quel dialecte SQL est utilisé dans les tests de recrutement ?
La plupart des plateformes utilisent MySQL ou PostgreSQL, parfois SQL Server. Les questions de QCM restent presque toujours en SQL standard ; quand un détail dépend du dialecte (LIMIT, FULL OUTER JOIN absent de MySQL, TOP en SQL Server), l'énoncé le précise.
Faut-il connaître les fonctions de fenêtrage pour un test SQL ?
Oui, elles sont devenues incontournables, même pour des postes de développeur généraliste. Attendez-vous à au moins une question sur ROW_NUMBER, RANK ou DENSE_RANK avec des valeurs ex aequo, et parfois sur PARTITION BY pour un top N par groupe.
Pourquoi NOT IN renvoie-t-il parfois zéro ligne alors qu'il devrait y avoir des résultats ?
Parce que la sous-requête contient un NULL. La comparaison avec ce NULL vaut UNKNOWN, ce qui rend toute la condition UNKNOWN et rejette toutes les lignes. Remplacez NOT IN par NOT EXISTS, ou excluez les NULL dans la sous-requête.
Combien de temps dure un QCM SQL en entretien ?
Généralement entre 15 et 30 minutes pour 10 à 20 questions, soit environ une minute par question. Entraînez-vous à dérouler mentalement une requête sur une petite table en moins d'une minute, c'est la compétence réellement évaluée.