Les 99 meilleures questions-réponses d’entretien SQL pour 2026

Aperçu des questions d’entretien SQL

Les entretiens SQL reflètent souvent la manière dont on apprend réellement le langage.

Au début, il s’agit surtout de vocabulaire et de grammaire : savoir ce qu’est un join, comment SELECT fonctionne, et la différence entre DDL et DML.

Avec l’expérience, on passe de « pouvez-vous écrire une requête » à « pouvez-vous écrire la bonne requête ». Vous apprenez quand un index aide, pourquoi la normalisation compte, et comment des commandes proches comme DELETE et TRUNCATE se comportent en coulisses.

Au niveau confirmé, la syntaxe est acquise et le vrai test, c’est la résolution de problèmes : gérer doublons, NULL, ex æquo et logique de classement avec fonctions de fenêtre et CTE, et raisonner sur transactions, concurrence et performance. 

Pour les praticiens intermédiaires

1. Fonctions en SQL. Vous devez connaître les fonctions d’agrégation et scalaires, ainsi que les fonctions intégrées et définies par l’utilisateur.

2. Commandes avancées. Les questions peuvent porter sur les joins, clés primaires et étrangères, index et relations SQL.

3. Conception de base de données. Attendez-vous à des questions sur la normalisation, la dénormalisation et les différences entre diverses instructions SQL comme DELETE, TRUNCATE et DROP.

4. Requêtes avancées. On peut vous interroger sur les sous-requêtes, imbriquées et corrélées, ainsi que sur des tâches spécifiques comme trouver la n-ième plus grande valeur d’une colonne.

Questions générales d’entretien SQL

Avant de vous poser des questions techniques, votre interlocuteur peut commencer par des questions générales sur votre expérience globale en SQL.\

Ne vous inquiétez pas si votre expérience en SQL est limitée : votre interlocuteur le sait probablement déjà via votre CV. S’il souhaite vous rencontrer, c’est que votre profil a été jugé pertinent. D’ailleurs, il n’y a aucun problème si vous n’avez travaillé qu’avec un seul dialecte SQL. Rappelez-vous que les dialectes SQL sont très proches. Maîtriser l’un d’eux constitue une base solide pour apprendre les autres.

1. Qu’est-ce que SQL ?

C’est l’Structured Query Language, un langage de programmation utilisé pour interagir avec les systèmes de gestion de bases de données relationnelles (SGBDR). Il permet notamment de récupérer, mettre à jour, insérer et supprimer des données dans des tables.

2. Que sont les dialectes SQL ? Donnez des exemples.

Les différentes versions de SQL, gratuites ou payantes, sont appelées dialectes SQL. Tous les dialectes ont une syntaxe très similaire et ne diffèrent que marginalement par des fonctionnalités additionnelles. Exemples : Microsoft SQL Server, PostgreSQL, MySQL, SQLite, T-SQL et Oracle.

3. Quelles sont les principales applications de SQL ?

Avec SQL, nous pouvons :

• créer, supprimer et mettre à jour des tables dans une base de données
• accéder, manipuler et modifier les données d’une table
• extraire et synthétiser l’information nécessaire à partir d’une ou plusieurs tables
• ajouter ou supprimer certaines lignes ou colonnes d’une table

Questions d’entretien SQL pour débutants 

Votre interlocuteur peut lancer l’entretien avec des questions plus simples :

4. Qu’est-ce qu’une instruction SQL ?

Aussi appelée commande SQL. C’est une chaîne de caractères interprétée par le moteur SQL comme une commande valide et exécutée en conséquence. Exemples d’instructions SQL : SELECT, CREATE, DELETE, DROP, REVOKE, etc.

5. Qu’est-ce qu’une requête SQL ?

Une requête est un morceau de code écrit en SQL pour accéder aux données d’une base ou les modifier.

Il existe deux types de requêtes SQL : requêtes de lecture et de modification. Les premières servent à récupérer les données nécessaires (y compris limiter, regrouper, trier, extraire depuis plusieurs tables, etc.), tandis que les secondes servent à créer, ajouter, supprimer, mettre à jour et renommer des données.

6. Qu’est-ce qu’une sous-requête SQL ?

Aussi appelée requête interne, requête placée dans une autre requête dite externe. Une sous-requête peut apparaître dans des clauses telles que SELECT, FROM, WHERE, UPDATE, etc. Des sous-requêtes peuvent être imbriquées. La plus interne s’exécute en premier et son résultat est transmis à la requête (ou sous-requête) englobante.

7. Qu’est-ce qu’un join SQL ?

Une clause utilisée pour combiner et récupérer des enregistrements depuis deux tables ou plus. Les tables peuvent être jointes selon la relation entre leurs colonnes. Consultez notre tutoriel sur les joins SQL pour le contexte, ainsi que notre guide dédié aux questions d’entretien sur les joins SQL. 

8. Qu’est-ce qu’un commentaire SQL ?

Une explication lisible par l’humain sur ce que fait un morceau de code. Les commentaires SQL peuvent être sur une seule ligne (précédés de deux tirets --) ou sur plusieurs lignes (ainsi : /*comment_text*/). Le moteur SQL les ignore à l’exécution. Leur but est d’améliorer la lisibilité du code pour les lecteurs futurs.

9. Qu’est-ce qu’un alias SQL ?

Un nom temporaire donné à une table (ou à une colonne) pendant l’exécution d’une requête. Les alias améliorent la lisibilité et la concision du code. Un alias s’introduit avec le mot-clé AS :

SELECT col_1 AS column
FROM table_name;

