Compacte os arquivos pequenos que os acréscimos horários deixam

Cerca de 22 minutos min de leitura, com 3 exemplos em 9 seções.

Edição 2026.11.10 Exemplos aprovados em 20 de nov de 2026 39 de 39 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.10. Leia o original

Este capítulo mostra como contar os arquivos de dados que uma tabela mantém, mesclá-los em menos arquivos no Delta Lake, no DuckLake e no Iceberg, e dizer o que cada união deixa no disco. O problema começa com as cargas. A tabela de pageviews do primeiro capítulo é carregada uma vez por hora em cada um dos três formatos. Cada carga é um commit, e cada commit grava os seus próprios arquivos de dados. Um arquivo de dados é um arquivo Parquet que guarda linhas de uma tabela.

Cargas de hora em hora deixam arquivos pequenos

Última alteração na edição 2026.11.10

Cada commit que acrescenta linhas grava pelo menos um arquivo de dados. Uma tabela que recebe uma carga por hora ganha 24 arquivos de dados por dia, cada um com uma hora de linhas, cerca de 500 linhas aqui. Uma consulta abre cada arquivo que o filtro não descarta, e cada abertura custa tempo. Os metadados da tabela também crescem a cada arquivo listado, porque cada formato mantém um registro de todos os arquivos de dados que a versão atual usa. Muitos arquivos pequenos custam leitura e planejamento mesmo quando o total de linhas é modesto.

O número de arquivos é o que você deve observar, porque ele cresce com o tempo. O tamanho dos arquivos também importa, mas este livro não imprime tamanhos de arquivo, já que um tamanho em bytes muda de uma execução para outra. Contar arquivos é também a verificação honesta de uma compactação. As linhas devem ser as mesmas antes e depois, e a contagem de arquivos deve cair.

A solução é a compactação. A compactação reescreve muitos arquivos de dados pequenos em menos arquivos maiores. Uma compactação é um commit como qualquer outro. Ela grava os arquivos de substituição, os lista nos metadados e deixa os arquivos antigos no disco enquanto o histórico da tabela ainda os referenciar. O capítulo 7 explica quando esses arquivos antigos podem ser removidos.

Os três formatos têm três chamadas diferentes para isso. A tabela abaixo mostra o que cada um fez com os seis arquivos horários que este capítulo constrói.

Formato Chamada Arquivos antes Arquivos depois
Delta Lake optimize.compact() 6 1
DuckLake ducklake_merge_adjacent_files 6 1
Iceberg table.overwrite(table.scan().to_arrow_batch_reader()) 6 1

As contagens da tabela são as que cada exemplo imprimiu. Cada exemplo carrega as seis horas do recorte, uma carga por hora, em uma tabela sem partições, de modo que cada formato começa com um arquivo de dados por carga. As tabelas particionadas do capítulo 4 se comportariam de forma diferente, porque cada partição é compactada separadamente nos formatos que suportam isso. Este capítulo mantém a tabela sem partições para que a contagem tenha uma só causa.

Os números do DuckLake precisam de mais uma configuração para fazerem sentido. As cargas horárias aqui têm cerca de 500 linhas cada, acima do limite de linhas para inlining que o capítulo 1 apresenta, então o padrão as gravaria como arquivos de qualquer forma. O exemplo do DuckLake ainda se conecta com o inlining desligado, a configuração que aquele capítulo explica, para que a contagem de arquivos nunca dependa de quantas linhas uma carga por acaso tenha.

Regra prática: Conte os arquivos de dados de cada tabela após cada carga e programe a compactação a partir da taxa com que os arquivos chegam e do tamanho de arquivo de que seus leitores precisam. Uma carga a cada hora dá 24 arquivos por dia por tabela, então uma compactação diária é uma primeira escolha razoável. Esta é uma regra prática, não uma medição. Compacte com mais frequência apenas quando os tempos de leitura ou as contagens de arquivos da sua própria tabela mostrarem que você precisa.

Compactar com optimize.compact()

Última alteração na edição 2026.11.10

