15th Mar 2024 22 minutes de lecture

9 exemples pratiques de SQL LEFT JOIN

Table des matières

Les bases de la jointure gauche en SQL
- Syntaxe de la jointure à gauche en SQL
Exemples de JOINTS DE GAUCHE
Autres exemples et ressources SQL LEFT JOIN

LEFT JOIN La jointure à gauche est l'une des formes les plus courantes de SQL. JOINs. Assurez-vous d'en connaître tous les tenants et aboutissants en parcourant nos neuf exemples réels. LEFT JOIN exemples concrets.

LEFT JOIN - La jointure à gauche - INNER JOIN - est l'un des outils SQL essentiels dont vous avez besoin pour travailler avec des données provenant de deux tables ou plus. Mais comment et quand l'utiliser ? Ces neuf exemples LEFT JOIN vous montreront la voie à suivre.

C'est la première fois que vous entendez parler de JOINs ? Si c'est le cas, nous avons tout prévu avec notre cours complet sur Les jointures en SQL . Vous découvrirez tous les types de SQL JOIN, les différentes façons de joindre deux tables ou plus, et quand utiliser chaque type de JOIN. Vous apprendrez même à joindre une table de façon autonome et à utiliser des jointures non équidistantes. À la fin du cours, vous aurez résolu 99 défis interactifs.

Les bases de la jointure gauche en SQL

LEFT JOIN est l'un des nombreux types de SQL JOINs. L'objectif de JOINs est d'obtenir les données de deux tables ou plus. LEFT JOIN atteint cet objectif en renvoyant toutes les données de la première table (gauche) et seulement les lignes correspondantes de la deuxième table (droite). Les valeurs non correspondantes de la table de droite seront affichées à l'adresse NULL.

En quoi cela diffère-t-il des autres JOIN? Voici un bref aperçu, mais pour une meilleure compréhension, jetez un coup d'œil à ces exemples de JOIN SQL.

(INNER) JOIN - Renvoie uniquement les lignes correspondantes des tables jointes. Voici un article pour en savoir plus sur les INNER JOIN.
RIGHT (OUTER) JOIN - Renvoie toutes les données de la table de droite et seulement les lignes correspondantes de la table de gauche. Les valeurs des lignes non correspondantes seront NULL.
FULL (OUTER) JOIN - Renvoie toutes les lignes des deux tables jointes. S'il y a des lignes non correspondantes entre les tables, elles sont affichées en tant que NULL. Pour en savoir plus, consultez notre article consacré au FULL JOIN.
CROSS JOIN - Renvoie toutes les combinaisons de toutes les lignes des tables jointes, c'est-à-dire un produit cartésien. Vous trouverez plus d'informations à ce sujet dans l'article CROSS JOIN.

Les mots entre parenthèses dans les noms de JOIN ci-dessus ne sont pas obligatoires ; SQL accepte les versions complètes et abrégées.

Cela signifie que LEFT JOIN est identique à LEFT OUTER JOIN. Donc, oui, LEFT JOIN est un type de jointure externe, tout comme RIGHT JOIN et FULL JOIN.

En tant qu'utilisateurs de SQL, nous écrivons généralement LEFT JOIN. La raison ? C'est plus court et nous sommes paresseux.

Pour en savoir plus, consultez l'article expliquant le fonctionnement de la jointure à gauche.

Syntaxe de la jointure à gauche en SQL

La syntaxe de LEFT JOIN est la suivante.

SELECT …
FROM table1
LEFT JOIN table2
ON table1.column = table2.column;

Les deux points clés sont le mot-clé LEFT JOIN et la clause de jonction ON. La première table jointe est référencée dans la clause FROM, puis la clause LEFT JOIN est ajoutée, suivie de la deuxième table que vous souhaitez joindre.

Les tables sont jointes sur la base des valeurs de colonnes correspondantes ; vous référencez ces colonnes dans la clause ON et placez un signe égal entre elles. Vous joindrez ainsi les tables pour lesquelles la colonne d'une table est égale à la colonne de la deuxième table. Il s'agit du type le plus courant de LEFT JOIN. On l'appelle equi-join à cause du signe égal. D'autres opérateurs de comparaison peuvent être utilisés ; il s'agit des jointures non égales, qui sortent du cadre de cet article.

Tout ceci est également expliqué dans l'Aide-mémoire SQL JOIN. Gardez-la à portée de main pendant les exemples suivants ; elle vous aidera à mieux les comprendre.

Exemples de JOINTS DE GAUCHE

Permettez-moi maintenant de vous présenter plusieurs exemples concrets d'utilisation de LEFT JOIN. Je commencerai par un exemple basique et simple pour vous montrer comment LEFT JOIN fonctionne sur des données réelles.