Questions techniques d’entretien SQL

Passons maintenant aux questions techniques SQL et à quelques pistes de réponses.

Pour les questions techniques, le mieux est de répondre avec précision, sans digresser : cela peut sinon sembler hors sujet et entraîner des questions additionnelles sur lesquelles vous êtes moins à l’aise.

Au final, SQL permet d’interroger une base de multiples façons et s’intègre facilement à d’autres langages comme Python ou R pour tirer parti de leur complémentarité.

10. Quels types de commandes SQL connaissez-vous ?

• Data Definition Language (DDL) – définir et modifier la structure d’une base.
• Data Manipulation Language (DML) – accéder, manipuler et modifier les données.
• Data Control Language (DCL) – contrôler l’accès des utilisateurs aux données et accorder/révoquer des privilèges.
• Transaction Control Language (TCL) – contrôler les transactions dans une base.
• Data Query Language (DQL) – interroger les données pour en extraire l’information requise.

11. Donnez des exemples de commandes SQL courantes.

• DDL : CREATE, ALTER TABLE, DROP, TRUNCATE et ADD COLUMN

• DML : UPDATE, DELETE et INSERT

• DCL : GRANT et REVOKE

• TCL : COMMIT, SET TRANSACTION, ROLLBACK et SAVEPOINT

• DQL : – SELECT

12. Qu’est-ce qu’un SGBD et quels types de SGBD connaissez-vous ?

Un Système de Gestion de Base de Données (SGBD) est un logiciel pour effectuer diverses opérations sur les données stockées : accès, mise à jour, préparation, insertion, suppression. Il en existe de plusieurs types : relationnel, hiérarchique, réseau, graphe ou orienté objet. Ces catégories reflètent la façon dont les données sont organisées, structurées et stockées.

13. Qu’est-ce qu’un SGBDR ? Donnez des exemples.

Un Système de Gestion de Base de Données Relationnelle. C’est le type de SGBD le plus courant pour travailler avec des données stockées dans plusieurs tables reliées par des clés partagées. Le langage SQL est conçu pour interagir avec un SGBDR. Exemples : MySQL, PostgreSQL, Oracle, MariaDB, etc.

14. Qu’est-ce que des tables et des champs en SQL ?

Une table est un ensemble organisé de données liées, stockées sous forme tabulaire, c’est-à-dire en lignes et colonnes. Un champ désigne une colonne d’une table.

15. Quels types de sous-requêtes SQL connaissez-vous ?

• Monoligne – renvoie au plus une ligne.
• Multiligne – renvoie au moins deux lignes.
• Multicolonne – renvoie au moins deux colonnes.
• Corrélée – sous-requête liée aux informations de la requête externe.
• Imbriquée – sous-requête à l’intérieur d’une autre sous-requête.

16. Qu’est-ce qu’une contrainte et pourquoi en utiliser ?

Un ensemble de conditions qui définissent le type de données autorisées pour chaque colonne d’une table. Les contraintes garantissent l’intégrité des données et empêchent les actions indésirables.

17. Quelles contraintes SQL connaissez-vous ?

• DEFAULT – fournit une valeur par défaut pour une colonne.

• UNIQUE – n’autorise que des valeurs uniques.

• NOT NULL – n’autorise que des valeurs non nulles.

• PRIMARY KEY – n’autorise que des valeurs uniques et strictement non nulles (NOT NULL et UNIQUE).

• FOREIGN KEY – relie des colonnes entre deux tables ou plus via des clés partagées.

18. Quels types de joins connaissez-vous ?

• (INNER) JOIN – renvoie uniquement les enregistrements qui satisfont la condition de jointure dans les deux (ou toutes les) tables. C’est la jointure par défaut en SQL.

• LEFT (OUTER) JOIN – renvoie toutes les lignes de la table de gauche et celles de la table de droite qui satisfont la condition.

• RIGHT (OUTER) JOIN – renvoie toutes les lignes de la table de droite et celles de la table de gauche qui satisfont la condition.

• FULL (OUTER) JOIN – renvoie toutes les lignes des deux (ou de toutes les) tables. C’est une combinaison de left et right joins.

Remarque : FULL OUTER JOIN est pris en charge par PostgreSQL, SQL Server, Oracle, et MySQL 8.0+ (chez MySQL via des schémas UNION) ; par ailleurs, SQLite ne prend pas en charge RIGHT JOIN, qui peut être émulé via LEFT JOIN combiné à UNION.

19. Qu’est-ce qu’une clé primaire en SQL ?

Une colonne (ou un ensemble de colonnes) d’une table sur laquelle la contrainte PRIMARY KEY est appliquée pour garantir des valeurs uniques et non nulles. Autrement dit, une clé primaire combine NOT NULL et UNIQUE. Elle identifie de façon unique chaque enregistrement de la table.

Concept associé — clé de substitution : une clé de substitution est un identifiant généré artificiellement (souvent un entier séquentiel ou un UUID) attribué à chaque enregistrement, indépendamment des valeurs métier. Contrairement aux clés naturelles (ex. une adresse e-mail), les clés de substitution restent stables quand les données métier évoluent, d’où leur popularité comme clés primaires en production.

 Chaque table ne peut définir qu’une seule PRIMARY KEY (qui peut être composite). Une PRIMARY KEY est vivement recommandée mais pas strictement requise par tous les moteurs.

20. Qu’est-ce qu’une clé unique en SQL ?

Une colonne (ou un ensemble de colonnes) d’une table sur laquelle la contrainte UNIQUE est appliquée pour garantir des valeurs uniques dans cette colonne, y compris éventuellement une valeur NULL (unique).

