Aula 12.1 · Tempo de leitura: ~10 min

Esta aula é dedicada ao processamento prático de strings em SQL. Você vai aprender como limpar valores textuais, normalizar caixa, extrair fragmentos úteis e montar campos legíveis para análise e relatórios. Vamos trabalhar com cenários reais usando a base Sakila. Ao final da aula, você conseguirá preparar dados de texto para análise diretamente em SQL.

Processamento prático de strings em SQL

No módulo anterior, falamos sobre qualidade de código SQL e desempenho de consultas. Agora passamos para análise aplicada: em dados reais, campos de texto muitas vezes não devem apenas ser exibidos, mas antes transformados para uso prático.

O processamento prático de strings é necessário em relatórios, segmentação de usuários, limpeza de dados de referência, preparação de exportações e verificações de qualidade de dados. Essas são exatamente as tarefas que analistas e desenvolvedores encontram no dia a dia.

Por que o processamento prático de strings é importante

Funções básicas de string são úteis por si só, mas o valor real aparece quando você as aplica a uma tarefa concreta. Por exemplo, o mesmo e-mail pode ser usado para verificar qualidade de dados, segmentar por domínio e preparar um relatório de marketing.

Na prática, o processamento de strings em SQL geralmente se resume a quatro tipos de tarefas:

• limpeza de texto para remover espaços extras e padrões repetidos;
• normalização de caixa e formato;
• extração de partes da string para análise;
• criação de novos campos textuais para interfaces e relatórios.

Abordagem básica para processar strings

Na maioria dos casos, o texto é processado por etapas:

1. primeiro limpar o valor;
2. depois normalizar para um formato consistente;
3. em seguida extrair as partes necessárias;
4. por fim usar o resultado em análises ou relatórios.

Essa abordagem torna as consultas mais previsíveis e facilita a depuração.

SELECT
   LOWER(TRIM(email)) AS email_normalized
FROM customer
LIMIT 5;

Resultado: o e-mail é limpo nas bordas e convertido para minúsculas.

Limpeza e normalização de texto

O cenário mais comum é preparar uma string para análise posterior. Para isso, normalmente usamos TRIM(), LOWER(), UPPER() e REPLACE().

Exemplo: normalização de e-mail

SELECT
   customer_id,
   email,
   LOWER(TRIM(email)) AS email_normalized
FROM customer
LIMIT 10;

Observação: mesmo quando os dados já parecem limpos, a normalização ajuda em comparações, agrupamentos e processamento automatizado.

Exemplo: limpeza de endereços

SELECT
   address_id,
   address,
   TRIM(REPLACE(address, 'Street', 'St.')) AS address_cleaned
FROM address
LIMIT 10;

Resultado: o endereço fica mais curto e consistente, o que facilita o uso em relatórios e interfaces.

Extração de partes úteis da string

Depois da limpeza, muitas vezes você precisa apenas de uma parte da string para análise. No MySQL, SUBSTRING(), LEFT(), RIGHT() e SUBSTRING_INDEX() são especialmente úteis.

Exemplo: extração do domínio do e-mail

SELECT
   customer_id,
   email,
   SUBSTRING_INDEX(LOWER(TRIM(email)), '@', -1) AS email_domain
FROM customer
LIMIT 10;

Resultado: a parte de domínio é extraída do e-mail, por exemplo example.com.

Exemplo: extração de prefixo do título do filme

SELECT
   film_id,
   title,
   LEFT(title, 5) AS title_prefix,
   RIGHT(title, 5) AS title_suffix
FROM film
LIMIT 10;

Observação: esses fragmentos podem ser úteis para heurísticas rápidas, verificação de padrões de nomenclatura e criação de rótulos curtos.

Criação de campos textuais analíticos

Em análise de dados, frequentemente precisamos de rótulos legíveis em vez de campos brutos. Para isso, CONCAT() e CONCAT_WS() são práticos.

Exemplo: rótulo de cliente para relatório

SELECT
   customer_id,
   CONCAT_WS(
      ' | ',
      CONCAT_WS(' ', first_name, last_name),
      LOWER(TRIM(email)),
      CONCAT('store=', store_id)
   ) AS customer_label
FROM customer
LIMIT 10;

Resultado: você obtém um campo textual compacto, útil para relatórios administrativos, arquivos de exportação e ferramentas internas.

Validação da qualidade de dados textuais

Processamento de strings não serve apenas para formatação, mas também para validação básica. SQL não substitui um sistema completo de validação, mas permite encontrar rapidamente valores suspeitos.

