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

# Funções de String do MySQL

> Guia de referência para as funções de string do MySQL: CONCAT, SUBSTRING, TRIM, REPLACE, UPPER, LOWER, LENGTH, LIKE, REGEXP, FORMAT e padrões comuns de manipulação de strings.

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

As funções de string do MySQL cobrem dividir, juntar, pesquisar, formatar e comparar texto. A maioria segue as mesmas convenções: indexação a partir de 1, propagação de NULL (qualquer argumento NULL retorna NULL) e comparações sem distinção entre maiúsculas e minúsculas por padrão.

## Combinando e Dividindo

**CONCAT** — junta strings:

```sql theme={null}
SELECT CONCAT(first_name, ' ', last_name) AS full_name FROM users;

-- CONCAT_WS: join with a separator, skipping NULLs
SELECT CONCAT_WS(', ', city, state, country) AS address FROM locations;
```

`CONCAT` com um argumento NULL retorna NULL. `CONCAT_WS` ignora valores NULL, mas mantém o separador entre os valores não NULL.

**SUBSTRING / SUBSTR / MID** — extrai parte de uma string:

```sql theme={null}
-- SUBSTRING(string, start, length)  — 1-based indexing
SELECT SUBSTRING('Hello, World!', 1, 5);   -- 'Hello'
SELECT SUBSTRING('Hello, World!', 8);      -- 'World!'  (to end of string)
SELECT SUBSTRING('Hello, World!', -6);     -- 'World!'  (from the right)
```

**SUBSTRING\_INDEX** — divide em um delimitador:

```sql theme={null}
-- Get everything before the second comma
SELECT SUBSTRING_INDEX('a,b,c,d', ',', 2);   -- 'a,b'

-- Get everything after the last dot (domain from email)
SELECT SUBSTRING_INDEX('user@example.com', '@', -1);  -- 'example.com'
```

## Pesquisando Dentro de Strings

**LOCATE / POSITION / INSTR** — encontra uma substring:

```sql theme={null}
SELECT LOCATE('World', 'Hello, World!');       -- 8  (1-based position)
SELECT LOCATE('world', 'Hello, World!');       -- 8  (case-insensitive by default)
SELECT LOCATE('xyz', 'Hello, World!');         -- 0  (not found)

-- LOCATE with start position
SELECT LOCATE('o', 'Hello, World!', 6);        -- 9  (skips first 'o')
```

**LIKE** — correspondência de padrões com curingas:

```sql theme={null}
-- % matches zero or more characters, _ matches exactly one
SELECT * FROM products WHERE name LIKE 'Widget%';       -- starts with Widget
SELECT * FROM products WHERE name LIKE '%Pro%';         -- contains Pro
SELECT * FROM products WHERE code LIKE 'SKU-___-2024';  -- three chars in middle
```

**REGEXP / RLIKE** — correspondência por expressão regular:

```sql theme={null}
SELECT * FROM users WHERE email REGEXP '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$';
SELECT * FROM products WHERE name REGEXP 'Pro|Plus|Max';
```

`REGEXP` usa a sintaxe de regex POSIX. Use `REGEXP_LIKE()` (MySQL 8.0+) para a forma de função.

## Modificando Strings

**REPLACE** — substitui todas as ocorrências de uma substring:

```sql theme={null}
SELECT REPLACE('Hello, World!', 'World', 'MySQL');  -- 'Hello, MySQL!'
UPDATE articles SET content = REPLACE(content, 'old_term', 'new_term');
```

**TRIM / LTRIM / RTRIM** — remove espaços em branco ou caracteres específicos:

```sql theme={null}
SELECT TRIM('  hello  ');                    -- 'hello'
SELECT TRIM(LEADING '0' FROM '007');         -- '7'
SELECT TRIM(BOTH 'x' FROM 'xxhelloxx');      -- 'hello'
```

**UPPER / LOWER** — altera maiúsculas e minúsculas:

```sql theme={null}
SELECT UPPER('hello');   -- 'HELLO'
SELECT LOWER('HELLO');   -- 'hello'
```

**LPAD / RPAD** — preenche até um comprimento fixo:

```sql theme={null}
SELECT LPAD('42', 6, '0');    -- '000042'
SELECT RPAD('hello', 10, '.');  -- 'hello.....'
```

**REPEAT** — repete uma string N vezes:

```sql theme={null}
SELECT REPEAT('ab', 3);   -- 'ababab'
```

**REVERSE** — inverte uma string:

```sql theme={null}
SELECT REVERSE('hello');  -- 'olleh'
```

## Comprimento e Comparação

O MySQL tem duas funções de comprimento que produzem resultados diferentes para caracteres multibyte:

| Função | O que mede |
| :- | :- |
| `LENGTH(s)` | Comprimento em bytes |
| `CHAR_LENGTH(s)` / `CHARACTER_LENGTH(s)` | Comprimento em caracteres |

```sql theme={null}
SELECT LENGTH('café');      -- 5  (the é is 2 bytes in UTF-8)
SELECT CHAR_LENGTH('café'); -- 4  (4 characters)
```

Use sempre `CHAR_LENGTH` quando o que importa é o número de caracteres, não de bytes.

**STRCMP** — compara duas strings e retorna -1, 0 ou 1:

```sql theme={null}
SELECT STRCMP('abc', 'abc');   -- 0
SELECT STRCMP('abc', 'abd');   -- -1
SELECT STRCMP('abd', 'abc');   -- 1
```

## Formatação

**FORMAT** — formata um número com separadores de milhares:

```sql theme={null}
SELECT FORMAT(1234567.891, 2);    -- '1,234,567.89'
SELECT FORMAT(1234567.891, 2, 'de_DE');  -- '1.234.567,89'  (German locale)
```

**LEFT / RIGHT** — pega N caracteres do início ou do fim:

```sql theme={null}
SELECT LEFT('Hello, World!', 5);   -- 'Hello'
SELECT RIGHT('Hello, World!', 6);  -- 'World!'
```

## Padrões Comuns

Extrair o domínio de um endereço de e-mail:

```sql theme={null}
SELECT SUBSTRING_INDEX(email, '@', -1) AS domain FROM users;
```

Truncar strings longas para exibição:

```sql theme={null}
SELECT CASE
    WHEN CHAR_LENGTH(description) > 100
    THEN CONCAT(LEFT(description, 97), '...')
    ELSE description
END AS short_description
FROM products;
```

Normalizar espaços em branco:

```sql theme={null}
UPDATE users SET name = TRIM(REGEXP_REPLACE(name, '\\s+', ' '));
```

## Perguntas Frequentes

#### As comparações de string do MySQL diferenciam maiúsculas de minúsculas?

Por padrão, não — as comparações de string usam a collation da coluna, e as collations mais comuns não diferenciam maiúsculas de minúsculas (por exemplo, `utf8mb4_general_ci`, onde `ci` = case-insensitive). Para comparações que diferenciam maiúsculas de minúsculas, use uma collation `_cs` ou o operador `BINARY`:

```sql theme={null}
SELECT * FROM users WHERE BINARY username = 'Alice';
-- or: WHERE username COLLATE utf8mb4_bin = 'Alice'
```

#### Qual é a diferença entre CHAR\_LENGTH e LENGTH?

`LENGTH` retorna a contagem de bytes; `CHAR_LENGTH` retorna a contagem de caracteres. Para strings ASCII, as duas são iguais. Para strings UTF-8 com caracteres multibyte (letras acentuadas, emoji, CJK), elas diferem. Use `CHAR_LENGTH` para limites de comprimento de string visíveis ao usuário.

## Solução de Problemas

| Problema | Solução |
| :- | :- |
| `CONCAT` retorna NULL | Um argumento é NULL — use `COALESCE(col, '')` para substituir os NULLs antes de concatenar, ou use `CONCAT_WS` |
| `LIKE '%pattern%'` é lento | O curinga no início impede o uso de índice — considere um índice FULLTEXT para pesquisa de texto em escala |
| A comparação de strings não corresponde às linhas esperadas | Diferença de maiúsculas e minúsculas ou de collation — verifique a collation da coluna com `SHOW CREATE TABLE` |
| `REPLACE` não encontrou o que `LIKE` encontrou | `REPLACE` compara byte a byte e ignora a collation da conexão, então ele *diferencia* maiúsculas de minúsculas mesmo em uma coluna `_ci` — ao contrário de `=`, `LIKE` ou `LOCATE` |
| `SUBSTRING` retorna uma string vazia, não NULL | SUBSTRING de uma posição fora do intervalo retorna uma string vazia, não NULL |

## Veja também

* [Conjuntos de Caracteres e Collations do MySQL](https://villagesql.com/docs/pt-BR/guides/character-sets.md) — as funções de string se comportam de forma diferente entre collations
* [Pesquisa Full-Text no MySQL](https://villagesql.com/docs/pt-BR/guides/full-text-search.md) — pesquisando strings em escala além do LIKE
* [Aliases de coluna no MySQL](https://villagesql.com/docs/pt-BR/tutorial/column-aliases.md) — nomeando a coluna que uma expressão de string produz
* [MySQL LIKE](https://villagesql.com/docs/pt-BR/tutorial/like.md) — o operador de padrão usado com frequência junto com essas funções
* [MySQL GROUP\_CONCAT](https://villagesql.com/docs/pt-BR/tutorial/group-concat.md) — juntando os valores de um grupo em uma única string


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