SQL Cross Join

Este artigo fornece uma visão geral do CROSS JOIN em SQL, bem como alguns exemplos básicos.

O SQL CROSS JOIN (ou FULL OUTER JOIN ) retorna linhas que combinam cada linha da primeira tabela com cada linha da segunda tabela.

Em outras palavras, ele retorna o produto cartesiano das linhas das tabelas na junção.

Sintaxe

Você especifica uma junção cruzada no FROM cláusula.

A sintaxe fica assim:

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

Exemplo 1

Aqui está um exemplo para demonstrar.

Dados de amostra

Primeiro, aqui estão as tabelas que usaremos para o exemplo.

O t1 tabela:

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

O t2 tabela:

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

A consulta de junção cruzada

Aqui está um exemplo de execução de uma junção cruzada nessas duas tabelas.

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)

Portanto, nossa consulta retorna 9 linhas, embora haja apenas 3 linhas em cada tabela.

Isso se deve ao modo como a junção cruzada funciona. O número de linhas retornado é o número de linhas na tabela à esquerda, multiplicado pelo número de linhas na tabela à direita.

Veja como ele itera pela tabela à esquerda, gerando cada linha na tabela à direita para cada linha na tabela à esquerda.

Isso tem o mesmo efeito que fazer o seguinte:

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)

Exemplo 2

Veja o que acontece se adicionarmos um WHERE cláusula para nossa junção cruzada.

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

Resultado:

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

Exemplo 3

Suponha que temos as seguintes tabelas.

Os PetTypes tabela:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Os Pets tabela:

+---------+-------------+-----------+-----------+------------+
| 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)

Nesse caso, o Pets.PetTypeId coluna é uma chave estrangeira do PetTypes.PetTypeId coluna.

Agora, aqui está um exemplo de execução de uma junção cruzada nessas duas tabelas, mas usando um 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)

Adicionando o WHERE cláusula para a junção cruzada transformou-a em uma junção interna.

Veja o que acontece se removermos o 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)

Obtemos uma junção cruzada que retorna 32 linhas.