Introducción a las uniones SQL

Tradicionalmente, extrae datos de dos o más tablas usando un WHERE cláusula en una consulta. Pero en un sistema de base de datos relacional (RDBMS), esto se puede lograr usando un solo SELECT consulta. Este es el verdadero poder de los sistemas de bases de datos relacionales. En esta guía, aprenderá sobre SQL Joins, una forma poderosa de comparar y seleccionar filas y tablas.

¿Qué es un SQL Join?

En SQL, un join La cláusula amplía la capacidad de comparar y seleccionar filas de tablas. Utiliza un proceso algebraico de combinar filas de dos o más tablas en función de una columna relacionada en esas tablas. Según la definición de SQL estándar ANSI, hay cinco tipos de uniones:uniones cruzadas , uniones internas , Uniones izquierdas (externas) , Uniones derechas (externas) y Combinaciones completas (externas) . Estas uniones se implementan en todos los sistemas de bases de datos relacionales y se tratan en las secciones a continuación.

Nota Las uniones se pueden realizar en cualquier número de tablas en una consulta determinada. Para mayor brevedad y claridad, esta guía analiza las uniones aplicadas a dos tablas.

Esta guía utiliza dos tablas, Employees y Address , respectivamente, para demostrar las uniones SQL. Cada una de estas tablas contiene las siguientes definiciones de columna y datos:

• Tabla de empleados

  EmpleadoId	Nombre del empleado
  1	Juan
  2	María
  3	Roberto

• Tabla de direcciones

  Id	Estado
  1	Nueva York
  2	Nueva Jersey
  3	Idaho
  4	Hawái

Nota A menos que se indique lo contrario, todos los comandos de esta guía funcionan bien tanto en MySQL y PostgreSQL bases de datos.

Combinaciones cruzadas de SQL

También conocida como Unión cartesiana , las uniones cruzadas ocurren cuando especifica varias tablas como fuente para su SELECT lista de columnas En este caso, omite el WHERE Expresión de unión de cláusula para hacer coincidir las filas. El conjunto de resultados contiene una fila para cada combinación de filas entre las tablas. En un escenario de dos tablas, cada fila de una tabla se empareja con cada fila de la otra tabla. El producto resultante se conoce como Producto cartesiano de las dos mesas. La sintaxis de Cross Join es la siguiente:

(# Rows in Table A) TIMES (# of Rows in Table B)

Nota

En la teoría de conjuntos, el producto cartesiano es una operación de multiplicación que genera todos los pares ordenados de los conjuntos dados. Por ejemplo, considere establecer A con elementos {a,b} y establecer B con elementos {1,2,3} . El producto cartesiano de A y B se denota por AxB y el resultado es el siguiente:

AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}

La sintaxis SQL para Cross Join es la siguiente:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM [Table_1]
     CROSS JOIN [Table_2]

De la sintaxis anterior, Column_1 , Column_2 , Column_N representan las columnas en una tabla, y el CROSS JOIN cláusula sirve para combinar las dos tablas, Table_1 y Table_2 . De las tablas de ejemplo anteriores, si necesita realizar una unión cruzada en Employees y Address tablas, use el siguiente código SQL:

SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address

El resultado del código SQL anterior se parece al siguiente:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| John         |   New Jersey |
| John         |   Idaho      |
| John         |   Hawaii     |
| John         |   New York   |
| Mary         |   New York   |
| Mary         |   New Jersey |
| Mary         |   Idaho      |
| Mary         |   Hawaii     |
| Robert       |   New York   |
| Robert       |   New Jersey |
| Robert       |   Idaho      |
| Robert       |   Hawaii     |
+------------+----------------+

Unión interna de SQL

Una combinación interna devuelve filas que tienen valores coincidentes en ambas tablas. Si no hay registros coincidentes, no se devuelven filas en los resultados.

La sintaxis SQL para Inner Join es la siguiente:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;

En el ejemplo anterior, key es la clave respectiva de las tablas. Si necesita realizar una unión interna en Employees y Address tablas, use el siguiente código SQL:

SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id

El resultado del código SQL anterior se parece al siguiente:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
+------------+----------------+

Unión izquierda (externa) de SQL

Una combinación izquierda devuelve un conjunto completo de filas de la tabla de la izquierda junto con las filas coincidentes de la tabla de la derecha. Si no hay registros coincidentes, entonces NULL los valores se devuelven de la tabla de la derecha.

Nota Algunas implementaciones de bases de datos relacionales usan las palabras clave "Unión externa izquierda", en lugar de "Unión izquierda", pero son funcionalmente equivalentes.

La sintaxis SQL para Left Join es la siguiente:

SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key

En el ejemplo anterior, key es la clave respectiva de las tablas. Si necesita realizar una combinación izquierda en Employees y Address tablas, use el siguiente código SQL:

SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id

El resultado del código SQL anterior es el siguiente:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| Robert       |   NULL       |
+------------+----------------+

Unión SQL derecha (externa)

Un Right Join devuelve un conjunto completo de filas de la tabla de la derecha y las filas coincidentes de la tabla de la izquierda. Esto también se conoce como unión externa derecha. Si no hay registros coincidentes, entonces NULL los valores se devuelven desde la tabla de la derecha, para las filas afectadas en la tabla de la izquierda.

Nota Algunas implementaciones de bases de datos relacionales usan las palabras clave "Unión externa derecha", en lugar de "Unión derecha", pero son funcionalmente equivalentes.

La sintaxis SQL para una combinación derecha es la siguiente:

SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key

Desde el código anterior, key es la clave respectiva de las tablas. Si necesita realizar una combinación correcta en Employees y Address tablas, use el siguiente código SQL:

SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id

El resultado del código SQL anterior es el siguiente:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| NULL         |   Idaho      |
| NULL         |   Hawaii     |
+------------+----------------+

Unión completa (externa) de SQL

Una combinación completa devuelve todas las filas de la tabla de la izquierda, todas las filas de la tabla de la derecha. Esto también se conoce como Full Outer Join. Una combinación completa también devuelve todos los registros coincidentes de ambas tablas cuando estén disponibles. Si no hay registros coincidentes, entonces NULL los valores se devuelven de la tabla de la izquierda. También devuelve NULL valores de la tabla de la derecha.

Nota Algunas implementaciones de bases de datos relacionales usan las palabras clave "Full Outer Join", en lugar de "Full Join", pero son funcionalmente equivalentes.

La sintaxis SQL para Full Join es la siguiente:

SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key

En el código anterior, key es la clave respectiva de las tablas. Si necesita realizar una unión completa en Employees y Address tablas, use el siguiente código SQL:

SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id

El resultado del código SQL anterior es el siguiente:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| Robert       |   NULL       |
| NULL         |   Idaho      |
| NULL         |   Hawaii     |
+------------+----------------+

Nota Durante los cálculos de unión, si compara los datos de la tabla con NULL valores, no coinciden entre sí. Por lo tanto, NULL los valores solo se devuelven como parte de los resultados de Join y se ignoran durante los cálculos de Join.

Comparación de rendimiento de uniones SQL

Teniendo en cuenta las tablas de ejemplo anteriores, la combinación interna suele ser la más rápida de las cinco cláusulas de combinación en términos de rendimiento de la base de datos. Left Join y Right Join son los siguientes más rápidos según el tamaño de las dos tablas. La combinación completa suele ser más lenta que la combinación izquierda o la combinación derecha. Cross Join, que depende del producto cartesiano de las dos tablas, suele ser el más lento en términos de rendimiento de la base de datos. La jerarquía de rendimiento especificada puede diferir según la longitud de la columna de la tabla, el tipo de datos de la columna y las definiciones clave.

Conclusión

El uso de SQL Joins amplía la funcionalidad de poder comparar filas de tablas, sobre WHERE tradicional Consultas de cláusulas. Las uniones son un mecanismo valioso para aplicar la lógica algebraica a dos o más tablas.