Unión completa de SQL

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

SQL FULL JOIN (o FULL OUTER JOIN ) devuelve todas las filas, siempre que haya datos coincidentes en una de las tablas.

Es como tener una combinación de izquierda y derecha en una sola combinación.

Sintaxis

Especificas una unión completa en el FROM cláusula. Puede usar el FULL JOIN o FULL OUTER JOIN sintaxis.

Usando FULL JOIN sintaxis:

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

Usando FULL OUTER JOIN sintaxis:

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

Ambos hacen exactamente lo mismo. Es solo que el OUTER la palabra clave es opcional.

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

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.

La consulta de unión completa

Este es un ejemplo de cómo realizar una unión completa en dos de esas tablas.

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

Resultado:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

En este ejemplo, obtenemos un PetType valor que no se corresponde con un PetName . Esto se debe a que no hay conejos como mascotas. Pero la unión completa provoca Rabbit para ser devuelto, aunque no haya ninguna mascota en Pets tabla de ese tipo. Esto da como resultado un NULL valor en PetName columna contra Rabbit .

Este es el mismo resultado que habríamos obtenido si hubiéramos usado una unión derecha, porque los PetTypes la tabla está a la derecha de JOIN palabra clave. Esto no habría sucedido con una combinación izquierda, porque PetTypes la tabla no está a la izquierda de JOIN palabra clave. Si quisiéramos recrearlo con una combinación izquierda, tendríamos que cambiar el orden de las tablas, de modo que PetTypes la tabla estaba a la izquierda de JOIN palabra clave.

Esto es lo que sucede si cambiamos el orden de la tabla en nuestra consulta cuando usamos una unión completa.

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

Resultado:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

Obtenemos exactamente el mismo resultado. Esto se debe a que la combinación completa devuelve todas las filas, siempre que haya datos coincidentes en una de las tablas. Como se mencionó, es como tener una combinación izquierda y derecha en una combinación.

Unión completa en 3 mesas

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

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;

Resultado:

+-----------+-----------+----------------+
| 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 |
| NULL      | Rabbit    |                |
+-----------+-----------+----------------+
(10 rows affected)

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.

Si cambiamos el orden de las tablas, obtenemos el mismo resultado, aunque las filas se enumeran en un orden diferente.

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;

Resultado:

-----------+-----------+----------------+
| 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    |                |
| NULL      | NULL      | Woody Eastwood |
+-----------+-----------+----------------+
(10 rows affected)

Y si los mezclamos una vez más, obtenemos el mismo resultado.

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;

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    |
| NULL      | NULL      | Woody Eastwood |
| NULL      | Rabbit    |                |
+-----------+-----------+----------------+
(10 rows affected)

Si te preguntas por qué el último PetOwner no es NULL (como el último PetName is), es porque es el resultado de una concatenación de cadenas. Usé T-SQL CONCAT() función para concatenar el nombre y apellido del propietario.