Combinación cruzada de SQL

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

El SQL CROSS JOIN (o FULL OUTER 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.

Sintaxis

Usted especifica una unión cruzada en el FROM cláusula.

La sintaxis es así:

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

Ejemplo 1

Aquí hay un ejemplo para demostrarlo.

Datos de muestra

Primero, aquí están las tablas que usaremos para el ejemplo.

El t1 tabla:

+--------+
| col1   |
|--------|
| a      |
| b      |
| c      |
+--------+

El t2 tabla:

+--------+
| col1   |
|--------|
| 1      |
| 2      |
| 3      |
+--------+

La consulta de unión cruzada

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

SELECT * FROM t1 
CROSS JOIN t2;

Resultado:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| b      | 1      |
| c      | 1      |
| a      | 2      |
| b      | 2      |
| c      | 2      |
| a      | 3      |
| b      | 3      |
| c      | 3      |
+--------+--------+
(9 rows affected)

Entonces, nuestra consulta devuelve 9 filas, aunque solo hay 3 filas en cada tabla.

Esto se debe a la forma en que funciona la unión cruzada. El número de filas devuelto es el número de filas de la tabla de la izquierda, multiplicado por el número de filas de la tabla de la derecha.

Vea cómo itera a través de la tabla de la izquierda, generando cada fila de la tabla de la derecha para cada fila de la tabla de la izquierda.

Esto tiene el mismo efecto que hacer lo siguiente:

SELECT * FROM t1, t2

Resultado:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| b      | 1      |
| c      | 1      |
| a      | 2      |
| b      | 2      |
| c      | 2      |
| a      | 3      |
| b      | 3      |
| c      | 3      |
+--------+--------+
(9 rows affected)

Ejemplo 2

Esto es lo que sucede si agregamos un WHERE cláusula a nuestra unión cruzada.

SELECT * FROM t1 
CROSS JOIN t2
WHERE t1.col1 = 'a';

Resultado:

+--------+--------+
| col1   | col1   |
|--------+--------|
| a      | 1      |
| a      | 2      |
| a      | 3      |
+--------+--------+
(3 rows affected)

Ejemplo 3

Supongamos que tenemos las siguientes 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)

En este caso, el Pets.PetTypeId la columna es una clave externa de PetTypes.PetTypeId columna.

Ahora, aquí hay un ejemplo de cómo ejecutar una combinación cruzada en esas dos tablas, pero usando un WHERE cláusula.

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)

Agregando el WHERE la cláusula a la combinación cruzada la convirtió en una combinación interna.

Esto es lo que sucede si eliminamos WHERE cláusula.

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)

Obtenemos una unión cruzada que devuelve 32 filas.