O Delta Lake é o primeiro dos três formatos na tabela acima. A sua biblioteca Python, deltalake, coloca a compactação na propriedade optimize da tabela. O método compact() reescreve os arquivos de dados pequenos da tabela em arquivos maiores e retorna um dicionário de métricas. O dicionário traz as contagens de arquivos adicionados e removidos, e campos de tamanho que este livro não imprime.

Você carrega as seis horas em uma tabela Delta, com um append para cada uma, conta os arquivos que a tabela lista, compacta e conta de novo. Cada contagem vem da própria lista de arquivos da tabela para a sua versão atual.

file-counts-before-after.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Aprovado
"""Load six hourly appends into a Delta Lake table, compact it, and count its files and rows before and after.The point rests on the file-count lines, and on the row count read from the version before the compaction."""from deltalake import DeltaTable, write_deltalakefrom lib.lakehouse import delta_file_count, new_warehouse, read_cut_hour, read_deltadef main():    with new_warehouse() as wh:        path = str(wh.root / "delta" / "pageviews_hourly")        for hour in range(6):            write_deltalake(path, read_cut_hour(hour), mode="append")        table = DeltaTable(path)        version_before = table.version()  # the version the read at the end goes back to        print(f"files before compaction: {delta_file_count(table)}")  # counts the files this version lists, not the disk        metrics = table.optimize.compact()  # a dict; numFilesAdded and numFilesRemoved are the two counts printed below        print(f"files added by compaction: {metrics['numFilesAdded']}")        print(f"files removed by compaction: {metrics['numFilesRemoved']}")        table = DeltaTable(path)        print(f"files after compaction: {delta_file_count(table)}")        print(f"rows after compaction: {len(read_delta(path))}")        before = read_delta(path, version=version_before)        print(f"rows at the version before compaction: {len(before)}")        parquet = list((wh.root / "delta").rglob("*.parquet"))  # every file on disk, including ones the current version dropped        print(f"parquet files on disk after compaction: {len(parquet)}")if __name__ == "__main__":    main()
Saídapython file-counts-before-after.py
files before compaction: 6
files added by compaction: 1
files removed by compaction: 6
files after compaction: 1
rows after compaction: 2999
rows at the version before compaction: 2999
parquet files on disk after compaction: 7

A compactação altera os arquivos, não as linhas. A tabela lista 6 arquivos de dados antes da chamada e 1 depois dela, e uma leitura da versão atual retorna 2999 linhas, as mesmas linhas de antes, em menos arquivos.

As métricas que a chamada retorna contam a mesma mudança do lado da biblioteca: 1 arquivo adicionado e 6 arquivos removidos.

A compactação não removeu os arquivos antigos. Lida na versão de antes da chamada, a tabela ainda retorna todas as 2999 linhas, porque essa versão aponta para os arquivos antigos. O diretório contém 7 arquivos Parquet após a chamada, os seis antigos e o novo. O Delta Lake remove os arquivos que nenhuma versão retida usa em uma etapa separada chamada vacuum, que o capítulo 7 mostra. Até que essa etapa seja executada, uma compactação adiciona arquivos ao disco em vez de retirar algum.

As leituras Delta aqui passam pelo construtor de consultas da biblioteca, como todas as leituras Delta deste livro. Como o ponto é a contagem de arquivos, as linhas são comparadas apenas pela contagem.

Regra prática: Compacte uma tabela Delta na programação da primeira seção (diariamente para cargas horárias) e verifique a contagem de arquivos depois. Leia as regras de retenção do capítulo 7 antes de remover qualquer coisa: uma compactação adiciona um commit e deixa os arquivos antigos no lugar, o que aumenta o armazenamento até que o vacuum seja executado.

Compactação no DuckLake

O DuckLake tem a compactação como uma função de manutenção que você chama a partir do SQL. A função é uma única chamada e retorna uma linha que informa o que ela fez para cada tabela que mescla. A próxima parte descreve a função e o único caso que ela ignora.

Mesclar arquivos adjacentes

Última alteração na edição 2026.11.10

