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

# Aliases de tabela no MySQL

> Como dar a uma tabela do MySQL um nome curto com AS, por que um join precisa de nomes de coluna qualificados, e os 2 erros que indicam que um alias está ausente ou errado.

> [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 alias de tabela é um nome curto para uma tabela, pela duração de 1 consulta. Ele economiza
digitação em um join, e há 2 situações em que uma consulta não funciona
sem um.

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

## Como um alias de tabela funciona

```sql theme={null}
SELECT ALIAS_NAME.COLUMN_NAME
FROM TABLE_NAME AS ALIAS_NAME;
```

Substitua `TABLE_NAME` pela tabela, `ALIAS_NAME` pelo nome curto que você quer,
e `COLUMN_NAME` por uma coluna dessa tabela. A partir desse ponto, o alias
é o nome da tabela nesta consulta, e você escreve `ALIAS_NAME.COLUMN_NAME`
para nomear uma coluna dela.

`AS` é opcional aqui, como é com um alias de coluna, então `FROM film f` significa o
mesmo que `FROM film AS f`. Escrever `AS` deixa a intenção clara.

## O mesmo join, escrito das duas formas

Sem aliases, toda coluna qualificada carrega o nome completo da tabela.

```sql theme={null}
SELECT film.title, language.name
FROM film
JOIN language ON film.language_id = language.language_id
ORDER BY film.title
LIMIT 3;
```

```text theme={null}
+------------------+---------+
| title            | name    |
+------------------+---------+
| ACADEMY DINOSAUR | English |
| ACE GOLDFINGER   | English |
| ADAPTATION HOLES | English |
+------------------+---------+
3 rows in set (0.00 sec)
```

Com aliases, a mesma consulta fica mais curta e a forma é mais fácil de ver.

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

```text theme={null}
+------------------+---------+
| title            | name    |
+------------------+---------+
| ACADEMY DINOSAUR | English |
| ACE GOLDFINGER   | English |
| ADAPTATION HOLES | English |
+------------------+---------+
3 rows in set (0.00 sec)
```

Linhas idênticas. Um alias não muda nada na resposta.

## Uma coluna que existe nas duas tabelas precisa ser qualificada

`film` e `language` têm, ambas, um `language_id`. Nomeá-lo sem qualificação não dá ao
servidor nenhuma forma de escolher.

```sql theme={null}
SELECT language_id
FROM film
JOIN language ON film.language_id = language.language_id
LIMIT 1;
```

```text theme={null}
ERROR 1052 (23000): Column 'language_id' in field list is ambiguous
```

`ERROR 1052` significa que o servidor encontrou mais de 1 coisa a que o nome poderia se referir.
Em um join, isso é quase sempre uma coluna que 2 tabelas compartilham, e qualificá-la com
a tabela ou o alias que você quis dizer resolve. Um nome de coluna que apenas 1 tabela tem não precisa
de qualificação, e é por isso que `title` e `name` funcionam sem qualificação nas consultas
acima.

## O alias substitui o nome da tabela

Depois que uma tabela tem um alias, o nome original desaparece pelo resto da consulta.

```sql theme={null}
SELECT film.title
FROM film AS f
JOIN language AS l ON f.language_id = l.language_id
LIMIT 1;
```

```text theme={null}
ERROR 1054 (42S22): Unknown column 'film.title' in 'field list'
```

A tabela continua sendo `film` no banco de dados. Dentro desta consulta, ela atende por `f`
e por nada mais. `ERROR 1054` em um nome que você consegue ver no esquema normalmente é
isso.

## O caso que não pode ser escrito sem um alias

Uma consulta que nomeia a mesma tabela duas vezes tem 2 coisas chamadas `actor` e nenhuma forma
de distingui-las. Os aliases são o que torna essa consulta possível, e a
lição sobre [Self join](https://villagesql.com/docs/pt-BR/tutorial/self-join.md) é construída sobre isso.

## Um alias de tabela não é um alias de coluna

Eles usam a mesma palavra-chave e fazem trabalhos diferentes. Um alias de coluna renomeia uma
coluna do resultado e aparece no cabeçalho. Um alias de tabela renomeia uma tabela
dentro da consulta e nunca aparece na saída. Consulte
[Aliases de coluna](https://villagesql.com/docs/pt-BR/tutorial/column-aliases.md) para o outro tipo.

## Resumo

* Use `TABLE_NAME AS ALIAS_NAME` para dar a uma tabela um nome curto por 1 consulta.
* Qualifique qualquer nome de coluna que mais de 1 tabela da consulta tenha.
* Leia `ERROR 1052` em um join como um nome de coluna que você precisa qualificar.
* Suspeite de um alias esquecido quando `ERROR 1054` nomeia uma coluna que você sabe que existe.
* Espere que um alias não mude nada no resultado.

## Veja também

* [Como os joins funcionam](https://villagesql.com/docs/pt-BR/tutorial/joins.md) — onde os aliases começam a compensar
* [Aliases de coluna](https://villagesql.com/docs/pt-BR/tutorial/column-aliases.md) — a outra coisa que `AS` faz
* [Self join](https://villagesql.com/docs/pt-BR/tutorial/self-join.md) — a consulta que não pode ser escrita sem um
* [Desempenho de JOIN no MySQL e erros comuns](https://villagesql.com/docs/pt-BR/guides/joins.md) — os joins em que esses aliases acabam entrando


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