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

Jointure complète SQL

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

Le SQL FULL JOIN (ou FULL OUTER JOIN ) renvoie toutes les lignes, tant qu'il y a des données correspondantes dans l'une des tables.

C'est comme avoir une jointure gauche droite dans une seule jointure.

Syntaxe

Vous spécifiez une jointure complète dans le FROM clause. Vous pouvez utiliser soit le FULL JOIN ou FULL OUTER JOIN syntaxe.

Utilisation de la FULL JOIN syntaxe :

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

Utilisation de la FULL OUTER JOIN syntaxe :

SELECT *
FROM Table1 FULL 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 :

+---------------------+-----------+| IDTypeAnimal | TypeAnimal ||-------------+-----------|| 1 | Oiseau || 2 | Chat || 3 | Chien || 4 | Lapin |+-------------+-----------+(4 lignes concernées)

Les Pets tableau :

+---------+-------------+-----------+---------- -+------------+| ID animal | IDTypeAnimal | Identifiant du propriétaire | NomAnimal | Date de naissance ||---------+------------+-----------+----------- +--------------------|| 1 | 2 | 3 | Moelleux | 2020-11-20 || 2 | 3 | 3 | Récupérer | 2019-08-16 || 3 | 2 | 2 | gratter | 2018-10-01 || 4 | 3 | 3 | remuer | 2020-03-15 || 5 | 1 | 1 | Tweeter | 2020-11-28 || 6 | 3 | 4 | Moelleux | 2020-09-17 || 7 | 3 | 2 | Écorce | NUL || 8 | 2 | 4 | Miaou | NULL |+---------+-------------+-----------+----------- +--------------------+(8 lignes concernées)

Les Owners tableau :

+-----------+-------------+------------+------- ---------+-------------------+| Identifiant du propriétaire | Prénom | Nom | Téléphone | E-mail ||-----------+-------------+------------+-------- --------+-------------------|| 1 | Homère | Connery | (308) 555-0100 | [email protected] || 2 | Bart | Pitt | (231) 465-3497 | [email protected] || 3 | Nancy | Simpson | (489) 591-0408 | NUL || 4 | Boris | Atout | (349) 611-8908 | NUL || 5 | Boisé | 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 complète

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

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

Résultat :

+-----------+-----------+| NomAnimal | TypeAnimal ||-----------+-----------|| Tweeter | Oiseau || Moelleux | Chat || gratter | Chat || Miaou | Chat || Récupérer | Chien || remuer | Chien || Moelleux | Chien || Écorce | Chien || NUL | Lapin |+-----------+-----------+(9 lignes concernées)

Dans cet exemple, nous obtenons un PetType valeur qui ne correspond pas à un PetName . C'est parce qu'il n'y a pas de lapins comme animaux de compagnie. Mais la jointure complète 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 .

C'est le même résultat que nous aurions obtenu si nous avions utilisé une jointure droite, car les PetTypes table est à droite du JOIN mot-clé. Cela ne se serait pas produit avec une jointure à gauche, car PetTypes table n'est pas à gauche du JOIN mot-clé. Si nous voulions le recréer avec une jointure à gauche, nous devrions changer l'ordre des tables, de sorte que les PetTypes table était à gauche du JOIN mot-clé.

Voici ce qui se passe si nous changeons l'ordre des tables dans notre requête lors de l'utilisation d'une jointure complète.

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

Résultat :

+-----------+-----------+| NomAnimal | TypeAnimal ||-----------+-----------|| Tweeter | Oiseau || Moelleux | Chat || gratter | Chat || Miaou | Chat || Récupérer | Chien || remuer | Chien || Moelleux | Chien || Écorce | Chien || NUL | Lapin |+-----------+-----------+(9 lignes concernées)

On obtient exactement le même résultat. En effet, la jointure complète renvoie toutes les lignes, tant qu'il existe des données correspondantes dans l'une des tables. Comme mentionné, c'est comme avoir une jointure gauche et droite dans une seule jointure.

Joindre complet sur 3 tables

Voici un exemple d'exécution d'une jointure complète sur les trois tables.

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

Résultat :

+-----------+-----------+-----------+| NomAnimal | TypeAnimal | Propriétaire ||-----------+-----------+----------------|| Tweeter | Oiseau | Homer Connery || gratter | Chat | Bart Pitt || Écorce | Chien | Bart Pitt || Moelleux | Chat | Nancy Simpson || Récupérer | Chien | Nancy Simpson || remuer | Chien | Nancy Simpson || Moelleux | Chien | Boris Trump || Miaou | Chat | Boris Trump || NUL | NUL | Woody Eastwood || NUL | Lapin | |+-----------+-----------+----------------+(10 lignes concernées) 

 Cette fois, nous avons un propriétaire d'animal qui n'a pas d'animal, ainsi qu'un type d'animal qui n'est pas attribué à un animal. 
 

 Si nous mélangeons l'ordre des tables, nous obtenons le même résultat, bien que les lignes soient répertoriées dans un ordre différent.
 
SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM PetTypes pt FULL JOIN Pets p
    ON p.PetTypeId = pt.PetTypeId
FULL JOIN Owners o 
    ON p.OwnerId = o.OwnerId; 
 

 Résultat :
 
-----------+-----------+----------------+| NomAnimal | TypeAnimal | Propriétaire ||-----------+-----------+----------------|| Tweeter | Oiseau | Homer Connery || Moelleux | Chat | Nancy Simpson || gratter | Chat | Bart Pitt || Miaou | Chat | Boris Trump || Récupérer | Chien | Nancy Simpson || remuer | Chien | Nancy Simpson || Moelleux | Chien | Boris Trump || Écorce | Chien | Bart Pitt || NUL | Lapin | || NUL | NUL | Woody Eastwood |+-----------+-----------+----------------+(10 lignes concernées) 
 

 Et si nous les mélangeons à nouveau, nous obtenons toujours le même résultat.
 
SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p FULL JOIN Owners o
    ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId; 
 

 Résultat :
 
+-----------+-----------+-----------+| NomAnimal | TypeAnimal | Propriétaire ||-----------+-----------+----------------|| Moelleux | Chat | Nancy Simpson || Récupérer | Chien | Nancy Simpson || gratter | Chat | Bart Pitt || remuer | Chien | Nancy Simpson || Tweeter | Oiseau | Homer Connery || Moelleux | Chien | Boris Trump || Écorce | Chien | Bart Pitt || Miaou | Chat | Boris Trump || NUL | NUL | Woody Eastwood || NUL | Lapin | |+-----------+-----------+----------------+(10 lignes concernées) 

 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.