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

# Expressões de tabela comuns no MySQL

> Como a cláusula WITH do MySQL dá nome a uma consulta para que a consulta principal possa lê-la, como definir várias de uma vez, e quando uma CTE se lê melhor do que uma tabela derivada.

> [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 →

Uma expressão de tabela comum dá um nome a uma consulta, no topo, antes da consulta
que a usa. O resultado é o mesmo de uma [tabela
derivada](https://villagesql.com/docs/pt-BR/tutorial/derived-tables.md), e se lê na ordem em que você pensa: defina
as partes, depois use-as.

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

## Como uma CTE funciona

```sql theme={null}
WITH CTE_NAME AS (
  SELECT COLUMN_LIST FROM TABLE_NAME
)
SELECT COLUMN_LIST FROM CTE_NAME;
```

Substitua `CTE_NAME` por um nome para o resultado intermediário, `COLUMN_LIST` pelas
colunas que você quer, e `TABLE_NAME` pela tabela que a consulta interna lê. A consulta principal então lê `CTE_NAME` como se fosse
uma tabela.

Uma CTE dura 1 instrução. Ela não é armazenada, e a próxima consulta não sabe nada
sobre ela.

## Exemplos

### Um passo com nome

```sql theme={null}
WITH counts AS (
  SELECT rating, COUNT(*) AS films FROM film GROUP BY rating
)
SELECT rating, films FROM counts WHERE films > 200 ORDER BY rating;
```

```text theme={null}
+--------+-------+
| rating | films |
+--------+-------+
| PG-13  |   223 |
| NC-17  |   210 |
+--------+-------+
2 rows in set (0.00 sec)
```

As mesmas linhas que a lição de tabela derivada retorna, com a contagem tirada de dentro do
`FROM` e recebendo um nome.

### Vários passos, cada um construído sobre o anterior

Separe as CTEs com vírgula, e uma posterior pode ler uma anterior. É isso
que uma tabela derivada não consegue fazer sem se repetir.

```sql theme={null}
WITH counts AS (
  SELECT rating, COUNT(*) AS films FROM film GROUP BY rating
),
busiest AS (
  SELECT MAX(films) AS most FROM counts
)
SELECT c.rating, c.films
FROM counts AS c
INNER JOIN busiest AS b ON c.films = b.most;
```

```text theme={null}
+--------+-------+
| rating | films |
+--------+-------+
| PG-13  |   223 |
+--------+-------+
1 row in set (0.00 sec)
```

`busiest` lê `counts`, e a consulta principal lê as duas. Escrita com tabelas
derivadas, a consulta de contagem apareceria duas vezes.

## O que uma CTE dá a você que uma tabela derivada não dá

As linhas são as mesmas de qualquer forma. 2 coisas diferem:

* Uma CTE carrega um nome, então uma consulta de 3 estágios se lê de cima para baixo. `counts` e
  `busiest` dizem ao próximo leitor para que serve cada parte.
* Uma CTE pode ser referenciada pelo nome mais de uma vez na mesma instrução. Uma tabela derivada tem
  de ser escrita de novo.

Se o otimizador trata as 2 formas de modo diferente é uma questão separada,
e [Quando uma CTE do MySQL supera uma tabela derivada](https://villagesql.com/docs/pt-BR/guides/ctes-in-mysql.md) mede
isso.

## Resumo

* Use `WITH name AS (...)` para dar nome a uma consulta antes da consulta que a lê.
* Separe várias CTEs com vírgulas, e deixe uma posterior ler uma anterior.
* Espere que uma CTE dure apenas 1 instrução.
* Prefira uma CTE quando uma consulta tem vários estágios ou repete uma subconsulta.

## Veja também

* [Tabelas derivadas](https://villagesql.com/docs/pt-BR/tutorial/derived-tables.md) — a mesma ideia, em linha
* [CTEs recursivas](https://villagesql.com/docs/pt-BR/tutorial/recursive-cte.md) — uma CTE que lê a si mesma
* [GROUP BY](https://villagesql.com/docs/pt-BR/tutorial/group-by.md) — o que o passo interno normalmente faz
* [Quando uma CTE do MySQL supera uma tabela derivada](https://villagesql.com/docs/pt-BR/guides/ctes-in-mysql.md) — como o otimizador lida com elas


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