Exemple 1 : Jointure gauche de base

Je vais travailler avec deux tables. La première est companyqui contient une liste de sociétés d'électronique. Utilisez ce script pour créer la table.

id	company_name
1	Lenovo
2	Apple
3	Samsung
4	Huawei
5	Fairphone

La deuxième table est la table product est la table Le script de création de la table se trouve ici.

id	product_name	company_id
1	Fairphone 4	5
2	Galaxy S24 Ultra	3
3	Galaxy Z Flip5	3
4	iPhone 15 Pro	2
5	Fairbuds XL	5
6	MacBook Pro 16' M3 Pro	2
7	iPad Air 10.9' M1	2
8	Galaxy Tab S9 FE+	3

LEFT JOIN ces deux tables et voyons ce qui se passe :

SELECT company_name,
	 product_name
FROM company
LEFT JOIN product
ON company.id = product.company_id
ORDER BY company_name;

Je sélectionne le nom de la société et du produit. Ces colonnes proviennent de deux tables. Je dois donc joindre les tables pour obtenir ces colonnes dans le résultat.

La table de gauche est companyet j'y fais référence dans FROM. J'ajoute ensuite LEFT JOIN et la deuxième table, qui est product.

Dans la clause ON, je spécifie les colonnes sur lesquelles les tables seront jointes. Dans ce cas, il s'agit de la colonne id de la première table et de la colonne company_id de la deuxième table.

J'ai utilisé ORDER BY pour rendre la sortie plus lisible. (Vous n'avez pas besoin de ORDER BY pour que la jointure fonctionne).

En parlant de résultat, le voici.

company_name	product_name
Apple	iPhone 15 Pro
Apple	iPad Air 10.9' M1
Apple	MacBook Pro 16' M3 Pro
Fairphone	Fairphone 4
Fairphone	Fairbuds XL
Huawei	NULL
Lenovo	NULL
Samsung	Galaxy Z Flip5
Samsung	Galaxy S24 Ultra
Samsung	Galaxy Tab S9 FE+

La sortie montre une liste de toutes les entreprises, ce qui est conforme à l'adresse LEFT JOIN qui montre toutes les données de la table de gauche.

Lorsqu'une entreprise a plusieurs produits, tous ces produits sont listés et le nom de l'entreprise est dupliqué. Lorsqu'il n'y a pas de produits de l'entreprise (Huawei et Lenovo), la valeur de la colonne product_name est NULL.

Exemple 2 : Un exemple concret de JOINTE À GAUCHE

Explorons un scénario courant. Dans cet exemple, vous souhaitez dresser la liste de tous les départements et de leurs employés, mais aussi afficher les départements sans employés, s'il y en a.

Pour ce faire, vous avez besoin de LEFT JOIN.

Voici le tableau department et son script. Il s'agit d'une liste de départements.

id	department_name
1	Sales
2	Accounting
3	IT
4	HR
5	Operations

La deuxième table est employee, qui est une liste d'employés. Voici son script.

id	first_name	last_name	department_id
1	Bob	Estevez	3
2	Francesca	Gotze	2
3	Frank	Gordon	2
4	Milicent	Johnson	3
5	Hans	Handke	NULL
6	Katie	Keaton	1
7	Luca	Di Francesco	NULL
8	Zoe	Jong	1
9	Patrick	Rose	2
10	Billie	Thompson	NULL

Les valeurs NULL signifient que cet employé n'a pas encore été affecté à un département.

Pour afficher les départements et leurs employés - ainsi que les départements sans employés - voici le code :

SELECT department.id AS department_id,
	 department_name,
	 employee.id AS employee_id,
       first_name,
       last_name	   
FROM department
LEFT JOIN employee
ON department.id = employee.department_id
ORDER BY department_id, employee_id;

Je sélectionne l'ID dans le tableau department et je le renomme department_id. La deuxième colonne sélectionnée dans le même tableau est department_name. Les données sélectionnées dans le tableau employee sont id (renommé employee_id) et les noms des employés. Tout ce renommage des colonnes a pour seul but de rendre le résultat plus facile à lire.

Maintenant, je peux faire référence au tableau department dans FROM et LEFT JOIN avec le tableau employee. Les tables sont jointes lorsque les identifiants des départements sont identiques.

Enfin, je trie le résultat par département, puis par numéro d'identification de l'employé pour le rendre plus lisible. Voici le résultat :

department_id	department_name	employee_id	first_name	last_name
1	Sales	6	Katie	Keaton
1	Sales	8	Zoe	Jong
2	Accounting	2	Francesca	Gotze
2	Accounting	3	Frank	Gordon
2	Accounting	9	Patrick	Rose
3	IT	1	Bob	Estevez
3	IT	4	Milicent	Johnson
4	HR	NULL	NULL	NULL
5	Operations	NULL	NULL	NULL