ducklake_merge_adjacent_files recebe um catálogo e, opcionalmente, um nome de tabela e um nome de esquema, o que a chamada exige quando a tabela não está no esquema main. Sem um nome de tabela, ela mescla os arquivos de todas as tabelas. A documentação do DuckLake diz que a função pode "mesclar múltiplos arquivos Parquet em um único arquivo Parquet que contém dados inseridos por múltiplos snapshots" (Documentação do DuckLake: Merge Files). A mesclagem também funciona sem expirar snapshots, e não exclui os arquivos antigos de imediato. Esses dois pontos importam para o restante deste capítulo. Como a mesclagem não expira snapshots, todo snapshot mais antigo ainda se refere aos arquivos antigos.

O que a mesclagem deixa para um snapshot anterior a ela? O exemplo abaixo lê um. Ele conecta o catálogo com o inlining desligado, insere as seis horas, uma inserção por hora, e chama a mesclagem uma vez. A tabela fica no esquema wiki, então a chamada a nomeia. Ele lê o número do snapshot antes da mesclagem, para poder ler a tabela como estava naquele ponto.

compact-ducklake.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Aprovado
"""Merge six DuckLake data files, then read a snapshot from before the merge to see what the merge left behind.The point rests on the data-file lines, and on the row count read at the earlier snapshot."""from lib.lakehouse import (    DUCKLAKE_ALIAS,    NAMESPACE,    TABLE,    connect_ducklake,    create_ducklake_table,    ducklake_file_count,    new_warehouse,    read_cut_hour,)def main():    with new_warehouse() as wh:        lake = connect_ducklake(wh.con)        create_ducklake_table(lake, wh.root)  # inlining is off here, so every insert writes a data file        table = f"{DUCKLAKE_ALIAS}.{NAMESPACE}.{TABLE}"        for hour in range(6):            lake.register("hour", read_cut_hour(hour))            lake.execute(f"INSERT INTO {table} SELECT * FROM hour")            lake.unregister("hour")        # the newest snapshot before the merge, which the read at the end goes back to        before = lake.execute(f"SELECT max(snapshot_id) FROM ducklake_snapshots('{DUCKLAKE_ALIAS}')").fetchall()[0][0]        print(f"data files before merge: {ducklake_file_count(lake, DUCKLAKE_ALIAS, TABLE)}")        # the schema is named because the table is not in main; the call returns one row        result = lake.execute(            f"CALL ducklake_merge_adjacent_files('{DUCKLAKE_ALIAS}', '{TABLE}', schema => '{NAMESPACE}')"        ).fetchall()        # the row's fields: schema, table, files merged, files created        print(f"files merged: {result[0][2]}")        print(f"files created: {result[0][3]}")        print(f"data files after merge: {ducklake_file_count(lake, DUCKLAKE_ALIAS, TABLE)}")        print(f"rows after merge: {lake.execute(f'SELECT count(*) FROM {table}').fetchall()[0][0]}")        old = lake.execute(f"SELECT count(*) FROM {table} AT (VERSION => {before})").fetchall()[0][0]        print(f"rows at the snapshot before merge: {old}")        # every Parquet file under the data path, including the ones the table no longer lists        parquet = list((wh.root / f"{DUCKLAKE_ALIAS}_data").rglob("*.parquet"))        print(f"parquet files on disk after merge: {len(parquet)}")if __name__ == "__main__":    main()
Saídapython compact-ducklake.py
data files before merge: 6
files merged: 6
files created: 1
data files after merge: 1
rows after merge: 2999
rows at the snapshot before merge: 2999
parquet files on disk after merge: 7

A linha de resultado da mesclagem informa o que ela fez: 6 arquivos mesclados em 1 arquivo. A tabela lista depois 1 arquivo de dados, em comparação com 6 antes. A linha também nomeia o esquema e a tabela, então uma mesclagem apontada para a tabela errada aparece antes de qualquer outra coisa ser lida.

O snapshot antigo continua legível. Uma contagem feita no snapshot anterior à mesclagem retorna 2999 linhas, a mesma contagem que a tabela atual retorna. Os arquivos Parquet em disco somam 7, os seis que as inserções escreveram e o que a mesclagem escreveu. Os seis arquivos antigos permanecem em disco até que a limpeza do capítulo 7 os remova.

