Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Cláusula JOIN
<a name="join-clause"></a>

Se utiliza una cláusula JOIN de SQL para combinar los datos de dos o más tablas en función de los campos comunes. Es posible que los resultados cambien o no cambien según el método de combinación especificado. Las combinaciones externas izquierdas y derechas conservan valores de una de las tablas combinadas cuando no se encuentra una coincidencia en la otra tabla. 

La combinación del tipo JOIN y la condición de unión determina qué filas se incluyen en el conjunto de resultados final. A continuación, las cláusulas SELECT y WHERE controlan qué columnas se devuelven y cómo se filtran las filas. Comprender los diferentes tipos de JOIN y cómo utilizarlos de forma eficaz es una habilidad crucial en SQL, ya que permite combinar datos de varias tablas de forma flexible y eficaz.

## Sintaxis
<a name="join-clause-syntax"></a>

```
SELECT column1, column2, ..., columnn
FROM table1
join_type table2
ON table1.column = table2.column;
```

## Parameters
<a name="join-clause-parameters"></a>

 *SELECCIONE la columna 1, la columna 2,..., la columna N*   
Las columnas que desea incluir en el conjunto de resultados. Puede seleccionar columnas de una o de las dos tablas incluidas en la COMBINACIÓN. 

 *DE LA TABLA 1*   
La primera tabla (izquierda) de la operación JOIN.

 *[UNIÓN \$1 UNIÓN INTERIOR \$1 UNIÓN IZQUIERDA [EXTERIOR] \$1 UNIÓN DERECHA [EXTERIOR] UNIÓN \$1 UNIÓN COMPLETA [EXTERIOR]] Tabla 2:*   
El tipo de UNIÓN que se va a realizar. JOIN o INNER JOIN devuelven solo las filas con valores coincidentes en ambas tablas.   
LEFT [OUTER] JOIN devuelve todas las filas de la tabla de la izquierda, con las filas coincidentes de la tabla de la derecha.   
RIGHT [OUTER] JOIN devuelve todas las filas de la tabla de la derecha, con las filas coincidentes de la tabla de la izquierda.   
FULL [OUTER] JOIN devuelve todas las filas de ambas tablas, independientemente de si coinciden o no.   
CROSS JOIN crea un producto cartesiano de las filas de las dos tablas.

 *EN la tabla1.columna = tabla2.columna*   
La condición de unión, que especifica cómo se hacen coincidir las filas de las dos tablas. La condición de unión se puede basar en una o más columnas.

 *Condición WHERE:*   
Cláusula opcional que se puede utilizar para filtrar aún más el conjunto de resultados en función de una condición específica. 

## Ejemplo
<a name="Join_examples"></a>

El ejemplo siguiente es una combinación entre dos tablas con la cláusula USING. En este caso, las columnas listid y eventid se utilizan como columnas de combinación. Los resultados tienen un límite de cinco filas.

```
select listid, listing.sellerid, eventid, listing.dateid, numtickets
from listing join sales
using (listid, eventid)
order by 1
limit 5;

listid | sellerid | eventid | dateid | numtickets
-------+----------+---------+--------+-----------
1      | 36861    | 7872    | 1850   | 10
4      | 8117     | 4337    | 1970   | 8
5      | 1616     | 8647    | 1963   | 4
5      | 1616     | 8647    | 1963   | 4
6      | 47402    | 8240    | 2053   | 18
```

# Tipos de combinación
<a name="join-types"></a>

## INNER
<a name="inner-join"></a>

Este es el tipo de unión predeterminado. Devuelve las filas que tienen valores coincidentes en ambas referencias de tabla. 