Le résultat montre tous les départements et leurs employés. Il montre également deux départements qui n'ont pas d'employés : RH et Opérations. Il se peut que la base de données n'ait pas encore été mise à jour et que les nouveaux employés ne soient pas affectés au département.

Exemple 3 : Un autre exemple concret de JOINTE À GAUCHE

Un autre exemple typique de LEFT JOIN est celui où vous voulez trouver tous les clients et leurs commandes, mais où vous voulez aussi inclure les clients qui n'ont pas encore passé de commande.

Pour cet exemple, j'utiliserai l'ensemble de données suivant. La première table est customerqui est une simple liste de clients. Voici le script.

id	first_name	last_name
1	Florentinus	Glöckner
2	Eman	Adcock
3	Erik	Nyman
4	Leeba	Kubo
5	Lias	Vámos
6	Lavanya	Nikolaev
7	Rishi	Petit
8	Christie	Fodor
9	Andris	Lončar
10	Juliana	Harlan

La deuxième table de l'ensemble de données est orders. Vous pouvez la créer vous-même à l'aide de ce script.

Voici comment j'écris le code pour obtenir le résultat souhaité :

SELECT customer.first_name, 
       customer.last_name,
	 orders.id AS order_id,
	 orders.order_date
FROM customer
LEFT JOIN orders
ON customer.id = orders.customer_id;

Je sélectionne les noms des clients dans le tableau customer. Logiquement, les informations sur les commandes proviennent de la table orders.

Le tableau de gauche est customeret je veux toutes ses lignes. Je la LEFT JOIN avec la table orders sur l'ID du client.

Le résultat ressemble à ceci :

first_name	last_name	order_id	order_date
Lias	Vámos	1	2024-01-01
Eman	Adcock	2	2024-01-08
Christie	Fodor	3	2024-01-08
Andris	Lončar	4	2024-01-12
Lias	Vámos	5	2024-01-18
Lavanya	Nikolaev	6	2024-01-22
Juliana	Harlan	NULL	NULL
Leeba	Kubo	NULL	NULL
Florentinus	Glöckner	NULL	NULL
Erik	Nyman	NULL	NULL
Rishi	Petit	NULL	NULL

Vous pouvez voir que tous les clients et leurs commandes sont affichés. Lorsque le client n'a pas de commande, il y a NULLs.

Pour plus de pratique, consultez cet article qui présente quatre autres exemples de LEFT JOIN.

Exemple 4 : LEFT JOIN avec 3 tables

Voici un exemple LEFT JOIN dans lequel je vous montrerai comment joindre trois tables.

Jetons d'abord un coup d'œil à l'ensemble de données.

La première table est writeravec le script ici. Il s'agit simplement d'une liste de rédacteurs.

id	first_name	last_name
1	Bernardine	Evaristo
2	Albert	Camus
3	George	Orwell
4	Émile	Zola
5	Milan	Kundera
6	Charles	Dickens
7	Bohumil	Hrabal
8	Witold	Gombrowicz

La deuxième table est translator. Il s'agit d'une liste de traducteurs de livres. Le script de création de la table est ici.

id	first_name	last_name
1	Jennifer	Croft
2	Peter	Constantine
3	Ewald	Osers

La dernière table est celle des livres, qui donne des informations sur les livres en question. Voici le script.

id	book_title	publication_year	writer_id	translator_id
1	The Plague	2008	2	3
2	Cosmos	2015	8	1
3	Manifesto: On Never Giving Up	2021	1	NULL
4	Girl, Woman, Other	2019	1	NULL
5	The Stranger	2022	2	3
6	Germinal	2012	4	3
7	1984	2020	3	NULL

Si la valeur de la colonne translator_id est NULL, ce livre n'est pas une traduction.

Dans cet exemple, je veux afficher tous les écrivains, qu'ils aient un livre ou non. Je souhaite également afficher les informations relatives au traducteur du livre.

Voici à quoi devrait ressembler le code :

SELECT writer.first_name AS writer_first_name,
	 writer.last_name AS writer_last_name,
	 book_title,
	 translator.first_name AS translator_first_name,
	 translator.last_name AS translator_last_name
FROM writer
LEFT JOIN book
ON writer.id = book.writer_id
LEFT JOIN translator
ON book.translator_id = translator.id;

Je sélectionne les noms des écrivains, les titres de leurs livres et les noms des traducteurs. Pour obtenir toutes ces données, je dois joindre les trois tables.