Remarque :

• SQL Server : une seule valeur NULL autorisée, sauf usage d’un index filtré.
• PostgreSQL / Oracle / MySQL : plusieurs NULLs autorisés car NULL <> NULL.

21. Qu’est-ce qu’une clé étrangère en SQL ? 

Une colonne (ou un ensemble de colonnes) d’une table sur laquelle la contrainte FOREIGN KEY (ou une clé UNIQUE) est appliquée pour relier cette colonne à la clé primaire d’une autre table (ou plusieurs). L’objectif des clés étrangères est d’assurer la cohérence des liens entre les tables.

22. Qu’est-ce qu’un index SQL ?

Une structure de données spéciale liée à une table et utilisée pour stocker des éléments importants afin d’accélérer la recherche et la récupération. Les index sont particulièrement efficaces sur de grandes bases où ils améliorent nettement les performances des requêtes.

23. Quels types d’index connaissez-vous ?

• Index unique – empêche les doublons dans une colonne et contribue à l’intégrité des données.
• Index cluster – définit l’ordre physique des enregistrements d’une table et recherche selon les valeurs de clé. Une table ne peut avoir qu’un seul index cluster.
• Index non cluster – maintient un ordre logique distinct de l’ordre physique des données sur le disque. Les données sont stockées à un endroit et l’index non cluster à un autre. Une table peut en avoir plusieurs.

24. Qu’est-ce qu’un schéma ?

Un ensemble d’éléments structurels d’une base : tables, procédures stockées, index, fonctions et triggers. Il illustre l’architecture globale, précise les relations entre objets et définit des permissions d’accès. Lisez notre guide sur les schémas de base pour approfondir.

25. Qu’est-ce qu’un opérateur SQL ?

Un caractère réservé, une combinaison de caractères ou un mot-clé utilisé dans les requêtes pour réaliser une opération donnée. Les opérateurs SQL s’emploient souvent avec WHERE pour définir une ou plusieurs conditions de filtrage.

26. Quels types d’opérateurs SQL connaissez-vous ?

• Aritmétiques (+, -, *, /, etc.)

• Comparaison (>, <, =, >=, etc.)

• Composés (+=, -=, *=, /=, etc.)

• Logiques (AND, OR, NOT, BETWEEN, etc.)

• Chaîne (%, _, +, ^, etc.)

• Ensemble (UNION, UNION ALL, INTERSECT, et MINUS (ou EXCEPT))

27. Qu’est-ce qu’une clause ?

Une condition imposée à une requête SQL pour filtrer les données et obtenir le résultat souhaité. Exemples : WHERE, LIMIT, HAVING, LIKE, AND, OR, ORDER BY, etc.

28. Quelles instructions courantes accompagne-t-on avec SELECT ?

Les plus fréquentes : FROM, GROUP BY, JOIN, WHERE, ORDER BY, LIMIT et HAVING.

29. Comment créer une table en SQL ?

Avec l’instruction CREATE TABLE. Par exemple, pour créer une table avec trois colonnes de types prédéfinis :

CREATE TABLE table_name (col_1 datatype,
                         col_2 datatype,
                         col_3 datatype);

30. Comment mettre à jour une table ?

Avec l’instruction UPDATE. Syntaxe :

UPDATE table_name
SET col_1 = value_1, col_2 = value_2
WHERE condition;

31. Comment supprimer une table d’une base ?

Avec l’instruction DROP TABLE. Syntaxe : DROP TABLE table_name;.

32. Comment obtenir le nombre d’enregistrements d’une table ?

Avec la fonction d’agrégation COUNT() en passant l’astérisque en argument : SELECT COUNT(*) FROM table_name;.

33. Comment trier les enregistrements d’une table ?

Avec ORDER BY :

SELECT * FROM table_name
ORDER BY col_1;

On peut préciser un ordre décroissant avec DESC ; sinon l’ordre est croissant par défaut. On peut trier par plusieurs colonnes et définir pour chacune l’ordre croissant ou décroissant. Exemple :

SELECT * FROM table_name
ORDER BY col_1 DESC, col_3, col_6 DESC;

34. Comment sélectionner toutes les colonnes d’une table ?

Avec l’astérisque * et SELECT. Syntaxe : SELECT * FROM table_name;.

35. Comment sélectionner les enregistrements communs entre deux tables ?

Avec l’instruction INTERSECT :

SELECT col1, col2 FROM table_1
INTERSECT
SELECT col1, col2 FROM table_2;

Remarque : INTERSECT exige le même nombre de colonnes et des types compatibles.

36. Qu’est-ce que DISTINCT et comment l’utiliser ?

Cette instruction, utilisée avec SELECT, filtre les doublons et renvoie uniquement les valeurs uniques d’une colonne. Syntaxe :

SELECT DISTINCT col_1
FROM table_name;

37. Qu’est-ce qu’une relation ? Donnez des exemples.

Les relations sont les liens et corrélations entre entités, autrement dit la manière dont deux tables ou plus sont reliées. Par exemple, on peut retrouver l’ID d’un même client à la fois dans une table de ventes et dans une table clients.

38. Qu’est-ce qu’une valeur NULL ? En quoi diffère-t-elle de zéro ou d’un blanc ?

Une valeur NULL indique l’absence de donnée pour une cellule. Zéro est une valeur numérique valide et une chaîne vide est une chaîne de longueur zéro, valide.

39. Quelle est la différence entre SQL et NoSQL ?

Les bases SQL sont relationnelles, structurées, avec des tables et des schémas prédéfinis, tandis que les bases NoSQL sont non relationnelles, sans schéma fixe, conçues pour des données non ou semi-structurées.

40. Quelles difficultés courantes rencontre-t-on avec les bases SQL ?

Parmi les défis : l’optimisation des performances sur de grands volumes, la gestion des stratégies d’indexation, l’assurance de l’intégrité via des contraintes, la gestion des transactions concurrentes et l’optimisation de l’exécution des requêtes.

Questions d’entretien SQL intermédiaires

41. Qu’est-ce qu’une Common Table Expression (CTE) ?

Une Common Table Expression (CTE) est un jeu de résultats temporaire et nommé, référençable dans une instruction SELECT, INSERT, UPDATE ou DELETE. Les CTE améliorent la lisibilité des requêtes et permettent de décomposer des requêtes complexes en parties plus simples et réutilisables. La syntaxe utilise le mot-clé WITH :

WITH sales_summary AS (
  SELECT product_id, SUM(amount) AS total_sales
  FROM sales
  GROUP BY product_id
)
SELECT p.product_name, s.total_sales
FROM products p
JOIN sales_summary s ON p.id = s.product_id
WHERE s.total_sales > 10000;

Les CTE sont particulièrement utiles pour les requêtes récursives (données hiérarchiques comme des organigrammes) et lorsque la même sous-requête doit être référencée plusieurs fois.

42. Qu’est-ce qu’une fonction de fenêtre et en quoi diffère-t-elle d’une fonction d’agrégation ?

Les fonctions de fenêtre effectuent des calculs sur un ensemble de lignes liées à la ligne courante, sans réduire le résultat à une seule ligne comme le font les agrégations. Elles utilisent la clause OVER() pour définir la fenêtre.

Fonctions de fenêtre clés :

• ROW_NUMBER() – attribue un numéro séquentiel unique à chaque ligne
• RANK() – attribue un rang avec des sauts en cas d’égalité
• DENSE_RANK() – attribue un rang sans sauts en cas d’égalité
• LAG() / LEAD() – accèdent aux valeurs des lignes précédente/suivante
• SUM() OVER(), AVG() OVER() – calculs cumulés

Exemple : calcul d’un total cumulé des ventes

SELECT 
  order_date,
  amount,
  SUM(amount) OVER (ORDER BY order_date) AS running_total
FROM orders;

43. Quelle différence entre RANK(), DENSE_RANK() et ROW_NUMBER() ?

Ces trois fonctions classent, mais gèrent les ex æquo différemment :

• ROW_NUMBER() – attribue toujours des numéros uniques (1, 2, 3, 4...), même en cas d’égalité
• RANK() – attribue le même rang aux ex æquo puis saute des numéros (1, 2, 2, 4...)
• DENSE_RANK() – attribue le même rang sans saut (1, 2, 2, 3...)

SELECT 
  name, 
  score,
  ROW_NUMBER() OVER (ORDER BY score DESC) AS row_num,
  RANK() OVER (ORDER BY score DESC) AS rank,
  DENSE_RANK() OVER (ORDER BY score DESC) AS dense_rank
FROM students;

Utilisez DENSE_RANK() pour trouver la « n-ième plus grande » valeur lorsque les ex æquo doivent partager la même position.

Dans cette section, nous passons en revue les questions intermédiaires les plus fréquentes afin que vous sachiez à quoi vous attendre.

44. Qu’est-ce qu’une fonction en SQL ?

Un objet base de données représentant un ensemble d’instructions SQL fréquemment utilisées pour une tâche donnée. Une fonction prend des paramètres en entrée, effectue des calculs ou transformations et renvoie un résultat. Les fonctions améliorent la lisibilité et évitent la répétition.

45. Quels types de fonctions SQL connaissez-vous ?

• Fonctions d’agrégation – opèrent sur plusieurs enregistrements (souvent groupés) et renvoient une valeur unique (souvent par groupe).
• Fonctions scalaires – s’appliquent à chaque valeur individuellement et renvoient une valeur unique.

Par ailleurs, les fonctions SQL peuvent être intégrées (système) ou définies par l’utilisateur (créées selon des besoins spécifiques).

46. Quelles fonctions d’agrégation SQL connaissez-vous ?

• AVG() – renvoie la moyenne

• SUM() – renvoie la somme

• MIN() – renvoie le minimum

• MAX() – renvoie le maximum

• COUNT() – renvoie le nombre de lignes, y compris avec valeurs nulles

47. Quelles fonctions scalaires SQL connaissez-vous ?

• LEN() (dans d’autres dialectes – LENGTH()) – longueur d’une chaîne, espaces compris

• UCASE() (dans d’autres dialectes – UPPER()) – conversion en majuscules

• LCASE() (dans d’autres dialectes – LOWER()) – conversion en minuscules

• INITCAP() – conversion en casse « titre » (initiale de chaque mot en capitale)

• MID() (dans d’autres dialectes – SUBSTR()) – extrait une sous-chaîne

• ROUND() – arrondit une valeur numérique au nombre de décimales spécifié

• NOW() – renvoie la date et l’heure courantes

48. Quelles sont les fonctions de changement de casse en SQL ?

Sous-ensemble des fonctions de caractères, elles modifient la casse du texte : majuscules, minuscules ou casse « titre ».

• UCASE() (autres dialectes – UPPER()) – majuscules

• LCASE() (autres dialectes – LOWER()) – minuscules

• INITCAP() – casse « titre »

49. Quelles sont les fonctions de manipulation de chaînes en SQL ?

Elles servent à modifier des données textuelles.

