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

Jointure droite SQL

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

Aussi connu sous le nom de RIGHT OUTER JOIN , le RIGHT JOIN renvoie les lignes qui ont des données dans la bonne table (à droite du JOIN mot-clé), même s'il n'y a pas de lignes correspondantes dans le tableau de gauche.

Syntaxe

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

Utilisation de la RIGHT JOIN syntaxe :

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

Utilisation de la RIGHT OUTER JOIN syntaxe :

SELECT *
FROM Table1 RIGHT 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 bonne requête de jointure

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

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt
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 bonne jointure nous fait obtenir un PetType valeur qui ne correspond pas à un PetName . Plus précisément, il n'y a pas de lapins comme animaux de compagnie. Mais la bonne jointure 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 bonne table (c'est-à-dire à droite du RIGHT JOIN mots clés).

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

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
RIGHT JOIN Pets p
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 ) était sur le côté gauche de la jointure.

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

Joindre à droite sur 3 tables

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

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

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 Pets p RIGHT JOIN Owners o 
    ON p.OwnerId = o.OwnerId
RIGHT JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId;

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.