Coding Solution

QCM SQL : 12 questions corrigées (type CodinGame, SkillValue)

QCMSQL12 questionsMis à jour le

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

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.

Soit la table products :
id | category | price
---+----------+------
 1 | book     | 10
 2 | book     | 15
 3 | pen      | 2
 4 | pen      | 2
 5 | lamp     | 30
Qu'affiche cette requête (PostgreSQL / MySQL) ?
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.

Le jour du test

  1. 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.
  2. 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.
  3. 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.
  4. 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.

S'entraîner avec Coding Solutions

Sur un QCM d'entraînement affiché à l'écran, l'extension Coding Solutions explique la bonne réponse et la règle derrière, dans 29 langages. Pour les exercices de code, voyez aussi nos solutions CodinGame expliquées et les guides par plateforme.

Questions fréquentes

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.

Autres langages

★ 5,0 · 16 avis · 928 utilisateurs Ajouter à Chrome