La jointure de trois tables (ou plus) se fait sous la forme d'une chaîne. Après avoir joint les deux premières tables, vous ajoutez une autre jointure, faites référence à la troisième table et indiquez la condition de jointure dans la deuxième clause ON.

Tout d'abord, je référence la table writeret LEFT JOIN avec la table book sur l'auteur ID.

Ensuite, j'ajoute la deuxième clause LEFT JOIN. Je l'utilise pour joindre la deuxième table (book) avec la table translator sur l'ID du traducteur.

Pourquoi ces LEFT JOINsont-ils le résultat de la relation entre les tables ? Le premier LEFT JOIN est là parce qu'il peut y avoir des écrivains sans livre. Toutefois, cela est également vrai pour la relation entre les tables book et translatorun livre peut être ou ne pas être une traduction, et il peut donc y avoir ou non un traducteur correspondant. Vous devez donc utiliser LEFT JOIN entre les deux, car vous voulez montrer les livres, qu'il s'agisse ou non de traductions.

Voici le résultat du code :

writer_first_name	writer_last_name	book_title	translator_first_name	translator_last_name
Albert	Camus	The Plague	Ewald	Osers
Witold	Gombrowicz	Cosmos	Jennifer	Croft
Bernardine	Evaristo	Manifesto: On Never Giving Up	NULL	NULL
Bernardine	Evaristo	Girl, Woman, Other	NULL	NULL
Albert	Camus	The Stranger	Ewald	Osers
Émile	Zola	Germinal	Ewald	Osers
George	Orwell	1984	NULL	NULL
Milan	Kundera	NULL	NULL	NULL
Charles	Dickens	NULL	NULL	NULL
Bohumil	Hrabal	NULL	NULL	NULL

Comme vous pouvez le voir, les livres de Bernardine Evaristo sont affichés bien qu'ils ne soient pas des traductions. C'est parce que j'ai utilisé LEFT JOIN comme deuxième jointure.

De même, Milan Kundera, Charles Dickens et Bohumil Hrabal sont affichés bien qu'ils n'aient pas de livres et donc pas de traducteurs.

Exemple 5 : Jointure à gauche "forcée" avec trois tables

En général, le choix de LEFT JOIN découle de la nature des relations entre les tables. Cependant, il arrive que nous soyons "obligés" d'utiliser LEFT JOIN. Vous verrez bientôt ce que je veux dire.

Le premier tableau de l'ensemble de données est une liste de directeurs nommés director. Voici le script.

id	first_name	last_name
1	Stanley	Kubrick
2	Céline	Sciamma
3	Woody	Allen
4	Lynne	Ramsay
5	Krzysztof	Kieślowski

Le tableau suivant est le tableau streaming_platformqui est une liste des plateformes de streaming disponibles. Vous pouvez créer la table à l'aide de ce script.

id	platform_name
1	Netflix
2	HBO
3	Hulu
4	Mubi
5	Apple TV

Le troisième tableau est streaming_catalogue. Elle contient des informations sur les films et entretient des relations avec les deux premières tables via director_id et streaming_platform_id. Voici le script de création de la table.

id	movie_title	release_year	director_id	streaming_platform_id	started_showing	ended_showing
1	Three Colours: Blue	1993	5	4	2023-02-28	2023-09-30
2	Three Colours: White	1994	5	4	2023-02-28	2023-09-30
3	Three Colours: Red	1994	5	4	2023-02-28	2023-09-30
4	Manhattan Murder Mystery	1993	3	1	2023-08-15	NULL
5	Portrait of a Lady on Fire	2019	2	1	2023-01-01	2023-09-28
6	Three Colours: Blue	1993	5	2	2024-01-15	NULL
7	Three Colours: White	1994	5	2	2024-01-15	NULL
8	Three Colours: Red	1994	5	2	2024-01-15	NULL
9	Tomboy	2011	2	1	2020-04-01	2021-04-01
10	Vicky Cristina Barcelona	2008	3	1	2023-10-01	NULL

Les valeurs NULL dans la colonne ended_showing signifient que le film est toujours diffusé sur la plateforme.

Je souhaite afficher tous les réalisateurs, leurs films et les plateformes de streaming qui diffusent (ou ont diffusé) leurs films. Je souhaite également afficher les réalisateurs dont aucun film n'est diffusé en continu.

La relation entre les tables est que chaque film doit avoir un réalisateur, mais pas l'inverse. De même, chaque film du catalogue doit avoir une plate-forme de diffusion en continu, mais toutes les plates-formes de diffusion en continu ne doivent pas figurer dans le catalogue.

Je commence à écrire le code en sélectionnant les noms des réalisateurs, les titres des films, les noms des plateformes et les dates de début et de fin des projections.