Exemplo: localizar e-mails sem @

SELECT
   customer_id,
   email
FROM customer
WHERE INSTR(LOWER(TRIM(email)), '@') = 0;

Resultado: a consulta retorna registros em que o e-mail não contém o separador obrigatório.

Exemplo: validar o tamanho do título do filme

SELECT
   film_id,
   title,
   CHAR_LENGTH(title) AS title_length
FROM film
WHERE CHAR_LENGTH(title) > 20
ORDER BY title_length DESC
LIMIT 10;

Observação: verificações como essa ajudam a encontrar valores longos demais para cards, telas de interface ou limites de exportação.

Exemplo prático: segmentação de clientes por domínio de e-mail

Agora vamos combinar várias técnicas em uma única consulta analítica. Suponha que precisemos entender quais domínios são mais frequentes entre os clientes.

SELECT
   SUBSTRING_INDEX(LOWER(TRIM(email)), '@', -1) AS email_domain,
   COUNT(*) AS customer_count
FROM customer
WHERE email IS NOT NULL
  AND INSTR(LOWER(TRIM(email)), '@') > 0
GROUP BY SUBSTRING_INDEX(LOWER(TRIM(email)), '@', -1)
ORDER BY customer_count DESC, email_domain
LIMIT 15;

Resultado: você obtém a distribuição de clientes por domínio de e-mail. Essa consulta é útil para exploração inicial da audiência, detecção de anomalias e preparação de segmentos de comunicação.

Este exemplo mostra um ponto importante: funções de string são mais poderosas em cadeia. Primeiro limpamos o valor, depois validamos a estrutura, em seguida extraímos o domínio e só então agregamos.

Recomendações práticas

• Normalize o texto antes de comparar e agrupar.
• Se a mesma função for usada muitas vezes na mesma consulta, considere um CTE ou subconsulta para melhorar a legibilidade.
• SUBSTRING_INDEX() é muito útil no MySQL, mas outros SGBDs podem exigir sintaxe diferente.
• Não tente resolver toda a lógica de limpeza em uma única linha; processe o texto por etapas.

Principais conclusões desta aula:

• O processamento prático de strings em SQL é essencial para limpeza, normalização, extração e validação de dados textuais.
• TRIM, LOWER, REPLACE, SUBSTRING_INDEX, LEFT, RIGHT e CONCAT_WS são especialmente úteis no trabalho diário.
• Antes da análise, o texto deve ser normalizado para um formato consistente, evitando agrupamentos e comparações incorretas.
• SQL não apenas formata strings, mas também ajuda a detectar rapidamente problemas de qualidade de dados.
• O maior ganho vem da aplicação sequencial de funções em um fluxo claro de trabalho.

Perguntas frequentes

Por que normalizar texto se os valores da tabela já parecem corretos?

Porque mesmo dados aparentemente limpos podem conter espaços extras, caixa inconsistente ou pequenas variações de formato. A normalização torna filtros, comparações e agrupamentos mais confiáveis.

Por que extrair o domínio do e-mail é útil para análise?

O domínio ajuda a segmentar usuários, identificar endereços corporativos e detectar anomalias. É uma forma simples de transformar um campo textual bruto em atributo analítico.

Quando é melhor montar campos textuais no SQL em vez da aplicação?

Quando esses campos são necessários para relatórios, interfaces administrativas, exportações ou análises intermediárias. Nesses casos, montar rótulos no SQL reduz pós-processamento e mantém a lógica próxima dos dados.

Perguntas de entrevista

Que tipos de tarefas você resolve com funções de string em SQL analítico?

Normalmente: limpeza de texto, normalização de formato, extração de atributos e validação de dados. Na prática, essas funções são usadas antes de agrupamentos, segmentações e montagem de campos de relatório.

Por que aplicar TRIM() e LOWER() antes de GROUP BY em colunas de texto?

Sem normalização, o mesmo valor pode cair em grupos diferentes por causa de caixa distinta ou espaços extras. A limpeza prévia melhora a precisão da agregação e reduz diferenças falsas.

Como você explicaria o valor de SUBSTRING_INDEX() com um exemplo prático?

No MySQL, essa função é útil para extrair rapidamente uma parte da string usando um separador. Por exemplo, você pode extrair o domínio de um e-mail e usar isso imediatamente em segmentação de usuários ou relatórios analíticos.

Na próxima aula, vamos avançar para o uso de SQL em análise e relatórios e ver como transformar dados preparados em insights de negócio úteis.