SQL Funções de Texto
Esta é a página de consulta rápida das funções que trabalham com texto no SQLite 3.50: juntar, medir, cortar, trocar, limpar e formatar. Cada linha das tabelas traz um exemplo e o resultado que ele dá de verdade. A explicação passo a passo, com exercícios, está na aula Funções de Texto.
- Exemplo é o que vai dentro de um
SELECT: para testar, escrevaSELECTantes e;depois, como emSELECT upper('Ana');. - Resultado foi colhido no editor do guia (SQLite 3.50.4). NULL quer dizer "sem valor". Espaços que importam aparecem entre colchetes, como
[Ana ]. - Texto vai sempre entre aspas simples. Para pôr uma aspa dentro do texto, dobre-a:
'Loja D''Água'. - Quase todas as funções devolvem NULL quando recebem NULL (as exceções estão marcadas).
Juntar textos
| Função / operador | O que faz | Exemplo | Resultado | Aula |
|---|---|---|---|---|
a || b | Junta (concatena) dois valores. Números viram texto. | 'Ana' || ' ' || 'Sousa' | Ana Sousa | Funções de Texto |
| Número junto com texto | 'Pedido nº ' || 7 | Pedido nº 7 | ||
| Com NULL, o resultado inteiro vira NULL | 'Ana' || NULL | NULL | O Valor NULL | |
concat(x, …) | Junta todos os argumentos. Ignora os NULL. | concat('Ana', NULL, 'Sousa') | AnaSousa | Funções de Texto |
concat_ws(sep, x, …) | Junta com um separador entre os valores (ws = with separator, "com separador"). Pula os NULL sem deixar separador sobrando. | concat_ws(', ', 'Porto', NULL, 'Portugal') | Porto, Portugal | Funções de Texto |
group_concat(x, sep) e string_agg(x, sep) | Juntam os valores de várias linhas num texto só. São funções agregadas. | veja Funções Agregadas | GROUP BY | |
Com dados da Loja Aurora: o || monta "cidade (UF)", e o concat_ws lida bem com o estado NULL dos fornecedores estrangeiros:
SELECT nome,
concat_ws(' / ', cidade, estado, pais) AS local
FROM fornecedores;
Repare nas linhas de Porto e Buenos Aires: o estado é NULL, e o concat_ws simplesmente o pulou. Com cidade || ' / ' || estado || ' / ' || pais, essas duas linhas sairiam NULL inteiras.
Medir
| Função | O que faz | Exemplo | Resultado | Aula |
|---|---|---|---|---|
length(x) | Quantos caracteres o texto tem (letras acentuadas contam 1). | length('Conceição') | 9 | Funções de Texto |
| Num número, mede o número escrito como texto | length(1234.5) | 6 | ||
| Texto vazio tem 0; um espaço tem 1 | length(''), length(' ') | 0, 1 | ||
octet_length(x) | Quantos bytes o texto ocupa. Em UTF-8, cada letra acentuada ocupa 2 bytes. | octet_length('Conceição') | 11 | Os Tipos no SQLite |
Maiúsculas e minúsculas
| Função | O que faz | Exemplo | Resultado | Aula |
|---|---|---|---|---|
upper(x) | Passa para MAIÚSCULAS (upper case). | upper('Ana Beatriz') | ANA BEATRIZ | Funções de Texto |
| Só as letras sem acento mudam! | upper('Conceição') | CONCEIçãO | ||
lower(x) | Passa para minúsculas (lower case). Mesmo limite. | lower('JOSÉ RIBAMAR') | josÉ ribamar | Funções de Texto |
x = y COLLATE NOCASE | Compara sem diferenciar maiúsculas de minúsculas (também só nas letras sem acento). | 'Ana' = 'ana' COLLATE NOCASE | 1 (verdadeiro) | Comparações |
'Água' = 'água' COLLATE NOCASE | 0 (falso) |
O SQLite que vem pronto só sabe trocar a caixa das 26 letras do alfabeto inglês (A a Z). Letras como é, ç, ã ficam como estão. Veja nos clientes da loja:
SELECT nome, upper(nome) AS maiusculo, length(nome) AS letras FROM clientes WHERE id IN (1, 5, 9);
O length conta certo (as letras acentuadas valem 1), mas o upper deixou é, ç, ã e ô minúsculos. Para trocar a caixa de qualquer letra, o SQLite precisa de uma extensão chamada ICU, que não vem no editor do guia nem no sqlite3 padrão. Os outros bancos (MySQL, PostgreSQL, SQL Server) tratam os acentos corretamente.
Cortar, procurar e trocar
| Função | O que faz | Exemplo | Resultado | Aula |
|---|---|---|---|---|
substr(x, início, n) | Pedaço do texto: começa na posição início (a primeira letra é 1) e pega n caracteres. | substr('Lápis Grafite HB', 1, 5) | Lápis | Funções de Texto |
substr(x, início) | Sem o n: vai até o fim. | substr('Lápis Grafite HB', 7) | Grafite HB | |
início negativo conta do fim para trás. | substr('Lápis Grafite HB', -2) | HB | ||
| Começo depois do fim: texto vazio. | substr('Teresina', 10) | (texto vazio) | ||
substring(x, início, n) | Outro nome do substr (o nome do padrão SQL). | substring('Teresina', 1, 3) | Ter | |
instr(x, procurado) | Posição da primeira vez que procurado aparece em x (in string, "no texto"). 0 se não aparece. | instr('ana.beatriz@exemplo.com.br', '@') | 12 | Funções de Texto |
| Não achou | instr('Teresina', 'x') | 0 | ||
replace(x, de, para) | Troca todas as vezes que de aparece por para. Diferencia maiúsculas. | replace('2026-10-18', '-', '/') | 2026/10/18 | Funções de Texto |
Trocar por '' apaga | replace('Loja D''Água', '''', '') | Loja DÁgua |
Combinando substr e instr: tudo o que vem depois do @ do email (o domínio):
SELECT nome, substr(email, instr(email, '@') + 1) AS dominio FROM clientes WHERE id <= 3;
Limpar as pontas
| Função | O que faz | Exemplo | Resultado | Aula |
|---|---|---|---|---|
trim(x) | Tira os espaços do começo e do fim (trim = "aparar"). | '[' || trim(' Ana ') || ']' | [Ana] | Funções de Texto |
ltrim(x) | Só da esquerda (left). | '[' || ltrim(' Ana ') || ']' | [Ana ] | |
rtrim(x) | Só da direita (right). | '[' || rtrim(' Ana ') || ']' | [ Ana] | |
trim(x, letras) | Com o segundo argumento, tira qualquer das letras dadas, em vez de espaços. | trim('--PI--', '-') | PI | |
ltrim(x, letras) | ltrim('000123', '0') | 123 | ||
rtrim(x, letras) | rtrim('Teresina...', '.') | Teresina |
Formatar: format() e printf()
format(modelo, valores…) monta um texto a partir de um modelo: cada % do modelo é trocado pelo próximo valor. printf é outro nome da mesma função (o nome antigo, que vem da linguagem C).
| No modelo | O que faz | Exemplo | Resultado |
|---|---|---|---|
%s | Põe o valor como texto (string). | format('%s mora em %s', 'Ana', 'Teresina') | Ana mora em Teresina |
%d | Número inteiro (decimal). | format('%d%%', 15) | 15% |
%.2f | Número com 2 casas depois do ponto (float). | format('R$ %.2f', 89.99) | R$ 89.99 |
format('%.2f', 3.5) | 3.50 | ||
%05d | Inteiro com 5 posições, completando com zeros à esquerda. | printf('%05d', 42) | 00042 |
%8s / %-8s | Ocupa 8 posições, alinhado à direita / à esquerda (com -). | format('[%8s]', 'Ana')format('[%-8s]', 'Ana') | [ Ana][Ana ] |
%,d | Inteiro com separador de milhar (vírgula, no estilo americano). | format('%,d', 1234567) | 1,234,567 |
%x | Inteiro em hexadecimal. | format('%x', 255) | ff |
%e | Notação científica. | format('%e', 1234.5) | 1.234500e+03 |
%q | Texto com as aspas simples dobradas (pronto para ir dentro de '…'). | format('%q', 'Loja D''Água') | Loja D''Água |
%% | Um % de verdade. | format('%%') | % |
O uso mais comum na loja: mostrar o preço com duas casas.
SELECT nome, format('R$ %.2f', preco) AS preco
FROM produtos
WHERE id <= 3;
O format sempre usa ponto nos decimais e vírgula no milhar, como nos Estados Unidos. Para o formato brasileiro (R$ 1.234,50), troque os sinais com replace ou, melhor, deixe a formatação para o programa que mostra os dados ao usuário.
Comparar com padrões
| Operador / função | O que faz | Exemplo | Resultado | Aula |
|---|---|---|---|---|
x LIKE padrão | Compara com curingas: % = qualquer sequência, _ = um caractere. Não diferencia maiúsculas (nas letras sem acento). | 'Ana Beatriz' LIKE 'ana%' | 1 | LIKE |
| Com acento, diferencia | 'Água' LIKE 'água' | 0 | Curingas | |
x GLOB padrão | Curingas do estilo do terminal: * e ?. Diferencia maiúsculas. | 'Ana Beatriz' GLOB 'ana*' | 0 | Curingas |
'Ana Beatriz' GLOB 'Ana*' | 1 | |||
like(padrão, x) | O LIKE escrito como função. Atenção: o padrão vem primeiro. | like('ana%', 'Ana Beatriz') | 1 | |
glob(padrão, x) | O GLOB como função, também com o padrão primeiro. | glob('A*', 'Ana') | 1 |
Códigos, bytes e aspas
| Função | O que faz | Exemplo | Resultado |
|---|---|---|---|
char(n, …) | Monta um texto a partir dos códigos Unicode das letras. | char(65, 110, 97) | Ana |
unicode(x) | O código Unicode da primeira letra. | unicode('Água') | 193 |
hex(x) | Os bytes do valor escritos em hexadecimal. | hex('Ana') | 416E61 |
unhex(x) | O contrário do hex: devolve os bytes (um valor do tipo blob). | typeof(unhex('416E61')) | blob |
quote(x) | Escreve o valor como ele seria escrito num comando SQL: texto entre aspas (com as aspas de dentro dobradas), NULL como a palavra NULL. | quote('Loja D''Água') | 'Loja D''Água' |
| Funciona com NULL (não devolve NULL) | quote(NULL) | NULL (o texto) | |
unistr(x) | Novo no 3.50: troca códigos como \u00e1 pela letra. | unistr('Ol\u00e1') | Olá |
unistr_quote(x) | Novo no 3.50: como o quote, mas escreve caracteres de controle (como a quebra de linha) com \u. | unistr_quote(char(65, 10, 66)) | unistr('A\u000aB') |
CAST(x AS TEXT) | Converte um valor em texto. | CAST(123 AS TEXT) || '!' | 123! |
typeof(x) | Diz o tipo do valor: text, integer, real, blob ou null. | typeof('Ana') | text |
Funções que o SQLite não tem
Quem vem de outro banco sente falta de algumas funções. Todas dão no such function no SQLite, mas há um jeito de fazer cada uma:
| Em outros bancos | O que faz | No SQLite | Resultado |
|---|---|---|---|
LEFT('Teresina', 4) | as primeiras 4 letras | substr('Teresina', 1, 4) | Tere |
RIGHT('Teresina', 4) | as últimas 4 letras | substr('Teresina', -4) | sina |
LPAD(42, 5, '0') | completar com zeros à esquerda | printf('%05d', 42) ou substr('00000' || 42, -5) | 00042 |
RPAD('Ana', 8) | completar com espaços à direita | format('%-8s', 'Ana') | Ana |
REPEAT('*', 5) | repetir um caractere | printf('%.*c', 5, '*') | ***** |
LEN(x) (SQL Server) | tamanho | length(x) | |
SOUNDEX(x) | código de "som parecido" | Existe no SQLite só quando ele é compilado com essa opção; no editor e no sqlite3 do guia, dá no such function: soundex. |
SELECT left('Teresina', 3);
Nos outros bancos
Conferido nas documentações oficiais do MySQL 8.4, do PostgreSQL e do SQL Server. Os trechos não rodam no editor do guia; são só para comparar.
| Para | SQLite | MySQL | PostgreSQL | SQL Server |
|---|---|---|---|---|
| juntar | a || b, concat | CONCAT(a, b); o || é OU lógico, a não ser com o modo PIPES_AS_CONCAT; e o CONCAT dá NULL se um argumento for NULL | a || b, concat (ignora NULL) | a + b, CONCAT |
| juntar com separador | concat_ws | CONCAT_WS | concat_ws | CONCAT_WS |
| tamanho em letras | length | CHAR_LENGTH (o LENGTH do MySQL conta bytes!) | length, char_length | LEN (ignora espaços no fim) |
| tamanho em bytes | octet_length | LENGTH | octet_length | DATALENGTH |
| posição | instr(texto, procurado) | INSTR(texto, procurado) ou LOCATE(procurado, texto) | strpos(texto, procurado) ou position(procurado IN texto) | CHARINDEX(procurado, texto) |
| pedaço | substr, substring | SUBSTRING, SUBSTR | substring(x FROM 2 FOR 3), substr | SUBSTRING(x, início, n) |
| esquerda / direita | substr | LEFT, RIGHT | left, right | LEFT, RIGHT |
| completar | printf | LPAD, RPAD | lpad, rpad | — |
| repetir / inverter | — | REPEAT, REVERSE | repeat, reverse | REPLICATE, REVERSE |
| formatar | format / printf (estilo C) | FORMAT(número, casas): formata números, como '12,332.1235' | format com %s, %I (nome) e %L (valor) | FORMAT (estilo .NET) |
| maiúsculas com acento | só com a extensão ICU | sim | sim (pelas regras do idioma do banco) | sim |
Experimente
Missão: o catálogo da loja precisa mostrar o preço como texto, com R$ e duas casas (R$ 1.15, R$ 12.35…). Mostre o nome de todos os produtos e o preço formatado numa coluna chamada preco_txt.
SELECT nome, preco FROM produtos;
SELECT nome, format('R$ %.2f', preco) AS preco_txt
FROM produtos;
Livre: teste qualquer função desta página. Troque os nomes, junte funções umas dentro das outras.
SELECT nome,
upper(substr(nome, 1, 1)) AS inicial,
length(nome) AS letras,
replace(nome, ' ', '_') AS sem_espacos
FROM clientes
LIMIT 5;
Resumo
- Juntar:
||(com NULL vira NULL),concateconcat_ws(pulam os NULL). - Medir:
lengthem letras,octet_lengthem bytes. - Cortar e procurar:
substr(x, início, n)(início 1, negativo conta do fim),instr,replace. - Limpar:
trim,ltrim,rtrim, com ou sem a lista de letras. - Formatar:
format/printfcom%s,%d,%.2f,%05d. upper,lower,LIKEeNOCASEsó tratam as letras sem acento.- Não existem no SQLite:
LEFT,RIGHT,LPAD,REPEAT,LEN; usesubstreprintf.