Combinación natural de SQL

Este artículo proporciona una descripción general de la unión natural en SQL, así como algunos ejemplos básicos.

¿Qué es una unión natural?

La combinación natural de SQL es un tipo de equi-join que combina implícitamente tablas basadas en columnas con el mismo nombre y tipo. El predicado de combinación surge implícitamente al comparar todas las columnas en ambas tablas que tienen los mismos nombres de columna en las tablas combinadas.

El conjunto de resultados contiene solo una columna para cada par de columnas con el mismo nombre. Si no se encuentran columnas con los mismos nombres, el resultado será una unión cruzada.

Sintaxis

Se puede aplicar una unión natural a cualquier INNER , LEFT , RIGHT o FULL entrar. Simplemente anteponga el tipo de combinación con el NATURAL palabra clave.

Ejemplo de la sintaxis utilizada en una unión interna:

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

Ver como INNER es el valor predeterminado, también puede hacerlo así:

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

El NATURAL la palabra clave coloca un USING implícito cláusula a las restricciones de unión. Forma un USING lista que consta de todos los nombres de columna que aparecen en ambas tablas de entrada. Obviamente, esto solo se aplica a los DBMS que admiten el USING cláusula.

No todos los DBMS admiten uniones naturales, así que consulte la documentación de su DBMS.

Mientras escribo esto, las uniones naturales son compatibles con PostgreSQL, MySQL, MariaDB, SQLite y Oracle. Sin embargo, las uniones naturales no son compatibles con SQL Server (2019).

Ejemplos

Aquí hay algunos ejemplos para demostrar.

Datos de muestra

Primero, aquí están las tablas que usaremos para los ejemplos.

Los PetTypes tabla:

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

Las Pets tabla:

+---------+-------------+-----------+-----------+------------+
| 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)

Los Owners tabla:

+-----------+-------------+------------+----------------+-------------------+
| 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] |
+-----------+-------------+------------+----------------+-------------------+

Tenga en cuenta que:

• El PetTypeId columna de Pets la tabla es una clave externa del PetTypeId de los PetTypes tabla (que es la clave principal de esa tabla).
• El OwnerId columna de Pets la tabla es una clave externa del OwnerId columna de los Owners mesa.

Ejemplo 1:unión interna natural

Este es un ejemplo de cómo realizar una combinación interna natural en dos de esas tablas.

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Resultado:

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

En este ejemplo, la combinación natural unió implícitamente las tablas en los dos PetTypeId columnas (es decir, Pets.PetTypeId y la columna PetTypes.PetTypeId columna).

Esta es una forma implícita de hacer lo siguiente:

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

Que en realidad hace lo siguiente.

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

Ejemplo 2:Unión por derecho natural

Aquí hay un ejemplo de cómo realizar una combinación derecha natural contra dos de esas tablas. Esta vez tenemos que especificar el tipo de combinación, ya que no queremos la combinación interna (predeterminada).

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

Resultado:

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

En este caso, es lo mismo que hacer lo siguiente:

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

Ejemplo 3:Unión completa natural en 3 tablas

Este es un ejemplo de cómo realizar una unión completa natural en las tres tablas.

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

Resultado:

 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)

Esta vez tenemos un dueño de mascota que no tiene mascota, así como un tipo de mascota que no está asignado a una mascota.

Ejemplo 4:uso del asterisco (* ) Carácter comodín

Aquí hay un ejemplo que usa el carácter comodín asterisco (*) para seleccionar todas las columnas.

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Resultado:

 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)

Tenga en cuenta que el pettypeid columna solo se devuelve una vez, aunque hay dos columnas con ese nombre (una en cada tabla). Así es como las uniones naturales tratan las columnas del mismo nombre en las tablas.