15 questions d'entretien SQL difficiles pour les utilisateurs expérimentés

Les questions d'entretien SQL pour utilisateurs expérimentés contiennent généralement des questions pièges. Les intervieweurs les utilisent pour tester votre courage, qui est généralement le résultat d'une longue expérience et d'un haut niveau de connaissances en SQL.

Dans cet article, je vais vous présenter 15 questions d'entretien SQL délicates (principalement sur le codage). Attention, il ne s'agit pas nécessairement de questions complexes. En fait, c'est leur principale caractéristique : elles semblent très faciles et directes, mais c'est l'interviewer qui essaie de vous tromper. Mais en tant qu'utilisateur expérimenté de SQL, vous devriez être capable de reconnaître les pièges et de les éviter.

Je vous montrerai comment faire, mais je ne peux pas préparer l'entretien à votre place. Alors, comment aborder la préparation à l'entretien ?

Préparation à l'entretien en tant qu'utilisateur SQL expérimenté

Des bases solides dans les sujets SQL de base et intermédiaires sont des conditions préalables pour se considérer comme un utilisateur SQL expérimenté. Si vous ne savez pas où vous vous situez sur l'échelle des connaissances SQL, nous avons quelque chose de nouveau pour vous : notre évaluation des compétences SQL. Vous pouvez passer le test et évaluer votre niveau de connaissances en SQL. Il s'agit d'une fonctionnalité gratuite ; vous pouvez effectuer un test tous les 30 jours. À la fin du test, vous obtenez une note globale sur vos connaissances en SQL. Les résultats sont détaillés pour six domaines de compétences : Requêtes SQL de base, Les jointures en SQL, Fonctions SQL standard, Rapports SQL de base, Rapports SQL intermédiaires et Rapports SQL complexes.

Après l'évaluation, vous pouvez vous rendre sur notre site SQL avancé pour plus de pratique. Il s'agit de trois cours interactifs principaux qui couvrent les détails des fonctions de fenêtre, les extensions GROUP BY et les requêtes récursives. Les sujets sont répartis sur 395 défis de codage, de sorte que vous écrirez beaucoup de code - ce qui s'est avéré être la manière la plus efficace d'apprendre le langage SQL. Après le cours, vous serez à l'aise avec les sujets SQL avancés.

Le parcours d'apprentissage vous apportera des connaissances, cela ne fait aucun doute. Toutefois, les employeurs comptent sur des utilisateurs expérimentés pour exploiter le langage SQL afin de résoudre des problèmes concrets. Mais dans la vie, les choses sont rarement simples ; les problèmes réels ont tendance à ne pas être des exemples de manuels SQL adaptés à l'apprentissage. Vous devez donc aller au-delà des exemples du cours. Vous devez travailler sur la flexibilité et la créativité, voir les pièges potentiels à l'avance et les éviter dans votre code SQL. C'est ce que les examinateurs attendent d'utilisateurs expérimentés. Pour cette raison, il ne suffit pas de se préparer à l'entretien avec des questions SQL simples. Vous devez également vous familiariser avec les questions délicates, car les examinateurs aiment les utiliser pour essayer de vous prendre au dépourvu.

Voici quelques-unes des questions d'entretien SQL les plus courantes et les plus délicates pour les utilisateurs expérimentés.

Question 1 : Sélectionner les freelances et les informations sur leurs tâches

Ecrivez une requête qui sélectionne tous les freelances avec leurs informations de tâches :

• Titre de la tâche
• Type et sous-type de tâche
• Date d'échéance

Inclure les freelances qui n'ont pas de tâches assignées.

Ensemble de données : L'ensemble de données concerne une entreprise qui emploie des free-lances pour certaines tâches. Il se compose de trois tableaux. La première table est freelancer. Vous pouvez trouver le script ici.

id	first_name	last_name
1	Bob	Franklin
2	Dionne	Ravanelli
3	Marek	Lewandowski
4	Francois	Cousteau
5	Emma	Biesa

La deuxième table est un dictionnaire des différents types de tâches nommé task_category. Voici le script.

id	task_type	task_subtype
1	Blog article	SQL
2	Blog article	Python
3	Blog article	Career
4	Social media post	LinkedIn
5	Social media post	Other social media

Le troisième tableau montre les détails du travail assigné aux freelances pour notre société. Le tableau s'appelle taskVoici le script.

id	task_category_id	title	freelancer_id	date_assigned	due_date	completed_date
1	2	Working With Pandas in Python	5	2023-11-30	2023-12-15	2023-12-15
2	4	Promote SQL avancé Learning Track	4	2023-12-18	2023-12-20	2023-12-20
3	1	Working With LEFT JOIN in SQL	1	2023-12-08	2024-03-01	NULL
4	3	What Does a Data Analyst Do?	2	2023-12-20	2024-02-01	2024-02-10
5	4	Promote Working With Pandas in Python	4	2024-01-15	2024-01-18	2024-01-18
6	2	Python Libraries You Should Know	1	2024-01-15	2024-02-15	2024-02-15
7	1	Using COUNT in SQL	2	2024-01-20	2024-02-15	2024-02-15
8	1	Filtering Data in SQL	5	2024-02-20	NULL	NULL