• CONCAT() – concatène deux chaînes ou plus

• SUBSTRING()/SUBSTR() – renvoie une partie d’une chaîne selon un début et une fin

• LENGTH() (autres dialectes – LEN()) – longueur d’une chaîne

• REPLACE() – remplace toutes les occurrences d’une sous-chaîne

• INSTR() – renvoie la position numérique d’une sous-chaîne

• LPAD() et RPAD() – ajoutent un remplissage à gauche/droite

• TRIM() – supprime des caractères donnés, ainsi que les espaces, en début, fin ou des deux côtés

50. Différence entre variables locales et globales ?

Les variables locales ne sont accessibles qu’à l’intérieur de la fonction où elles sont déclarées. Les variables globales, déclarées hors de toute fonction, sont stockées de façon fixe et utilisables dans tout le programme.

51. Quelle différence entre SQL et PL/SQL ?

Il n’y a aucune différence entre LEFT JOIN et LEFT OUTER JOIN. Ils sont interchangeables. Le mot-clé OUTER est optionnel, LEFT JOIN est donc une forme abrégée de LEFT OUTER JOIN. Les deux renvoient toutes les lignes de la table de gauche et les correspondances de la table de droite.

53. Qu’est-ce que l’indexation en SQL et comment améliore-t-elle les performances ?

L’indexation crée une structure de données spécifique qui accélère la recherche, en permettant au SGBD de localiser les lignes efficacement. Elle fonctionne comme une table d’appoint optimisée, réduisant les scans complets. Trop d’index peuvent toutefois ralentir insertions, mises à jour et suppressions à cause de leur maintenance.

54. Qu’est-ce qu’une procédure stockée, et en quoi diffère-t-elle d’une fonction ?

Une procédure stockée est un ensemble précompilé d’instructions SQL exécutées en bloc pour accomplir une tâche. Les procédures peuvent modifier des données ou des objets de schéma, gérer des transactions et renvoyer zéro ou plusieurs jeux de résultats. Les fonctions, elles, s’emploient typiquement dans des expressions SQL, doivent retourner une valeur (scalaire ou table) et, dans de nombreux SGBD, sont limitées en effets de bord. Le comportement exact dépend du SGBD (ex. T-SQL a des fonctions scalaires et table, PostgreSQL distingue fonctions et procédures).

55. Quel est l’ordre par défaut avec ORDER BY et comment le changer ?

Par défaut, l’ordre est croissant (NULLS FIRST/LAST varie selon le SGBD). Utilisez les mots-clés ASC/DESC par colonne :

SELECT * FROM table_name 
ORDER BY col_1 DESC;

56. Quels sont les opérateurs d’ensemble en SQL ?

• UNION – renvoie les enregistrements obtenus par au moins une des deux requêtes (doublons exclus)

• UNION ALL – renvoie les enregistrements obtenus par au moins une des deux requêtes (doublons inclus)

• INTERSECT – renvoie les enregistrements communs aux deux requêtes

• EXCEPT (appelé MINUS sous MySQL et Oracle) – renvoie uniquement les enregistrements de la première requête absents de la seconde

57. Quel opérateur utilise-t-on pour faire du pattern matching ?

L’opérateur LIKE avec les jokers % et _. % représente n’importe quel nombre de caractères (y compris zéro) et _ exactement un caractère.

58. Différence entre clé primaire et clé unique en SQL ?

Les deux garantissent l’unicité des valeurs d’une colonne, mais la clé primaire identifie chaque enregistrement de la table, tandis que la clé unique empêche les doublons dans cette colonne.

59. Qu’est-ce qu’une clé primaire composite ?

Une clé primaire fondée sur plusieurs colonnes.

60. Quel est l’ordre typique des clauses dans une instruction SELECT ?

SELECT – FROM – JOIN – ON – WHERE – GROUP BY – HAVING – ORDER BY – LIMIT

61. Dans quel ordre l’interpréteur exécute-t-il ces clauses ?

Voici l’ordre d’exécution SQL :

FROM → ON → JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT/OFFSET (FETCH)

62. Qu’est-ce qu’une vue en SQL ?

Une table virtuelle contenant un sous-ensemble de données récupérées depuis une ou plusieurs tables (ou vues). Les vues standards ne stockent pas de données ; les vues matérialisées si. Les vues simplifient les requêtes, encapsulent la logique et, avec les privilèges, restreignent colonnes/lignes. Elles peuvent joindre et agréger des données issues de plusieurs tables.

63. Peut-on créer une vue à partir d’une autre vue ?

Oui, on parle de vues imbriquées. Évitez toutefois des niveaux multiples qui nuisent à la lisibilité et au débogage.

64. Peut-on utiliser une vue si la table d’origine est supprimée ?

Non. Toute vue basée sur cette table devient invalide après la suppression. Une tentative d’utilisation renverra une erreur.

65. Quels types de relations SQL connaissez-vous ?

• Un-à-un – chaque enregistrement d’une table correspond à un seul d’une autre
• Un-à-plusieurs – un enregistrement correspond à plusieurs dans l’autre table
• Plusieurs-à-plusieurs – chaque table peut avoir plusieurs correspondances dans l’autre

66. Quelles valeurs un champ BOOLEAN peut-il prendre ?

Dans certains dialectes comme PostgreSQL, le type BOOLEAN existe explicitement et prend TRUE, FALSE ou NULL. Dans d’autres comme Microsoft SQL Server, le type BIT stocke TRUE/FALSE en 1 ou 0.

67. Qu’est-ce que la normalisation en SQL ?