A mesclagem ignora um arquivo que tenha um arquivo de exclusão associado. Um arquivo de exclusão é um registro de linhas apagadas, que o DuckLake escreve no lugar de reescrever o arquivo de dados quando linhas são apagadas. O capítulo 5 escreve arquivos de exclusão no DuckLake, então esse limite se aplica ali. A documentação do DuckLake nomeia ducklake_rewrite_data_files como a chamada que reescreve esses arquivos, e seu padrão delete_threshold é 0.95, que reescreve um arquivo somente quando essa parcela de suas linhas foi apagada (Documentação do DuckLake: Rewrite Files with Deletes). O padrão é um valor que você deve escolher para os seus próprios dados, e não aceitar sem verificar.

Regra prática: Execute ducklake_merge_adjacent_files depois que as inserções de um período terminarem, e leia a contagem de arquivos que ela retorna. Uma mesclagem não remove linhas apagadas, então, para uma tabela com arquivos de exclusão, chame ducklake_rewrite_data_files com um delete_threshold que você escolheu para essa tabela, e confira o resultado.

Reescreva a tabela para compactá-la

Última alteração na edição 2026.11.7

A compactação no Iceberg, na versão fixada do pyiceberg, é uma reescrita por sobrescrita. Este capítulo reescreve a tabela inteira, que é o caso de uma tabela não particionada. Você lê a tabela com uma varredura e sobrescreve a tabela com as linhas que ela devolve. A sobrescrita grava as linhas como novos arquivos de dados de substituição, e os arquivos antigos deixam o snapshot atual. Este é o único caminho de compactação do livro para o Iceberg, e é uma solução alternativa para uma chamada ausente, que a próxima parte explica.

Uma reescrita é avaliada pelo que deixa para trás. A verificação abaixo lê os arquivos e as linhas da tabela após seis appends e uma sobrescrita, e lê um snapshot anterior à reescrita.

iceberg-rewrite-by-overwrite.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Aprovado
"""Rewrite an unpartitioned Iceberg table by overwriting it with its own scan, then check its data files, its snapshothistory and a snapshot from before the rewrite. The point rests on the data-file lines and on the row count of snapshot 6."""from lib.lakehouse import (    create_iceberg_table,    iceberg_file_count,    new_warehouse,    read_cut_hour,    scan_arrow,    snapshot_labels,)def main():    with new_warehouse() as wh:        table = create_iceberg_table(wh)        for hour in range(6):            table.append(read_cut_hour(hour))        last_append = table.current_snapshot().snapshot_id  # the snapshot after the sixth append        print(f"data files before rewrite: {iceberg_file_count(table)}")        # a batch reader, so the rows are not all read into one Arrow table first        table.overwrite(table.scan().to_arrow_batch_reader())        print(f"data files after rewrite: {iceberg_file_count(table)}")        print(f"rows after rewrite: {len(scan_arrow(table))}")        # sorted by sequence number, which puts the snapshots in commit order        snapshots = sorted(table.snapshots(), key=lambda snapshot: snapshot.sequence_number)        # labels count up in commit order, so the sixth append is snapshot 6        labels = snapshot_labels([snapshot.snapshot_id for snapshot in snapshots])        operations = [snapshot.summary.operation.value for snapshot in snapshots]        print("snapshot operations in order: " + ", ".join(operations))        print(f"{labels[last_append]} rows: {len(scan_arrow(table, snapshot_id=last_append))}")        # every Parquet file in the warehouse, including those that only older snapshots still hold        parquet = list((wh.root / "warehouse").rglob("*.parquet"))        print(f"parquet files on disk after rewrite: {len(parquet)}")if __name__ == "__main__":    main()
Saídapython iceberg-rewrite-by-overwrite.py
data files before rewrite: 6
data files after rewrite: 1
rows after rewrite: 2999
snapshot operations in order: append, append, append, append, append, append, delete, append
snapshot 6 rows: 2999
parquet files on disk after rewrite: 7

