> ## Documentation Index
> Fetch the complete documentation index at: https://villagesql.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# CROSS JOIN no MySQL

> Como um CROSS JOIN do MySQL combina cada linha de uma tabela com cada linha de outra, quantas linhas isso produz, e como distinguir um intencional de um acidente.

> [card] [VillageSQL is a drop-in replacement for MySQL with extensions.](https://villagesql.com/docs/en/8.4/stable/install-server.md)
>
> All examples on this page work on VillageSQL. Install Now →

Um `CROSS JOIN` combina cada linha de uma tabela com cada linha de outra. Você
não escreve nenhuma condição `ON`, porque nada está sendo correspondido. É o join que
você pede quando quer todas as combinações, e o que você obtém por acidente quando
deixa uma cláusula `ON` de fora.

Abra o cliente com `mysql -u root -p sakila` antes de começar.

## Como CROSS JOIN funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM FIRST_TABLE
CROSS JOIN SECOND_TABLE;
```

Substitua `COLUMN_LIST` pelas colunas que você quer, e `FIRST_TABLE` e
`SECOND_TABLE` pelas tabelas a combinar. O resultado contém 1 linha
para cada par possível, então seu tamanho é a contagem de linhas da primeira tabela
multiplicada pela da segunda. 6 linhas cruzadas com 2 linhas dão 12.

## Exemplos

### Todas as combinações

O Sakila tem 6 idiomas e 2 lojas.

```sql theme={null}
SELECT l.name, s.store_id
FROM language AS l
CROSS JOIN store AS s
ORDER BY l.name, s.store_id;
```

```text theme={null}
+----------+----------+
| name     | store_id |
+----------+----------+
| English  |        1 |
| English  |        2 |
| French   |        1 |
| French   |        2 |
| German   |        1 |
| German   |        2 |
| Italian  |        1 |
| Italian  |        2 |
| Japanese |        1 |
| Japanese |        2 |
| Mandarin |        1 |
| Mandarin |        2 |
+----------+----------+
12 rows in set (0.00 sec)
```

Cada idioma aparece uma vez por loja. Nada aqui diz que uma loja tem filmes
naquele idioma: as linhas são combinações, não fatos sobre os dados. Esse é
o objetivo da consulta. Uma grade como esta é uma forma inicial quando você quer uma
linha para cada par, tenha acontecido algo para ele ou não.

### A vírgula é a grafia mais antiga

```sql theme={null}
SELECT l.name, s.store_id
FROM language AS l, store AS s
ORDER BY l.name, s.store_id;
```

```text theme={null}
+----------+----------+
| name     | store_id |
+----------+----------+
| English  |        1 |
| English  |        2 |
| French   |        1 |
| French   |        2 |
| German   |        1 |
| German   |        2 |
| Italian  |        1 |
| Italian  |        2 |
| Japanese |        1 |
| Japanese |        2 |
| Mandarin |        1 |
| Mandarin |        2 |
+----------+----------+
12 rows in set (0.00 sec)
```

As mesmas 12 linhas. Uma vírgula entre 2 tabelas no `FROM` é um cross join. Você vai
encontrá-la em SQL mais antigo, muitas vezes com a condição de correspondência lá embaixo no `WHERE`, o que
funciona e esconde que tipo de join você está lendo.

Uma vírgula tem precedência mais baixa do que `JOIN`, então uma cláusula `ON` não consegue alcançar uma tabela
do outro lado de uma vírgula. As 2 grafias aparecem juntas em consultas
reais, e isto é o que dá errado quando aparecem.

```sql theme={null}
SELECT COUNT(*) FROM film f, language l JOIN store s ON s.store_id = f.language_id;
```

```text theme={null}
ERROR 1054 (42S22): Unknown column 'f.language_id' in 'on clause'
```

Escreva `CROSS JOIN` quando for isso que você quer, e mantenha uma única grafia por consulta.

A palavra-chave também não impõe a regra. O MySQL aceita uma cláusula `ON` em um
`CROSS JOIN` e então se comporta como um `INNER JOIN`, então a palavra na consulta não
é prova do join que você obteve.

```sql theme={null}
SELECT COUNT(*) AS rows_returned
FROM film AS f CROSS JOIN language AS l ON f.language_id = l.language_id;
```

```text theme={null}
+---------------+
| rows_returned |
+---------------+
|          1000 |
+---------------+
1 row in set (0.00 sec)
```

1.000 em vez de 6.000: cada filme correspondido ao seu próprio idioma. Leia a cláusula
`ON`, não a palavra-chave, para saber o que um join faz.

## O número cresce rápido

12 linhas é inofensivo. A mesma operação nas tabelas que você normalmente consulta não é.

```sql theme={null}
SELECT f.title, l.name
FROM film AS f
CROSS JOIN language AS l
ORDER BY f.title, l.name;
```

```text theme={null}
+-----------------------------+----------+
| title                       | name     |
+-----------------------------+----------+
| ACADEMY DINOSAUR            | English  |
| ACADEMY DINOSAUR            | French   |
| ACADEMY DINOSAUR            | German   |
...
+-----------------------------+----------+
6000 rows in set (0.01 sec)
```

1.000 filmes vezes 6 idiomas são 6.000 linhas, e cada filme agora aparece com todos os 6
idiomas. Cruze 2 tabelas de 10.000 linhas cada e a resposta tem 100 milhões de
linhas, que é como uma consulta que deveria ter sido instantânea roda até alguém
matá-la.

O MySQL aceita `INNER JOIN` sem cláusula `ON` e o trata como um `CROSS JOIN`. Então quando um
join retorna um número suspeitosamente redondo e suspeitosamente grande, um `ON` ausente
é a primeira coisa a verificar. A lição [INNER JOIN](https://villagesql.com/docs/pt-BR/tutorial/inner-join.md)
mostra esse acidente.

## Resumo

* Use `CROSS JOIN` para combinar cada linha de uma tabela com cada linha de outra.
* Não escreva nenhuma cláusula `ON`, porque nada está sendo correspondido.
* Espere que o MySQL aceite `CROSS JOIN ... ON` mesmo assim, e o trate como um inner join.
* Multiplique as 2 contagens de linhas para saber o tamanho antes de executar.
* Leia uma vírgula entre tabelas no `FROM` como um cross join, e mantenha 1 grafia por consulta.
* Suspeite de um `ON` ausente quando um join retorna um número redondo e grande de linhas.

## Veja também

* [Como os joins funcionam](https://villagesql.com/docs/pt-BR/tutorial/joins.md) — onde este fica entre os outros tipos
* [INNER JOIN](https://villagesql.com/docs/pt-BR/tutorial/inner-join.md) — o join que, em vez disso, faz a correspondência entre linhas
* [Aliases de tabela](https://villagesql.com/docs/pt-BR/tutorial/table-aliases.md) — os nomes curtos que estas consultas usam
* [Desempenho de JOIN no MySQL e erros comuns](https://villagesql.com/docs/pt-BR/guides/joins.md) — o acidente, visto do outro lado


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.