Réponse : Cette question teste vos compétences en matière de jointure de trois tables et de choix du type de jointure correct.

Voici la solution :

SELECT f.first_name,
	 f.last_name,
	 t.title,
	 t.due_date,
	 tc.task_type,
	 tc.task_subtype
FROM freelancer f
JOIN task t
ON f.id = t.freelancer_id
JOIN task_category tc
ON t.task_category_id = tc.id;

Explication : Pour obtenir toutes les informations requises, vous devez joindre les trois tables. Tout d'abord, joignez les tables freelancer et task sur l'ID du freelance. Pour ajouter la troisième table, vous devez à nouveau écrire le mot-clé JOIN. Ensuite, indiquez dans la clause ON que vous joignez les tables sur l'ID de la catégorie de tâches.

Le type de jointure que vous utilisez doit être JOIN. C'est parce qu'il est possible que certains free-lances n'aient pas encore de tâches. Vous n'avez besoin que de ceux qui en ont.

Résultat : Voici le résultat de la requête :

first_name	last_name	title	due_date	task_type	task_subtype
Emma	Biesa	Working With Pandas in Python	2023-12-15	Blog article	Python
Francois	Cousteau	Promote SQL avancé Learning Track	2023-12-20	Social media post	LinkedIn
Bob	Franklin	Working With LEFT JOIN in SQL	2024-03-01	Blog article	SQL
Dionne	Ravanelli	What Does a Data Analyst Do?	2024-02-01	Blog article	Career
Francois	Cousteau	Promote Working With Pandas in Python	2024-01-18	Social media post	LinkedIn
Bob	Franklin	Python Libraries You Should Know	2024-02-15	Blog article	Python
Dionne	Ravanelli	Using COUNT in SQL	2024-02-15	Blog article	SQL
Emma	Biesa	Filtering Data in SQL	NULL	Blog article	SQL

Question 2 : Qu'est-ce qu'un OUTER JOIN et quand l'utiliser ?

Réponse : Cette question vise à vérifier si vous comprenez vraiment comment fonctionnent les jointures externes et en quoi elles sont différentes des autres jointures.

OUTER JOINLes jointures externes sont l'une des catégories de jointures distinctes en SQL, avec les jointures INNER JOINet CROSS JOIN.

Les jointures suivantes appartiennent à la famille OUTER JOIN:

• LEFT (OUTER) JOIN
• RIGHT (OUTER) JOIN
• FULL (OUTER) JOIN

La principale caractéristique de tous les OUTER JOINs est qu'ils joignent des tables de manière à ce qu'une table soit dominante et que toutes ses données soient affichées. La deuxième table est subordonnée, de sorte que la requête n'affiche que les lignes correspondantes de cette table. S'il y a des lignes non correspondantes, elles apparaîtront comme NULL.

Ainsi, OUTER JOINs doit être utilisé lorsque vous souhaitez afficher les lignes non concordantes ainsi que les lignes concordantes dans les tables.

Chacune des jointures externes ci-dessus fonctionne selon ce principe, mais voici en quoi elles diffèrent :

• LEFT JOIN affiche toutes les données de la première table (gauche) et uniquement les lignes correspondantes de la deuxième table (droite). S'il y a des lignes non correspondantes, elles sont affichées à l'adresse NULL.

• RIGHT JOIN affiche toutes les données de la deuxième table (droite) et uniquement les lignes correspondantes de la première table (gauche). Les lignes non correspondantes sont affichées sous la forme NULL.

• FULL JOIN combine les tables LEFT JOIN et RIGHT JOIN et affiche toutes les données des deux tables. En d'autres termes, il affiche toutes les lignes - correspondantes et non correspondantes - de la table de gauche. Il ajoute ensuite toutes les lignes du tableau de droite qui ne peuvent être trouvées dans le tableau de gauche. Lorsqu'il y a des données non concordantes, vous verrez NULLs.

Question 3 : Sélectionner les informations sur les freelances et les tâches, partie 2

Ecrivez une requête qui renvoie :

• Les noms et prénoms des freelances.
• Les titres des tâches qui leur sont assignées.
• Le type et le sous-type de la tâche.
• Les dates d'échéance des tâches.

Inclure tous les free-lances, même ceux qui n'ont pas de tâches.

Ensemble de données : Identique à la question 1.

Réponse : Encore une autre question d'entretien SQL pour les utilisateurs expérimentés. Ici, vous devez montrer que vous comprenez les relations entre les tables. Vous devez utiliser LEFT JOIN pour joindre les trois tables. Vous devez utiliser LEFT JOIN comme première jointure. Mais vous devez savoir que la relation entre les tables vous "oblige" à utiliser LEFT JOIN comme deuxième jointure.

