Qu'est-ce qu'un LEFT OUTER JOIN en SQL ? Une explication avec 4 exemples

L'article d'aujourd'hui traite du LEFT OUTER JOIN en SQL. Nous verrons plusieurs exemples d'utilisation de la LEFT OUTER JOIN et la comparerons à l'INNER JOIN.

JOIN est une fonction SQL qui vous permet de combiner des données provenant de deux tables ou plus. La nature des bases de données relationnelles fait de JOIN l'une des fonctions SQL les plus utilisées. Pourquoi ? Dans la pratique, il est très rare que toutes les données nécessaires se trouvent dans une seule table. Même les bases de données les plus primitives sont constituées d'au moins deux tables.

Il existe de nombreux types différents de JOINs. Nous nous concentrerons ici sur LEFT OUTER JOIN. Pour obtenir un récapitulatif complet des différents types de JOINs, essayez notre cours interactif. Les jointures en SQL cours interactif. Outre les principes de base, il explique comment joindre plusieurs tables et utiliser des jointures égales et non égales. Vous ferez plus de 90 exercices pratiques, tous basés sur des exemples concrets !

Présentons LEFT OUTER JOIN; nous rendrons ensuite le cours plus intéressant avec des exemples pratiques. Si vous avez besoin de rafraîchir certains concepts au fur et à mesure, n'oubliez pas l'aide-mémoire sur les jointures en SQL.

Qu'est-ce qu'un LEFT OUTER JOIN ?

L'adresse JOIN la plus courante est INNER JOIN. Il s'agit d'un type de jointure qui renvoie uniquement les lignes correspondantes des deux tables jointes. Il existe d'autres types de JOIN qui peuvent renvoyer des lignes d'une table jointe même si la ligne n'a pas de ligne correspondante dans l'autre table. Ces types de JOINs sont appelés jointures externes.

Une LEFT JOIN est un type de jointure externe qui renvoie toutes les lignes de la table de gauche et les lignes correspondantes de la table de droite.

Quelle est la différence entre LEFT OUTER JOIN et LEFT JOIN ?

Réponse courte : Il n'y a pas de différence !

Réponse longue : Le nom complet de ce type de jointure est LEFT OUTER JOIN. Vous avez probablement vu des exemples de code SQL où les tables sont jointes uniquement à l'aide de LEFT JOIN. En effet, SQL accepte à la fois LEFT OUTER JOIN et LEFT JOIN.

Comme LEFT JOIN est plus court, il est utilisé plus souvent. Lorsque vous le voyez, cela signifie simplement LEFT OUTER JOIN. Le terme "Outer" est implicite, car il n'y a pas d'autre jointure à gauche qu'une jointure externe à gauche.

Syntaxe de la jointure gauche (LEFT [OUTER] JOIN)

La syntaxe de LEFT JOIN suit la syntaxe standard de JOIN:

1. Référencez la première table dans FROM.
2. Utilisez le mot-clé LEFT JOIN pour référencer la deuxième table.
3. Utilisez le mot-clé ON pour spécifier la condition de jonction.

En d'autres termes, la syntaxe est la suivante :

SELECT …
FROM table_1
LEFT JOIN table_2
ON table_1.column = table_2.column;

Comment fonctionne LEFT OUTER JOIN? Dans l'exemple générique ci-dessus, la requête fera référence à table_1 et la jointure gauche avec table_2. Elle renverra d'abord toutes les lignes de table_1, quelle que soit la condition de jointure. Pourquoi ? Parce que c'est la nature même de LEFT JOIN - elle renvoie toutes les lignes de la table de gauche (c'est-à-dire la première).

Ensuite, la requête examine la condition de jonction - dans ce cas, lorsqu'une valeur de la colonne de table_2 correspond à une valeur de la colonne de table_1. Le site LEFT JOIN ne renvoie que les valeurs de la table de droite (c'est-à-dire la deuxième table, ou table_2) pour lesquelles la condition de jointure est remplie. Si aucune valeur de ce type ne se trouve dans la table de droite, les valeurs renvoyées seront NULL. Vous pouvez en voir un exemple visuel dans notre article sur le fonctionnement de la LEFT JOIN.

Lorsque les tables sont jointes, il va sans dire que vous pouvez choisir n'importe quelle colonne des deux tables à l'adresse SELECT.

Maintenant que vous connaissez la syntaxe, il ne vous reste plus qu'à la mettre en pratique.

4 Exemples de LEFT OUTER JOIN

L'ensemble de données pour les exemples 1 à 3

Tout d'abord, présentons l'ensemble de données.