Os arquivos de dados passam de 6 para 1, e um leitor da tabela vê as mesmas 2999 linhas, lidas da mesma forma, a partir de menos arquivos. A reescrita é um único commit que adiciona dois snapshots. As operações, em ordem de commit, são seis appends e depois delete e append: o snapshot de delete remove todos os arquivos de dados da tabela, e o snapshot de append adiciona os arquivos reescritos. O snapshot atual muda uma única vez, de modo que nenhum leitor vê a tabela vazia, mas o histórico guarda os dois snapshots. Excluir arquivos inteiros dessa forma é o comportamento copy-on-write que o capítulo 5 descreve para exclusões no Iceberg.

O snapshot anterior à reescrita ainda lê todas as linhas. Os rótulos contam os snapshots em ordem de commit, de modo que o snapshot 6 é o último append antes da reescrita. Lido nesse snapshot, a tabela ainda devolve 2999 linhas. Os arquivos Parquet em disco somam 7: os seis arquivos antigos e o que a reescrita gravou. O capítulo 7 explica como expirar os snapshots antigos e contar o que eles ainda guardam.

Regra prática: Reescreva uma tabela Iceberg por sobrescrita somente quando nenhum outro escritor fizer commit na tabela durante a reescrita. Em uma tabela não particionada, faça a varredura em fluxo, como este exemplo faz. Em uma tabela particionada, a varredura deve ser lida com to_arrow(), de modo que a varredura inteira precisa caber na memória do job. Um leitor de fluxo só pode ser lido uma vez: se o commit falhar, crie um novo leitor para a próxima tentativa. Verifique a contagem de arquivos e a contagem de linhas após cada reescrita, e guarde o snapshot anterior a ela até que você tenha verificado o resultado.

Por que o pyiceberg não tem uma chamada de reescrita

Última alteração na edição 2026.11.7

A documentação da API do pyiceberg lista overwrite entre as operações de tabela (Documentação da API do PyIceberg). Sua única frase sobre compactação está na nota sobre appends rápidos, e ela trata de metadados: a página diz que a compactação de metadados está planejada. Ela não diz nada sobre arquivos de dados. Sua única chamada de manutenção é expire_snapshots, que o capítulo 7 aborda. O código-fonte do pyiceberg 0.12.0, em pyiceberg/table/__init__.py, não tem nenhum método que compacte ou reescreva arquivos de dados. Suas operações de escrita são append, overwrite, delete, upsert, dynamic_partition_overwrite e add_files. Todas, exceto add_files, gravam arquivos de dados, e add_files registra arquivos que já existem e não grava nenhum. dynamic_partition_overwrite, e overwrite com um overwrite_filter, podem substituir as linhas de uma partição, de modo que uma tabela particionada pode ser reescrita uma partição por vez. Uma compactação é, portanto, uma reescrita construída a partir dessas operações.

A reescrita tem um custo de memória que a contagem de arquivos não mostra, e a forma como o scan é lido determina esse custo. table.scan().to_arrow() lê o snapshot atual inteiro em uma única tabela Arrow na memória antes de a sobrescrita começar. A reescrita acima passa table.scan().to_arrow_batch_reader() em vez disso, e o pyiceberg documenta que uma sobrescrita em streaming é processada em microlotes conforme write.target-file-size-bytes, de modo que sua memória fica limitada. O streaming funciona apenas em tabelas não particionadas, que este capítulo usa. Uma tabela particionada precisa ser lida com to_arrow(), então a memória deve conter todas as suas linhas de uma só vez. O limite é o comportamento documentado do pyiceberg, não uma medição feita aqui.

A reescrita também lê todos os arquivos e grava todos os arquivos, inclusive os que já tinham tamanho suficiente. Uma tabela cujos arquivos têm, em sua maioria, o tamanho certo não se beneficia dela. Esse é o motivo para usá-la apenas quando a contagem de arquivos cresceu e a tabela cabe na memória.

Regra prática: Verifique as notas de versão do pyiceberg a cada atualização em busca de uma chamada de compactação, pois uma chamada dessas substituiria a sobrescrita usada como reescrita neste capítulo. Até lá, trate a sobrescrita como um job em lote, execute-a quando nenhum outro escritor estiver fazendo commit e, em uma tabela particionada, reserve memória para o scan inteiro.

Verifique cada compactação antes de confiar nela

Última alteração na edição 2026.11.7

Juntos, os exemplos deste capítulo imprimem quatro informações, e essas quatro são o que você deve verificar após qualquer compactação que executar. A primeira é a contagem de arquivos da listagem da própria tabela. A segunda é a contagem de linhas da versão atual, que deve coincidir com a contagem anterior à compactação. A terceira é a contagem de linhas de uma versão ou snapshot anterior à compactação, que ainda deve poder ser lida. A quarta é o número de arquivos Parquet no local da tabela, que deve exceder a contagem de arquivos pelo número de arquivos antigos que aguardam limpeza.

As duas primeiras verificações mostram que a compactação fez o que afirma e não alterou nenhuma linha. A terceira mostra que o histórico continua funcionando, o que importa para qualquer leitor que fixe uma versão antiga. A quarta mostra o que a compactação deixou no disco. A primeira e a quarta vêm de lugares diferentes, e os exemplos do livro imprimem ambas, para que uma divergência fique visível na saída e não escondida em um único número. A quarta contagem é 7 para a tabela DuckLake e 7 para a tabela Iceberg, em cada caso um arquivo a mais do que os arquivos que continuam listados. Uma compactação que passa nas três primeiras verificações não tem culpa por uma contagem desse tipo. Os arquivos extras são o estado que o capítulo 7 limpa.

Cada biblioteca tem sua própria listagem de arquivos. O exemplo Delta conta as URIs da versão atual, o exemplo DuckLake pede ao seu catálogo os arquivos da tabela, e o exemplo Iceberg conta as entradas da inspeção de arquivos da tabela. Os três números são lidos dos metadados, portanto não dependem da listagem do diretório, que é a segunda fonte. Quando as duas divergem, pare e descubra o motivo antes de executar a próxima compactação.

Quando uma verificação falhar, interrompa o job e deixe a tabela como está. Não execute uma segunda compactação para corrigir a primeira, porque cada execução é um commit, e a segunda torna o histórico mais difícil de ler. Leia o histórico da tabela para os commits em ordem, encontre aquele que alterou a contagem de linhas e decida a partir daí. O estado anterior à falha é mais fácil de examinar enquanto a tabela ainda o mantém.

Regra prática: Após cada compactação, compare a contagem de linhas com a contagem de antes dela e leia uma versão anterior a ela. Uma compactação que altera a contagem de linhas é uma falha a corrigir antes de executar qualquer outra coisa nessa tabela.

O que dá errado em produção

Última alteração na edição 2026.11.10

O armazenamento cresce antes de diminuir. Cada compactação deste capítulo grava arquivos de substituição e deixa os antigos no disco. Os números mostram isso. Depois da mesclagem do DuckLake, a tabela lista 1 arquivo de dados enquanto 7 arquivos Parquet estão no disco, e depois da reescrita do Iceberg a tabela lista 1 enquanto 7 estão no disco. Uma compactação executada sem uma etapa de expiração deixa a conta de armazenamento maior do que antes. Planeje a expiração e a limpeza junto com a compactação, e meça o disco depois de ambas. O sinal é um disco que cresce após cada execução enquanto a quantidade de linhas e de arquivos da tabela permanece estável.

Linhas excluídas permanecem até que uma reescrita as trate. A mesclagem do DuckLake ignora qualquer arquivo que tenha um arquivo de exclusão, como mostra a seção sobre mesclagem. Uma tabela com exclusões que apenas é mesclada mantém esses arquivos como estão. Use ducklake_rewrite_data_files para eles, com um limite que você escolheu. Meça as linhas antes e depois, porque a mesclagem sozinha não mostrará que as linhas excluídas ainda estão nos arquivos. Observe uma contagem de arquivos com arquivos de exclusão que permanece a mesma após cada mesclagem.

