Database
 sql >> Base de données >  >> RDS >> Database

Jointure gauche SQL

Cet article donne un aperçu de la LEFT JOIN en SQL, ainsi que quelques exemples de base.

Le LEFT JOIN , ou LEFT OUTER JOIN , renvoie les lignes contenant des données dans le tableau de gauche (à gauche de JOIN mot-clé), même s'il n'y a pas de lignes correspondantes dans le bon tableau.

Syntaxe

Vous spécifiez une jointure gauche dans le FROM clause. Vous pouvez utiliser soit le LEFT JOIN ou LEFT OUTER JOIN syntaxe.

Utilisation de la LEFT JOIN syntaxe :

SELECT *
FROM Table1 LEFT JOIN Table2 
ON Table1.Column = Table2.Column;

Utilisation de la LEFT OUTER JOIN syntaxe :

SELECT *
FROM Table1 LEFT OUTER JOIN Table2 
ON Table1.Column = Table2.Column;

Les deux font exactement la même chose. C'est juste que le OUTER le mot-clé est facultatif.

Exemples

Voici quelques exemples à démontrer.

Exemple de données

Tout d'abord, voici les tableaux que nous utiliserons pour les exemples.

Les PetTypes tableau :

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Les Pets tableau :

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)

Les Owners tableau :

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
+-----------+-------------+------------+----------------+-------------------+

Notez que :

  • Le PetTypeId colonne des Pets table est une clé étrangère de PetTypeId des PetTypes table (qui est la clé primaire de cette table).
  • Le OwnerId colonne des Pets table est une clé étrangère de OwnerId colonne des Owners tableau.

La requête de jointure à gauche

Voici un exemple d'exécution d'une jointure gauche sur deux de ces tables.

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Résultat :

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

La jointure gauche nous fait obtenir un PetType valeur qui ne correspond pas à un PetName . Il n'y a pas de lapins comme animaux de compagnie. Mais la jointure gauche provoque Rabbit à retourner, même s'il n'y a pas d'animal dans le Pets tableau de ce type. Cela se traduit par un NULL valeur dans le PetName colonne contre Rabbit .

Cela n'est arrivé que parce que Rabbit était dans la table de gauche (c'est-à-dire à gauche du LEFT JOIN mots clés). OK, mon formatage le rend plus "au-dessus" que "à gauche", mais vous obtenez l'image.

Voici ce qui se passe si nous changeons l'ordre des tables dans notre requête.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
LEFT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

Résultat :

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

Cette fois Rabbits n'a pas été retourné. C'est parce que sa table (PetTypes ) se trouvait du côté droit de la jointure.

Nous aurions besoin de le changer en une jointure droite ou une jointure complète si nous voulions Rabbits à retourner en utilisant cet ordre de table.

Joindre à gauche sur 3 tables

Voici un exemple d'exécution d'une jointure gauche sur les trois tables.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o LEFT JOIN Pets p
    ON p.OwnerId = o.OwnerId
LEFT JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId;

Résultat :

+-----------+-----------+----------------+
| PetName   | PetType   | PetOwner       |
|-----------+-----------+----------------|
| Tweet     | Bird      | Homer Connery  |
| Scratch   | Cat       | Bart Pitt      |
| Bark      | Dog       | Bart Pitt      |
| Fluffy    | Cat       | Nancy Simpson  |
| Fetch     | Dog       | Nancy Simpson  |
| Wag       | Dog       | Nancy Simpson  |
| Fluffy    | Dog       | Boris Trump    |
| Meow      | Cat       | Boris Trump    |
| NULL      | NULL      | Woody Eastwood |
+-----------+-----------+----------------+
(9 rows affected)

Cette fois, nous avons un propriétaire d'animal de compagnie qui n'a pas d'animal de compagnie.

Nous pourrions à nouveau mélanger l'ordre des tables, et nous obtiendrions un résultat différent.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM PetTypes pt LEFT JOIN Pets p
    ON p.PetTypeId = pt.PetTypeId
LEFT JOIN Owners o 
    ON p.OwnerId = o.OwnerId;

Résultat :

+-----------+-----------+---------------+
| PetName   | PetType   | PetOwner      |
|-----------+-----------+---------------|
| Tweet     | Bird      | Homer Connery |
| Fluffy    | Cat       | Nancy Simpson |
| Scratch   | Cat       | Bart Pitt     |
| Meow      | Cat       | Boris Trump   |
| Fetch     | Dog       | Nancy Simpson |
| Wag       | Dog       | Nancy Simpson |
| Fluffy    | Dog       | Boris Trump   |
| Bark      | Dog       | Bart Pitt     |
| NULL      | Rabbit    |               |
+-----------+-----------+---------------+
(9 rows affected)

Cette fois, nous avons obtenu le type d'animal de compagnie supplémentaire (Rabbit ), mais pas le propriétaire supplémentaire.

Si vous vous demandez pourquoi le dernier PetOwner n'est pas NULL (comme le dernier PetName est), c'est parce que c'est le résultat d'une concaténation de chaînes. J'ai utilisé le T-SQL CONCAT() fonction pour concaténer les noms et prénoms du propriétaire.