D'après les exemples précédents, vous savez qu'il est prévu de joindre la table director avec la table streaming_catalogue sur la colonne ID du réalisateur. C'est ce que je fais pour m'assurer d'afficher également les réalisateurs qui n'ont pas de films dans le catalogue.

Maintenant, j'ajoute le second LEFT JOIN pour joindre la table streaming_catalogue avec la table streaming_platform sur l'ID de la plateforme.

SELECT first_name AS director_first_name,
	 last_name AS director_last_name,
	 movie_title,
	 platform_name,
	 started_showing, 
	 ended_showing
FROM director
LEFT JOIN streaming_catalogue
ON director.id = streaming_catalogue.director_id
LEFT JOIN streaming_platform
ON streaming_catalogue.streaming_platform_id = streaming_platform.id;

La requête renvoie le résultat suivant :

director_first_name	director_last_name	movie_title	platform_name	started_showing	ended_showing
Krzysztof	Kieślowski	Three Colours: Blue	Mubi	2023-02-28	2023-09-30
Krzysztof	Kieślowski	Three Colours: White	Mubi	2023-02-28	2023-09-30
Krzysztof	Kieślowski	Three Colours: Red	Mubi	2023-02-28	2023-09-30
Woody	Allen	Manhattan Murder Mystery	Netflix	2023-08-15	NULL
Céline	Sciamma	Portrait of a Lady on Fire	Netflix	2023-01-01	2023-09-28
Krzysztof	Kieślowski	Three Colours: Blue	HBO	2024-01-15	NULL
Krzysztof	Kieślowski	Three Colours: White	HBO	2024-01-15	NULL
Krzysztof	Kieślowski	Three Colours: Red	HBO	2024-01-15	NULL
Céline	Sciamma	Tomboy	Netflix	2020-04-01	2021-04-01
Woody	Allen	Vicky Cristina Barcelona	Netflix	2023-10-01	NULL
Lynne	Ramsay	NULL	NULL	NULL	NULL
Stanley	Kubrick	NULL	NULL	NULL	NULL

Le résultat montre tous les réalisateurs, leurs films et les plateformes où ils sont ou ont été diffusés.

Les films contenant toutes les données , à l'exception d' un NULL dans les colonnes ended_showing, peuvent toujours être vus sur une plateforme particulière.

Bien qu'il n'y ait aucun film dans le catalogue, Lynne Ramsay et Stanley Kubrick sont également répertoriés. Cela se reconnaît à la présence de leurs noms, mais à l'absence d'autres données.

J'ai pu les obtenir parce que j'ai utilisé deux LEFT JOINs. Le premier LEFT JOIN n'est pas contestable ; j'ai dû l'utiliser au cas où il y aurait des réalisateurs sans films. Il s'avère que c'est le cas.

Mais qu'en est-il du second LEFT JOIN? J'ai été en quelque sorte forcé de l'utiliser pour retenir tous ces réalisateurs sans films et obtenir le résultat souhaité. Pourquoi "forcé" ? Eh bien, utilisons INNER JOIN au lieu du second LEFT JOIN, et vous verrez.

SELECT first_name AS director_first_name,
	 last_name AS director_last_name,
	 movie_title,
	 platform_name,
	 started_showing, 
	 ended_showing
FROM director
LEFT JOIN streaming_catalogue
ON director.id = streaming_catalogue.director_id
JOIN streaming_platform
ON streaming_catalogue.streaming_platform_id = streaming_platform.id;

Il manque maintenant Lynne Ramsay et Stanley Kubrick dans le résultat !

director_first_name	director_last_name	movie_title	platform_name	started_showing	ended_showing
Krzysztof	Kieślowski	Three Colours: Blue	Mubi	2023-02-28	2023-09-30
Krzysztof	Kieślowski	Three Colours: White	Mubi	2023-02-28	2023-09-30
Krzysztof	Kieślowski	Three Colours: Red	Mubi	2023-02-28	2023-09-30
Woody	Allen	Manhattan Murder Mystery	Netflix	2023-08-15	NULL
Céline	Sciamma	Portrait of a Lady on Fire	Netflix	2023-01-01	2023-09-28
Krzysztof	Kieślowski	Three Colours: Blue	HBO	2024-01-15	NULL
Krzysztof	Kieślowski	Three Colours: White	HBO	2024-01-15	NULL
Krzysztof	Kieślowski	Three Colours: Red	HBO	2024-01-15	NULL
Céline	Sciamma	Tomboy	Netflix	2020-04-01	2021-04-01
Woody	Allen	Vicky Cristina Barcelona	Netflix	2023-10-01	NULL

Comment cela se fait-il ? Parce que INNER JOIN ne renvoie que les lignes correspondantes des tables jointes. J'ai donc pu obtenir les noms des réalisateurs sans les films avec le premier LEFT JOIN. Bravo !