La combinación interna es el tipo de combinación más común que se utiliza en SQL. Es una forma eficaz de combinar datos de varias tablas en función de una columna o conjunto de columnas común. 

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
INNER JOIN table2
ON table1.column = table2.column;
```

La siguiente consulta devolverá todas las filas en las que haya un valor de custome\$1id coincidente entre las tablas de clientes y pedidos. El conjunto de resultados contendrá las columnas customer\$1id, name, order\$1id y order\$1date.

```
SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date
FROM customers
INNER JOIN orders
ON customers.customer_id = orders.customer_id;
```

La siguiente consulta es una combinación interna (sin la palabra clave JOIN) entre la tabla LISTING y la tabla SALES, donde LISTID de la tabla LISTING está entre 1 y 5. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTID 1, 4 y 5 coinciden con los criterios.

```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing, sales
where listing.listid = sales.listid
and listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75
```

El siguiente ejemplo es una combinación interna con la cláusula ON. En este caso, las filas NULL no se devuelven.

```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from sales join listing
on sales.listid=listing.listid and sales.eventid=listing.eventid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75
```

La siguiente consulta es una combinación interna de dos subconsultas en la cláusula FROM. La consulta busca la cantidad de tickets vendidos y sin vender para diferentes categorías de eventos (conciertos y espectáculos). Estas subconsultas de la cláusula FROM son subconsultas de *tabla*; pueden devolver varias columnas y filas.

```
select catgroup1, sold, unsold
from
(select catgroup, sum(qtysold) as sold
from category c, event e, sales s
where c.catid = e.catid and e.eventid = s.eventid
group by catgroup) as a(catgroup1, sold)
join
(select catgroup, sum(numtickets)-sum(qtysold) as unsold
from category c, event e, sales s, listing l
where c.catid = e.catid and e.eventid = s.eventid
and s.listid = l.listid
group by catgroup) as b(catgroup2, unsold)

on a.catgroup1 = b.catgroup2
order by 1;

catgroup1 |  sold  | unsold
----------+--------+--------
Concerts  | 195444 |1067199
Shows     | 149905 | 817736
```

## IZQUIERDA [EXTERIOR]
<a name="left-outer-join"></a>

Devuelve todos los valores de la referencia de la tabla izquierda y los valores coincidentes de la referencia de la tabla derecha, o añade NULL si no hay ninguna coincidencia. También se conoce como *unión exterior izquierda*. 

Devuelve todas las filas de la tabla izquierda (primera) y las filas coincidentes de la tabla derecha (segunda). Si no hay ninguna coincidencia en la tabla de la derecha, el conjunto de resultados contendrá valores NULOS para las columnas de la tabla de la derecha. La palabra clave OUTER se puede omitir y la unión se puede escribir simplemente como LEFT JOIN. Lo opuesto a una unión exterior izquierda es una unión exterior derecha, que devuelve todas las filas de la tabla de la derecha y las filas coincidentes de la tabla de la izquierda.

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
LEFT [OUTER] JOIN table2
ON table1.column = table2.column;
```

La siguiente consulta devolverá todas las filas de la tabla de clientes, junto con las filas coincidentes de la tabla de pedidos. Si un cliente no tiene ningún pedido, el conjunto de resultados seguirá incluyendo la información del cliente, con valores NULOS para las columnas order\$1id y order\$1date.

```
SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date
FROM customers
LEFT OUTER JOIN orders
ON customers.customer_id = orders.customer_id;
```

La siguiente consulta es una combinación externa izquierda. Las combinaciones externas izquierdas y derechas conservan valores de una de las tablas combinadas cuando no se encuentra una coincidencia en la otra tabla. Las tablas izquierda y derecha son la primera tabla y la segunda tabla que aparecen en la sintaxis. Los valores NULL se utilizan para rellenar los "espacios" en el conjunto de resultados. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTIDs 2 y 3 no generaron ninguna venta.

```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing left outer join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     2 | NULL   | NULL
     3 | NULL   | NULL
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75
```

## DERECHA [EXTERIOR]
<a name="right-outer-join"></a>

Devuelve todos los valores de la referencia de la tabla derecha y los valores coincidentes de la referencia de la tabla izquierda, o añade NULL si no hay ninguna coincidencia. También se conoce como *unión exterior derecha*.

