# Redshift e Iceberg: transação, conflito e time travel na prática

O Redshift passou a publicar vários DML como um único snapshot Iceberg, a resolver escritas concorrentes que não se sobrepõem e a ler a tabela num instante passado. Avalio o que isso tira da sua fila de plantão, onde a regra de uma tabela por transação e as exclusões do time travel ainda doem, e como eu adotaria.

- URL: https://fernando.moretes.com/blog/redshift-e-iceberg-transacao-conflito-e-time-travel-na-pratica

- Markdown: https://fernando.moretes.com/blog/redshift-e-iceberg-transacao-conflito-e-time-travel-na-pratica/article.md?lang=pt

- Published: 2026-11-17T10:13:40.135Z

- Category: Dados & Plataformas

- Tags: Amazon Redshift, Apache Iceberg, Lakehouse, Data Engineering, ACID, Auditoria

- Reading time: 8 min

- Source: [Amazon Redshift now supports multi-statement transactions, conflict resolution, and time travel for Apache Iceberg](https://aws.amazon.com/about-aws/whats-new/2026/11/redshift-time-travel-multi-statement)

---

Quem já rodou carga noturna em data lake conhece o incidente: o `MERGE` terminou, o `DELETE` dos estornos falhou, e por quarenta minutos o painel de receita mostrou um número inflado que alguém já tinha mandado para a diretoria. A pergunta que esse anúncio do Redshift responde não é "o Iceberg suporta ACID?". O formato sempre suportou commit atômico por snapshot. A pergunta é outra: quem garante que três passos de uma carga viram um snapshot só, e quem resolve quando o streaming e o job agendado escrevem na mesma tabela no mesmo minuto? Até 16/11/2026 a resposta era o seu código de orquestração. Agora uma parte dela é o motor.

## Os números que a AWS publicou

- **12x**: mais commits com 16 escritores. Benchmark de `INSERT` autocommit numa tabela não particionada: sem resolução, 94% dos commits falhavam e a vazão caía para 0,17x a de um escritor.
- **1 em 5**: falhas de escrita eram conflito. Fração semanal de queries de escrita Iceberg com falha causada por conflito concorrente, antes da verificação por operação chegar à frota inteira no início de
- **1**: tabela Iceberg por transação. A transação lê de qualquer lugar, mas escreve em uma tabela só. Escrever numa segunda aborta tudo.

## O que mudou de fato

São três capacidades, e elas valem para o Redshift **provisionado RG** ou **Serverless** escrevendo ou lendo Iceberg, em todas as regiões comerciais. Repare no que ficou de fora: o anúncio não cita RA3. Se o seu cluster ainda é RA3, a conversa começa pela migração para RG, não pelo `BEGIN`.

**Transações multi-statement:** você agrupa `INSERT`, `UPDATE`, `DELETE` e `MERGE` num bloco `BEGIN…COMMIT` e o Redshift publica um único snapshot com uma única atualização de catálogo. Cada statement constrói sobre o metadata não commitado do anterior. Falhou um, nada é publicado, e não há o que desfazer. Funciona também em string com vários statements e em JDBC com `autoCommit=false`. Exige o **patch 206** ou posterior.

**Resolução automática de conflito:** quando outro escritor commita enquanto o seu roda, o motor tenta fazer rebase das suas mudanças sobre a versão mais nova usando só metadata, sem reler dados e sem replanejar a query. Só falha quando os dois mexeram nos mesmos dados.

**Time travel:** `AS OF TIMESTAMP` depois do nome da tabela, em `FROM`, `JOIN` ou `USING`, lê o snapshot que estava corrente naquele instante. Só leitura: não serve como alvo de DML nem de DDL.

O conjunto não é uma feature nova do Iceberg. É o Redshift deixando de ser um escritor ingênuo do formato e passando a ter a semântica que você esperava de um warehouse.

## Dois escritores, um snapshot, uma leitura no passado

Responde a uma pergunta: onde a atomicidade e o conflito são resolvidos. O batch e o streaming escrevem na mesma tabela; o Redshift faz o rebase no commit e publica um snapshot por transação no Glue Data Catalog. O auditor lê um snapshot anterior pelo mesmo motor. A linha tracejada é a manutenção assíncrona, que decide até onde o time travel alcança e limpa os arquivos de transações abortadas.

### Clients

- Nightly batch MERGE + DELETE (compute)
- Streaming ingest INSERT autocommit (messaging)
- Auditor or agent AS OF TIMESTAMP (user)

### Redshift

- Redshift RG / Serverless rebase at commit (compute)

### Lake

- Glue Data Catalog metadata pointer (data)
- S3 Iceberg files data + snapshots (storage)
- Glue optimizers retention + orphans (ci)

### Fluxos

- batch -> rs: BEGIN…COMMIT
- stream -> rs: INSERT concorrente
- rs -> s3: grava arquivos
- rs -> glue: um snapshot por commit
- glue -> s3: aponta o metadata
- auditor -> rs: lê snapshot antigo
- opt -> s3: expira e limpa

## Conflito: o que o motor resolve e o que ele devolve para você

A resolução sobe de granularidade e para assim que prova independência. Primeiro, **por operação**: se um dos lados só acrescentou dados (`INSERT`), o rebase é sempre possível. Depois, **por partição**: se os dois removeram dados, verifica se tocaram partições disjuntas. Por último, **por arquivo**: mesma partição, arquivos diferentes, ainda passa. **Não existe verificação por linha.** Dois `UPDATE` em linhas diferentes que caem no mesmo arquivo de dados são conflito, e o segundo escritor falha.

Isso tem consequência direta no desenho da tabela. Uma tabela não particionada com streaming e um `DELETE` agendado convive bem, porque o streaming só insere. Uma tabela de saldos com dois jobs fazendo `MERGE` concorrente só convive se a partição separar o que cada job toca. Se os dois escrevem em `dt = current_date`, você continua precisando de retry com backoff na orquestração.

Dois detalhes que eu vi pegar gente. O comportamento é governado pela propriedade da tabela `write.*.isolation-level`: tabela marcada como `serializable` devolve todo conflito, sem resolver nenhum. E o `ALTER DATABASE … ISOLATION LEVEL` do Redshift não tem efeito nenhum sobre conflito de commit Iceberg, então mexer nele achando que resolve é perder uma tarde. `ALTER TABLE` concorrente sempre exige reexecução.

O dado de frota é o que me convence: conflito respondia por cerca de uma em cada cinco escritas Iceberg com falha por semana, e caiu para perto de zero com o volume de escrita mais que dobrando.

## Quem resolve sozinho sob concorrência
| Sua escrita | Contra INSERT concorrente | Contra remoção ou compactação | O que você mantém no código |
| --- | --- | --- | --- |
| INSERT | Resolve | Resolve | - |
| DELETE, UPDATE, MERGE | Resolve | Só se partição ou arquivo forem diferentes | Retry com backoff e idempotência |
| ALTER TABLE | Exige reexecução | Exige reexecução | Janela de DDL fora das cargas |
| Tabela serializable | Devolve conflito | Devolve conflito | Todo o retry |

## Onde brilha

- **Nenhum estado intermediário legível:** Spark, Athena ou outro Redshift veem a tabela antes ou depois do batch, nunca no meio. O SELECT de conferência dentro da transação enxerga as próprias mudanças antes do COMMIT.
- **Menos snapshots, menos metadata:** um snapshot por carga em vez de um por statement. Com 25 statements pequenos por commit, a AWS mediu 14,77% menos tempo em INSERT e 11,29% em DELETE.
- **Vazão concorrente real:** com 32 escritores, transações de quatro INSERT chegaram a 10,37x a vazão de um escritor autocommit único.
- **Relatório reproduzível:** um MERGE que lê `AS OF TIMESTAMP '2026-11-01 02:00:00 UTC'` devolve o mesmo total toda vez que roda, mesmo com pedido chegando depois do corte.
- **Recuperação sem cópia:** DELETE e INSERT a partir do snapshot de uma hora atrás, numa transação só, restauram um cliente inteiro sem manter tabela de backup.

> **Os limites que vão aparecer no primeiro sprint:** **Uma tabela por transação:** não dá para gravar a tabela fato e a tabela de controle de carga no mesmo commit. COPY, UNLOAD, GRANT, ANALYZE, DML em tabela RMS ou temporária e qualquer DDL Iceberg abortam a transação inteira. **Stored procedure:** escrita Iceberg não roda dentro de procedure, então o ETL legado em PL/pgSQL não aproveita nada disso. **Mesmo nome:** acessar a mesma tabela por dois external schemas, ou por um schema e por `awsdatacatalog`, conta como duas tabelas, e a escrita pelo segundo nome falha. **Mudança de comportamento:** um DDL Iceberg sozinho dentro de BEGIN…COMMIT funcionava antes e agora é rejeitado. Cliente com autocommit desligado quebra no deploy.

## Time travel não é trilha de auditoria regulatória

A tentação em ambiente financeiro é ler "auditores consultam a tabela em qualquer ponto no tempo" e riscar o requisito de rastreabilidade da lista. Eu não riscaria, por quatro motivos que estão na documentação.

**Alcance é retenção, não intenção:** o time travel só lê snapshots que ainda existem. Se o otimizador de retenção do Glue expirou o snapshot, a query devolve erro. Quanto você enxerga para trás é uma configuração de manutenção, não uma garantia.

**Lake Formation fica de fora:** tabela governada por Lake Formation, inclusive com data filter ou permissão por coluna, não aceita `AS OF TIMESTAMP`. Isso inclui o catálogo `s3tablescatalog`. Em banco, os dados sensíveis são justamente os que estão sob Lake Formation. E o desencontro é curioso: a transação multi-statement funciona em S3 Tables, o time travel não.

**Permissão é a de hoje:** o Redshift checa o acesso como ele é agora, não como era no instante consultado. Para auditoria de "quem podia ver o quê em março", isso não responde nada.

**Schema aninhado bloqueia:** se o snapshot lido tiver qualquer coluna `struct`, `array` ou `map`, a query falha, mesmo sem selecionar a coluna. Nada de data sharing, nada de `AS OF VERSION` por snapshot ID, nada de `AS OF TIMESTAMP` em definição de view.

A própria AWS recomenda guardar histórico de meses ou anos na tabela, com colunas de timestamp e operação. Concordo: time travel é ferramenta de operação para dias, não arquivo de compliance para anos.

## O custo que aparece depois: arquivos órfãos, snapshots e compactação

Construir a transação é escrever BEGIN e COMMIT. O custo real não é esse, é manter o lake limpo e previsível por anos.

**Transação abortada deixa lixo:** cada statement grava arquivos de dados e metadata intermediário na localização da tabela antes do COMMIT. Se a transação falha, nenhum snapshot referencia esses arquivos e eles viram órfãos. Em S3 Tables a remoção de arquivos não referenciados vem ligada. No Glue Data Catalog você precisa habilitar o otimizador de deleção de órfãos, e ele só remove arquivos criados **depois** de habilitado. Ligue antes do primeiro deploy, não depois de perceber a fatura do S3.

**Retenção é um trade-off de três lados:** cada snapshot retido deixa o planejamento do time travel mais lento e segura no storage os arquivos que só ele referencia. Retenção curta demais quebra a recuperação; longa demais cobra em S3 e em latência de planejamento. Defina pelo requisito real: se a janela de detecção de carga ruim é de 48 horas, retenha um pouco mais que isso.

**Snapshot antigo lê devagar:** um snapshot de antes da compactação carrega os arquivos pequenos de quando foi escrito. Consultar a tabela de sete dias atrás pode custar mais que consultar a atual. Compactação regular pelo otimizador do Glue ou do S3 Tables entra na conta.

**Recuperação também desfaz o trabalho dos outros:** restaurar a partir de uma hora atrás apaga o que outros escritores gravaram nessa hora. Escolha o instante logo antes da carga ruim e filtre pelo escopo dela.

## Como eu adotaria

1. **Confirme o terreno**: Cluster RG ou Serverless, patch 206 ou posterior, tabela no Glue Data Catalog ou em S3 Tables. RA3 fica fora do anúncio.

2. **Ligue a manutenção antes**: No Glue, habilite deleção de órfãos, retenção de snapshots com janela tirada do requisito de recuperação e compactação. Sem isso a primeira transação abortada já deixa lixo permanente.

3. **Padronize um nome por tabela**: Escolha um external schema por tabela Iceberg e proíba o acesso por `awsdatacatalog` nos jobs de escrita. Revise com grep antes de ligar.

4. **Reescreva a carga como uma transação com portão**: MERGE, DELETE, SELECT de conferência contra o total de controle e COMMIT ou ROLLBACK. A tabela de controle de carga é gravada depois, em transação própria, com chave idempotente por execução.

5. **Desenhe a partição para o conflito**: Se dois jobs removem dados da mesma tabela, a partição precisa separar o que cada um toca. Mantenha retry com backoff exponencial para o conflito que sobra e mova DDL para uma janela fora das cargas.

6. **Fixe o instante nos relatórios**: Use timestamp literal com fuso, como `'2026-11-01 02:00:00 UTC'`. `CURRENT_TIMESTAMP` muda a cada execução, `GETDATE` não é aceito e prepared statement com instante móvel devolve erro.

## Anti-padrões

- **Tratar time travel como backup:** snapshot expirado não volta. Para dado que precisa sobreviver, grave com CREATE TABLE AS a partir do snapshot, ou mantenha histórico na própria tabela.
- **Supor atomicidade entre tabelas:** fato e dimensão não commitam juntos. O consumidor pode ver a fato nova com a dimensão velha, então o contrato de leitura precisa tolerar isso.
- **Remover o retry porque agora resolve sozinho:** UPDATE concorrente no mesmo arquivo ainda falha. Sem retry idempotente, a carga das 2h morre em silêncio na primeira colisão.
- **Confiar no isolamento do banco:** mudar `ALTER DATABASE … ISOLATION LEVEL` não altera nada no Iceberg. Quem manda é `write.*.isolation-level` na tabela.

> **Nota do curador:** Eu adotaria já nas cargas de tabela única que hoje usam staging mais swap só para esconder o estado intermediário: essa engenharia toda vira um BEGIN e um COMMIT. O que eu não faria é apresentar o time travel ao time de risco como trilha de auditoria, porque a tabela mais sensível costuma estar sob Lake Formation e ali ele não funciona. A lição que carrego de plataformas financeiras é que o custo de um recurso de consistência não está no dia em que você liga, está no órfão, no snapshot retido e no retry que alguém removeu meses depois. Ligue a manutenção do Glue antes da primeira transação, não depois da primeira fatura.

## Referências

- [AWS What's New: Amazon Redshift now supports multi-statement transactions, conflict resolution, and time travel for Apac](https://aws.amazon.com/about-aws/whats-new/2026/11/redshift-time-travel-multi-statement)
- [Amazon Redshift Developer Guide: Transaction semantics for Iceberg writes](https://docs.aws.amazon.com/redshift/latest/dg/iceberg-writes-transaction-semantics.html)
- [Amazon Redshift Developer Guide: Time travel queries on Iceberg tables](https://docs.aws.amazon.com/redshift/latest/dg/iceberg-time-travel.html)
- [AWS Big Data Blog: Multi-statement transactions for Apache Iceberg tables in Amazon Redshift](https://aws.amazon.com/blogs/big-data/multi-statement-transactions-for-apache-iceberg-tables-in-amazon-redshift/)
- [AWS Big Data Blog: Resolving concurrent write conflicts for Apache Iceberg tables in Amazon Redshift](https://aws.amazon.com/blogs/big-data/resolving-concurrent-write-conflicts-for-apache-iceberg-tables-in-amazon-redshift/)
- [AWS Glue Developer Guide: Snapshot retention optimization](https://docs.aws.amazon.com/glue/latest/dg/snapshot-retention-management.html)

## Veredito

**Adote** quando a carga escreve em uma tabela Iceberg, o cluster é RG ou Serverless e o problema de hoje é estado intermediário visível ou commit concorrente falhando: é o caso mais comum e o ganho é imediato. **Espere ou complemente** quando você precisa de atomicidade entre fato e dimensão, quando o ETL vive em stored procedure, ou quando a tabela está sob Lake Formation e o requisito é auditoria de longo prazo. Aí o desenho continua sendo seu: transação por tabela com chave idempotente, e histórico regulatório como dado na tabela. A AWS fechou a maior lacuna de semântica entre o Redshift e um warehouse de verdade; as que sobraram estão documentadas e são contornáveis.

**Rating:** 8/10
