Pular para o conteúdo

Chega um pedido de eliminação de dados. Do lado do produto, é um formulário. Do lado da
engenharia, a resposta não depende do SQL que você escreve hoje, depende de como a tabela foi
criada anos atrás.

Este artigo é sobre o que acontece de verdade quando você tenta atender esse pedido no Amazon
Athena, e sobre os dois comandos que quase ninguém roda depois do DELETE.

A LGPD dá ao titular o direito de obter do controlador a “eliminação dos dados pessoais tratados
com o consentimento do titular, exceto nas hipóteses previstas no art. 16″ (Art. 18, inciso VI).

O Art. 16 é a contrapartida: os dados são eliminados após o término do tratamento, e a
conservação fica autorizada em quatro hipóteses, entre elas o cumprimento de obrigação legal ou
regulatória pelo controlador e o uso exclusivo do controlador com os dados anonimizados.

Repare no que a lei não diz. Ela não diz “rode um DELETE“. Ela fala em eliminação, e
transfere para você a pergunta técnica: o dado saiu, ou só parou de aparecer?

Essa distinção é o assunto inteiro daqui para frente.

Em tabela Hive, o DELETE não existe

Antes de discutir estratégia, o fato simples: DELETE FROM está na lista de instruções não
suportadas
pelo Athena SQL. A mesma página remete, logo na abertura, às instruções que existem
para tabelas Iceberg, e essa separação já entrega o enredo: o comando não é do Athena, é do tipo
de tabela.

Em tabela no formato tradicional, gerenciada pelo metastore como uma coleção de arquivos num
prefixo do S3, não há exclusão em nível de linha.

A operação real é outra: reconstruir o conjunto de arquivos sem aquelas linhas.

CREATE TABLE bruto.clientes_sem_titular
WITH (
    external_location = 's3://meu-lake/bruto/clientes_sem_titular/',
    format = 'PARQUET'
) AS
SELECT *
FROM bruto.clientes
WHERE id_titular <> 4711;

E depois, na mão: trocar os arquivos de lugar, corrigir as partições, atualizar o catálogo e
apagar o conjunto antigo. Três consequências, nenhuma delas confortável.

Não há transação. Quem estiver consultando no meio do caminho enxerga um estado
inconsistente, porque a troca de arquivos não é atômica.

O custo cresce com o histórico, não com o titular. Se aquele CPF aparece em quarenta
partições, o pedido de uma pessoa custa a reescrita de quarenta partições.

O processo não é auditável por padrão. O que ficou registrado foi um chamado fechado, não uma
operação versionada.

Em tabela Iceberg, o DELETE existe e não apaga

Em tabela Iceberg, o Athena aceita o comando. É o mesmo SQL que você escreveria em qualquer banco.

DELETE FROM bruto.clientes WHERE id_titular = 4711;

Aqui começa a parte que importa. A documentação da AWS é explícita: o DELETE do Athena em
Iceberg grava arquivos de exclusão posicional, o que se chama exclusão merge-on-read. Ao
contrário de uma exclusão copy-on-write, ela é mais eficiente justamente porque não reescreve
os dados do arquivo
. Quando o Athena lê a tabela, ele combina os arquivos de exclusão com os
arquivos de dados para produzir a visão atual.

Traduzindo para o que interessa num pedido de eliminação: o Parquet original continua no S3, e o
CPF continua legível dentro dele. O que mudou foi a resposta da consulta.

A reação natural é procurar a configuração que troca merge-on-read por copy-on-write. Ela não
existe no Athena, e o motivo é mais interessante que uma simples ausência: o Athena aceita
apenas uma lista predefinida de pares chave-valor nas propriedades de tabela Iceberg. A lista
tem oito entradas, entre elas o formato do arquivo, a compressão, dois limiares de compactação e
três parâmetros de VACUUM. Nenhuma delas controla o modo de escrita.

Não há um write.delete.mode para ajustar. O merge-on-read deixa de ser um padrão que você possa
inverter e passa a ser o contrato, e o procedimento de eliminação precisa ser desenhado em cima
dele.

É aqui que mora o problema real deste artigo. Depois do DELETE, o SELECT não devolve mais o
titular, o relatório fecha, o chamado é marcado como resolvido e todo mundo passa para a próxima
tarefa. A conformidade foi atendida na consulta, e só nela.

Os dois comandos que fecham o pedido

Para o byte sair do disco, faltam duas operações. A sequência completa de um pedido de eliminação
tem três comandos, e o DELETE é apenas o primeiro deles.

A primeira operação que falta funde os arquivos de exclusão nos arquivos de dados, reescrevendo o
layout:

OPTIMIZE bruto.clientes REWRITE DATA USING BIN_PACK
WHERE ano = 2026;

O WHERE aceita somente colunas de partição; coluna comum faz a consulta falhar. Ele existe
para limitar o volume reescrito, porque a compactação é cobrada pela quantidade de dados
percorrida. Sem ele, você reescreve a tabela inteira para atender um titular.

Vale saber como a seleção acontece, porque ela define a conta: o REWRITE DATA usa o predicado
para escolher arquivos, não linhas. Se qualquer linha do arquivo casa com o WHERE, o arquivo
inteiro entra na reescrita. Um titular espalhado fino por muitos arquivos custa caro mesmo com um
WHERE bem apertado.

A segunda operação expira os snapshots antigos e remove arquivos órfãos. Ela é transacional e
existe apenas para tabelas Iceberg na versão 3 do engine do Athena:

VACUUM bruto.clientes;

São quatro remoções, cada uma com seu critério: snapshots mais antigos que a idade configurada;
snapshots que excedem o mínimo que a tabela manda preservar; metadados e dados que ficaram
inalcançáveis depois da saída desses snapshots; e arquivos órfãos mais antigos que a mesma janela
de idade, sendo órfão o arquivo que está no diretório da tabela sem fazer parte do estado dela.

Três das quatro dependem da mesma janela de tempo, e é o padrão dela que engana. O
vacuum_max_snapshot_age_seconds vem em 432000 segundos, ou seja 5 dias. Rodar VACUUM logo
depois do DELETE não expira o snapshot que ainda referencia a linha, porque ele tem minutos de
idade, não dias.

As outras duas propriedades também chegam com padrão herdado: vacuum_min_snapshots_to_keep em
1 e vacuum_max_metadata_files_to_keep em 100.

E aqui está a sutileza que inverte a expectativa de quem encurtou só a janela de idade: o
vacuum_min_snapshots_to_keep tem precedência sobre o vacuum_max_snapshot_age_seconds. A
documentação é direta ao dizer que, se os snapshots mínimos remanescentes forem mais antigos que
a idade especificada, eles são mantidos e o valor da idade é ignorado.

Mexer só na idade, portanto, não garante que o snapshot antigo saia. As duas propriedades são
decididas juntas, ou nenhuma das duas foi realmente decidida. O exemplo da AWS ajusta apenas a
idade; a segunda linha abaixo é acréscimo deliberado, para que a intenção fique escrita na tabela
e não dependa do padrão herdado:

ALTER TABLE bruto.clientes SET TBLPROPERTIES (
    'vacuum_max_snapshot_age_seconds' = '259200',
    'vacuum_min_snapshots_to_keep' = '1'
);

Três armadilhas que sobrevivem ao VACUUM

A permissão que falha em silêncio. Esta é a pior, e vem literalmente da documentação: para o
VACUUM conseguir apagar arquivos de dados, o papel de execução da consulta precisa de
s3:DeleteObject no bucket. Se a permissão não estiver presente, a consulta terá sucesso e os
arquivos não serão apagados
.

Pense no que isso significa num processo de conformidade. Você roda os três comandos, todos
retornam sucesso, o chamado é fechado com evidência de execução, e o CPF continua no bucket. Não
há erro para investigar, porque não houve erro.

Pasta, não raiz de bucket. O VACUUM espera que os dados Iceberg estejam numa pasta do S3, e
não na raiz do bucket. Com os dados em s3://meu-bucket/ em vez de s3://meu-bucket/pasta/, a
instrução falha com GENERIC_INTERNAL_ERROR: Path missing in file system location.

Ainda na mesma família de esquisitice: tabela cujo nome começa com underline precisa de crase no
VACUUM, e aspas duplas não servem no lugar. É particularidade dessa instrução, já que CREATE e
INSERT INTO aceitam o mesmo nome sem crase. Detalhe pequeno até o dia em que o pedido cai numa
tabela chamada _clientes.

O versionamento do S3. Com versionamento habilitado, um DELETE simples não consegue
apagar o objeto permanentemente
: o S3 insere um marcador de exclusão, que passa a ser a versão
atual. Um GET devolve 404 e o S3 se comporta como se o objeto tivesse sido apagado, mesmo que
ele não tenha sido eliminado
. A versão anterior continua lá, com o CPF dentro, e continua sendo
cobrada como armazenamento.

Para remover permanentemente é preciso apagar por versionId, ou deixar o ciclo de vida fazer
isso. E aqui a escolha da ação importa mais do que parece: Expiration age sobre a versão atual e
não a apaga, ela apenas insere o marcador de exclusão e transforma a versão corrente em não
atual. Quem monta a regra com Expiration acreditando estar limpando o bucket está produzindo
exatamente o estado que queria evitar.

A ação que remove de forma definitiva é a NoncurrentVersionExpiration, e a própria documentação
avisa que objetos removidos por ela não podem ser recuperados:

{
  "Rules": [
    {
      "ID": "expira-versoes-nao-atuais",
      "Status": "Enabled",
      "Filter": { "Prefix": "bruto/" },
      "NoncurrentVersionExpiration": { "NoncurrentDays": 7 }
    }
  ]
}

Vale conferir o que ficou para trás antes de declarar o pedido encerrado:

aws s3api list-object-versions \
  --bucket meu-lake \
  --prefix bruto/clientes/ \
  --query 'Versions[?IsLatest==`false`].[Key,VersionId]' \
  --output text

O conflito que ninguém combinou

A documentação do VACUUM traz um aviso curto e importante: ao executar uma operação de
expiração de snapshot, você não consegue mais fazer viagem no tempo para os snapshots
expirados
.

Isso põe duas exigências legítimas em rota de colisão. A conformidade quer a janela de retenção
curta, para que o dado eliminado saia rápido do disco. A auditoria e a capacidade de reprocessar
querem a janela longa, porque é o snapshot antigo que permite reconstruir o que a tabela mostrava
na semana passada.

Não existe configuração que satisfaça as duas. Existe uma decisão, que precisa ser tomada por
tabela, escrita e revisada. Tabela que carrega dado pessoal e tabela analítica agregada não
merecem a mesma janela.

Roteiro para fechar um pedido de eliminação

  1. Descobrir onde o titular está. Um pedido alcança a camada bruta, os modelos derivados e o
    histórico versionado que a própria tabela guarda.
  2. Conferir o formato de cada tabela envolvida. Hive e Iceberg exigem procedimentos
    diferentes, e a resposta ao pedido é do conjunto, não da melhor tabela do conjunto.
  3. Definir a janela de retenção antes de rodar qualquer coisa, com a decisão registrada. As
    duas propriedades juntas, idade máxima e mínimo de snapshots, porque a segunda vence a primeira.
  4. Executar DELETE, depois OPTIMIZE REWRITE DATA, depois VACUUM. Nessa ordem.
  5. Confirmar que o papel de execução tem s3:DeleteObject. Sem isso, os passos anteriores
    produzem sucesso sem efeito.
  6. Verificar o versionamento do bucket e as versões não atuais.
  7. Registrar a evidência. Não o “rodei os comandos”, e sim a contagem depois:

SELECT count(*) AS linhas_restantes
FROM bruto.clientes
WHERE id_titular = 4711;

Essa consulta prova que a linha saiu da visão da tabela. Ela não prova que o byte saiu do
disco. Para isso, a evidência é a listagem de objetos e versões do passo 6.

O que levar disso

A escolha entre Hive e Iceberg foi feita, na maioria das empresas, por motivo de performance e
custo. Ninguém a registrou como decisão de conformidade. E ela é, porque define se atender um
pedido de eliminação é um comando ou um projeto.

Iceberg torna o pedido viável, e não o torna automático. Apagar da consulta leva um comando.
Apagar do disco leva três, mais uma permissão, mais uma regra de ciclo de vida. É o terceiro
comando que ninguém roda, e é a permissão que falha sem avisar.

Formatos de arquivo, tipos de tabela, Hive e Iceberg lado a lado estão no módulo
Formatos de arquivo e tipos de tabela
da trilha de Engenharia de Dados. É material aberto e gratuito.

Referências