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 | example@sqldat.com | | 2 | Bart | Pitt | (231) 465-3497 | example@sqldat.com | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | example@sqldat.com | +-----------+-------------+------------+----------------+-------------------+
Notez que :
- Le
PetTypeIdcolonne desPetstable est une clé étrangère dePetTypeIddesPetTypestable (qui est la clé primaire de cette table). - Le
OwnerIdcolonne desPetstable est une clé étrangère deOwnerIdcolonne desOwnerstableau.
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.