Mais j'ai ensuite utilisé INNER JOIN et j'ai tout gâché ! INNER JOIN annule le premier LEFT JOIN, car il n'affiche que les lignes correspondantes entre streaming_catalogue et streaming_platform.

Puisque Lynne Ramsay et Stanley Kubrick n'ont pas de films dans la table streaming_catalogueleurs films inexistants ne peuvent pas être mis en correspondance dans le tableau streaming_platform et ils n'apparaissent pas dans le résultat final.

Voici un article qui fournit d'autres conseils et exemples sur la JONCTION À GAUCHE de plusieurs tables.

Exemple 6 : Jonction à gauche avec WHERE

Poursuivons les exemples de SQL LEFT JOIN en utilisant les mêmes données que dans l'exemple précédent.

Cet exemple vous montrera comment LEFT JOIN peut être utilisé avec la clause WHERE.

C'est exactement ce que fait le code ci-dessous pour trouver les réalisateurs, leurs films et les dates de début et de fin des projections. Cependant, il n'affiche pas tous les films, mais seulement ceux dont la projection s'est terminée avant le 1er octobre 2023.

SELECT first_name,
	 last_name,
	 movie_title, 
	 started_showing, 
	 ended_showing
FROM director
LEFT JOIN streaming_catalogue
ON director.id = streaming_catalogue.director_id
WHERE ended_showing < '2023_10_01';

Après avoir sélectionné les colonnes nécessaires, j'ai LEFT JOIN le tableau director avec la table streaming_ catalogue. Les tables sont jointes sur l'ID du réalisateur.

J'utilise la clause WHERE pour ne sortir que les films dont la diffusion s'est terminée avant le 1er octobre 2023. Dans WHERE, je compare la colonne ended_showing à la date limite requise en utilisant l'opérateur de comparaison "less than" (<).

Voici le résultat. Aucun film n'est sorti après le 1er octobre 2023.

first_name	last_name	movie_title	started_showing	ended_showing
Krzysztof	Kieślowski	Three Colours: Blue	2023-02-28	2023-09-30
Krzysztof	Kieślowski	Three Colours: White	2023-02-28	2023-09-30
Krzysztof	Kieślowski	Three Colours: Red	2023-02-28	2023-09-30
Céline	Sciamma	Portrait of a Lady on Fire	2023-01-01	2023-09-28
Céline	Sciamma	Tomboy	2020-04-01	2021-04-01

Exemple 7 : WHERE vs. ON dans LEFT JOIN

Je vais maintenant vous montrer comment l'effet de LEFT JOIN peut être annulé si WHERE est utilisé sur la bonne table. Et, bien sûr, je vous montrerai comment y remédier.

J'utilise à nouveau le même ensemble de données que dans l'exemple précédent. Supposons que je veuille l'interroger et récupérer tous les réalisateurs, qu'ils aient ou non un film dans la base de données. Pour les réalisateurs qui ont un film, je veux afficher uniquement les films sortis en 1993.

Je pourrais essayer d'y parvenir en écrivant cette requête :

SELECT DISTINCT first_name,
	   	    last_name,
	   	    movie_title, 
	   	    release_year
FROM director
LEFT JOIN streaming_catalogue
ON director.id = streaming_catalogue.director_id
WHERE release_year = 1993;

Tout d'abord, je sélectionne les colonnes nécessaires. J'utilise SELECT DISTINCT pour éviter la duplication des lignes, car certains films apparaissent plus d'une fois dans la table streaming_catalogue.

Maintenant, je LEFT JOIN le tableau director avec streaming_catalogue sur l'ID du réalisateur.

L'étape finale consisterait à utiliser la clause WHERE et à ne récupérer que les films sortis en 1993.

Voyons le résultat :

first_name	last_name	movie_title	release_year
Krzysztof	Kieślowski	Three Colours: Blue	1993
Woody	Allen	Manhattan Murder Mystery	1993

Non, ce n'est pas correct ! Je n'ai obtenu que deux réalisateurs au lieu de cinq. Rappelez-vous que je voulais une liste de tous les réalisateurs. Pourquoi cela s'est-il produit, bien que j'aie utilisé LEFT JOIN?

La raison en est que lorsque le filtre de WHERE est appliqué aux données du tableau de droite, il annule l'effet de LEFT JOIN. N'oubliez pas que si le réalisateur n'a aucun film dans le tableau, les valeurs de la colonne release_year seront NULL. C'est le résultat de LEFT JOIN. Et le filtre de WHERE exclura également NULLde la sortie.

Alors, comment pouvez-vous lister tous les directeurs et utiliser le filtre sur l'année de publication en même temps ? La réponse est que vous devez déplacer la condition de filtrage de WHERE à ON, comme suit.