La première table, departmentscontient les données suivantes :

Vous pouvez obtenir la requête de création du tableau ici.

La deuxième table est employeeset vous pouvez la créer à l'aide de cette requête. La table contient les données suivantes :

Deux employés ont une valeur NULL dans la colonne department_id. Il s'agit de nouveaux enregistrements d'employés qui n'ont pas encore été mis à jour avec le département.

Exemple 1 : Recherche de tous les employés et de leurs départements

Utilisons les tableaux ci-dessus pour dresser la liste de tous les salariés et de leurs départements.

Il s'agit d'un article sur LEFT OUTER JOIN, donc il n'y a pas de surprise : nous utiliserons exactement cette jointure pour résoudre ce problème. Voici la requête :

SELECT e.id,
	 e.first_name,
	 e.last_name,
	 d.department_name
FROM employees e 
LEFT JOIN departments d
ON e.department_id = d.id
ORDER BY e.id;

Les données de résultat dont nous avons besoin sont les numéros d'identification, les noms et les départements des employés. C'est pourquoi ces colonnes sont dans SELECT.

Pour obtenir toutes ces colonnes, nous devons accéder aux données des deux tables. Voyons comment procéder.

Tout d'abord, la table employees est référencée dans FROM. Pourquoi cette table et pas l'autre ? Rappelez-vous : La table référencée en premier a de l'importance dans LEFT JOIN. Pourquoi ? Parce que cette table est la table de gauche et que LEFT JOIN renverra toutes les lignes de cette table, quoi qu'il arrive.

Nous référençons la table employees en premier parce que nous devons dresser la liste de tous les employés de cette table. Nous référençons ensuite la table departments. Nous joignons les deux tables à condition que la colonne department_id de la table employees est identique à la colonne id de la table departments. Ces deux colonnes sont des dimensions partagées (la clé primaire et la clé étrangère) entre ces deux tables, elles sont donc idéales pour être utilisées dans la condition de jointure.

Pour obtenir un résultat plus lisible, nous classons les résultats par ID d'employé :

Le résultat répertorie tous les employés - les 15. Il indique également leurs services, à savoir "Comptabilité" et "Ventes". Vous remarquerez que certains employés ont des valeurs NULL dans la colonne department_name. Deux d'entre eux ont été mentionnés plus tôt : il s'agit de nouveaux employés dont l'ID de département n'a pas été mis à jour dans la table. Ils avaient des valeurs NULL dans le tableau initial et sont marqués en bleu. employees et sont marqués en bleu.

Il y a cependant d'autres employés - marqués en vert - avec des valeurs NULL. C'est le résultat de l'opération LEFT JOIN. Tous ces employés ont un ID de département de 4, mais la table ne contient pas cette valeur. departments ne contient pas cette valeur. Il semble que la table departments semble également avoir besoin d'une mise à jour. Une base de données vraiment minable pour une entreprise fictive aussi respectable !

Rappelez-vous : Les valeurs de la table de gauche qui ne se trouvent pas dans la table de droite sont affichées à l'adresse NULL.

Et si nous utilisions un INNER JOIN ?

Réécrivons la requête ci-dessus, cette fois avec un INNER JOIN (généralement abrégé en JOIN) au lieu d'un LEFT JOIN:

SELECT e.id,
	 e.first_name,
	 e.last_name,
	 d.department_name
FROM departments d
JOIN employees e
ON e.department_id = d.id
ORDER BY e.id;

La syntaxe est exactement la même ; nous avons simplement utilisé un type de jointure différent. Voyons quel sera le résultat :

Certains employés sont manquants ; il n'y en a que neuf ici. Un examen plus approfondi montre que les employés dont l'ID est 3, 4, 7, 9, 11 et 12 ne sont pas inclus dans le résultat. Pourquoi ? Si vous revenez en arrière, vous verrez que les employés manquants sont ceux dont l'adresse est NULLs dans department_name dans la sortie LEFT OUTER JOIN.

N'oubliez pas que INNER JOIN ne renvoie que les lignes correspondantes des deux tables - en d'autres termes, uniquement les employés dont l'ID de département se trouve dans les deux tables.

Donc, dans cette situation, où nous voulions tous les employés et leurs départements, LEFT JOIN est le bon choix. Maintenant, nous voyons aussi les employés sans département, et nous pouvons dire que notre base de données a besoin d'être mise à jour.

Exemple 2 : Liste de tous les départements et de leurs employés

Pour obtenir le résultat souhaité, nous devons inverser l'ordre des tables dans LEFT JOIN.

Voici la requête :

