Una unión SQL es donde ejecuta una consulta que une varias tablas.
Este tutorial de uniones SQL presenta ejemplos básicos de uniones SQL, así como una introducción a los distintos tipos de uniones.
Tipos de combinación SQL
El estándar ANSI SQL especifica cinco tipos de uniones, como se enumeran en la siguiente tabla.
| Tipo de unión | Descripción |
|---|---|
 INNER JOIN | Devuelve filas cuando hay al menos una fila en ambas tablas que coincide con la condición de combinación. |
 LEFT OUTER JOIN o LEFT JOIN | Devuelve filas que tienen datos en la tabla de la izquierda (a la izquierda de JOIN palabra clave), incluso si no hay filas coincidentes en la tabla de la derecha. |
 RIGHT OUTER JOIN o RIGHT JOIN | Devuelve filas que tienen datos en la tabla derecha (a la derecha de JOIN palabra clave), incluso si no hay filas coincidentes en la tabla de la izquierda. |
 FULL OUTER JOIN o FULL JOIN | Devuelve todas las filas, siempre que haya datos coincidentes en una de las tablas. |
CROSS JOIN | Devuelve filas que combinan cada fila de la primera tabla con cada fila de la segunda tabla. |
También hay otros términos para varias operaciones de combinación, como las siguientes:
| Unirse | Descripción |
|---|---|
| Auto-unión | Cuando una tabla se une a sí misma. |
| Unión natural | Una unión implícita basada en las columnas comunes de las dos tablas que se unen. |
| Equi-unión | Una combinación que contiene solo comparaciones de igualdad en el predicado de combinación. |
Sintaxis de Unión SQL
Las uniones internas se pueden especificar en FROM o WHERE cláusulas. Las uniones externas y las uniones cruzadas se pueden especificar en FROM cláusula solamente.
Para crear una unión SQL en FROM cláusula, haga algo como esto:
SELECT *
FROM Table1 < JoinType > Table2 [ ON ( JoinCondition ) ]
Donde JoinType especifica qué tipo de combinación se realiza y JoinCondition define el predicado que se evaluará para cada par de filas unidas.
Para especificar una combinación en WHERE cláusula, haga algo como esto:
SELECT *
FROM Table1, Table2 [ WHERE ( JoinCondition ) ]
De nuevo, JoinCondition define el predicado que se evaluará para cada par de filas unidas.
Además, todo lo encerrado entre corchetes ([] ) es opcional.
Tablas de muestra para los ejemplos de este tutorial
La mayoría de los ejemplos de este tutorial realizan uniones en las siguientes dos tablas.
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)
La unión interna
SQL INNER JOIN devuelve filas cuando hay al menos una fila en ambas tablas que coincide con la condición de combinación.
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets
INNER JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId;Resultado:
-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Para especificar una combinación interna en FROM cláusula, usamos INNER JOIN . También usamos el ON palabra clave para definir el predicado que se evaluará para cada par de filas unidas.
Independientemente del tipo de combinación, calificamos los nombres de nuestras columnas con los nombres de las tablas. La razón por la que hacemos esto es para evitar cualquier ambigüedad con respecto a los nombres de las columnas entre las tablas. Ambas tablas pueden tener columnas con el mismo nombre (como en nuestro ejemplo) y, en tales casos, el DBMS no sabrá a qué columna se refiere. Prefijar los nombres de las columnas con sus nombres de tabla asegura que está haciendo referencia a la columna correcta y evita cualquier error que pueda resultar de cualquier ambigüedad sobre a qué columna se está refiriendo.
En este ejemplo, ambas tablas tienen un PetTypeId columna. Las Pets.PetTypeId la columna es una clave externa a PetTypes.PetTypeId columna, que es la clave principal para esa tabla.
En este ejemplo, podemos ver que se devuelven todas las mascotas, pero no todos los tipos de mascotas. No hay conejos en Pets tabla, y así los Rabbits no se devuelve el tipo de mascota.
La razón por la que los Rabbits type no se devuelve porque INNER JOIN solo devuelve filas cuando hay al menos una fila en ambas tablas que coincide con la condición de unión. En este caso, Rabbits está solo en una tabla (los PetTypes tabla).
Tenga en cuenta que el tipo de combinación es opcional. Por lo tanto, la mayoría (si no todos) los DBMS le permiten omitir el INNER palabra clave. Cuando omite esto (es decir, solo especifica JOIN ), se supone que es una combinación interna.
Por lo tanto, podríamos reescribir el ejemplo anterior a esto:
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets
JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId;
Además, como con cualquier sentencia SQL, el FROM la cláusula puede estar en una línea completa si lo prefiere:
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId;Alias
Es una práctica común usar alias de tabla cuando se realizan uniones SQL. Los alias ayudan a que el código sea más conciso y más fácil de leer.
Por lo tanto, podríamos cambiar el ejemplo anterior por este:
SELECT
p.PetName,
pt.PetType
FROM Pets p INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Resultado:
-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Equi-Join
La unión anterior también se puede denominar equi-unión . Una unión equitativa es una unión que contiene solo comparaciones de igualdad en el predicado de unión.
Otra forma de escribir la combinación anterior es así:
SELECT
p.PetName,
pt.PetType
FROM
Pets p,
PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;Resultado:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
Este es un ejemplo de cómo especificar una combinación interna en WHERE cláusula. Simplemente proporcionamos una lista separada por comas de las tablas, y luego un WHERE condición. Si hubiéramos omitido el WHERE condición, habríamos terminado con un CROSS JOIN .
Muchos principiantes encuentran la sintaxis anterior mucho más fácil de entender que INNER JOIN sintaxis. Siéntase libre de usar esta sintaxis si lo prefiere, sin embargo, tenga en cuenta que la mayoría de los profesionales de SQL prefieren usar INNER JOIN sintaxis del ejemplo anterior.
Consulte Combinación interna de SQL para obtener más ejemplos, incluida una combinación interna que une 3 tablas.
La Unión Correcta
También conocido como RIGHT OUTER JOIN , la RIGHT JOIN devuelve filas que tienen datos en la tabla de la derecha (a la derecha de JOIN palabra clave), incluso si no hay filas coincidentes en la tabla de la izquierda.
SELECT
p.PetName,
pt.PetType
FROM Pets p
RIGHT 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 caso, tenemos un PetType extra valor – Rabbit – aunque no haya ninguna mascota en Pets tabla de ese tipo. Esto da como resultado un NULL valor en PetName columna contra Rabbit .
Consulte Unión derecha de SQL para obtener más ejemplos, incluida una unión derecha que une 3 tablas.
La unión izquierda
También conocido como LEFT OUTER JOIN , el SQL LEFT JOIN devuelve filas que tienen datos en la tabla de la izquierda (a la izquierda de JOIN palabra clave), incluso si no hay filas coincidentes en la tabla de la derecha.
Esto es lo opuesto a RIGHT JOIN .
Si cambiamos el ejemplo anterior para usar una combinación izquierda, obtenemos el siguiente resultado.
SELECT
p.PetName,
pt.PetType
FROM Pets p
LEFT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Resultado:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
En este caso particular, nuestros resultados son los mismos que con la unión interna.
Sin embargo, si cambiamos el orden de la tabla en nuestro FROM cláusula, obtendremos un resultado similar a la unión derecha en el ejemplo anterior.
SELECT
p.PetName,
pt.PetType
FROM PetTypes pt
LEFT 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)
Entonces puede ver que cualquier diferencia resultante entre las uniones izquierda y derecha depende únicamente de cómo ordene las columnas en FROM cláusula.
Consulte SQL Left Join para obtener más ejemplos, incluida una combinación izquierda que une 3 tablas.
La unión completa
SQL FULL JOIN (o FULL OUTER JOIN ) devuelve todas las filas, siempre que haya datos coincidentes en una de las tablas.
En otras palabras, es como tener una combinación izquierda y derecha en una combinación.
Este es un ejemplo de una unión completa.
SELECT
p.PetName,
pt.PetType
FROM Pets p
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Resultado:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | | NULL | Rabbit | +-----------+-----------+ (9 rows affected)
Esto devuelve el mismo resultado que obtuvimos con la combinación derecha, pero habría devuelto un resultado diferente si hubiera una fila en la tabla de la izquierda que no tuviera un valor correspondiente en la tabla de la derecha.
Intercambiemos los nombres de las tablas y volvamos a ejecutarlo.
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)
Mismo resultado.
Consulte Combinación completa de SQL para obtener más ejemplos, incluida una combinación completa que une 3 tablas.
La unión cruzada
El SQL CROSS JOIN devuelve filas que combinan cada fila de la primera tabla con cada fila de la segunda tabla.
En otras palabras, devuelve el producto cartesiano de filas de tablas en la combinación.
SELECT
p.PetName,
pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt;Resultado:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Bird | | Fetch | Bird | | Scratch | Bird | | Wag | Bird | | Tweet | Bird | | Fluffy | Bird | | Bark | Bird | | Meow | Bird | | Fluffy | Cat | | Fetch | Cat | | Scratch | Cat | | Wag | Cat | | Tweet | Cat | | Fluffy | Cat | | Bark | Cat | | Meow | Cat | | Fluffy | Dog | | Fetch | Dog | | Scratch | Dog | | Wag | Dog | | Tweet | Dog | | Fluffy | Dog | | Bark | Dog | | Meow | Dog | | Fluffy | Rabbit | | Fetch | Rabbit | | Scratch | Rabbit | | Wag | Rabbit | | Tweet | Rabbit | | Fluffy | Rabbit | | Bark | Rabbit | | Meow | Rabbit | +-----------+-----------+ (32 rows affected)
Como probablemente pueda imaginar, esto podría ser muy peligroso si lo ejecuta en las tablas incorrectas.
Es lo mismo que hacer esto:
SELECT
p.PetName,
pt.PetType
FROM Pets p, PetTypes pt;
Puedes agregar un WHERE cláusula a una unión cruzada, lo que la convertirá en una unión interna.
Así:
SELECT
p.PetName,
pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;Resultado:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Consulte SQL Cross Join para obtener más ejemplos.
La unión natural
El SQL NATURAL JOIN es un tipo de combinación equitativa donde 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.
SELECT
Pets.PetName,
PetTypes.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 realidad, la unión natural no es realmente un tipo de unión, como lo considera el estándar ANSI. Es una palabra clave que puede insertar opcionalmente para que la unión sea natural.
Por lo tanto, podríamos cambiar el ejemplo anterior a NATURAL INNER JOIN si quisiéramos:
SELECT
Pets.PetName,
PetTypes.PetType
FROM Pets NATURAL INNER JOIN PetTypes;
Como se mencionó anteriormente, las combinaciones internas son el tipo de combinación predeterminado, por lo que si omite el tipo de combinación (p. ej., INNER , LEFT , RIGHT , etc.), entonces se trata como una unión interna.
Si el formato de estos resultados se ve diferente a los resultados anteriores, es porque tuve que saltar a PostgreSQL para ejecutar esta consulta. Ejecuté los ejemplos anteriores en SQL Server, pero SQL Server no admite la unión natural.
Consulte Combinación natural de SQL para obtener más ejemplos, incluida una combinación natural que une 3 tablas.
La auto unión
El SELF JOIN de SQL está uniendo una tabla a sí mismo.
Un ejemplo clásico de autocombinación está en una tabla de Empleados. En tal tabla, un empleado podría informar a otro empleado. Por lo tanto, podría usar una unión automática para unirse a la tabla en su columna de ID de empleado y columna de ID de gerente.
Supongamos que tenemos la siguiente tabla:
+--------------+-------------+------------+-------------+ | EmployeeId | FirstName | LastName | ReportsTo | |--------------+-------------+------------+-------------| | 1 | Homer | Connery | NULL | | 2 | Bart | Pitt | 1 | | 3 | Maggie | Griffin | 1 | | 4 | Peter | Farnsworth | 2 | | 5 | Marge | Morrison | NULL | | 6 | Lisa | Batch | 5 | | 7 | Dave | Zuckerberg | 6 | | 8 | Vlad | Cook | 7 | +--------------+-------------+------------+-------------+
Podemos hacer una unión automática en esta tabla para devolver todos los empleados y sus gerentes.
SELECT
CONCAT(e1.FirstName, ' ', e1.LastName) AS Employee,
CONCAT(e2.FirstName, ' ', e2.LastName) AS Manager
FROM Employees e1
LEFT JOIN Employees e2
ON e1.ReportsTo = e2.EmployeeId;Resultado:
+------------------+-----------------+ | Employee | Manager | |------------------+-----------------| | Homer Connery | | | Bart Pitt | Homer Connery | | Maggie Griffin | Homer Connery | | Peter Farnsworth | Bart Pitt | | Marge Morrison | | | Lisa Batch | Marge Morrison | | Dave Zuckerberg | Lisa Batch | | Vlad Cook | Dave Zuckerberg | +------------------+-----------------+
Consulte SQL Self Join para obtener más ejemplos.