SELECT DISTINCT first_name,
	          last_name,
	          movie_title, 
	          release_year
FROM director
LEFT JOIN streaming_catalogue
ON director.id = streaming_catalogue.director_id AND release_year = 1993;

La condition relative à l'année de publication devient alors la deuxième condition de jointure dans la clause ON. La deuxième (troisième, quatrième...) condition est ajoutée à l'aide du mot-clé AND.

Regardez, la sortie est maintenant correcte :

first_name	last_name	movie_title	release_year
Stanley	Kubrick	NULL	NULL
Lynne	Ramsay	NULL	NULL
Céline	Sciamma	NULL	NULL
Krzysztof	Kieślowski	Three Colours: Blue	1993
Woody	Allen	Manhattan Murder Mystery	1993

Vous pouvez en apprendre davantage dans cet article consacré à la différence entre WHERE et ON dans Les jointures en SQL.

Exemple 8 : LEFT JOIN avec Alias

Dans tous les exemples précédents, l'utilisation d'alias avec les tables dans LEFT JOIN n'était pas nécessaire. Cela aurait pu vous aider à raccourcir les noms des tables et à écrire le code un peu plus rapidement. Utile, certes, mais pas obligatoire.

Cependant, les alias deviennent obligatoires lorsque vous LEFT JOINING la table avec elle-même - c'est-à-dire lorsque vous auto-jointoyez la table.

Voyons comment cela fonctionne dans un exemple où je souhaite récupérer les noms de tous les employés et les noms de leurs responsables. Je veux que cette liste contienne les employés qui n'ont pas de supérieur hiérarchique.

J'en ferai la démonstration dans le tableau intitulé employees_managers. Voici le script:

id	first_name	last_name	manager_id
1	Lind	Kaiser	2
2	Ian	McKune	8
3	Deck	Trustrie	NULL
4	Ruperta	Nind	1
5	Garrot	Charsley	NULL
6	Athene	Fedoronko	8
7	Priscilla	Crocombe	NULL
8	Stafani	Sidebottom	8
9	Marve	Trustie	1
10	Antony	Marple	2

Voici la liste des employés. La colonne manager_id contient l'ID de l'employé qui est le manager de l'employé en question. Certains employés n'ont pas de responsable, la valeur est donc NULL.

Pour réaliser la tâche demandée, je dois écrire cette requête :

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_managers e
LEFT JOIN employees_managers m
ON e.manager_id = m.id;

Je fais référence à la table dans la clause FROM et je lui donne l'alias e. Cette table servira de données sur les employés.

Ensuite, je référence la même table dans la clause LEFT JOIN et lui donne l'alias m. Elle sera utilisée pour les données des managers.

De cette manière, j'ai pu joindre la table à elle-même. C'est la même chose que de joindre deux tables différentes. Lors d'une jointure automatique, une table agit comme deux tables. Il suffit de leur donner des alias pour que SQL sache à quelle table vous faites référence.

La table est auto-jointe lorsque l'ID du manager de la table "employé" est égal à l'ID de l'employé de la table "manager". De cette façon, j'obtiendrai tous les employés et leurs responsables.

Maintenant que les tables sont en place, il ne me reste plus qu'à sélectionner les colonnes nécessaires. Là encore, pour faire la distinction, j'utilise des alias de table différents pour obtenir les noms des employés et des responsables.

Voici le résultat :

employee_first_name	employee_last_name	manager_first_name	manager_last_name
Lind	Kaiser	Ian	McKune
Ian	McKune	Stafani	Sidebottom
Deck	Trustrie	NULL	NULL
Ruperta	Nind	Lind	Kaiser
Garrot	Charsley	NULL	NULL
Athene	Fedoronko	Stafani	Sidebottom
Priscilla	Crocombe	NULL	NULL
Stafani	Sidebottom	Stafani	Sidebottom
Marve	Trustie	Lind	Kaiser
Antony	Marple	Ian	McKune

Comme vous pouvez le constater, il s'agit d'une liste complète des employés et de leurs responsables. Deck Trustrie, Garrot Charsley et Priscilla Crocombe n'ont pas de responsable. Ils se trouvent au sommet de la structure hiérarchique de l'entreprise.

Exemple 9 : JOINT A GAUCHE avec GROUP BY

Revenons maintenant à l'exemple 2, dans lequel nous avons travaillé avec une liste de départements et d'employés.

Un exemple simple de LEFT JOIN avec GROUP BY serait de lister tous les départements et de compter le nombre d'employés dans chacun d'eux :

SELECT department_name,
	 COUNT(employee.id) AS number_of_employees
FROM department
LEFT JOIN employee
ON department.id = employee.department_id
GROUP BY department_name;

Je sélectionne le département et j'utilise la fonction d'agrégation COUNT() sur la colonne de l'ID de l'employé pour trouver le nombre d'employés.

Les données proviennent de deux tables. Je dois LEFT JOIN la table department avec la table employee car je veux aussi des départements qui n'ont pas d'employés. Les tables sont jointes sur l'ID du département.

Comme j'ai utilisé une fonction d'agrégation, je dois également regrouper les données. Pour ce faire, j'utilise la clause GROUP BY. Le regroupement des résultats par nom de département permet d'afficher le nombre d'employés pour chaque département.

Jetez un coup d'œil. Sympathique, n'est-ce pas ?

department_name	number_of_employees
Accounting	3
Operations	0
Sales	2
IT	2
HR	0

Essayons maintenant un autre exemple et utilisons COUNT(*) au lieu d'appliquer COUNT() à une colonne particulière.

Cette fois, j'utilise les données sur les entreprises et leurs produits de l'exemple 1. Dans cet exemple, je souhaite récupérer toutes les entreprises et afficher le nombre de produits qu'elles possèdent.

Voyons ce qui se passe si j'utilise COUNT(*):

SELECT company_name,
	 COUNT(*) AS number_of_products
FROM company
LEFT JOIN product
ON company.id = product.company_id
GROUP BY company_name;

Les tables company et product sont LEFT JOINsur la base de l'identifiant de l'entreprise. J'utilise COUNT(*) et GROUP BY pour trouver le nombre de produits par société.

Voici le résultat :

company_name	number_of_products
Huawei	1
Lenovo	1
Samsung	3
Apple	3
Fairphone	2

Cependant, je peux vous dire que ce résultat n'est pas correct : Huawei et Lenovo auraient dû avoir zéro produit. Pourquoi cette erreur s'est-elle produite ?

Le coupable est COUNT(*)! L'astérisque dans la fonction COUNT() signifie qu'elle compte toutes les lignes, y compris NULLs. Est-ce plus clair maintenant ? Oui, c'est exact : lorsque les entreprises sans produits sont LEFT JOIN, elles ont des produits NULS. Cependant, il s'agit toujours d'une valeur et COUNT(*) considérera chaque valeur NULL comme un produit. En d'autres termes, même les entreprises sans produits seront considérées comme ayant un produit.

Pour résoudre ce problème, utilisez COUNT(expression). Dans ce cas, cela signifie COUNT(product.id). L'utilisation de COUNT() avec un nom de colonne ignore NULLs :

SELECT company_name,
	 COUNT(product.id) AS number_of_products
FROM company
LEFT JOIN product
ON company.id = product.company_id
GROUP BY company_name;

Le résultat est maintenant conforme aux attentes :

company_name	number_of_products
Huawei	0
Lenovo	0
Samsung	3
Apple	3
Fairphone	2

Vous pouvez aller plus loin en lisant cet article sur les différentes variations de la fonction agrégée COUNT().

Autres exemples et ressources SQL LEFT JOIN

Les exemples ci-dessus montrent que LEFT JOIN est largement utilisé dans les travaux pratiques sur les données. Il peut être utilisé pour une simple recherche de données lorsque vous avez besoin de toutes les données d'une table et uniquement des données correspondantes d'une autre table. Cependant, il peut également être utilisé pour joindre plusieurs tables, avec WHERE, dans les jointures automatiques et avec les fonctions d'agrégation et GROUP BY.

Les jointures SQL sont essentielles pour travailler avec plusieurs tables, ce qui est une tâche quotidienne, même pour les analystes de données débutants. Connaître les jointures est une nécessité absolue si vous voulez vous considérer comme maîtrisant le langage SQL et progresser dans votre travail.

Cela implique également de connaître LEFT JOIN, car c'est l'un des deux types de jointures les plus utilisés. En raison de ses caractéristiques très spécifiques, de nombreuses tâches ne peuvent être effectuées qu'en exploitant LEFT JOIN. Si vous avez besoin d'un guide approfondi sur ces sujets, nous vous invitons à consulter notre coursLes jointures en SQL .

De plus, vous devez pratiquer tous ces concepts pour qu'ils soient vraiment assimilés. Cela signifie que vous devez pratiquer LEFT JOIN ainsi que d'autres types de JOIN afin de pouvoir les différencier. Vous pouvez essayer ces 12 questions pratiques sur les JO IN ou certaines des suggestions sur la façon de pratiquer Les jointures en SQL. Si vous devez bientôt passer un entretien d'embauche en SQL, essayez de répondre à ces 10 questions d'entretien sur les JOIN SQL. Bon apprentissage !

Tags: