O problema das listas que nunca atualizam
Eu passei dois dias numa sexta-feira tentando descobrir por que um sistema de catálogo inteiro estava ficando desatualizado e ninguém percebia. A causa raiz era simples: o processo de revisão dependia de um livro deixada para tras que não tinha gatilhos automáticos de sincronização. Quando um registro novo entra no banco, ele fica parado lá, esperando que alguém se lembre de atualizar a lista. Na prática, isso significa que a versão impressa ou digital do catálogo começa a divergir da realidade operacional dentro de algumas horas, e quem trabalha no campo é que carrega essa inconsistência no dia a dia.
Como configurar livro deixada para tras com gatilhos de atualização
O primeiro passo é entender que a lista não é um arquivo estático. Ela é uma representação viva do estado do sistema naquele momento, e qualquer mudança no banco de dados deve disparar um evento de recalculo. No meu caso, o workaround que funcionou foi criar um trigger SQL que escuta INSERT e UPDATE na tabela de produtos e então dispara um job que roda em background, recalculando a versão da lista em cache. O tempo de recalculo caiu de algo em torno de 45 minutos para cerca de 3 segundos, mas o custo foi a complexidade adicionada ao pipeline de deploy. Configuração básica: primeiro defina a fonte da verdade. No sistema que eu gerencio, a tabela de produtos é a fonte, mas em outros contextos pode ser um arquivo CSV, uma API externa, ou até um formulário web. A escolha da fonte define tudo: latência de atualização, consistência eventual versus forte, e o custo de rollback quando algo dá errado.
👉 Clique no botão abaixo para saber mais sobre o assunto!
A armadilha da consistência eventual
Aqui está o insight contr-intuitivo que aprendi na prática: a maioria dos sistemas não falha porque a lista não atualiza rápido o suficiente. Ela falha porque o mecanismo de atualização assume que a fonte da verdade é absoluta, quando na realidade existem múltiplas fontes concorrentes. Eu vi um caso onde duas equipes escreviam na mesma tabela de produtos, uma via interface gráfica e outra via lote noturno. O sistema de recalculo de lista via interface era disparado em tempo real, mas o lote noturno simplesmente sobrescrevia as mudanças feitas durante o dia, porque não respeitava timestamps. O resultado era uma lista que parecia atualizada mas refletia dados de 24 horas atrás. O workaround que usei foi implementar um campo de versão incrementa a cada mudança, e só permitir escrita quando o timestamp da operação fosse maior que o timestamp atual do registro. Isso custou uma migration de 3 tabelas e cerca de 4 horas de teste de regressão, mas eliminou completamente a inconsistência de dados. Sem esse campo de versão, qualquer mecanismo de atualização acaba criando conflitos silenciosos que só aparecem quando alguém tenta usar dados desatualizados em produção.
Limitações e quando isso falha completamente
Vou ser direto: livro deixada para tras com gatilhos de atualização não funciona bem em três cenários. Primeiro, quando a fonte da verdade é um arquivo CSV enviado manualmente por um fornecedor que não segue um padrão de naming consistente. Segundo, quando existem mais de 3 fontes concorrentes escrevendo na mesma tabela sem um mecanismo de arbitragem. Terceiro, quando a latência de atualização aceitável é menor que 1 segundo, porque mesmo com triggers otimizados, o tempo de rede e serialize overhead limita a velocidade. Nesses casos, a alternativa que recomendo é abandonar a atualização em tempo real e adotar um modelo de replay de eventos. Você para de tentar manter a lista sempre consistente e passa a reconstruir o estado a partir de um log de mudanças. O custo é que você perde a capacidade de consulta em tempo real, mas ganha consistência eventual garantida. Em sistemas que eu configurei dessa forma, o tempo de reconstrução do log foi de cerca de 12 minutos para 500 mil registros, o que é aceitável quando a alternativa é ter dados errados e ninguém perceber.
Um exemplo prático de edge-case
O edge-case mais difícil que encontrei envolveu um sistema onde a lista precisava ser atualizada a cada 5 minutos, mas a fonte da verdade era uma API de terceiro que tinha quota de requisições por hora. Eu configurei o trigger para fazer batch de 100 atualizações por chamada, reduzindo o número de requisições de 200 por hora para cerca de 20, mas o custo foi a latência de batch de cerca de 30 segundos. Se a sua aplicação exige atualizações individuais em tempo real, essa abordagem simplesmente não funciona. A lição prática é que livro deixada para tras é um mecanismo, não uma solução. Ele resolve o problema de inconsistência de dados quando as condições são adequadas, mas cria novos problemas quando as condições mudam. O ajuste fino do trigger, da fonte da verdade, e do mecanismo de arbitragem define se o sistema vai funcionar ou vai gerar inconsistências mais sutis e mais difíceis de detectar.