SELECT d.id,
	 d.department_name,
	 e.first_name,
	 e.last_name
FROM  departments d
LEFT JOIN employees e
ON d.id = e.department_id
ORDER BY d.id;

Nous modifions l'ordre des colonnes dans SELECT pour obtenir un meilleur résultat. La plupart des colonnes sont les mêmes que précédemment. Cette fois, nous sélectionnons l'ID du département dans la table departmentset non l'ID de l'employé.

Maintenant, le tableau departments est notre tableau de gauche. En effet, nous voulons afficher tous les départements de ce tableau, qu'ils apparaissent ou non dans le tableau employees - notre table de droite.

La condition ON reste la même ; nous avons seulement inversé l'ordre des colonnes. Cela n'a pas vraiment d'importance ; l'ordre aurait pu rester le même. C'est juste pour des raisons esthétiques, car il est plus facile de lire la condition lorsqu'elle suit l'ordre des tableaux dans LEFT JOIN.

Nous trions également les résultats par ID de département.

Voici le résultat :

Ce résultat ne montre que neuf employés, contre 15 dans l'exemple précédent. Tous les employés ayant des valeurs NULL dans le résultat du dernier exemple n'apparaissent pas dans ce résultat.

La raison en est, une fois de plus, LEFT JOIN. Lorsque nous avons créé departments notre tableau de gauche, il répertoriait tous les départements et leurs employés. Tous les autres employés ne figurent pas dans ce tableau. Pourquoi ? Soit ils ont l'ID de département 4, qui n'apparaît pas dans le tableau, soit il s'agit de nouveaux employés (vous vous en souvenez ?) dont le nom est . departmentssoit il s'agit de nouveaux employés (vous vous souvenez d'eux ?) dont l'ID de département est NULL.

Les seuls NULLs dans cette sortie apparaissent dans la dernière ligne. Il y a le département "Compliance", auquel aucun employé n'est affecté. En d'autres termes, il n'y a pas d'employés avec la valeur 5 dans la colonne department_id de la table. employees tableau.

N'oubliez pas : L'ordre des tables dans LEFT JOIN est important !

Et si nous utilisions un INNER JOIN ?

Modifions la requête et utilisons un INNER JOIN:

SELECT d.id,
	 d.department_name,
	 e.first_name,
	 e.last_name
FROM  departments d
INNER JOIN employees e
ON d.id = e.department_id
ORDER BY d.id;

Le résultat est pratiquement le même que celui obtenu avec la jointure interne de l'exemple 1. La seule différence est qu'il y a un identifiant de département au lieu d'un identifiant d'employé. Pour le reste, c'est la même chose, nous ne passerons donc pas de temps à l'analyser.

Exemple 3 : Liste de tous les départements et du nombre d'employés dans chacun d'eux

LEFT JOINLa jointure, comme toutes les autres jointures, est souvent utilisée avec les fonctions d'agrégation de SQL. Cette fonction sera très utile ici.

Jetez un coup d'œil à cette requête :

SELECT d.department_name, 
 COUNT(e.id) AS number_of_employees
FROM departments d
LEFT JOIN employees e
ON d.id = e.department_id
GROUP BY d.department_name;

Commençons par expliquer la clause FROM. Puisque nous voulons dresser la liste de tous les départements existants, nous nous référons d'abord à la table departments dans FROM. Pourquoi ? Parce que certains employés n'ont pas de département et que nous ne voulons pas les voir figurer dans notre résultat. Comme nous l'avons vu, il y a aussi un département sans employés ; nous voulons que ce département figure quand même dans le résultat.

Vient ensuite le tableau employees après LEFT JOIN. Les tables sont jointes selon la même condition que dans l'exemple précédent.

Pour obtenir un résultat correct, nous devons énumérer le nom du département dans SELECT. Nous devons également utiliser la fonction d'agrégation COUNT(e.id) pour compter le nombre d'identifiants d'employés.

Pourquoi ne pouvons-nous pas utiliser COUNT(*)? Parce qu'elle compte toutes les lignes, y compris les valeurs de NULL. Cela fausserait nos résultats. Le département de la conformité a zéro employé, ce qui aurait été indiqué comme NULL lors de la jointure. COUNT(*) aurait compté ce NULL comme un, ce qui n'aurait pas été exact.

L'option COUNT(e.id) ignore les valeurs de NULL et ne compte que les employés dont l'ID n'est pas NULL. Il s'agit davantage d'un sujet relatif aux fonctions d'agrégation que d'un sujet relatif à LEFT JOIN, c'est pourquoi nous n'entrerons pas dans les détails.

Cependant, il est extrêmement important de comprendre quand utiliser les différentes options de COUNT(). Vous pouvez vous référer à notre article détaillant toutes les différentes incarnations et utilisations de la fonction COUNT() pour plus d'informations.

Revenons à notre code. Après avoir compté et joint, le résultat est regroupé par nom de département. Il en résulte une liste de départements avec le nombre d'employés dans chacun d'entre eux :

Le résultat montre qu'il y a, au total, neuf employés dans les départements de la société : six dans la comptabilité, zéro dans la conformité et trois dans les ventes.

Et si nous utilisions INNER JOIN ?

Effectuons maintenant la même requête, mais avec INNER JOIN.

SELECT d.department_name, 
	 COUNT(e.id) AS number_of_employees
FROM departments d
JOIN employees e
ON d.id = e.department_id
GROUP BY d.department_name;

Le résultat sera-t-il différent ? Voyons ce qu'il en est.

Le résultat, une fois de plus, montre qu'il y a neuf employés répartis dans différents services. Ce qui manque manifestement, c'est que l'entreprise dispose d'un service de conformité qui n'apparaît pas dans ce résultat.

Si nous avions utilisé INNER JOIN, nous aurions conclu qu'il n'y a que deux départements dans l'entreprise. LEFT JOIN était, encore une fois, le bon choix puisqu'il peut y avoir (au moins temporairement) un département sans employés.

Ensemble de données pour l'exemple 4

Nous utiliserons trois tableaux dans cet exemple. La première est artists; elle contient les données suivantes sur les artistes musicaux :

Créez la table à l'aide de la requête présentée ici.

La table suivante est albums:

Et voici la requête pour créer cette table.

La requête pour la troisième table est ici. La table est nommée grammy_award. Il s'agit d'une liste de catégories de prix Grammy. Elle ne comporte que deux catégories : le gagnant du meilleur album et le candidat au meilleur album.

Exemple 4 : Liste de tous les artistes, de leurs albums et de la catégorie de prix Grammy

LEFT JOIN peut également être utilisé pour relier plus de deux tables, comme nous le verrons dans la requête ci-dessous :

SELECT artist_name,
	 album_title,
	 grammy_category
FROM artists ar
LEFT JOIN albums al
ON ar.id = al.artist_id
LEFT JOIN grammy_award ga
ON al.grammy_category_id = ga.id;

Tout d'abord, nous avons listé toutes les colonnes nécessaires pour afficher le nom de l'artiste, le titre de l'album, l'année de sortie et la catégorie des Grammy Awards.

Les tableaux présentés montrent que certains albums ne contiennent pas d'informations sur l'artiste. Notre catalogue étant incomplet, le moyen le plus sûr de répertorier tous les artistes disponibles est d'utiliser les tableaux LEFT JOIN et de considérer le tableau artists comme la table de gauche. Elle est jointe à gauche avec la table albums sur l'ID de l'artiste.

Pour récupérer les données sur les Grammys, nous devons joindre la troisième table d'une manière ou d'une autre. Comment procéder ? C'est simple : écrivez à nouveau la commande LEFT JOIN et faites référence à la table grammy_award après elle. Cela donnera LEFT JOIN albums avec grammy_award. Les tables sont jointes sur l'ID de la catégorie Grammy.

Voyons le résultat :

Le résultat indique tous les artistes, leurs albums et si l'album a été nommé ou a gagné le prix de l'album de l'année. Il indique également les albums qui n'ont été ni nominés ni gagnants aux Grammy Awards.

Et si nous utilisions INNER JOIN ?

Voici le même code que ci-dessus, avec JOIN au lieu de LEFT JOIN:

SELECT artist_name,
	 album_title,
	 grammy_category
FROM artists ar
JOIN albums al
ON ar.id = al.artist_id
JOIN grammy_award ga
ON al.grammy_category_id = ga.id;

Voyons ce que le code renvoie :

Ce résultat est incomplet. Il manque un artiste : George Benson. Il manque également les albums sans catégorie Grammy. Comme nous n'essayons pas de lister uniquement les albums avec une catégorie Grammy, LEFT JOIN était le bon choix.

Voici quelques explications supplémentaires sur la façon de joindre à gauche plusieurs tables.

Le coin des débutants : Quelques conseils sur l'écriture des JOIN

Voici un aperçu des erreurs les plus courantes commises par les débutants lors de l'utilisation de LEFT OUTER JOIN en SQL.

Nous les avons déjà abordées dans les exemples, mais elles ne sont pas forcément évidentes pour un œil moins expérimenté. Nous allons donc les mettre en mots.

Choisir la bonne jointure

Nous avons comparé tous les exemples de LEFT JOIN avec les versions de INNER JOIN. Comme vous l'avez vu, les résultats changent de manière significative. C'est pourquoi vous devez choisir avec soin la jointure que vous allez utiliser.

Le meilleur conseil est de penser à ces deux définitions de jointure. Ainsi, si vous n'avez besoin que de données correspondantes provenant de deux tables, vous devez utiliser INNER JOIN. Dans tous les autres cas, LEFT JOIN sera probablement le bon choix.

Déterminer quelle est la table de gauche

Une fois que vous avez choisi d'utiliser le site LEFT JOIN, comment savoir quelle table doit être la table de gauche ? Tout d'abord, le tableau de gauche est celui qui vient immédiatement après FROM. Le tableau de droite est celui qui vient après LEFT JOIN.

Vous devez comprendre correctement le problème que vous êtes en train de résoudre. Cherchez des indices dans la formulation et la logique. Si vous avez besoin de tous les employés, le tableau contenant les employés sera le tableau de gauche. En d'autres termes, si vous pensez que l'un de vos tableaux doit être affiché tel quel, c'est le tableau de gauche.

Attention aux fonctions d'agrégation

Même si vous commettez une erreur et choisissez la mauvaise jointure, il est très probable que vous vous en aperceviez dans le résultat si vous n'agrégez pas les données. Si vous connaissez bien vos données, vous verrez qu'il manque des lignes ou qu'il n'y a pas de NULLs là où vous vous y attendiez.

Cependant, soyez très prudent lorsque vous utilisez des fonctions d'agrégation. Comme la sortie sera agrégée, il sera beaucoup plus difficile de voir l'erreur dans la sortie - à moins que vous ne connaissiez par cœur tous vos résultats d'agrégation de données, ce qui est très improbable. Dans ce cas, vous n'auriez pas besoin de SQL, n'est-ce pas ?

Ceci est particulièrement vrai lors de l'utilisation de COUNT(). Comme vous l'avez vu dans l'un de nos exemples, COUNT(*) peut donner des résultats différents de COUNT(column_name). Il est extrêmement important que vous sachiez ce que vous voulez obtenir et comment fonctionne COUNT().

Rappelez-vous : COUNT(column_name) ignore les valeurs de NULL, alors que COUNT(*) ne les ignore pas !

Ainsi, lorsque vous travaillez avec des fonctions agrégées, testez votre requête avec INNER JOIN - si vous en avez la possibilité - et voyez si les résultats sont différents. Si ce n'est pas le cas, la jointure utilisée n'a pas d'importance, mais si c'est le cas, revenez à la définition de votre problème et voyez quelle logique de jointure correspond le mieux à votre logique d'entreprise.

LEFT JOIN en cascade

Ce phénomène s'observe lorsque l'on joint plus de deux tables. Si vous choisissez de LEFT JOIN pour les deux premières tables, vous devez généralement LEFT JOIN pour toutes les autres tables.

Vous l'avez vu dans notre dernier exemple, car nous avons utilisé deux LEFT JOINs. Même si nous utilisions d'abord LEFT JOIN et ensuite INNER JOIN, nous n'obtiendrions pas la liste de tous les artistes et les autres données. L'inclusion de INNER JOIN dans cette chaîne de jointures donnera le même résultat que l'utilisation de INNER JOIN au lieu de chaque LEFT JOIN.

Ce n'est pas toujours le cas. Mais il est assez sûr de suivre cette règle empirique : si vous avez besoin d'une jointure à gauche, vous avez besoin de toutes les jointures à gauche.

Vous voulez en savoir plus sur les jointures à gauche ?

Cet article vous a donné un avant-goût de ce qu'est une LEFT JOIN et de la façon de gérer ses pièges occasionnels. Nous avons également pratiqué l'écriture de code pour vous familiariser avec la syntaxe de LEFT JOIN.

Pour maîtriser toutes les nuances de LEFT OUTER JOIN en SQL, nous vous recommandons de vous entraîner davantage. Trois exemples ne suffisent pas ! Pour approfondir ce que vous avez appris ici, nous vous recommandons notre cours de Les jointures en SQL cours. Outre les bases théoriques, vous bénéficierez également de nombreux exercices pratiques avec des scénarios du monde réel.

Voici quelques idées supplémentaires sur la façon de pratiquer Les jointures en SQL. Les questions d'entretien deLes jointures en SQL sont également une ressource précieuse pour pratiquer le matériel. Bon apprentissage !