Compacta los archivos pequeños que dejan las inserciones por hora

Unos 19 minutos de lectura, con 3 ejemplos en 9 secciones.

Edición 2026.11.10 Ejemplos verificados el 20 de nov de 2026 39 de 39 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.10. Lee el original

Este capítulo te muestra cómo contar los archivos de datos que contiene una tabla, fusionarlos en menos archivos en Delta Lake, DuckLake e Iceberg, y explicar lo que cada fusión deja en disco. El problema empieza con las cargas. La tabla de pageviews del primer capítulo se carga una vez por hora en cada uno de los tres formatos. Cada carga es un commit, y cada commit escribe sus propios archivos de datos. Un archivo de datos es un archivo Parquet que contiene filas de una tabla.

Las cargas por hora dejan archivos pequeños

Último cambio en la edición 2026.11.10

Cada confirmación que añade filas escribe al menos un archivo de datos. Una tabla que recibe una carga por hora obtiene 24 archivos de datos al día, cada uno con una hora de filas, unos 500 aquí. Una consulta abre cada archivo que su filtro no descarta, y cada apertura cuesta tiempo. Además, los metadatos de la tabla crecen con cada archivo que enumeran, porque cada formato guarda un registro de cada archivo de datos que usa la versión actual. Por tanto, muchos archivos pequeños encarecen las lecturas y la planificación, incluso cuando el número total de filas es modesto.

El número de archivos es la cifra que conviene vigilar, porque crece con el tiempo. El tamaño de los archivos también importa, pero este libro no muestra tamaños de archivo, ya que un tamaño en bytes cambia de una ejecución a otra. Contar archivos es, además, la comprobación honesta de una compactación. Las filas deben ser las mismas antes y después, y el número de archivos debe bajar.

La solución es la compactación. La compactación reescribe muchos archivos de datos pequeños en menos archivos más grandes. Una compactación es una confirmación como cualquier otra. Escribe los archivos de reemplazo, los enumera en los metadatos y deja los archivos antiguos en disco mientras el historial de la tabla siga haciendo referencia a ellos. El capítulo 7 explica cuándo pueden eliminarse esos archivos antiguos.

Cada uno de los tres formatos tiene una llamada distinta para ello. La tabla siguiente muestra lo que cada uno hizo con los seis archivos horarios que construye este capítulo.

Formato Llamada Archivos antes Archivos después
Delta Lake optimize.compact() 6 1
DuckLake ducklake_merge_adjacent_files 6 1
Iceberg table.overwrite(table.scan().to_arrow_batch_reader()) 6 1

Las cifras de la tabla son las que imprimió cada ejemplo. Cada ejemplo carga las seis horas del corte, una carga por hora, en una tabla sin particiones, de modo que cada formato empieza con un archivo de datos por carga. Las tablas particionadas del capítulo 4 se comportarían de otra forma, porque en los formatos que lo admiten cada partición se compacta por separado. Este capítulo mantiene la tabla sin particiones para que el recuento tenga una sola causa.

Las cifras de DuckLake necesitan un ajuste más para tener sentido. Las cargas horarias de aquí tienen unas 500 filas cada una, por encima del límite de filas para la inserción en línea que da el capítulo 1, así que el valor por defecto las escribiría igualmente como archivos. El ejemplo de DuckLake se conecta aun así con la inserción en línea desactivada, el ajuste que explica ese capítulo, para que un recuento de archivos nunca dependa de cuántas filas tenga una carga en particular.

Regla práctica: Cuenta los archivos de datos de cada tabla después de cada carga, y programa la compactación a partir de la velocidad a la que llegan los archivos y del tamaño de archivo que necesitan tus lectores. Una carga cada hora da 24 archivos al día por tabla, así que una compactación diaria es una primera elección razonable. Esto es una regla práctica, no una medición. Compacta con más frecuencia solo cuando tus propios tiempos de lectura o recuentos de archivos demuestren que lo necesitas.

Compactar con optimize.compact()

Último cambio en la edición 2026.11.10

Delta Lake es el primero de los tres formatos de la tabla de arriba. Su biblioteca de Python, deltalake, pone la compactación en la propiedad optimize de la tabla. Su método compact() reescribe los archivos de datos pequeños de la tabla en otros más grandes y devuelve un diccionario de métricas. El diccionario contiene los conteos de archivos añadidos y eliminados, y campos de tamaño que este libro no muestra.

Cargas las seis horas en una tabla Delta, con un append por cada una, luego cuentas los archivos que la tabla lista, compactas y vuelves a contar. Cada conteo proviene de la propia lista de archivos de la tabla para su versión actual.

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 Superado
"""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()
Salidapython 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

La compactación cambia los archivos, no las filas. La tabla lista 6 archivos de datos antes de la llamada y 1 después de ella, y una lectura de la versión actual devuelve 2999 filas, las mismas filas que antes, en menos archivos.

Las métricas que devuelve la llamada registran el mismo cambio desde el lado de la biblioteca: 1 archivo añadido y 6 archivos eliminados.

La compactación no eliminó los archivos antiguos. Leída en la versión anterior a la llamada, la tabla sigue devolviendo las 2999 filas, porque esa versión apunta a los archivos antiguos. El directorio contiene 7 archivos Parquet después de la llamada: los seis antiguos y el nuevo. Delta Lake elimina los archivos que ninguna versión conservada usa en un paso aparte llamado vacuum, que muestra el capítulo 7. Hasta que ese paso se ejecute, una compactación añade archivos al disco en lugar de quitarlos.

Las lecturas de Delta aquí pasan por el constructor de consultas de la biblioteca, como todas las lecturas de Delta de este libro. Como el punto es el número de archivos, las filas se comparan solo por su conteo.

Regla práctica: Compacta una tabla Delta según la programación de la primera sección (a diario para cargas por hora) y comprueba el número de archivos después. Lee las reglas de retención del capítulo 7 antes de eliminar nada: una compactación añade un commit y deja los archivos antiguos en su lugar, así que aumenta el almacenamiento hasta que se ejecute el vacuum.

Compactación en DuckLake

DuckLake tiene la compactación como una función de mantenimiento que tú llamas desde SQL. La función es una sola llamada, y devuelve una fila que indica lo que hizo para cada tabla que fusiona. La siguiente parte describe la función y el único caso que omite.

Fusionar archivos adyacentes

Último cambio en la edición 2026.11.10

ducklake_merge_adjacent_files recibe un catálogo y, opcionalmente, un nombre de tabla y un nombre de esquema, que la llamada necesita cuando la tabla no está en el esquema main. Sin nombre de tabla, fusiona los archivos de todas las tablas. La documentación de DuckLake dice que la función puede "fusionar varios archivos Parquet en un único archivo Parquet que contiene datos insertados por varias instantáneas" (DuckLake documentation: Merge Files). La fusión también funciona sin expirar instantáneas, y no elimina de inmediato los archivos antiguos. Ambos puntos importan para el resto de este capítulo. Como la fusión no expira instantáneas, cada instantánea anterior sigue haciendo referencia a los archivos antiguos.

¿Qué deja la fusión para una instantánea anterior? El siguiente ejemplo lo muestra. Conecta el catálogo con la inserción en línea desactivada, inserta las seis horas, una inserción por hora, y llama a la fusión una vez. La tabla vive en el esquema wiki, así que la llamada la nombra. Lee el número de instantánea antes de la fusión, para poder leer la tabla tal como estaba en ese punto.

compact-ducklake.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Superado
"""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()
Salidapython 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

La fila de resultado de la fusión indica lo que hizo: 6 archivos fusionados en 1 archivo. La tabla muestra 1 archivo de datos después, frente a 6 antes. La fila también indica el esquema y la tabla, de modo que una fusión dirigida a la tabla equivocada se ve antes que cualquier otra cosa.

La instantánea antigua sigue siendo legible. Un recuento tomado en la instantánea anterior a la fusión devuelve 2999 filas, el mismo recuento que devuelve la tabla actual. Los archivos Parquet en disco suman 7: los seis que escribieron las inserciones y el que escribió la fusión. Los seis archivos antiguos permanecen en disco hasta que la limpieza del capítulo 7 los elimine.

La fusión omite un archivo que tiene adjunto un archivo de eliminación. Un archivo de eliminación es un registro de filas borradas, que DuckLake escribe en lugar de reescribir el archivo de datos cuando se borran filas. El capítulo 5 escribe archivos de eliminación en DuckLake, así que esta limitación se aplica allí. La documentación de DuckLake nombra ducklake_rewrite_data_files como la llamada que reescribe esos archivos, y su valor predeterminado delete_threshold es 0.95, que solo reescribe un archivo cuando esa proporción de sus filas está borrada (DuckLake documentation: Rewrite Files with Deletes). El valor predeterminado es algo que debes elegir para tus propios datos, no aceptar sin revisarlo.

Regla práctica: Ejecuta ducklake_merge_adjacent_files cuando terminen las inserciones de un periodo, y lee el recuento de archivos que devuelve. Una fusión no elimina las filas borradas, así que para una tabla con archivos de eliminación, llama a ducklake_rewrite_data_files con un delete_threshold que hayas elegido para esa tabla, y comprueba el resultado.

Reescribe la tabla para compactarla

Último cambio en la edición 2026.11.7

La compactación en Iceberg, con la versión fijada de pyiceberg, es una reescritura por sobrescritura. Este capítulo reescribe la tabla completa, que es el caso de una tabla sin particiones. Lees la tabla con un escaneo y sobrescribes la tabla con las filas que devuelve. La sobrescritura escribe las filas como archivos de datos de reemplazo, y los archivos antiguos salen de la instantánea actual. Esta es la única vía de compactación del libro para Iceberg, y es una solución provisional por una llamada que falta, que explica la siguiente parte.

Una reescritura se juzga por lo que deja. La comprobación siguiente lee los archivos y las filas de la tabla tras seis adiciones y una sobrescritura, y lee una instantánea anterior a la reescritura.

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 Superado
"""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()
Salidapython 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

Los archivos de datos pasan de 6 a 1, y quien lee la tabla ve las mismas 2999 filas, leídas de la misma forma, desde menos archivos. La reescritura es una sola confirmación que añade dos instantáneas. Las operaciones, en orden de confirmación, son seis adiciones y después delete y append: la instantánea de delete elimina de la tabla todos los archivos de datos, y la instantánea de append añade los archivos reescritos. La instantánea actual cambia una vez, así que ningún lector ve la tabla vacía, pero el historial conserva ambas instantáneas. Eliminar archivos completos de esta forma es el comportamiento de copy-on-write (copia al escribir) que describe el capítulo 5 para los borrados en Iceberg.

La instantánea anterior a la reescritura sigue leyendo todas las filas. Las etiquetas cuentan las instantáneas en orden de confirmación, así que la instantánea 6 es la última adición antes de la reescritura. Leída en esa instantánea, la tabla todavía devuelve 2999 filas. Los archivos Parquet en disco suman 7: los seis archivos antiguos y el que escribió la reescritura. El capítulo 7 explica cómo expirar las instantáneas antiguas y contar lo que todavía retienen.

Regla práctica: Reescribe una tabla de Iceberg por sobrescritura solo cuando ningún otro escritor confirme cambios en la tabla durante la reescritura. En una tabla sin particiones, transmite el escaneo como hace este ejemplo. En una tabla con particiones, el escaneo debe leerse con to_arrow(), así que todo el escaneo tiene que caber en la memoria del trabajo. Un lector transmitido solo puede leerse una vez: si la confirmación falla, crea un lector nuevo para el siguiente intento. Comprueba el número de archivos y el número de filas tras cada reescritura, y conserva la instantánea anterior a ella hasta que hayas verificado el resultado.

Por qué pyiceberg no tiene una llamada de reescritura

Último cambio en la edición 2026.11.7

La documentación de la API de pyiceberg enumera overwrite entre sus operaciones sobre tablas (Documentación de la API de pyiceberg). Su única oración sobre la compactación está en la nota sobre los anexados rápidos (fast appends), y trata de metadatos: la página dice que la compactación de metadatos está planificada. No dice nada sobre los archivos de datos. Su única llamada de mantenimiento es expire_snapshots, que cubre el capítulo 7. El código fuente de pyiceberg 0.12.0, en pyiceberg/table/__init__.py, no tiene ningún método que compacte o reescriba archivos de datos. Sus operaciones de escritura son append, overwrite, delete, upsert, dynamic_partition_overwrite y add_files. Todas, salvo add_files, escriben archivos de datos, y add_files registra archivos que ya existen y no escribe ninguno. dynamic_partition_overwrite, y overwrite con un overwrite_filter, pueden reemplazar las filas de una partición, de modo que una tabla particionada puede reescribirse una partición a la vez. Una compactación es, por tanto, una reescritura construida a partir de esas operaciones.

La reescritura tiene un costo de memoria que los recuentos de archivos no muestran, y la forma de leer el escaneo lo determina. table.scan().to_arrow() lee la instantánea actual completa en una sola tabla Arrow en memoria antes de que empiece la sobrescritura. La reescritura anterior pasa table.scan().to_arrow_batch_reader() en su lugar, y pyiceberg documenta que una sobrescritura en flujo se divide en microlotes según write.target-file-size-bytes, de modo que su memoria queda acotada. El flujo solo funciona en tablas no particionadas, que es el caso de este capítulo. Una tabla particionada debe leerse con to_arrow(), por lo que la memoria debe contener todas sus filas a la vez. La cota es el comportamiento documentado de pyiceberg, no una medición hecha aquí.

La reescritura también lee y escribe todos los archivos, incluidos los que ya tenían el tamaño suficiente. Una tabla cuyos archivos tienen mayormente el tamaño adecuado no obtiene ningún beneficio de ella. Esta es la razón para usarla solo cuando el número de archivos ha crecido y la tabla cabe en memoria.

Regla práctica: Revisa las notas de versión de pyiceberg en cada actualización en busca de una llamada de compactación, porque una llamada así reemplazaría la reescritura con sobrescritura de este capítulo. Mientras tanto, trata la sobrescritura como un trabajo por lotes, ejecútala cuando ningún otro escritor esté confirmando cambios y, en el caso de una tabla particionada, reserva memoria para todo el escaneo.

Verifica cada compactación antes de confiar en ella

Último cambio en la edición 2026.11.7

Entre todos, los ejemplos de este capítulo imprimen cuatro datos, y esos cuatro son los que debes revisar después de cualquier compactación que ejecutes. El primero es el número de archivos del listado propio de la tabla. El segundo es el número de filas de la versión actual, que debe coincidir con el número antes de la compactación. El tercero es el número de filas de una versión o snapshot anterior a la compactación, que debe seguir pudiendo leerse. El cuarto es el número de archivos Parquet bajo la ubicación de la tabla, que debería superar al número de archivos por la cantidad de archivos antiguos que esperan a la limpieza.

Las dos primeras comprobaciones muestran que la compactación hizo lo que afirma y no cambió ninguna fila. La tercera muestra que el historial sigue funcionando, lo que importa para cualquier lector que fije una versión anterior. La cuarta muestra lo que la compactación dejó en el disco. La primera y la cuarta proceden de lugares distintos, y los ejemplos del libro muestran ambas, de modo que una discrepancia se vea en la salida y no quede oculta en un solo número. El cuarto recuento es 7 para la tabla DuckLake y 7 para la tabla Iceberg, uno más que los archivos que siguen listados en cada caso. Una compactación que supera las tres primeras comprobaciones no tiene la culpa de un recuento así. Los archivos sobrantes son el estado que el capítulo 7 limpia.

Cada biblioteca tiene su propio listado de archivos. El ejemplo de Delta cuenta las URI de la versión actual, el ejemplo de DuckLake pide a su catálogo los archivos de la tabla, y el ejemplo de Iceberg cuenta las entradas de la inspección de archivos de la tabla. Los tres números se leen de los metadatos, así que no dependen del listado del directorio, que es la segunda fuente. Cuando las dos fuentes no coinciden, detente y averigua la causa antes de ejecutar la siguiente compactación.

Cuando una comprobación falla, detén el trabajo y deja la tabla como está. No ejecutes una segunda compactación para corregir la primera, porque cada ejecución es una confirmación y la segunda hace más difícil leer el historial. Lee el historial de la tabla con las confirmaciones en orden, localiza la que cambió el número de filas y decide a partir de ahí. El estado anterior a la falla es más fácil de examinar mientras la tabla todavía lo conserve.

Regla práctica: Después de cada compactación, compara el número de filas con el recuento de antes y lee una versión anterior a ella. Una compactación que cambia el número de filas es un fallo que hay que corregir antes de ejecutar cualquier otra cosa sobre esa tabla.

Qué sale mal en producción

Último cambio en la edición 2026.11.10

El almacenamiento crece antes de reducirse. Cada compactación de este capítulo escribe archivos de reemplazo y deja los antiguos en disco. Los conteos lo muestran. Después de la fusión de DuckLake, la tabla lista 1 archivo de datos mientras 7 archivos Parquet siguen en disco, y después de la reescritura de Iceberg la tabla lista 1 mientras 7 siguen en disco. Una compactación que se ejecuta sin un paso de expiración deja la factura de almacenamiento más alta que antes. Planifica la expiración y la limpieza junto con la compactación, y mide el disco después de ambas. La señal es un disco que crece después de cada ejecución mientras el número de filas y de archivos de la tabla se mantiene estable.

Las filas eliminadas permanecen hasta que una reescritura las trate. Una fusión de DuckLake omite cualquier archivo que tenga un archivo de eliminación, como muestra la sección de fusión. Una tabla con eliminaciones que solo se fusiona conserva esos archivos tal como están. Usa ducklake_rewrite_data_files para ellos, con un umbral que tú elijas. Mide las filas antes y después, porque la fusión por sí sola no te mostrará que las filas eliminadas siguen en los archivos. Vigila un conteo de archivos con archivos de eliminación que se mantenga igual después de cada fusión.

Los escritores concurrentes no están probados aquí. Los ejemplos de este capítulo ejecutan un escritor a la vez y no prueban una compactación que se solape con una confirmación. Prueba el solapamiento en tu propio motor y programa la compactación en una ventana donde ningún escritor confirme cambios hasta que tengas esa prueba. La reescritura de Iceberg es la más expuesta de las tres, porque lee la tabla entera y luego la vuelve a escribir. Un solapamiento fallido se manifestaría como un error del escritor o de la compactación, y el libro no ha reproducido ninguno.

Compactar con demasiada frecuencia cuesta confirmaciones; hacerlo con muy poca frecuencia cuesta lecturas. Cada compactación es una confirmación, y cada confirmación añade metadatos. Compactar después de cada carga duplica las confirmaciones por carga. Compactar una vez al mes deja que los archivos pequeños se acumulen durante un mes. La primera situación se ve como un conteo de confirmaciones que crece más rápido que las cargas, y la segunda como tiempos de consulta que suben con el número de archivos. Es una compensación que mides en tu propia tabla, no una regla que demuestren los ejemplos.

Un objetivo de conteo no es un objetivo de tamaño. Un único archivo muy grande da al lector menos trabajo paralelo y menos archivos que podar mediante las estadísticas a nivel de archivo. Estos ejemplos apuntan a un número de archivos y no imprimen tamaños de archivo. Es un juicio sobre los lectores, y los tiempos de consulta de tus lectores deben fijar el objetivo. Los tiempos de consulta que empeoran después de una compactación que produjo un único archivo muy grande son la señal de alerta.

Regla práctica: Programa la compactación junto a la expiración y la limpieza, no aparte de ellas. Ejecuta las cuatro comprobaciones de la sección de comprobación después de cada ejecución, y detén la programación si cambia el número de filas o si falla un escritor concurrente.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.7
  • Cada formato usa la llamada de su propia biblioteca, y ningún ejemplo de este capítulo usa una extensión de DuckDB para Iceberg o Delta Lake. Las lecturas y escrituras pasan por las bibliotecas de Python y por el soporte de DuckLake de DuckDB, de modo que cada recuento proviene de la herramienta que escribió los archivos.
  • El ejemplo de DuckLake se conecta con la inserción de datos desactivada. Desactivar la inserción hace que cada recuento sea un recuento de archivos, sea cual sea el tamaño de la carga.
  • Los recuentos de archivos provienen del listado de archivos de cada biblioteca. El recuento de Parquet en disco es una segunda comprobación, y no se imprime ningún tamaño de archivo.
  • Las tablas no están particionadas, así que cada recuento tiene una sola causa: el número de cargas. El caso particionado se deja para el capítulo sobre la evolución de particiones.
  • La compactación de Iceberg es una reescritura por sobrescritura, porque pyiceberg 0.12.0 no tiene una llamada de compactación. La reescritura transmite el escaneo, algo que pyiceberg permite en tablas no particionadas. El capítulo nombra la solución alternativa y el costo de memoria que permanece en tablas particionadas.
  • Nada en este capítulo expira una instantánea ni elimina un archivo. El capítulo 7 hace ambas cosas, y los recuentos de este capítulo son el punto de partida para ese trabajo.
  • El calendario de la regla práctica es un punto de partida. El libro no afirma un mejor intervalo, porque el adecuado depende de la rapidez con que llegan los archivos de una tabla y de lo grandes que los necesitan sus lectores.

Este capítulo, en esta edición

Edición 2026.11.10Ejemplos verificados el 20 de nov de 2026Superan la prueba 3 de 3 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.10.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 6 de 10: Compacta los archivos pequeños que dejan las inserciones por hora

  1. Las cargas por hora dejan archivos pequeños
  2. Compactar con optimize.compact()
  3. Compactación en DuckLake
  4. Fusionar archivos adyacentes
  5. Reescribe la tabla para compactarla
  6. Por qué pyiceberg no tiene una llamada de reescritura
  7. Verifica cada compactación antes de confiar en ella
  8. Qué sale mal en producción
  9. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos