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

# GROUP_CONCAT no MySQL

> Como GROUP_CONCAT junta os valores de um grupo do MySQL em 1 string, como ordená-los e separá-los, e o limite de bytes que o trunca com apenas um aviso.

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

`COUNT` diz a você quantas linhas há em um grupo. `GROUP_CONCAT` diz a você quais
eram, juntando seus valores em 1 string. É a agregação que
mantém o detalhe em vez de reduzi-lo a um número.

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

## Como GROUP\_CONCAT funciona

```sql theme={null}
SELECT GROUPING_COLUMN,
       GROUP_CONCAT(COLUMN_NAME ORDER BY COLUMN_NAME SEPARATOR 'SEPARATOR_TEXT')
FROM TABLE_NAME
GROUP BY GROUPING_COLUMN;
```

Substitua `GROUPING_COLUMN` pela coluna que define os grupos, `TABLE_NAME`
pela tabela, `COLUMN_NAME` pela coluna a juntar, e `SEPARATOR_TEXT` pelo
que vai entre os valores. Tanto `ORDER BY` quanto `SEPARATOR` são opcionais, e eles
ficam dentro dos parênteses, não na consulta ao redor deles.

Sem `SEPARATOR` os valores são juntados com uma vírgula e sem espaço. Sem
`ORDER BY` eles chegam sem nenhuma ordem em particular.

## Exemplos

### Juntar os valores de cada grupo

```sql theme={null}
SELECT rating, GROUP_CONCAT(title ORDER BY title SEPARATOR ', ') AS titles
FROM film
WHERE length = 185
GROUP BY rating
ORDER BY rating;
```

```text theme={null}
+--------+--------------------------------------------------+
| rating | titles                                           |
+--------+--------------------------------------------------+
| G      | CONTROL ANTHEM, DARN FORRESTER, MUSCLE BRIGHT    |
| PG     | WORST BANGER                                     |
| PG-13  | CHICAGO NORTH, GANGS PRIDE, POND SEATTLE         |
| R      | HOME PITY, SOLDIERS EVOLUTION, SWEET BROTHERHOOD |
+--------+--------------------------------------------------+
4 rows in set (0.00 sec)
```

4 linhas em vez de 5, porque nenhum filme `NC-17` dura 185 minutos e o `WHERE`
removeu suas linhas antes do agrupamento. Um grupo sem linhas restantes não
aparece.

### Descartar as repetições

`DISTINCT` dentro dos parênteses remove os valores duplicados dentro de cada grupo.

```sql theme={null}
SELECT rating, GROUP_CONCAT(DISTINCT rental_rate ORDER BY rental_rate) AS rates
FROM film
GROUP BY rating
ORDER BY rating;
```

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

Sem `DISTINCT` cada string conteria 1 cópia da tarifa por filme do
grupo, entre 178 e 223 delas, e as 2 mais longas bateriam no limite
de que trata a próxima seção. Este é também o separador padrão: uma vírgula e
nada mais.

## O resultado é cortado em group\_concat\_max\_len bytes

Esta é a armadilha. O servidor trunca um resultado de `GROUP_CONCAT` que fica longo
demais, e não gera erro. O limite é uma configuração, então o número
abaixo é deste servidor, e não uma propriedade do MySQL, e ele conta bytes,
não caracteres.

```sql theme={null}
SELECT LENGTH(GROUP_CONCAT(title)) AS bytes FROM film;
```

```text theme={null}
+-------+
| bytes |
+-------+
|  1024 |
+-------+
1 row in set, 1 warning (0.00 sec)
```

Exatamente 1.024, o que é suspeito por si só: um total real raramente cairia
em um número redondo. Compare com a configuração.

```sql theme={null}
SELECT @@group_concat_max_len AS max_len;
```

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

O rodapé da primeira consulta informou um aviso, e `SHOW WARNINGS` diz o que
foi perdido: `Warning 1260 Row 65 was cut by GROUP_CONCAT()`. A string contém 64
títulos inteiros de 1.000 e então para no meio do 65º.

Execute `SHOW WARNINGS` você mesmo depois de um `GROUP_CONCAT` para ver a mesma mensagem.

`SET SESSION group_concat_max_len = 100000;` aumenta o limite pelo resto da
sua conexão e volta ao normal quando você reconecta. Como o limite conta bytes,
texto fora do ASCII é cortado antes do que o número sugere: um caractere pode ocupar
até 4 bytes em `utf8mb4`.

Trate um resultado cujo comprimento é exatamente igual a `group_concat_max_len` como truncado
até que você tenha verificado, e observe a contagem de avisos no rodapé.

## Resumo

* Use `GROUP_CONCAT` para juntar os valores de um grupo em 1 string.
* Coloque `ORDER BY`, `SEPARATOR` e `DISTINCT` dentro dos parênteses.
* Espere uma vírgula sem espaço quando você não nomeia nenhum separador.
* Espere truncamento em `group_concat_max_len` bytes, com um aviso em vez de um erro.
* Suspeite de truncamento sempre que o comprimento for exatamente igual ao limite.

## Veja também

* [Funções de agregação](https://villagesql.com/docs/pt-BR/tutorial/aggregate-functions.md) — as agregações que retornam um número
* [GROUP BY](https://villagesql.com/docs/pt-BR/tutorial/group-by.md) — construindo os grupos que esta função junta
* [Funções de string no MySQL](https://villagesql.com/docs/pt-BR/guides/string-functions.md) — remodelando a string depois
* [Desempenho de GROUP BY no MySQL](https://villagesql.com/docs/pt-BR/guides/group-by-having.md) — o que construir essas strings custa em escala


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