Devuelve todas las filas de la tabla derecha (segunda) y las filas coincidentes de la tabla izquierda (primera). Si no hay ninguna coincidencia en la tabla de la izquierda, el conjunto de resultados contendrá valores NULOS para las columnas de la tabla de la izquierda. La palabra clave OUTER se puede omitir y la unión se puede escribir simplemente como RIGHT JOIN. Lo opuesto a una unión exterior derecha es una unión exterior izquierda, que devuelve todas las filas de la tabla izquierda y las filas coincidentes de la tabla derecha.

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
RIGHT [OUTER] JOIN table2
ON table1.column = table2.column;
```

La siguiente consulta devolverá todas las filas de la tabla de clientes, junto con las filas coincidentes de la tabla de pedidos. Si un cliente no tiene ningún pedido, el conjunto de resultados seguirá incluyendo la información del cliente, con valores NULOS para las columnas order\$1id y order\$1date.

```
SELECT orders.order_id, orders.order_date, customers.customer_id, customers.name
FROM orders
RIGHT OUTER JOIN customers
ON orders.customer_id = customers.customer_id;
```

La siguiente consulta es una combinación externa derecha. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTIDs 1, 4 y 5 coinciden con los criterios.

```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing right outer join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75
```

## COMPLETO [EXTERIOR]
<a name="full-join"></a>

Devuelve todos los valores de ambas relaciones, añadiendo valores NULL en el lado que no coincida. También se conoce como *unión externa completa*. 

Devuelve todas las filas de las tablas izquierda y derecha, independientemente de si coinciden o no. Si no hay ninguna coincidencia, el conjunto de resultados contendrá valores NULOS para las columnas de la tabla que no tengan ninguna fila coincidente. La palabra clave OUTER se puede omitir y la unión se puede escribir simplemente como FULL JOIN. La combinación externa completa se usa con menos frecuencia que la unión externa izquierda o la unión externa derecha, pero puede resultar útil en algunos escenarios en los que es necesario ver todos los datos de ambas tablas, incluso si no hay coincidencias.

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
FULL [OUTER] JOIN table2
ON table1.column = table2.column;
```

La siguiente consulta devolverá todas las filas de las tablas de clientes y de pedidos. Si un cliente no tiene ningún pedido, el conjunto de resultados seguirá incluyendo la información del cliente, con valores NULOS para las columnas order\$1id y order\$1date. Si un pedido no tiene ningún cliente asociado, el conjunto de resultados incluirá ese pedido, con valores NULOS para las columnas customer\$1id y name.

```
SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date
FROM customers
FULL OUTER JOIN orders
ON customers.customer_id = orders.customer_id;
```

La siguiente consulta es una combinación completa. Las combinaciones completas retienen valores de las tablas combinadas cuando no se encuentra una coincidencia en la otra tabla. Las tablas izquierda y derecha son la primera tabla y la segunda tabla que aparecen en la sintaxis. Los valores NULL se utilizan para rellenar los "espacios" en el conjunto de resultados. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTIDs 2 y 3 no generaron ninguna venta.

```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing full join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     1 | 728.00 | 109.20
     2 | NULL   | NULL
     3 | NULL   | NULL
     4 |  76.00 |  11.40
     5 | 525.00 |  78.75
```

La siguiente consulta es una combinación completa. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). En los resultados solo aparecen las filas que no generan ventas (LISTIDs 2 y 3).

```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing full join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
and (listing.listid IS NULL or sales.listid IS NULL)
group by 1
order by 1;

listid | price  |  comm
-------+--------+--------
     2 | NULL   | NULL
     3 | NULL   | NULL
```

## [IZQUIERDA] SEMIRREMOLQUE
<a name="left-semi-join"></a>

Devuelve los valores del lado izquierdo de la referencia de la tabla que coinciden con los de la derecha. También se conoce como *semiunión izquierda*. 

Solo devuelve las filas de la tabla izquierda (primera) que tienen una fila coincidente en la tabla derecha (segunda). No devuelve ninguna columna de la tabla de la derecha, solo las columnas de la tabla de la izquierda. El comando LEFT SEMI JOIN es útil cuando se quieren buscar las filas de una tabla que coinciden con las de otra tabla, sin necesidad de devolver ningún dato de la segunda tabla. LEFT SEMI JOIN es una alternativa más eficaz que utilizar una subconsulta con una cláusula IN o EXISTS.

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
LEFT SEMI JOIN table2
ON table1.column = table2.column;
```

La siguiente consulta devolverá solo las columnas customer\$1id y name de la tabla de clientes, para los clientes que tengan al menos un pedido en la tabla de pedidos. El conjunto de resultados no incluirá ninguna columna de la tabla de pedidos.

```
SELECT customers.customer_id, customers.name
FROM customers
LEFT SEMI JOIN orders
ON customers.customer_id = orders.customer_id;
```

## CROSS JOIN
<a name="cross-join"></a>

Devuelve el producto cartesiano de dos relaciones. Esto significa que el conjunto de resultados contendrá todas las combinaciones posibles de filas de las dos tablas, sin aplicar ninguna condición ni filtro.

El método CROSS JOIN resulta útil cuando se necesitan generar todas las combinaciones posibles de datos a partir de dos tablas, como en el caso de crear un informe que muestre todas las combinaciones posibles de información sobre clientes y productos. La COMBINACIÓN CRUZADA es diferente de otros tipos de combinación (COMBINACIÓN INTERIOR, UNIÓN IZQUIERDA, etc.) porque no tiene una condición de unión en la cláusula ON. La condición de unión no es obligatoria para una COMBINACIÓN CRUZADA.

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
CROSS JOIN table2;
```

