Hard deletes no ELT: por que syncs baseadas em cursor não os capturam e como o CDC resolve
Linhas deletadas ficam para sempre no warehouse com sync por cursor. Veja como detectar e corrigir com full refresh, soft delete ou CDC.

Alguns minutos depois de fazer o pedido 3, o cliente o cancela. A aplicação remove a linha da tabela orders em produção. Uma hora depois, a sync para o warehouse termina sem nenhum erro. O dashboard de receita continua mostrando o pedido 3. Semana que vem também vai mostrar. No ano que vem também. Ninguém recebe um alerta, porque nada falhou. O warehouse vai se enchendo aos poucos de linhas que não existem mais na fonte. O financeiro vê um número no app e outro no dashboard. O time de dados não consegue explicar por quê.
Esse é o problema do hard delete. Ele é causado pela forma como as syncs incrementais procuram dados novos. E dá para comprovar isso com uma query SQL simples que você pode rodar no seu warehouse.
Por que uma sync incremental não captura linhas deletadas?
Uma sync incremental pede ao sistema de origem as linhas que mudaram desde a última execução da sync. Na maioria das vezes, o sistema de origem filtra a tabela usando algum timestamp (como updated_at) que faz parte dos dados. Se uma linha foi deletada, não há como a query retorná-la e, como resultado, o data warehouse mantém a cópia antiga para sempre.
A coluna que a sync usa como filtro se chama cursor. Na Erathos, a sync pega o maior valor de updated_at que já está no destino e pede à fonte apenas as linhas mais recentes que esse valor. A query fica assim:
SELECT id, status, amount, updated_atFROM ordersWHERE updated_at > '2026-10-22 09:00:00';
Rodamos isso em uma pequena tabela orders. Às 09:00, a tabela tinha os pedidos 1 a 5, e o warehouse tinha as mesmas cinco linhas. Antes da execução seguinte, deletamos o pedido 3, marcamos o pedido 2 como enviado e adicionamos o pedido 6. A query com cursor retornou apenas duas linhas:
+----+---------+--------+---------------------+| id | status | amount | updated_at |+----+---------+--------+---------------------+| 2 | shipped | 200.00 | 2026-10-22 09:30:00 || 6 | pending | 600.00 | 2026-10-22 09:40:00 |+----+---------+--------+---------------------+
No segundo e no sexto pedido, os timestamps mudaram. No terceiro pedido, o timestamp não é afetado pelo DELETE (o registro é removido, então a linha não está mais lá para ser lida). O processo de sync faz o merge dos dois registros e informa que deu tudo certo.
O processo completo, da primeira sync até o dashboard, é este:
[IMAGEM 1: fazer upload de gtm-1477-img1.png aqui]
Duas mudanças entre execuções, uma linha no warehouse
O caso mais escancarado do problema são os deletes, mas existe um mais silencioso: várias atualizações na mesma linha entre duas execuções da sync.
Imagine que um pedido passa de pending para paid às 09:10 e depois para refunded às 09:50. A próxima execução da sync, às 10:00, vai ler a linha como ela está agora. Então o warehouse só vai ver o estado refunded, e o estado paid se perde para sempre. Como a tabela de origem também não guarda versões antigas da linha, não há como uma query baseada em cursor ler os valores anteriores.
Isso só é um problema se você precisa de valores históricos. Um relatório com o status atual de todos os pedidos está correto, mas um relatório de quantos pedidos foram primeiro pagos e depois reembolsados, ou de quanto tempo ficaram pendentes antes do pagamento, está errado, mesmo parecendo certo.
Dá para diminuir essa janela rodando a sync com mais frequência, mas sempre existe a chance de várias atualizações acontecerem dentro dela. A única forma de resolver isso é com um método que registre cada atualização no momento em que ela acontece, e é isso que o CDC baseado em log faz.
Como verificar se o seu warehouse tem esse problema
Podemos comparar a contagem de linhas e as chaves primárias entre a fonte e o warehouse. Se houver linhas extras no warehouse com chaves que não existem na fonte, essas linhas extras são hard deletes que a sync não capturou.
Depois da sync no nosso teste, as contagens já não batiam:
SELECT COUNT(*) AS source_count FROM orders; -- 5SELECT COUNT(*) AS warehouse_count FROM wh_orders; -- 6
A diferença de valores é a primeira coisa que as pessoas notam. O total no warehouse estava 300.00 acima do de produção, exatamente o valor do pedido deletado:
+--------------+-----------------+---------------+| source_total | warehouse_total | excess_amount |+--------------+-----------------+---------------+| 1800.00 | 2100.00 | 300.00 |+--------------+-----------------+---------------+
Uma contagem mostra que algo está errado, mas não quais linhas. Para encontrá-las, copie a lista de chaves primárias da fonte para o warehouse, por exemplo como uma exportação pontual para uma tabela chamada source_order_ids. Depois procure linhas do warehouse sem correspondência:
SELECT w.id, w.status, w.amountFROM wh_orders wLEFT JOIN source_order_ids s ON s.id = w.idWHERE s.id IS NULL;
No nosso teste, a query retornou o pedido deletado e nada mais:
+----+---------+--------+| id | status | amount |+----+---------+--------+| 3 | pending | 300.00 |+----+---------+--------+
Se a tabela tiver movimento, novas linhas terão sido adicionadas na fonte entre as suas duas contagens. Por isso, você deve comparar as linhas criadas antes de um determinado momento (por exemplo, ontem à meia-noite).
Opção 1: full refresh periódico
Em um full refresh, a Erathos lê a tabela inteira na fonte e sobrescreve a tabela correspondente no destino. Isso remove do warehouse as linhas que foram deletadas na fonte, porque elas não vão existir na nova cópia da tabela. Esse método não exige uma coluna de cursor na tabela de origem nem qualquer modificação nela.
A desvantagem do full refresh é que o desempenho e o custo não acompanham a quantidade de dados que mudou. A Erathos lê todos os dados da tabela, independentemente de quanto mudou. Isso gera mais pressão sobre o seu banco de produção e mais processamento no warehouse, e, em tabelas muito grandes, o full refresh pode demorar muito para terminar. Além disso, como os planos da Erathos são baseados no número de linhas que passam pelos seus pipelines a cada mês, um full refresh diário de uma tabela de 1 milhão de linhas resultaria em 30 milhões de linhas processadas em um mês de 30 dias.
O melhor dos dois mundos é rodar atualizações incrementais na maior parte do tempo e um full refresh de vez em quando para fazer a limpeza. A configuração Enable Full On da Erathos permite agendar execuções completas em cima das execuções parciais. A desvantagem dessa abordagem é que as linhas deletadas continuam no warehouse até o próximo full refresh, e as mudanças de estado que acontecem entre as syncs se perdem.
Opção 2: soft deletes com uma coluna deleted_at
Com soft deletes, a aplicação nunca remove uma linha. Em vez disso, ela grava um timestamp em uma coluna deleted_at. Se ela também avançar o updated_at, a sync com cursor captura a mudança como qualquer outra atualização:
UPDATE ordersSET deleted_at = TIMESTAMP '2026-10-22 09:15:00', updated_at = TIMESTAMP '2026-10-22 09:15:00'WHERE id = 3;
A próxima query com cursor retorna o pedido 3 com o horário em que foi deletado:
+----+---------+--------+---------------------+| id | status | amount | deleted_at |+----+---------+--------+---------------------+| 3 | pending | 300.00 | 2026-10-22 09:15:00 |+----+---------+--------+---------------------+
Os relatórios então passam a filtrar as linhas deletadas: WHERE deleted_at IS NULL. No nosso caso, as linhas deletadas serão ignoradas e teremos 2 pedidos ativos somando 300.00.
Essa abordagem funciona bem desde que seja possível modificar a aplicação e o schema dela. Se estivermos usando uma aplicação de terceiros e o banco dela, não dá para usar soft deletes. Além disso, qualquer caminho que remova dados precisa conhecer e seguir a regra de soft delete. Isso inclui qualquer script administrativo, qualquer job de limpeza e até engenheiros de suporte rodando DELETE manualmente. Se a regra não for seguida em um único caminho, o problema volta. Soft deletes também não resolvem a questão dos estados perdidos entre execuções.
Opção 3: change data capture baseado em log
O log é onde todas as mudanças de um banco de dados ficam registradas. No PostgreSQL, é o write-ahead log (WAL). No MySQL, é o binary log (ou binlog). Em vez de consultar tabelas, o change data capture (CDC) baseado em log lê o log.
Cada insert, update e delete é registrado como uma mudança separada no log. Um delete é só mais um evento em um fluxo de mudanças. O PostgreSQL transforma o WAL em um fluxo de mudanças usando logical decoding. Um cliente pode reproduzir esse fluxo na mesma ordem em que as mudanças aconteceram. Uma linha que mudou de pending para paid e depois para refunded vai aparecer como três mudanças separadas, e não uma.
Este é o caminho que um delete percorre da aplicação até o warehouse:
[IMAGEM 2: fazer upload de gtm-1477-img2.png aqui]
Cada evento de delete contém a linha antiga (ou pelo menos a chave primária dela), mas nenhuma linha nova. No Debezium, um engine de CDC open source, um evento de delete tem os valores antigos no campo before, um null no campo after e um valor op igual a d. O campo after null significa que a linha não existe mais.
As ferramentas de warehouse então transformam esses eventos em um de dois formatos comuns:
- Uma coluna de flag. A linha continua existindo na tabela, e uma coluna indica se ela foi deletada ou não. O Fivetran, por exemplo, adiciona uma coluna
_fivetran_deleteda cada tabela no modo soft delete. - Um timestamp de delete em um registro de mudança. Cada mudança em uma linha é registrada como uma linha, e as linhas de delete têm o horário da exclusão. O Airbyte adiciona uma coluna
_ab_cdc_deleted_atque só é preenchida em registros vindos de comandosDELETE. Na tabela final, ele exclui as linhas cuja mudança mais recente foi um delete.
Em qualquer um dos casos, capturamos o delete com o horário em que aconteceu, então podemos ignorar essas linhas nos relatórios e, ao mesmo tempo, mantê-las nas tabelas de histórico. A sua ferramenta pode gravar deletes nas tabelas de formas diferentes dependendo da configuração, então confira a documentação dela antes de montar os relatórios.
Com CDC, a natureza da entrega incremental muda. Entrega incremental não é o mesmo que streaming, já que você ainda pode agendar a entrega das mudanças em lotes. A diferença é que, em vez de rodar uma query em uma tabela, o processo de entrega parte do log.
O que o banco de origem precisa para o CDC
O CDC depende do log do banco de dados, então o banco precisa gravar dados de log detalhados. Por isso, tanto o PostgreSQL quanto o MySQL exigem alguma configuração antes que a primeira conexão de CDC possa ser criada.
PostgreSQL
O PostgreSQL exige que o parâmetro de configuração wal_level esteja definido como logical. Se você vai criar uma conexão de CDC com a Erathos, o banco de origem precisa das seguintes configurações:
wal_level = logicalmax_replication_slotsemax_wal_sendersprecisam ser no mínimo 10max_slot_wal_keep_sizenão pode estar definido como -1- Um usuário com permissão de replicação precisa existir no banco
Você pode saber mais sobre como conectar o PostgreSQL à Erathos na nossa documentação de PostgreSQL.
Um restart do banco aplica essas configurações. A única exceção é o max_slot_wal_keep_size, que passa a valer sem restart. Em uma instalação nova do PostgreSQL, definimos o nível do WAL e reiniciamos:
ALTER SYSTEM SET wal_level = logical;ALTER SYSTEMSHOW wal_level; wal_level----------- logical(1 row)
max_slot_wal_keep_size: um replication slot retém dados do WAL até que o leitor de CDC os leia. Essa configuração define o tamanho máximo de WAL a ser retido. A Erathos observa que, por padrão, um slot retém uma quantidade infinita de WAL. Isso significa que, se o leitor parar por muito tempo, o WAL vai continuar crescendo até ultrapassar o tamanho do disco do banco. É uma boa ideia definir esse valor com base no tamanho do seu disco, por exemplo:ALTER SYSTEM SET max_slot_wal_keep_size = '5GB';.REPLICA IDENTITY: essa é uma configuração por tabela. Por padrão, o PostgreSQL só grava no WAL os valores antigos da chave primária quando uma linha é atualizada ou deletada. Definir a replica identity comoFULLfaz o WAL registrar os valores antigos de todas as colunas. A Erathos precisa disso em cada tabela para capturar o estado completo de antes e depois das linhas.
O PostgreSQL suporta quatro tipos de replica identity.
[IMAGEM 3: fazer upload de gtm-1477-img3.png aqui]
Criamos uma tabela orders, verificamos a replica identity dela, alteramos e verificamos de novo (d significa default e f significa full):
CREATE TABLE orders (id INT PRIMARY KEY, status TEXT);CREATE TABLESELECT relname, relreplident FROM pg_class WHERE relname = 'orders'; relname | relreplident---------+-------------- orders | d(1 row)ALTER TABLE orders REPLICA IDENTITY FULL;ALTER TABLESELECT relname, relreplident FROM pg_class WHERE relname = 'orders'; relname | relreplident---------+-------------- orders | f(1 row)
MySQL
O MySQL precisa do binlog ativado, no formato ROW com row images FULL. Sem isso, os eventos de update e delete não trazem o estado completo de antes e depois das linhas. O MySQL 8.0 já usa logging baseado em linha por padrão, e o row image padrão dele é full. Um servidor MySQL 8.4 recém-instalado mostrou os dois valores:
+---------------+-------+| Variable_name | Value |+---------------+-------+| binlog_format | ROW |+---------------+-------++------------------+-------+| Variable_name | Value |+------------------+-------+| binlog_row_image | FULL |+------------------+-------+
Ainda assim, vale conferir, já que servidores e serviços gerenciados podem ter alterado esses padrões. Note também que arquivos antigos de binlog são apagados depois de um período de retenção. Se a conexão da Erathos perder um arquivo de binlog de que o CDC precisa, a Erathos vai ter que rodar um novo snapshot inicial.
Modos de snapshot e plano
A primeira escolha é o modo de snapshot, que pode ser initial ou no_data. A primeira opção cria inicialmente uma cópia da tabela e, depois disso, as mudanças são transmitidas a partir do WAL/binlog. A segunda opção só transmite as mudanças que ainda estão disponíveis no log.
Normalmente, você usa initial quando tem uma tabela nova para replicar no warehouse, e no_data quando já tem o histórico e só precisa das mudanças futuras.
O CDC faz parte do plano Pro da Erathos, e temos um guia completo de como configurar uma replicação CDC do MySQL para o BigQuery aqui.
Escolhendo um tipo de atualização por tabela
Um mesmo banco de dados costuma ter tabelas muito diferentes. Uma lista de países, um log de page views e uma tabela de pedidos não precisam da mesma sync. Na Erathos, você define o tipo de atualização de cada tabela, para que cada uma use o método que faz sentido para ela:
Formato da tabela | Tipo de atualização | Por que funciona |
|---|---|---|
Tabelas pequenas de referência (países, planos, categorias) | Full refresh | Recarregar é barato, e os deletes somem a cada execução |
Tabelas com muitos inserts, com chave primária e coluna de date ou datetime (eventos, logs) | Incremental (parcial) | Lê só as linhas novas, e linhas raramente são deletadas |
Tabelas em que deletes ou mudanças de status importam (pedidos, assinaturas, pagamentos) | CDC | Captura cada insert, update e delete a partir do log, na ordem |
Para usar a sync incremental na Erathos, você precisa definir uma chave primária e escolher uma coluna date ou datetime para usar como cursor. Em fontes de banco de dados, o usuário precisa selecionar a coluna de cursor em cada job. Entre os modos parciais, o recomendado é o Partial Overwrite, que atualiza as linhas existentes no lugar em vez de inserir novas cópias de cada linha.
A terceira linha é o exemplo perfeito da nossa tabela de teste. Os cinco pedidos, o único delete e a diferença de $300 na receita poderiam ser resolvidos com um full refresh, desde que a tabela continue pequena. Para milhões de linhas, o CDC é a solução para evitar reler a tabela inteira.
FAQ
Rodar a sync incremental com mais frequência captura os deletes?
Não. Como as queries com cursor só retornam linhas que ainda existem, as linhas deletadas ficam de fora, não importa a frequência com que a query rode. Aumentar a frequência só diminui a janela de tempo em que uma linha pode mudar duas vezes.
Preciso de REPLICA IDENTITY FULL para capturar deletes no PostgreSQL?
Por padrão, o PostgreSQL inclui a chave primária antiga em um evento de delete. Isso basta para identificar a linha deletada. A Erathos usa a configuração FULL para obter o estado de antes e depois da linha modificada. Por padrão, uma tabela sem chave primária não gera nenhum evento de update ou delete no Debezium. Para mais informações, veja a documentação do Debezium sobre PostgreSQL: documentação do conector PostgreSQL do Debezium
O que acontece se a conexão de CDC parar por um tempo?
No PostgreSQL, o replication slot armazena o WAL até o leitor alcançá-lo, então, se o max_slot_wal_keep_size não tiver limite, o disco pode encher. No MySQL, o risco é o contrário. Se os arquivos de binlog forem apagados antes que o CDC consiga lê-los, a conexão vai ter que recomeçar com um novo snapshot inicial.
CDC significa streaming em tempo real?
Não necessariamente. CDC é só um jeito sofisticado de dizer "as mudanças vêm do log do banco de dados". Você pode continuar carregando essas mudanças no seu data warehouse de forma agendada, se quiser.
Devo usar o modo de snapshot initial ou no_data?
initialquando o warehouse ainda não tem a tabela. A Erathos copia a tabela e depois transmite as mudanças.no_dataquando o histórico já foi carregado e você só quer as mudanças daqui para frente.
Tabelas diferentes do mesmo banco podem usar métodos de sync diferentes?
Sim. Na Erathos, o tipo de atualização é uma configuração por tabela, então você pode fazer full refresh nas tabelas de referência enquanto usa CDC na tabela de pedidos.
Qual plano da Erathos inclui CDC?
O CDC está disponível no plano Pro, pelo preço de US$ 250/mês, com pagamento anual. Todas as contas novas têm acesso à versão Pro por 14 dias.
Teste nas suas próprias tabelas
Se os números do seu warehouse e de produção não estão batendo, rode primeiro a verificação de chaves primárias acima na sua maior tabela. Depois use CDC nas tabelas em que os deletes importam. Teste a Erathos grátis por 14 dias, com CDC incluído no teste.