Escritores concorrentes não são testados aqui. Os exemplos deste capítulo executam um escritor por vez e não testam uma compactação que se sobreponha a uma confirmação. Teste a sobreposição no seu próprio motor e agende a compactação em uma janela em que nenhum escritor confirme alterações até que você tenha esse teste. A reescrita do Iceberg é a mais exposta das três, porque lê a tabela inteira e depois a grava novamente. Uma sobreposição com falha apareceria como um erro do escritor ou da compactação, e o livro não reproduziu nenhum.

Compactar com frequência demais custa confirmações; com pouca frequência, custa leituras. Cada compactação é uma confirmação, e cada confirmação acrescenta metadados. Compactar após cada carga dobra as confirmações por carga. Compactar uma vez por mês deixa os arquivos pequenos se acumularem durante um mês. O primeiro caso aparece como uma contagem de confirmações que cresce mais depressa que as cargas; o segundo, como tempos de consulta que sobem com a quantidade de arquivos. Esta é uma troca que você mede na sua própria tabela, não uma regra que os exemplos comprovam.

Uma meta de quantidade não é uma meta de tamanho. Um único arquivo muito grande oferece ao leitor menos trabalho paralelo e menos arquivos a podar por estatísticas no nível do arquivo. Estes exemplos visam uma quantidade de arquivos e não imprimem tamanhos de arquivo. Isso é um juízo sobre os leitores, e os tempos de consulta dos seus leitores devem definir a meta. Tempos de consulta que pioram após uma compactação que produziu um único arquivo muito grande são o alerta.

Regra prática: Agende a compactação junto da expiração e da limpeza, e não separada delas. Execute as quatro verificações de a seção de verificação após cada execução, e interrompa o agendamento se a quantidade de linhas mudar ou se um escritor concorrente falhar.

Decisões tomadas neste capítulo

Última alteração na edição 2026.11.7
  • Cada formato usa a chamada da própria biblioteca, e nenhum exemplo aqui usa uma extensão do DuckDB para Iceberg ou Delta Lake. As leituras e as escritas passam pelas bibliotecas Python e pelo suporte do DuckDB ao DuckLake, de modo que cada contagem vem da ferramenta que escreveu os arquivos.
  • O exemplo do DuckLake faz o attach com o inlining de dados desligado. Desligar o inlining faz com que toda contagem seja uma contagem de arquivos, qualquer que seja o tamanho da carga.
  • As contagens de arquivos vêm da listagem de arquivos da própria biblioteca de cada formato. A contagem de arquivos Parquet no disco é uma segunda verificação, e nada imprime tamanhos de arquivo.
  • As tabelas não são particionadas, de modo que cada contagem tem uma única causa: o número de cargas. O caso particionado fica para o capítulo sobre evolução de partições.
  • A compactação do Iceberg é uma reescrita por sobrescrita, porque o pyiceberg 0.12.0 não tem uma chamada de compactação. A reescrita transmite a varredura, o que o pyiceberg permite para tabelas não particionadas. O capítulo nomeia a solução alternativa e o custo de memória que permanece para tabelas particionadas.
  • Nada neste capítulo expira um snapshot nem remove um arquivo. O capítulo 7 faz as duas coisas, e as contagens deste capítulo são o ponto de partida para esse trabalho.
  • A programação da regra prática é um ponto de partida. O livro não afirma um intervalo ideal, porque o intervalo certo depende da velocidade com que os arquivos de uma tabela chegam e do tamanho que seus leitores precisam que eles tenham.

Este capítulo, nesta edição

Edição 2026.11.10Exemplos aprovados em 20 de nov de 20263 de 3 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.10.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 6 de 10: Compacte os arquivos pequenos que os acréscimos horários deixam

  1. Cargas de hora em hora deixam arquivos pequenos
  2. Compactar com optimize.compact()
  3. Compactação no DuckLake
  4. Mesclar arquivos adjacentes
  5. Reescreva a tabela para compactá-la
  6. Por que o pyiceberg não tem uma chamada de reescrita
  7. Verifique cada compactação antes de confiar nela
  8. O que dá errado em produção
  9. Decisões tomadas neste capítulo

Voltar ao topoTodos os capítulos