SELECT f.first_name,
	 f.last_name,
	 t.title,
	 t.due_date,
	 tc.task_type,
	 tc.task_subtype
FROM freelancer f
LEFT JOIN task t
ON f.id = t.freelancer_id
LEFT JOIN task_category tc
ON t.task_category_id = tc.id;

Explication : La requête est très similaire à celle de la question 1. Votre première jointure est donc LEFT JOIN, car vous devez sortir tous les free-lances, et pas seulement ceux auxquels une tâche a été attribuée. En d'autres termes, la relation est telle qu'une tâche doit être assignée à un free-lance, mais qu'un free-lance ne doit pas nécessairement être assigné à une tâche.

Cependant, lorsque vous joignez la troisième table, vous avez à nouveau besoin de LEFT JOIN. Comment cela se fait-il ? Parce qu'une tâche doit avoir un type et un sous-type. En même temps, chaque type de tâche disponible ne doit pas nécessairement faire partie des tâches assignées. Si vous utilisiez INNER JOIN à la place, cela "annulerait" le premier LEFT JOIN et fausserait votre résultat.

Résultat: Voici à quoi devrait ressembler votre résultat :

first_name	last_name	title	due_date	task_type	task_subtype
Emma	Biesa	Working With Pandas in Python	2023-12-15	Blog article	Python
Francois	Cousteau	Promote SQL avancé Learning Track	2023-12-20	Social media post	LinkedIn
Bob	Franklin	Working With LEFT JOIN in SQL	2024-03-01	Blog article	SQL
Dionne	Ravanelli	What Does a Data Analyst Do?	2024-02-01	Blog article	Career
Francois	Cousteau	Promote Working With Pandas in Python	2024-01-18	Social media post	LinkedIn
Bob	Franklin	Python Libraries You Should Know	2024-02-15	Blog article	Python
Dionne	Ravanelli	Using COUNT in SQL	2024-02-15	Blog article	SQL
Emma	Biesa	Filtering Data in SQL	NULL	Blog article	SQL
Marek	Lewandowski	NULL	NULL	NULL	NULL

L'utilisation de INNER JOIN comme deuxième jointure supprimerait cette dernière ligne, qui montre un free-lance sans tâche assignée. S'il n'y a pas de tâche, il n'y a pas non plus de type de tâche. Et INNER JOIN n'affiche pas les lignes qui ne correspondent pas. C'est pourquoi LEFT JOIN est nécessaire ici.

Question 4 : Sélectionner les informations sur les freelances pour les projets dus en 2024

Ecrivez une requête qui sélectionne :

• Tous les freelances
• Les titres de leurs tâches
• Les dates d'échéance des tâches

Inclure uniquement les projets dont la date d'échéance est en 2024.

Ensemble de données : Les mêmes que dans la question précédente.

Solution : La question veut vous inciter à écrire une requête qui utilise la clause WHERE pour filtrer les données, comme indiqué ci-dessous :

SELECT f.first_name,
	 f.last_name,
	 t.title,
	 t.due_date
FROM freelancer f
LEFT JOIN task t
ON f.id = t.freelancer_id
WHERE t.due_date > '2023-12-31';

Mais ce n'est pas la bonne réponse. Pour obtenir le résultat souhaité, la condition de filtrage dans WHERE doit être remplacée par une condition de jointure, comme ceci :

SELECT f.first_name,
	 f.last_name,
	 t.title,
	 t.due_date
FROM freelancer f
LEFT JOIN task t
ON f.id = t.freelancer_id AND t.due_date > '2023-12-31';

Explication : Dans la première requête, l'utilisation de WHERE ne renverrait que les données relatives aux tâches dont la date d'échéance est 2024. Cela exclurait tous les free-lances qui n'ont pas de tâche assignée, mais aussi les tâches qui n'ont pas - pour diverses raisons - de date d'échéance.

Nous déplaçons donc la condition de filtrage vers la clause ON. La première condition joint les tables sur l'ID du freelance. La deuxième condition est ajoutée à l'aide du mot-clé AND. De cette manière, vous incluez tous les free-lances, mais vous filtrez les projets dont la date d'échéance est 2023.

Résultat : Voici le résultat correct :

first_name	last_name	title	due_date
Bob	Franklin	Working With LEFT JOIN in SQL	2024-03-01
Dionne	Ravanelli	What Does a Data Analyst Do?	2024-02-01
Francois	Cousteau	Promote Working With Pandas in Python	2024-01-18
Bob	Franklin	Python Libraries You Should Know	2024-02-15
Dionne	Ravanelli	Using COUNT in SQL	2024-02-15
Emma	Biesa	NULL	NULL
Marek	Lewandowski	NULL	NULL

Bien qu'Emma Biesa ait un projet intitulé "Filtrer les données en SQL", sa date d'échéance est NULL, de sorte que la valeur de la colonne title est également NULL. En d'autres termes, le projet d'Emma Biesa ne correspond pas à la condition de jonction.

D'autre part, le résultat est le même pour Marek Lewandowski. Cette fois, c'est parce que Marek n'a pas de projet attribué du tout.

Question 5 : Afficher tous les employés et leurs responsables

Ensemble de données : La question vous fournit le tableau suivant employees. Voici le script.

Le tableau est une liste d'employés.

id	first_name	last_name	manager_id
1	John	Borisov	2
2	Linda	Johnson	8
3	Frank	Ranieri	NULL
4	Nina	Bowie	1
5	Tamara	Felipe	NULL
6	Simon	Fyodorov	8
7	Lana	Hopkins	NULL
8	Tom	Bonfa	1
9	Maria	Fox	1
10	Victor	Ivanchich	2

Solution : Puisqu'il n'y a qu'une seule table, vous devez montrer que vous savez qu'une table peut être jointe à elle-même. En d'autres termes, vous devez résoudre la question en appliquant une jointure à soi-même.

Cela se fait de la manière suivante :

SELECT e.first_name AS employee_first_name, 
	 e.last_name AS employee_last_name, 
	 m.first_name AS manager_first_name,
	 m.last_name AS manager_last_name
FROM employees e
LEFT JOIN employees m
ON e.manager_id = m.id;

Explication : L'auto-jonction est simplement une table qui est jointe à elle-même. En fait, en donnant différents alias à une table, vous faites croire à SQL que vous avez joint deux tables différentes.

Notre "première" table a pour alias e. Nous l'utiliserons pour afficher les noms des employés.

L'alias de la "seconde" table jointe est m; elle servira à afficher les noms des managers.

Dans ce cas, vous devez les joindre en utilisant LEFT JOIN car la question vous demande de lister tous les employés. Cela inclut également les employés qui n'ont pas de responsable. Si vous utilisiez INNER JOIN, vous n'obtiendriez que les employés qui ont un responsable.

La table est auto-jointe à la condition que l'ID du manager soit égal à l'ID de l'employé. C'est ainsi que vous obtenez les noms des responsables de chaque employé.

Résultat : Voici la liste des employés et de leurs supérieurs :

employee_first_name	employee_last_name	manager_first_name	manager_last_name
John	Borisov	Linda	Johnson
Linda	Johnson	Tom	Bonfa
Frank	Ranieri	NULL	NULL
Nina	Bowie	John	Borisov
Tamara	Felipe	NULL	NULL
Simon	Fyodorov	Tom	Bonfa
Lana	Hopkins	NULL	NULL
Tom	Bonfa	John	Borisov
Maria	Fox	John	Borisov
Victor	Ivanchich	Linda	Johnson

NULLL'absence de noms de managers signifie que l'employé concerné n'a pas de supérieur.

Question 6 : Afficher les thérapeutes et leur première et deuxième langue

Ecrivez une requête qui renvoie tous les thérapeutes avec leur première et deuxième langue.

Ensemble de données : Cet ensemble de données provient d'un cabinet de psychothérapie collective destiné aux expatriés. Plusieurs thérapeutes proposent des thérapies, et ils le font chacun en deux langues.

La liste des langues se trouve dans le tableau language. Voici le script.

id	language_name
1	English
2	Dutch
3	Russian
4	Polish
5	Croatian

La liste des thérapeutes se trouve dans le tableau. therapist. Voici le script.

id	first_name	last_name	first_language_id	second_language_id
1	Maya	Hoekstra	2	1
2	Lana	Mayakovski	3	1
3	Marija	Abramović	5	2
4	Jan	Nowak	4	1
5	Francis	Gordon	1	2

Solution : L'une des nombreuses questions d'entretien SQL pour les utilisateurs expérimentés, cette tâche vous demande de démontrer vos compétences en matière de jointure de trois tables. Cependant, ici, une table est jointe deux fois. Vous devez vous en rendre compte, car la table therapist fait référence à la table language dans deux colonnes : first_language_id et second_language_id.

La solution devrait ressembler à ceci :

SELECT t.first_name,
	 t.last_name,
	 fl.language_name AS first_language_name,
	 sl.language_name AS second_language_name
FROM therapist t
JOIN language fl
ON t.first_language_id = fl.id
JOIN language sl
ON t.second_language_id = sl.id;

Explication : Tout d'abord, nous joignons la table therapist avec la table languageen donnant à cette dernière l'alias fl (comme dans "première langue"). Nous l'utiliserons pour indiquer la première langue du thérapeute, c'est-à-dire sa langue maternelle. C'est pourquoi la condition de jointure recherche les cas où l'ID de la première langue est le même que l'ID de la langue. Le nom de la première langue sera alors affiché.

Dans l'étape suivante, nous joignons à nouveau le tableau language. Cette fois, elle a l'alias sl pour "deuxième langue". La jointure prend l'identifiant de la deuxième langue et le recherche dans language. C'est ainsi que nous obtenons le nom de la deuxième langue.

Pour afficher la première et la deuxième langue, nous sélectionnons la colonne language_name - une fois dans la "table" et une autre fois dans le "tableau". fl et la seconde fois dans le sl et donnons aux colonnes les noms appropriés.

Résultat : Voici le résultat :

first_name	last_name	first_language_name	second_language_name
Jan	Nowak	Polish	English
Lana	Mayakovski	Russian	English
Maya	Hoekstra	Dutch	English
Francis	Gordon	English	Dutch
Marija	Abramović	Croatian	Dutch

Question 7 : Afficher le nombre de freelances auxquels des tâches ont été attribuées

Ensemble de données : L'ensemble de données sur les indépendants utilisé dans les questions 1, 3 et 4.

Solution : Cette question d'entretien délicate vous amène à utiliser la fonction agrégée COUNT(). Cela semble très facile, avec une requête simple qui n'utilise qu'une seule table. Mais la question vous demande d'être rapide et d'écrire la requête suivante :

SELECT COUNT(freelancer_id) AS number_of_working_freelancers
FROM task;

Cependant, vous devez montrer que vous êtes plus intelligent que cela et écrire une requête qui utilise COUNT(DISTINCT freelancer_id) au lieu de COUNT(freelancer_id).

SELECT COUNT(DISTINCT freelancer_id) AS number_of_working_freelancers
FROM task;

