> ## 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.

# Self join no MySQL

> Como juntar uma tabela do MySQL a ela mesma para comparar suas próprias linhas, por que a consulta precisa de 2 aliases, e a condição que impede que cada par apareça duas vezes.

> [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 self join lê 1 tabela duas vezes na mesma consulta, para que você possa comparar as linhas dela
entre si. É assim que você responde a perguntas sobre pares: quais linhas
compartilham um valor, qual linha é maior do que qual.

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

## Como um self join funciona

```sql theme={null}
SELECT FIRST_ALIAS.COLUMN_NAME, SECOND_ALIAS.COLUMN_NAME
FROM TABLE_NAME AS FIRST_ALIAS
JOIN TABLE_NAME AS SECOND_ALIAS
  ON FIRST_ALIAS.COLUMN_NAME = SECOND_ALIAS.COLUMN_NAME;
```

Substitua `TABLE_NAME` pela tabela, `FIRST_ALIAS` e `SECOND_ALIAS` por 2
nomes diferentes para ela, e cada `COLUMN_NAME` pela coluna que está sendo comparada.

Nada mais muda no join. O servidor não tem ideia de que os 2 lados são uma só
tabela, e os trata como trataria qualquer outro par.

## Os aliases não são opcionais

Sem eles, a consulta chama 2 coisas de `actor` e não consegue distingui-las.

```sql theme={null}
SELECT first_name FROM actor JOIN actor ON actor.last_name = actor.last_name LIMIT 1;
```

```text theme={null}
ERROR 1066 (42000): Not unique table/alias: 'actor'
```

`ERROR 1066` é o servidor dizendo que precisa de um nome para cada lado.

## Exemplos

### Linhas que compartilham um valor

Alguns atores do Sakila têm o mesmo sobrenome. Isto forma pares de cada um deles com os outros.

```sql theme={null}
SELECT a1.first_name, a1.last_name, a2.first_name AS also_named
FROM actor AS a1
JOIN actor AS a2 ON a1.last_name = a2.last_name AND a1.actor_id < a2.actor_id
ORDER BY a1.last_name, a1.first_name, a2.first_name;
```

```text theme={null}
+-------------+-------------+-------------+
| first_name  | last_name   | also_named  |
+-------------+-------------+-------------+
| CHRISTIAN   | AKROYD      | DEBBIE      |
| CHRISTIAN   | AKROYD      | KIRSTEN     |
| KIRSTEN     | AKROYD      | DEBBIE      |
| CUBA        | ALLEN       | KIM         |
| CUBA        | ALLEN       | MERYL       |
| KIM         | ALLEN       | MERYL       |
...
+-------------+-------------+-------------+
108 rows in set (0.00 sec)
```

3 atores se chamam AKROYD, o que forma 3 pares entre eles.

### Compare linhas por um número

A mesma forma responde "quais filmes duram exatamente o mesmo que quais". Isto restringe
a pergunta aos filmes mais longos do catálogo.

```sql theme={null}
SELECT f1.title, f2.title AS same_length, f1.length
FROM film AS f1
JOIN film AS f2 ON f1.length = f2.length AND f1.film_id < f2.film_id
WHERE f1.length = 185
ORDER BY f1.title, f2.title;
```

```text theme={null}
+--------------------+--------------------+--------+
| title              | same_length        | length |
+--------------------+--------------------+--------+
| CHICAGO NORTH      | CONTROL ANTHEM     |    185 |
| CHICAGO NORTH      | DARN FORRESTER     |    185 |
| CHICAGO NORTH      | GANGS PRIDE        |    185 |
...
+--------------------+--------------------+--------+
45 rows in set (0.00 sec)
```

10 filmes duram 185 minutos, e 45 é o número de pares que você consegue formar com 10
coisas.

## O que a segunda condição está fazendo

`a1.actor_id < a2.actor_id` é o que mantém cada par uma única vez e impede que um ator
forme par consigo mesmo. Retire essa condição e a mesma consulta responde a outra
coisa.

```sql theme={null}
SELECT a1.first_name, a1.last_name, a2.first_name AS also_named
FROM actor AS a1
JOIN actor AS a2 ON a1.last_name = a2.last_name
ORDER BY a1.last_name, a1.first_name, a2.first_name;
```

```text theme={null}
+-------------+--------------+-------------+
| first_name  | last_name    | also_named  |
+-------------+--------------+-------------+
| CHRISTIAN   | AKROYD       | CHRISTIAN   |
| CHRISTIAN   | AKROYD       | DEBBIE      |
| CHRISTIAN   | AKROYD       | KIRSTEN     |
| DEBBIE      | AKROYD       | CHRISTIAN   |
| DEBBIE      | AKROYD       | DEBBIE      |
| DEBBIE      | AKROYD       | KIRSTEN     |
...
+-------------+--------------+-------------+
416 rows in set (0.00 sec)
```

416 linhas em vez de 108, e 2 tipos de linha se infiltraram. `CHRISTIAN AKROYD`
forma par consigo mesmo, porque a própria linha dele satisfaz `a1.last_name =
a2.last_name`. E `CHRISTIAN` com `DEBBIE` aparece, depois `DEBBIE` com
`CHRISTIAN`, que é o mesmo par escrito ao contrário.

Comparar os ids com `<` corrige os dois problemas de uma vez. Isso impede que a linha corresponda a
si mesma, porque nenhum id é menor do que ele mesmo, e mantém apenas 1 arranjo de
cada par genuíno. Use `<` sempre que um self join estiver procurando pares.

## Resumo

* Use um self join para comparar as linhas de 1 tabela entre si.
* Dê à tabela 2 aliases, porque `ERROR 1066` é o que você recebe sem eles.
* Compare as chaves primárias dos 2 aliases com `<` quando quiser cada par uma única vez.
* Espere que uma linha corresponda a si mesma se você não excluir essa possibilidade.

## Veja também

* [Aliases de tabela](https://villagesql.com/docs/pt-BR/tutorial/table-aliases.md) — a nomeação de que esta consulta depende
* [INNER JOIN](https://villagesql.com/docs/pt-BR/tutorial/inner-join.md) — o join do qual um self join é um caso especial
* [Como os joins funcionam](https://villagesql.com/docs/pt-BR/tutorial/joins.md) — onde ele se encaixa entre os outros tipos
* [Desempenho de JOIN no MySQL e erros comuns](https://villagesql.com/docs/pt-BR/guides/joins.md) — o que um self join custa em uma tabela grande


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