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

# UNION no MySQL

> Como UNION empilha as linhas de 2 consultas do MySQL em 1 resultado, o que o separa de UNION ALL, e a única regra com que as 2 consultas realmente precisam concordar.

> [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 join coloca tabelas lado a lado e alarga o resultado. `UNION` empilha resultados
um sobre o outro e o alonga. Recorra a ele quando 2 consultas produzem a
mesma forma de linha e você as quer em 1 lista.

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

## Como UNION funciona

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

Substitua cada `COLUMN_LIST` pelas colunas que você quer, e `FIRST_TABLE` e
`SECOND_TABLE` pelas tabelas a ler.

As 2 consultas precisam retornar o mesmo número de colunas, e o servidor casa
essas colunas pela posição, e não pelo nome.

`UNION` remove linhas duplicadas. `UNION ALL` as mantém, e é mais rápido porque
não precisa comparar nada.

## Exemplos

### UNION remove duplicatas

As duas metades aqui são a mesma consulta, então toda linha da segunda é uma duplicata
de uma linha da primeira.

```sql theme={null}
SELECT rating FROM film UNION SELECT rating FROM film;
```

```text theme={null}
+--------+
| rating |
+--------+
| PG     |
| G      |
| NC-17  |
| PG-13  |
| R      |
+--------+
5 rows in set (0.00 sec)
```

5 linhas de 2.000. `UNION` desduplica o resultado combinado em 1 passagem, então
as repetições dentro de uma metade são tratadas da mesma forma que as repetições entre as metades. A resposta
é igual à de [SELECT DISTINCT](https://villagesql.com/docs/pt-BR/tutorial/select-distinct.md) na mesma coluna.

### UNION ALL as mantém

```sql theme={null}
SELECT rating FROM film UNION ALL SELECT rating FROM film;
```

```text theme={null}
+--------+
| rating |
+--------+
| PG     |
| G      |
| NC-17  |
...
+--------+
2000 rows in set (0.00 sec)
```

Todas as linhas das duas metades. Use `UNION ALL` sempre que souber que não há
duplicatas, ou quando as duplicatas são o objetivo.

### Empilhe linhas de tabelas diferentes

É para isto que `UNION` realmente serve: 2 tabelas que guardam o mesmo tipo de coisa.
Uma coluna literal diz de qual metade cada linha veio.

```sql theme={null}
SELECT 'staff' AS source, first_name, last_name FROM staff
UNION ALL
SELECT 'actor', first_name, last_name FROM actor WHERE actor_id <= 3;
```

```text theme={null}
+--------+------------+-----------+
| source | first_name | last_name |
+--------+------------+-----------+
| staff  | Mike       | Hillyer   |
| staff  | Jon        | Stephens  |
| actor  | PENELOPE   | GUINESS   |
| actor  | NICK       | WAHLBERG  |
| actor  | ED         | CHASE     |
+--------+------------+-----------+
5 rows in set (0.00 sec)
```

A segunda consulta não nomeia nenhum alias para seu literal. Ela não precisa de um, porque
os cabeçalhos das colunas vêm apenas da primeira consulta.

## UNION não promete uma ordem

Nenhuma das metades tem garantia de chegar inteira, ou primeiro. O servidor retorna as
linhas na ordem em que seu plano as produziu, então um `UNION ALL` de 2 consultas
idênticas pode intercalar. `ORDER BY` no final é a única forma de fixar a ordem, o
mesmo que acontece com [LIMIT](https://villagesql.com/docs/pt-BR/tutorial/limit.md) e [GROUP BY](https://villagesql.com/docs/pt-BR/tutorial/group-by.md).

## As metades precisam ter o mesmo número de colunas

```sql theme={null}
SELECT first_name FROM actor UNION SELECT first_name, last_name FROM actor;
```

```text theme={null}
ERROR 1222 (21000): The used SELECT statements have a different number of columns
```

Os nomes das colunas não precisam ser iguais. Apenas a contagem é estrita, e ela é
verificada antes de qualquer coisa ser executada.

## ORDER BY se aplica ao resultado inteiro

Um `ORDER BY` no final ordena as linhas combinadas, e não a última consulta. Nomeie o
alias da primeira metade, que é como a coluna do resultado se chama.

```sql theme={null}
SELECT first_name AS name FROM staff
UNION
SELECT last_name FROM staff
ORDER BY name;
```

```text theme={null}
+----------+
| name     |
+----------+
| Hillyer  |
| Jon      |
| Mike     |
| Stephens |
+----------+
4 rows in set (0.00 sec)
```

Para ordenar ou limitar 1 metade sozinha, envolva essa metade em parênteses e coloque seu
`ORDER BY` e `LIMIT` dentro deles.

## Resumo

* Use `UNION` para empilhar as linhas de 2 consultas em 1 resultado.
* Espere que `UNION` remova as duplicatas e que `UNION ALL` as mantenha.
* Prefira `UNION ALL` quando souber que não há nenhuma, porque ele faz menos trabalho.
* Dê às duas metades o mesmo número de colunas, ou receba `ERROR 1222`.
* Espere que os cabeçalhos venham da primeira consulta, e que um `ORDER BY` no final ordene tudo.

## Veja também

* [SELECT DISTINCT](https://villagesql.com/docs/pt-BR/tutorial/select-distinct.md) — removendo duplicatas de 1 consulta
* [Como os joins funcionam](https://villagesql.com/docs/pt-BR/tutorial/joins.md) — combinando tabelas lado a lado em vez disso
* [Subconsultas](https://villagesql.com/docs/pt-BR/tutorial/subqueries.md) — uma consulta usada como valor, e não empilhada


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