Explication : Pourquoi la première requête est-elle erronée ? Eh bien, COUNT(freelancer_id) comptera toutes les occurrences de l'ID d'un freelance. Cela signifie qu'il comptera également les doublons en tant qu'autres freelances. (N'oubliez pas que chaque free-lance peut avoir plusieurs tâches).

Pour éviter cela, il suffit d'ajouter DISTINCT dans cette expression. Cela éliminera les doublons - c'est-à-dire que chaque freelance ne sera compté qu'une seule fois.

Résultat : La première requête renvoie le résultat suivant :

number_of_working_freelancers
8

Vous savez que c'est faux parce que vous connaissez vos données. La table freelancer ne contient que cinq free-lances, il ne peut donc pas être vrai qu'il y a plus de free-lances en activité qu'il n'y en a.

La sortie correcte est donc la suivante. Il y a quatre free-lances parce que nous savons que l'un d'entre eux n'est pas affecté, c'est-à-dire qu'il ne travaille pas.

number_of_working_freelancers
4

Question 8 : Afficher le nombre de tâches par type et sous-type de tâche

Ensemble de données : Identique à la question précédente.

Solution : Ici, vous devez reconnaître que vous devez utiliser une fonction d'agrégation et regrouper les résultats sur deux colonnes.

SELECT task_type,
	 task_subtype,
	 COUNT(*) AS number_of_tasks
FROM task_category tc
JOIN task t
ON tc.id = t.task_category_id
GROUP BY task_type, task_subtype;

Explication : Pour obtenir le résultat, vous devez joindre les tables task_category et task sur l'ID de la catégorie de tâches.

Ensuite, sélectionnez le type de tâche et le sous-type, et utilisez COUNT(*), qui comptera simplement le nombre de lignes, qui est égal au nombre de tâches. Chaque ligne correspond à une tâche.

Ensuite, utilisez GROUP BY pour regrouper les données par type de tâche. Cependant, la question vous demande d'agréger les données au niveau du sous-type de tâche également, vous devez donc l'ajouter dans GROUP BY. Toutes les colonnes de GROUP BY doivent être séparées par une virgule.

Résultat : Le type de tâche "Social media post" n'apparaît qu'une seule fois, car il n'y a pas d'autres sous-types dans les tâches actives.

En revanche, le type de tâche "Article de blog" apparaît trois fois, chacune avec un sous-type de tâche différent. La colonne number_of_tasks représente le nombre de tâches par sous-type.

task_type	task_subtype	number_of_tasks
Social media post	LinkedIn	2
Blog article	SQL	3
Blog article	Python	2
Blog article	Career	1

Question 9 : Afficher le nombre de tâches actives par type et sous-type de tâche

Ecrivez une requête qui montre le nombre de tâches actives par type et sous-type de tâche.

N'incluez que les catégories comportant plus de deux tâches.

Ensemble de données : Identique au précédent.

Solution : Cette question d'entretien SQL courante vise à vérifier si vous savez que vous devez utiliser HAVING au lieu de WHERE pour filtrer la sortie. Vous pouvez résoudre la question comme suit :

SELECT task_type,
	 task_subtype,
	 COUNT(*) AS number_of_tasks
FROM task_category tc
JOIN task t
ON tc.id = t.task_category_id
WHERE COUNT(*) > 2
GROUP BY task_type, task_subtype;

C'est faux, vous devez donc remplacer WHERE par HAVING:

SELECT task_type,
	 task_subtype,
	 COUNT(*) AS number_of_tasks
FROM task_category tc
JOIN task t
ON tc.id = t.task_category_id
GROUP BY task_type, task_subtype
HAVING COUNT(*) > 2;

Explication : Cette requête est fondamentalement la même que celle de la question précédente. L'exigence supplémentaire est de n'afficher que les types et sous-types de tâches ayant plus de deux tâches actives.

La première requête ne renverra rien d'autre qu'une erreur indiquant que les fonctions d'agrégation ne peuvent pas être utilisées dans WHERE. C'est bien sûr parce que WHERE filtre les données avant de les agréger.

Vous devez donc d'abord agréger les données à l'aide de COUNT(*) pour trouver le nombre de tâches actives par type et sous-type. Ce n'est qu'ensuite que vous pouvez rechercher les catégories comportant plus de deux tâches.

En d'autres termes, vous devez utiliser HAVING, qui filtre les données après l'agrégation. Il vous suffit d'utiliser l'agrégation de la colonne number_of_tasks et d'indiquer une condition selon laquelle le nombre doit être supérieur à deux.

Résultat :

task_type	task_subtype	number_of_tasks
Blog article	SQL	3

Question 10 : Qu'est-ce qui ne va pas avec cette requête ?

Ensemble de données : Identique au précédent.

Solution : La question vous donne une requête :

SELECT first_name,
	 last_name,
	 task_type,
	 task_subtype,
	 COUNT(task_category_id) AS task_count
FROM freelancer f
JOIN task t
ON f.id = t.freelancer_id
JOIN task_category tc
ON t.task_category_ID = tc.id
GROUP BY first_name, last_name, task_type
ORDER BY last_name;

Votre réponse devrait être que cette requête ne fonctionne pas parce que la colonne task_subtype n'est pas listée dans la clause GROUP BY. La requête corrigée devrait ressembler à ceci :

SELECT first_name,
	 last_name,
	 task_type,
	 task_subtype,
	 COUNT(task_category_id) AS task_count
FROM freelancer f
JOIN task t
ON f.id = t.freelancer_id
JOIN task_category tc
ON t.task_category_ID = tc.id
GROUP BY first_name, last_name, task_type, task_subtype
ORDER BY last_name;

Explication : Pourquoi la colonne task_subtype doit-elle figurer dans GROUP BY? La règle en SQL est que toutes les colonnes (à l'exception de celles qui contiennent des fonctions d'agrégation) doivent apparaître dans GROUP BY. C'est quelque chose que vous devez savoir et que vous devez pouvoir reconnaître immédiatement dans la requête.

Résultat : La sortie corrigée fonctionnera désormais et renverra le résultat suivant. Elle affiche les indépendants et le nombre de leurs tâches par type et sous-type.

first_name	last_name	task_type	task_subtype	task_count
Emma	Biesa	Blog article	Python	1
Emma	Biesa	Blog article	SQL	1
Francois	Cousteau	Social media post	LinkedIn	2
Bob	Franklin	Blog article	Python	1
Bob	Franklin	Blog article	SQL	1
Dionne	Ravanelli	Blog article	Career	1
Dionne	Ravanelli	Blog article	SQL	1

Question 11 : Afficher tous les freelances et le nombre de leurs tâches

Ensemble de données : Identique au précédent.

Solution : Dans cette question, vous pourriez facilement être amené à écrire une requête qui utilise COUNT(*) pour trouver le nombre de tâches, comme ceci :

SELECT first_name,
	 last_name,
	 COUNT(*) AS task_count
FROM freelancer f
LEFT JOIN task t
ON f.id = t.freelancer_id
GROUP BY first_name, last_name;

Oui, vous avez judicieusement utilisé LEFT JOIN pour renvoyer les free-lances sans tâche. Cependant, vous devriez utiliser COUNT(task_category_id) au lieu de COUNT(*)...

SELECT first_name,
	 last_name,
	 COUNT(task_category_id) AS task_count
FROM freelancer f
LEFT JOIN task t
ON f.id = t.freelancer_id
GROUP BY first_name, last_name;

... n'est-ce pas ?

Explication : Ne tombez pas dans le piège ! Vous savez certainement que COUNT(*) ne doit pas être utilisé en combinaison avec LEFT JOIN.

Vous utilisez LEFT JOIN pour inclure des free-lances sans tâche. Ces free-lances n'auront pas de valeurs correspondantes dans le tableau de droite, ils seront donc affichés comme NULL. Malheureusement, COUNT(*) n'ignore pas les NULL, qui seront donc comptés comme des valeurs normales.

Au lieu de cela, vous devez utiliser COUNT(task_category_id). De cette façon, vous ne compterez que les valeurs nonNULL.

Résultat : Jetez un coup d'œil au résultat de la première requête (incorrecte) :

first_name	last_name	task_count
Dionne	Ravanelli	2
Marek	Lewandowski	1
Emma	Biesa	2
Bob	Franklin	2
Francois	Cousteau	2

Marek Lewandowski a une tâche. Mais nous savons que ce n'est pas correct, car il n'a aucune tâche assignée. Le résultat indique le chiffre un parce que COUNT(*) a compté la valeur NULL (ligne non correspondante).

La sortie de la requête solution montre à juste titre que le nombre de tâches de Marek est de zéro :

first_name	last_name	task_count
Dionne	Ravanelli	2
Marek	Lewandowski	0
Emma	Biesa	2
Bob	Franklin	2
Francois	Cousteau	2

Question 12 : Afficher le nombre de tâches achevées par date d'achèvement

Ecrivez une requête qui montre le nombre de tâches terminées par date d'achèvement. Incluez NULLcomme une catégorie de date séparée.

Ensemble de données : Identique au précédent.

Solution : Cette question tente de vous faire croire que vous devez explicitement énoncer une condition selon laquelle toutes les tâches sans date d'achèvement seront comptabilisées ensemble dans la catégorie NULL en tant que date.

Mais la solution est plus simple que vous ne le pensez :

SELECT completed_date,
	 COUNT(id) AS completed_task_count
FROM task
GROUP BY completed_date
ORDER BY completed_date ASC;

L'explication : Comme vous pouvez le constater, la requête ci-dessus ne fait aucunement référence à NULLs. Elle sélectionne simplement la date d'achèvement et la date de fin. Elle sélectionne simplement la date d'achèvement et utilise COUNT() sur la colonne ID de la tâche pour compter le nombre de tâches achevées.

Bien entendu, les résultats doivent être regroupés en fonction de la date d'achèvement. Elle est également triée de la date la plus ancienne à la plus récente, ce qui n'est pas nécessaire mais est plus joli.

En écrivant une telle requête, vous montrez que vous comprenez que les valeurs NULL ne sont pas comptées séparément. Toutes les valeurs NULL seront affichées dans une seule catégorie - NULL.

Résultat : Comme vous pouvez le voir, toutes les tâches sans date d'achèvement sont affichées sur une seule ligne :

completed_date	completed_task_count
2023-12-15	1
2023-12-20	1
2024-01-18	1
2024-02-10	1
2024-02-15	2
NULL	2

Question 13 : Afficher les employés avec leurs départements et leurs salaires

Ecrivez une requête qui affiche les employés, leurs départements et leurs salaires.

N'incluez que les employés dont le salaire est inférieur à la moyenne de leur département.

Ensemble de données : Cette question d'entretien SQL utilise la table salaries. Vous pouvez trouver le script ici.

id	first_name	last_name	department	salary
1	Benny	Gilhespy	Sales	5,293.47
2	Benetta	Featherstonhaugh	Engineering	2,214.55
3	Karla	Stiell	Sales	2,070.45
4	Sissie	Seabon	Accounting	5,077.42
5	Genna	Beche	Accounting	7,451.65
6	Kirsten	Fernandez	Engineering	7,533.13
7	Pen	Fredy	Sales	7,867.54
8	Tish	Calderbank	Sales	4,103.19
9	Gallard	Philipet	Accounting	7,220.06
10	Walsh	Kleinholz	Accounting	4,000.18
11	Carce	Wilkenson	Accounting	3,991.00
12	Tami	Langrish	Sales	5,588.34
13	Shayne	Dearn	Engineering	2,785.92
14	Merla	Ingilson	Engineering	2,980.36
15	Keely	Patifield	Sales	2,877.92

Solution : La partie délicate ici est de reconnaître que la requête peut être très courte si vous savez comment utiliser des sous-requêtes corrélées.

Elle devrait être réalisée de la manière suivante :

SELECT id, 
	 first_name,
	 last_name,
	 department,
	 salary
FROM salaries s1
WHERE salary < (SELECT AVG(salary)
				FROM salaries s2
				WHERE s1.department = s2.department);

Explication : La requête énumère d'abord toutes les colonnes nécessaires de la table salaires. J'ai donné un alias à la table, s1.

Ensuite, j'utilise la clause WHERE pour comparer le salaire de chaque employé à la moyenne du département. La moyenne départementale est calculée dans un type spécial de sous-requête - une sous-requête corrélée.

Qu'est-ce qui est si spécial ? Cette sous-requête est corrélée parce qu'elle fait référence aux données de la requête principale. Cela se produit dans la clause WHERE d'une sous-requête : le département de la table s1 (apparaissant dans la requête principale) doit être le même que le département de la table s2 qui apparaît dans la sous-requête. Cette condition permettra à la fonction d'agrégation AVG() de calculer la moyenne départementale du département dans lequel travaille cet employé.

Résultat : Le tableau ci-dessous n'affiche que les employés dont les salaires sont inférieurs à la moyenne des salaires de leurs départements respectifs :

id	first_name	last_name	department	salary
2	Benetta	Featherstonhaugh	Engineering	2,214.55
3	Karla	Stiell	Sales	2,070.45
4	Sissie	Seabon	Accounting	5,077.42
8	Tish	Calderbank	Sales	4,103.19
10	Walsh	Kleinholz	Accounting	4,000.18
11	Carce	Wilkenson	Accounting	3,991.00
13	Shayne	Dearn	Engineering	2,785.92
14	Merla	Ingilson	Engineering	2,980.36
15	Keely	Patifield	Sales	2,877.92

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

Réponse : Pour répondre à cette question, vous devez évidemment connaître la différence entre les deux opérateurs d'ensemble les plus courants en SQL.

Les deux opérateurs fusionnent verticalement les résultats de deux ou plusieurs requêtes. UNION le fait en excluant les lignes dupliquées. En d'autres termes, si les mêmes lignes apparaissent dans les deux requêtes, elles ne seront affichées qu'une seule fois. C'est un peu comme DISTINCT dans le monde des opérateurs d'ensembles.

En revanche, UNION ALL affiche toutes les lignes des deux requêtes, y compris les doublons. Pour en savoir plus sur la différence entre UNION et UNION ALL, consultez notre guide.

Question 15 : Afficher les livres sélectionnés avec leur auteur et leur sous-titre

Ecrivez une requête qui sélectionne l'auteur, le titre et le sous-titre d'un livre, mais seulement pour les livres dont le sous-titre contient le mot "femme". Inclure les livres sans sous-titres.

Ensemble de données : La table utilisée dans cet exemple est bookset le script se trouve ici.

id	first_name	last_name	department	salary
2	Benetta	Featherstonhaugh	Engineering	2,214.55
3	Karla	Stiell	Sales	2,070.45
4	Sissie	Seabon	Accounting	5,077.42
8	Tish	Calderbank	Sales	4,103.19
10	Walsh	Kleinholz	Accounting	4,000.18
11	Carce	Wilkenson	Accounting	3,991.00
13	Shayne	Dearn	Engineering	2,785.92
14	Merla	Ingilson	Engineering	2,980.36
15	Keely	Patifield	Sales	2,877.92

Solution : Le plus simple est de rechercher le mot "femme" dans le sous-titre. Cependant, comment inclure également les livres sans sous-titres, c'est-à-dire avec des valeurs NULL?

La réponse est que vous devez traiter explicitement NULLs pour les inclure dans la sortie, comme ceci :

SELECT 
  author,
  title,
  subtitle
FROM books
WHERE subtitle ILIKE '%woman%' OR subtitle IS NULL;

Explication : Votre réponse comprend deux conditions dans WHERE. La première condition recherche le mot "femme" dans le sous-titre. Pour ce faire, vous pouvez utiliser LIKE (si votre base de données n'est pas sensible à la casse) ou ILIKE (si votre base de données est sensible à la casse, comme PostgreSQL). Pour rechercher le mot n'importe où dans une chaîne, vous devez l'entourer de '%'. Comme vous recherchez une chaîne de caractères, tout cela doit être écrit entre guillemets simples.

Vous pouvez maintenant ajouter une autre condition de filtrage en précisant que le sous-titre doit être NULL à l'aide de l'opérateur IS NULL. Les deux conditions sont jointes à l'aide du mot-clé OR, car elles ne peuvent pas être satisfaites en même temps : s'il n'y a pas de sous-titre, il ne peut pas contenir le mot "femme".

Résultat : Voici la sortie montrant toutes les données qui satisfont l'une ou l'autre condition :

author	title	subtitle
Miljenko Jergović	Sarajevo Marlboro	NULL
Tilar J. Mazzeo	Irena's Children	The Extraordinary Story of the Woman Who Saved 2,500 Children from the Warsaw Ghetto
Olga Tokarczuk	Primeval and Other Times	NULL
Thomas Hardy	Tess of the d' Urbevilles	A Pure Woman Faithfully Presented
Sylvia Plath	Ariel	NULL
Toni Morrison	Jazz	NULL
Haben Girma	Haben	The Deafblind Woman Who Conquered Harvard Law

Plus de ressources d'entretien pour les utilisateurs expérimentés de SQL

Ces 15 exercices couvrent certaines des questions d'entretien SQL "pièges" les plus courantes pour les utilisateurs expérimentés. Toutes ces solutions devraient vous permettre de prendre conscience des pièges qui vous sont tendus et de savoir comment les éviter.

Mais ne vous arrêtez pas en si bon chemin ! Il n'y a jamais trop de préparation pour un entretien d'embauche. Je vous recommande donc de consulter 25 autres exemples de requêtes SQL avancées ou 27 autres questions d'entretien SQL avancées.

Vous devriez également mettre en pratique ce que vous avez appris ici. Voici quelques idées pour pratiquer le langage SQL avancé avec nos cours et quelques exercices d'entraînement au langage SQL avancé pour vous aider à démarrer.

Utilisez ceci en conjonction avec notre piste SQL avancé et notre piste SQL avancé Practice, et vous serez bien préparé pour votre prochain entretien d'embauche !