Parenteses Dentro De Parenteses

Como lidar com parenteses dentro de parenteses em expressões regulares

A gente sempre esbarra nisso. Você tá montando uma regex pra extrair algo simples e na hora H descobre que o dado que precisa capturar já vem com um parêntese dentro dele. Parece besteira, mas é onde muita gente travinha e começa a chutar soluções que não funcionam. Basicamente, é a situação em que você precisa capturar um trecho que contém colchetes ou parênteses como parte do próprio conteúdo. O problema não é teórico. Eu tive isso numa extração de comandos SQL que vinham formatados assim: ALTER TABLE usuarios ADD COLUMN observacoes VARCHAR(100). A regex parecia lógica — capturar tudo entre ALTER TABLE e o fechamento — mas o parêntese de (100) quebrava o matcher na hora. A solução mais direta é usar uma regex com correspondência não-gulosa (lazy matching). Em vez de algo como ALTER TABLE\s+(\S+).*\), você troca por ALTER TABLE\s+(\S+).*?\). O ? faz o quantificador parar no primeiro fechamento possível, não no último. Isso resolve 80% dos casos.

Quando isso não basta, aí entra o truque que eu uso no dia a dia: char class com escape. Em vez de tentar capturar com parênteses convencionais, eu uso colchetes no padrão e faço o matching manual. Algo tipo ALTER TABLE\s+(\S+)\s+\w+\s+[^)]*\([^)]+\). Tá um pouco verboso, mas é previsível. E previsível é o que importa quando o parser começa a falhar às 2 da manhã.

Quando a regex comum não resolve

Tem situações em que a estrutura é tão aninhada que a regex virou um exercício de masoquismo. Eu me deparei com um caso desses num log de API onde os parâmetros vinham JSON dentro de JSON, tipo {"query": "SELECT * FROM table WHERE id IN (1, 2, 3)"}. Tentar capturar isso com regex pura era pedir para sofrer. Aí eu deixei a regex buscar só o payload inteiro e tratei o JSON internamente com o parser nativo da linguagem. Em Python, por exemplo, eu uso re.findall(r'{"query":\s*"([^"]+)"}', log) para puxar a string crua e depois faço json.loads() se precisar estruturar. É mais trabalho, mas evita aquele ciclo interminável de tentar ajustar o escape e nunca conseguir.

Limitações que ninguém conta

Regex com parenteses dentro de parenteses tem um limite prático: aninhamento profundo. Se o nível de aninhamento passar de 3 ou 4 camadas, a regex geralmente se torna ilegível e instável. Nesses casos, o recomendado é abandonar a abordagem e usar um parser de expressões com gramática formal. Em Python, o módulo regex (o != re) suporta recursão com (?R), o que resolve vários cenários. Mas esse módulo não vem instalado por padrão e pode causar problemas de performance em input grandes. Se o seu problema envolve aninhamento arbitrário — como de parênteses em código-fonte — a alternativa mais segura é construir um mini-analisador com pilha. Você percorre caractere por caractere, incrementa um contador quando encontra ( e decrementa quando encontra ). Quando o contador volta a zero, o trecho está balanceado. Leva uns 15 linhas de código e funciona de verdade.

Dica prática que eu apliquei hoje

Ontem precisei processar um arquivo de 400MB com comandos SQL aninhados de forma irregular. Usei o método de lazy matching primeiro, mas 12% dos registros falhavam por causa de parênteses dentro de strings literais. A solução foi adicionar uma condição negativa: (?![^\s])\) para ignorar parênteses que estavam dentro de aspas. Foi um ajuste fino que reduziu o tempo de processamento de 6 minutos para 47 segundos. O ponto é que parenteses dentro de parenteses raramente é um problema único. Geralmente é um conjunto de edge cases que se sobrepõem. A solução certa depende do formato exato dos seus dados, então testar com amostras reais antes de confiar na regex é mais eficiente do que adivinhar.