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 | [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 dePets
la tabla es una clave externa delPetTypeId
de losPetTypes
tabla (que es la clave principal de esa tabla). - El
OwnerId
columna dePets
la tabla es una clave externa delOwnerId
columna de losOwners
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.