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

Jointure naturelle SQL

Cet article fournit un aperçu de la jointure naturelle en SQL, ainsi que quelques exemples de base.

Qu'est-ce qu'une jointure naturelle ?

La jointure naturelle SQL est un type d'équi-jointure qui combine implicitement des tables basées sur des colonnes de même nom et de même type. Le prédicat de jointure apparaît implicitement en comparant toutes les colonnes des deux tables qui ont les mêmes noms de colonne dans les tables jointes.

Le jeu de résultats contient une seule colonne pour chaque paire de colonnes portant le même nom. Si aucune colonne portant le même nom n'est trouvée, le résultat sera une jointure croisée.

Syntaxe

Une jointure naturelle peut être appliquée à n'importe quel INNER , LEFT , RIGHT , ou FULL rejoindre. Vous préfixez simplement le type de jointure avec le NATURAL mot-clé.

Exemple de syntaxe utilisée sur une jointure interne :

SELECT *
FROM Table1 NATURAL INNER JOIN Table2 
ON Table1.Column = Table2.Column;

Voir comme INNER est la valeur par défaut, vous pouvez aussi le faire comme ceci :

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

Le NATURAL le mot-clé place un USING implicite clause aux contraintes de jointure. Il forme un USING liste composée de tous les noms de colonne qui apparaissent dans les deux tables d'entrée. Cela ne s'applique évidemment qu'aux SGBD qui prennent en charge le USING clause.

Tous les SGBD ne prennent pas en charge les jointures naturelles, consultez donc la documentation de votre SGBD.

Au moment où j'écris ceci, les jointures naturelles sont prises en charge dans PostgreSQL, MySQL, MariaDB, SQLite et Oracle. Cependant, les jointures naturelles ne sont pas prises en charge dans SQL Server (2019).

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.

Exemple 1 – Jointure interne naturelle

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

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Résultat :

 petname | pettype 
---------+---------
 Fluffy  | Cat
 Fetch   | Dog
 Scratch | Cat
 Wag     | Dog
 Tweet   | Bird
 Fluffy  | Dog
 Bark    | Dog
 Meow    | Cat
(8 rows)

Dans cet exemple, la jointure naturelle joint implicitement les tables sur les deux PetTypeId colonnes (c'est-à-dire le Pets.PetTypeId et la colonne PetTypes.PetTypeId colonne).

Il s'agit d'une manière implicite de procéder comme suit :

SELECT 
    PetName,
    PetType
FROM Pets
INNER JOIN PetTypes USING (PetTypeId);

Ce qui fait en fait ce qui suit.

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

Exemple 2 – Jointure droite naturelle

Voici un exemple d'exécution d'une jointure droite naturelle sur deux de ces tables. Cette fois, nous devons spécifier le type de jointure, car nous ne voulons pas de la jointure interne (par défaut).

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
NATURAL RIGHT JOIN PetTypes pt;

Résultat :

 petname | pettype 
---------+---------
 Fluffy  | Cat
 Fetch   | Dog
 Scratch | Cat
 Wag     | Dog
 Tweet   | Bird
 Fluffy  | Dog
 Bark    | Dog
 Meow    | Cat
         | Rabbit
(9 rows)

Dans ce cas, cela revient au même que de procéder comme suit :

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

Exemple 3 – Jointure complète naturelle sur 3 tables

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

SELECT 
    PetName,
    PetType,
    CONCAT(FirstName, ' ', LastName) AS PetOwner
FROM Owners NATURAL FULL JOIN Pets
NATURAL FULL JOIN PetTypes;

Résultat :

 petname | pettype |    petowner    
---------+---------+----------------
 Fluffy  | Cat     | Nancy Simpson
 Fetch   | Dog     | Nancy Simpson
 Scratch | Cat     | Bart Pitt
 Wag     | Dog     | Nancy Simpson
 Tweet   | Bird    | Homer Connery
 Fluffy  | Dog     | Boris Trump
 Bark    | Dog     | Bart Pitt
 Meow    | Cat     | Boris Trump
         |         | Woody Eastwood
         | Rabbit  |  
(10 rows)

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.

Exemple 4 - Utilisation de l'astérisque (* ) Caractère générique

Voici un exemple qui utilise le caractère générique astérisque (*) pour sélectionner toutes les colonnes.

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Résultat :

 pettypeid | petid | ownerid | petname |    dob     | pettype 
-----------+-------+---------+---------+------------+---------
         2 |     1 |       3 | Fluffy  | 2020-11-20 | Cat
         3 |     2 |       3 | Fetch   | 2019-08-16 | Dog
         2 |     3 |       2 | Scratch | 2018-10-01 | Cat
         3 |     4 |       3 | Wag     | 2020-03-15 | Dog
         1 |     5 |       1 | Tweet   | 2020-11-28 | Bird
         3 |     6 |       4 | Fluffy  | 2020-09-17 | Dog
         3 |     7 |       2 | Bark    |            | Dog
         2 |     8 |       4 | Meow    |            | Cat
(8 rows)

Notez que le pettypeid colonne n'est renvoyée qu'une seule fois, même s'il existe deux colonnes portant ce nom (une dans chaque table). C'est ainsi que les jointures naturelles traitent les colonnes du même nom dans toutes les tables.