La siguiente consulta devolverá un conjunto de resultados que contiene todas las combinaciones posibles de customer\$1id, customer\$1name, product\$1id y product\$1name de las tablas de clientes y productos. Si la tabla de clientes tiene 10 filas y la tabla de productos tiene 20 filas, el conjunto de resultados del CROSS JOIN contendrá 10 x 20 = 200 filas.

```
SELECT customers.customer_id, customers.name, products.product_id, products.product_name
FROM customers
CROSS JOIN products;
```

La siguiente consulta es una combinación cruzada o cartesiana de la tabla LISTING y la tabla SALES con un predicado para limitar los resultados. Esta consulta hace coincidir los valores de las columnas LISTID de la tabla VENTAS y los valores LISTIDs 1, 2, 3, 4 y 5 de la tabla LISTING de ambas tablas. Los resultados muestran que 20 filas coinciden con los criterios.

```
select sales.listid as sales_listid, listing.listid as listing_listid
from sales cross join listing
where sales.listid between 1 and 5
and listing.listid between 1 and 5
order by 1,2;

sales_listid | listing_listid
-------------+---------------
1            | 1
1            | 2
1            | 3
1            | 4
1            | 5
4            | 1
4            | 2
4            | 3
4            | 4
4            | 5
5            | 1
5            | 1
5            | 2
5            | 2
5            | 3
5            | 3
5            | 4
5            | 4
5            | 5
5            | 5
```

## ANTIUNIÓN
<a name="anti-join"></a>

Devuelve los valores de la referencia de la tabla izquierda que no coinciden con la referencia de la tabla derecha. También se conoce como *antiunión izquierda*.

La función ANTI JOIN es una operación útil cuando se quieren encontrar las filas de una tabla que no coinciden con las de otra. 

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
LEFT ANTI JOIN table2
ON table1.column = table2.column;
```

La siguiente consulta mostrará todos los clientes que no han realizado ningún pedido.

```
SELECT customers.customer_id, customers.name
FROM customers
LEFT ANTI JOIN orders
ON customers.customer_id = orders.customer_id
WHERE orders.order_id IS NULL;
```

## NATURAL
<a name="natural-join"></a>

Especifica que las filas de las dos relaciones coincidirán implícitamente en igualdad de condiciones en todas las columnas con nombres coincidentes. 

Hace coincidir automáticamente las columnas con el mismo nombre y tipo de datos entre las dos tablas. No requiere que especifique explícitamente la condición de unión en la cláusula ON. Combina todas las columnas coincidentes de las dos tablas en el conjunto de resultados.

La combinación NATURAL es una forma abreviada práctica cuando las tablas que se van a unir tienen columnas con los mismos nombres y tipos de datos. Sin embargo, generalmente se recomienda usar la combinación interna más explícita... La sintaxis ON permite que las condiciones de unión sean más explícitas y fáciles de entender.

**Sintaxis:**

```
SELECT column1, column2, ..., columnn
FROM table1
NATURAL JOIN table2;
```

El siguiente ejemplo es una unión natural entre dos tablas `employees` y`departments`, con las siguientes columnas: 
+ `employees`tabla:`employee_id`,`first_name`,`last_name`, `department_id `
+ `departments`mesa:`department_id`, `department_name `

La siguiente consulta devolverá un conjunto de resultados que incluye el nombre, los apellidos y el nombre del departamento de todas las filas coincidentes entre las dos tablas, según la `department_id` columna.

```
SELECT e.first_name, e.last_name, d.department_name
FROM employees e
NATURAL JOIN departments d;
```

El ejemplo siguiente es una combinación natural entre dos tablas. En este caso, las columnas listid, sellerid, eventid y dateid tienen nombres y tipos de datos idénticos en ambas tablas y, por lo tanto, se utilizan como columnas de combinación. Los resultados tienen un límite de cinco filas.

```
select listid, sellerid, eventid, dateid, numtickets
from listing natural join sales
order by 1
limit 5;

listid | sellerid  | eventid | dateid | numtickets
-------+-----------+---------+--------+-----------
113    | 29704     | 4699    | 2075   | 22
115    | 39115     | 3513    | 2062   | 14
116    | 43314     | 8675    | 1910   | 28
118    | 6079      | 1611    | 1862   | 9
163    | 24880     | 8253    | 1888   | 14
```