Un processus de conception qui organise et restructure les données pour réduire redondance, dépendances, duplications et incohérences. Résultat : meilleure intégrité, plus de tables, accès plus efficace, contrôle de sécurité accru et plus grande flexibilité de requêtes.

68. Qu’est-ce que la dénormalisation en SQL ?

La dénormalisation fait l’inverse : elle introduit de la redondance et combine des données de plusieurs tables. Elle optimise les performances quand la lecture prime sur l’écriture, en évitant des joins complexes et en réduisant le temps d’exécution.

69. Différence entre renommer une colonne et lui donner un alias ?

Renommer une colonne modifie durablement son nom dans la table. Donner un alias lui attribue un nom temporaire à l’exécution d’une requête pour améliorer lisibilité et concision.

70. Différence entre sous-requête imbriquée et corrélée ?

Une sous-requête corrélée fait référence à des valeurs de la requête externe pour s’exécuter : elle dépend donc de cette requête. Une sous-requête non corrélée est indépendante et peut s’exécuter seule.

71. Différence entre index cluster et non cluster ?

Un index cluster définit l’ordre physique des enregistrements et recherche selon la clé ; un index non cluster maintient un ordre logique distinct de l’ordre physique. Une table a au plus un index cluster mais peut avoir plusieurs non cluster.

72. Qu’est-ce que la fonction CASE() ?

C’est l’implémentation SQL de la logique if-then-else. Elle teste séquentiellement les conditions des clauses WHEN et renvoie la valeur de la clause THEN de la première condition satisfaite. Sinon, elle renvoie la valeur de ELSE si fournie, ou NULL. Syntaxe :

CASE
    WHEN condition_1 THEN value_1
    WHEN condition_2 THEN value_2
    WHEN condition_3 THEN value_3
    ...
    ELSE value
END;

73. Différence entre DELETE et TRUNCATE ?

DELETE est une commande DML qui supprime une ou plusieurs lignes selon une condition en WHERE. Elle est réversible seulement dans une transaction (via ROLLBACK).

TRUNCATE est une commande DDL qui supprime toutes les lignes d’une table en désallouant les pages. Plus rapide mais généralement irréversible, et impossible sur une table référencée par une clé étrangère.

74. Différence entre DROP et TRUNCATE ?

DROP supprime complètement la table de la base, y compris sa structure, contraintes, relations et privilèges. TRUNCATE supprime toutes les lignes sans toucher à la structure ni aux contraintes.  Tous deux sont DDL. DROP supprime la table et ses métadonnées ; TRUNCATE efface les lignes mais conserve la définition. Les performances et le comportement transactionnel dépendent du moteur.

75. Différence entre HAVING et WHERE ?

HAVING s’applique aux données agrégées après regroupement, tandis que WHERE filtre chaque ligne individuellement. Si les deux sont présents, l’ordre est : WHERE – GROUP BY – HAVING. Le moteur les interprète aussi dans cet ordre.

76. Comment ajouter un enregistrement à une table ?

Avec INSERT INTO et VALUES. Syntaxe :

INSERT INTO table_name
VALUES (value_1, value_2, ...);

77. Comment supprimer un enregistrement d’une table ?

Avec DELETE. Syntaxe :

DELETE FROM table_name
WHERE condition;

On peut ainsi supprimer plusieurs enregistrements s’ils satisfont la condition.

78. Comment ajouter une colonne à une table ?

Avec ALTER TABLE et ADD. Syntaxe :

ALTER TABLE table_name
ADD column_name datatype;

79. Comment renommer une colonne ?

Avec ALTER TABLE et RENAME COLUMN ... TO .... Syntaxe :

ALTER TABLE table_name
RENAME COLUMN old_column_name TO new_column_name;

80. Comment supprimer une colonne ?

Avec ALTER TABLE et DROP COLUMN. Syntaxe :

ALTER TABLE table_name
DROP COLUMN column_name;

81. Comment sélectionner toutes les lignes paires ou impaires d’une table ?

En testant le reste de la division par 2. Dans certains SQL (ex. PostgreSQL, MySQL), on utilise MOD ; dans d’autres (Microsoft SQL Server, SQLite), l’opérateur modulo (%). Pour sélectionner les lignes paires avec MOD :

SELECT * FROM table_name
WHERE MOD(ID_column, 2) = 0;

Pour sélectionner les lignes paires avec % :

SELECT * FROM table_name 
WHERE ID_column % 2 = 0;

Pour les impaires, on utilise l’inégalité <> au lieu de =.

82. Comment éviter les doublons dans une requête ?

Avec DISTINCT associé à SELECT, ou en créant une clé unique sur la table.

83. Comment insérer plusieurs lignes dans une table ?

Avec INSERT INTO et VALUES. Syntaxe :

INSERT INTO table_name
VALUES (value_1, value_2, ...),
      (value_3, value_4, ...),
      (value_5, value_6, ...),
      ...;

84. Comment trouver la n-ième plus grande valeur d’une colonne ?

En utilisant des fonctions de fenêtre pour gérer correctement les ex æquo :

SELECT column_name
FROM (
  SELECT column_name, DENSE_RANK() OVER (ORDER BY column_name DESC) AS rnk
  FROM table_name
) t
WHERE rnk = :n;

Pour la n-ième ligne par ordre (en ignorant les ex æquo) : ORDER BY column_name DESC OFFSET n-1 ROWS FETCH NEXT 1 ROW ONLY.

85. Comment trouver les valeurs d’une colonne texte qui commencent par une lettre donnée ?

Avec l’opérateur LIKE et les jokers % et _. Par exemple, pour trouver tous les noms de famille commençant par « A » :

SELECT * FROM table_name
WHERE surname LIKE 'A_';

Ici, on suppose un nom d’au moins deux lettres. Sans cette hypothèse (un nom pouvant être juste A) :

SELECT * FROM table_name
WHERE surname LIKE 'A%';

86. Comment trouver le dernier id d’une table ?

La méthode la plus simple est d’utiliser la fonction d’agrégation MAX().

SELECT MAX(id) AS highest_id
FROM table_name;

Avec ORDER BY et LIMIT ou TOP

SELECT id
FROM table_name
ORDER BY id DESC
LIMIT 1;

87. Comment sélectionner des lignes aléatoires ?

Avec RAND(), ORDER BY et LIMIT. Dans certains dialectes comme PostgreSQL, c’est RANDOM(). Exemple (MySQL) pour 5 lignes aléatoires :

SELECT * FROM table_name
ORDER BY RAND()
LIMIT 5;

Questions scénarisées d’entretien SQL

Ces questions évaluent votre capacité à résoudre des problèmes métiers concrets avec SQL. Elles testent votre approche, la gestion des cas limites (doublons, valeurs NULL, ex æquo) au-delà de la simple syntaxe.

88. Comment trouver et supprimer les doublons d’une table ?

Identifier les doublons :

SELECT email, COUNT(*) AS duplicate_count
FROM users
GROUP BY email
HAVING COUNT(*) > 1;

Supprimer les doublons (en conservant un enregistrement) :

WITH duplicates AS (
  SELECT id, 
         ROW_NUMBER() OVER (PARTITION BY email ORDER BY id) AS rn
  FROM users
)
DELETE FROM users 
WHERE id IN (SELECT id FROM duplicates WHERE rn > 1);

Cette approche utilise une CTE avec ROW_NUMBER() pour repérer les doublons et conserve l’ID le plus petit.

89. Comment calculer un total cumulé (cumulative sum) ?

Utilisez SUM() en fenêtre avec ORDER BY :

SELECT 
  transaction_date,
  amount,
  SUM(amount) OVER (ORDER BY transaction_date) AS running_total
FROM transactions;

Pour un cumul par catégorie (ex. par client) :

SELECT 
  customer_id,
  transaction_date,
  amount,
  SUM(amount) OVER (
    PARTITION BY customer_id 
    ORDER BY transaction_date
  ) AS customer_running_total
FROM transactions;

90. Comment trouver les employés gagnant plus que la moyenne de leur département ?

Cas classique de sous-requête corrélée :

SELECT e.name, e.department, e.salary
FROM employees e
WHERE e.salary > (
  SELECT AVG(salary) 
  FROM employees 
  WHERE department = e.department
);

Alternative avec fonction de fenêtre :

SELECT name, department, salary
FROM (
  SELECT 
    name, 
    department, 
    salary,
    AVG(salary) OVER (PARTITION BY department) AS dept_avg
  FROM employees
) t
WHERE salary > dept_avg;

91. Comment trouver les lacunes dans une séquence de nombres (ex. numéros de facture manquants) ?

Utilisez LEAD() pour comparer chaque valeur à la suivante :

SELECT 
  invoice_number,
  LEAD(invoice_number) OVER (ORDER BY invoice_number) AS next_invoice,
  LEAD(invoice_number) OVER (ORDER BY invoice_number) - invoice_number - 1 AS gap_size
FROM invoices
WHERE LEAD(invoice_number) OVER (ORDER BY invoice_number) - invoice_number > 1;

On identifie où l’écart entre deux factures consécutives dépasse 1.

92. Comment trouver les clients ayant acheté sur des mois consécutifs ?

Utilisez LAG() pour comparer à la ligne précédente :

WITH monthly_purchases AS (
  SELECT 
    customer_id,
    DATE_TRUNC('month', purchase_date) AS purchase_month,
    LAG(DATE_TRUNC('month', purchase_date)) OVER (
      PARTITION BY customer_id 
      ORDER BY DATE_TRUNC('month', purchase_date)
    ) AS prev_month
  FROM purchases
  GROUP BY customer_id, DATE_TRUNC('month', purchase_date)
)
SELECT DISTINCT customer_id
FROM monthly_purchases
WHERE purchase_month = prev_month + INTERVAL '1 month';

93. Comment pivoter des données de lignes en colonnes ?

Utilisez des agrégations conditionnelles avec CASE :

SELECT 
  product_name,
  SUM(CASE WHEN EXTRACT(MONTH FROM sale_date) = 1 THEN amount ELSE 0 END) AS jan_sales,
  SUM(CASE WHEN EXTRACT(MONTH FROM sale_date) = 2 THEN amount ELSE 0 END) AS feb_sales,
  SUM(CASE WHEN EXTRACT(MONTH FROM sale_date) = 3 THEN amount ELSE 0 END) AS mar_sales
FROM sales
GROUP BY product_name;

Certains SGBD (SQL Server, Oracle) disposent d’une syntaxe PIVOT native.

94. Comment trouver le top 3 des produits par ventes dans chaque catégorie ?

Utilisez DENSE_RANK() avec PARTITION BY :

WITH ranked_products AS (
  SELECT 
    category,
    product_name,
    SUM(sales_amount) AS total_sales,
    DENSE_RANK() OVER (
      PARTITION BY category 
      ORDER BY SUM(sales_amount) DESC
    ) AS sales_rank
  FROM sales
  GROUP BY category, product_name
)
SELECT category, product_name, total_sales
FROM ranked_products
WHERE sales_rank <= 3
ORDER BY category, sales_rank;

95. Quelles sont les propriétés ACID des transactions ?

ACID est l’acronyme des quatre propriétés garantissant des transactions fiables :

• Atomicité : une transaction est « tout ou rien » – toutes les opérations réussissent ou aucune
• Cohérence : la transaction fait passer la base d’un état valide à un autre, en respectant règles et contraintes
• Isolation : des transactions concurrentes ne se perturbent pas ; chacune voit un instantané cohérent
• Durabilité : une fois validées, les modifications persistent même en cas de panne

Exemple de transaction :

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

COMMIT;

96. Qu’est-ce qu’un interblocage (deadlock) et comment l’éviter ?

Un interblocage survient lorsque deux transactions (ou plus) attendent mutuellement la libération de verrous, créant une dépendance circulaire qui bloque toute progression.

Exemple : la transaction A verrouille la table X et attend Y, tandis que la transaction B verrouille Y et attend X.

Prévention :

• Ordre de verrou cohérent : acquérir les verrous dans le même ordre partout
• Transactions courtes : valider/annuler au plus vite
• Niveaux d’isolation appropriés : réduire la contention des verrous
• Accéder uniquement aux données nécessaires : éviter de verrouiller des lignes inutiles
• Gérer les réessais : la plupart des SGBD détectent et résolvent en annulant une transaction

97. Comment optimiser une requête SQL lente ?

Stratégies clés :

• Ajouter des index pertinents : sur les colonnes des clauses WHERE, JOIN et ORDER BY

• Analyser les plans d’exécution : EXPLAIN (PostgreSQL/MySQL) ou EXPLAIN PLAN (Oracle)

• Éviter SELECT * : ne récupérer que les colonnes nécessaires

• Utiliser des JOIN plutôt que des sous-requêtes : souvent plus efficaces que les sous-requêtes corrélées

• Limiter les résultats : LIMIT/TOP si tout n’est pas requis

• Éviter les fonctions sur colonnes indexées : WHERE YEAR(date_col) = 2026 ne peut pas utiliser un index ; préférez WHERE date_col >= '2026-01-01'

• Envisager le partitionnement : par date ou catégorie pour les très grandes tables

98. Comment gérer les valeurs NULL dans les calculs et comparaisons ?

NULL représente une donnée manquante ou inconnue et requiert un traitement spécifique :

• Comparaisons : utilisez IS NULL ou IS NOT NULL plutôt que = NULL

• COALESCE() : renvoie la première valeur non NULL : COALESCE(column, 'default')

• NULLIF() : renvoie NULL si deux valeurs sont égales : NULLIF(a, b)

• ISNULL() / NVL() : fonctions spécifiques à certains SGBD pour remplacer NULL

SELECT 
  name,
  COALESCE(phone, email, 'No contact') AS contact_info,
  CASE WHEN status IS NULL THEN 'Unknown' ELSE status END AS status
FROM customers;

99. Comment trouver la plus longue série de jours de connexion consécutifs pour un utilisateur ?

C’est un problème avancé de type « îlots et lacunes » :

WITH login_groups AS (
  SELECT 
    user_id,
    login_date,
    login_date - ROW_NUMBER() OVER (
      PARTITION BY user_id 
      ORDER BY login_date
    ) * INTERVAL '1 day' AS group_id
  FROM user_logins
)
SELECT 
  user_id,
  MIN(login_date) AS streak_start,
  MAX(login_date) AS streak_end,
  COUNT(*) AS streak_length
FROM login_groups
GROUP BY user_id, group_id
ORDER BY streak_length DESC
LIMIT 1;

L’astuce consiste à soustraire un numéro de ligne à chaque date : des dates consécutives produisent le même « group_id ».

Former vos équipes au SQL

La préparation aux entretiens SQL est cruciale pour les candidats et recruteurs, mais il est tout aussi important pour les entreprises d’investir dans une formation continue au SQL. La capacité à travailler avec les données est plus clé que jamais : des collaborateurs solides en SQL peuvent faire la différence pour la performance de votre organisation.

Si vous dirigez une équipe et souhaitez garantir une maîtrise du SQL à l’échelle de votre organisation, DataCamp for Business propose des formations adaptées pour faire progresser vos collaborateurs, des bases aux notions avancées. Nous offrons :

• Parcours d’apprentissage ciblés : personnalisables selon le niveau et les besoins métier.
• Pratique concrète : scénarios réels et exercices pour renforcer l’ancrage des acquis.
• Suivi des progrès : outils pour mesurer et piloter l’atteinte des objectifs.

Investir dans la montée en compétences SQL avec des plateformes comme DataCamp renforce vos capacités internes et vous donne un avantage stratégique pour rester compétitif et livrer des résultats. Échangez avec nos équipes et demandez une démo dès aujourd’hui. 

Conclusion

En résumé, nous avons passé en revue 99 questions essentielles – débutant, intermédiaire et scénarisées – et leurs réponses. Nous espérons que ces informations vous aideront à vous préparer et à gagner en confiance, que vous cherchiez un poste autour de SQL ou que vous recrutiez pour un rôle SQL intermédiaire.

Si vous avez besoin de davantage d’entraînement pour préparer un entretien, parcourez notre liste complète de cours SQL :

• Introduction to SQL
• SQL Foundations
• Data Analyst in SQL
• Exploratory Data Analysis in SQL
• SQL for Business Analysts
• Analyzing Business Data in SQL
• Intermediate SQL
• Intermediate SQL Server
• Applying SQL to Real-World Problems
• SQL Server for Database Administrators