Elige un formato según lo que admiten tus herramientas

Unos 20 minutos de lectura, con 5 ejemplos en 11 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

Una vez que hayas leído este capítulo, podrás enumerar cada herramienta que lee o escribe tus tablas, medir lo que admite cada una en su versión fijada, y elegir un formato y sus características a partir de esas mediciones.

A lo largo de los capítulos 1 a 9, una tabla, wiki.pageviews_hourly, recorrió toda su vida en tres formatos: Apache Iceberg, Delta Lake y DuckLake. Cada formato hace las mismas tareas de una manera distinta, y cada biblioteca admite un subconjunto diferente de ellas. La elección que tienes delante no consiste en determinar qué formato es el mejor en general. Consiste en determinar qué formato puede abrir, modificar y limpiar cada herramienta de tu equipo, con las versiones que ejecutas. Este capítulo explica cómo medir eso, muestra las mediciones de las versiones fijadas de este libro y ofrece una breve guía para tomar la decisión.

La elección depende de los lectores, y el caso práctico que seguimos, wiki.pageviews_hourly, tiene tres: un panel que consulta a través de DuckDB, un proceso que añade datos mediante pyiceberg y una tarea de archivo que lee una copia en Delta Lake mediante deltalake. Cada lector tiene su propia versión fijada, y todos deben poder abrir los datos que escriben los demás. Esa es la situación para la que prepara el resto de este capítulo.

Tres factores hacen que la elección sea más difícil de lo que parece. Las características que más difieren entre formatos, como las eliminaciones, los cambios de nombre y los cambios de partición, son las que un equipo necesita primero. Cada biblioteca cambia según su propio calendario, así que una tabla que una herramienta lee en una versión puede no abrirse en otra. Y una comprobación que funciona en una máquina no dice nada sobre las versiones que ejecutan tus demás herramientas. Las secciones de este capítulo abordan cada uno de estos factores por separado.

Mide el soporte antes de elegir

Último cambio en la edición 2026.11.7

El nombre de un formato no te dice qué soporta una herramienta. El soporte pertenece a una herramienta en una versión concreta: un escritor puede crear una característica que un lector no puede abrir, y una página del proveedor describe el motor del proveedor, no la biblioteca que tienes en tu portátil. Por eso, empieza por los lectores, no por el formato. Anota cada herramienta que leerá la tabla, con su versión, y luego prueba cada característica que planeas usar en cada una de esas versiones.

Cada medición que aparece a continuación parte de un lector y luego prueba una característica en él. A pyiceberg se le aplica un borrado sobre una tabla de formato versión 2, y después se le pide la versión 3 (iceberg-format-versions). A deltalake se le aplican vectores de eliminación, se activan y se leen de nuevo (feature-check). El ejemplo ducklake-catalog-version imprime la versión del catálogo de DuckLake, y los ejemplos ducklake-delete-files y ducklake-inlined-delete cuentan los archivos de borrado tras un borrado pequeño y uno grande. Cada ejemplo imprime una línea etiquetada por cada resultado, para que puedas comparar la salida con las tablas de la matriz de soporte y con tus propios lectores.

La persona que es responsable de la tabla debe ejecutar las mediciones en las máquinas que ejecutan los lectores, no en el portátil de un desarrollador con versiones distintas. Guarda el registro en una tabla pequeña con una fila por lector. Las columnas son el lector, su versión fijada, las características que necesitan tus tablas y la fecha en que las mediciste. Una característica sin medición se considera no soportada, y esa regla es la que evita la mayoría de los fallos más adelante en este capítulo.

Lector Versión fijada Características que necesitas Medido el
pyiceberg 0.12.0 Escrituras en formato versión 2, borrados Fecha de tu ejecución

Lee cada línea impresa como una afirmación que se cumple en una versión de una herramienta. Una línea que indica que una escritura fue rechazada es tan útil como una que indica que funcionó, porque el rechazo te dice qué versión de formato debes descartar. Un ejemplo que captura un error nombra su clase, no su mensaje, de modo que la salida se mantiene igual cuando una biblioteca reformula el error.

Regla práctica: Mide cada lector en su propia versión fijada antes de elegir una versión de formato o una característica. Anota cada resultado junto con la versión en la que se midió. Vuelve a ejecutar la medición cada vez que cambie la versión de cualquier lector, y no reutilices una tabla de soporte de la página de un proveedor.

Lea qué hicieron las herramientas fijadas

Estas tablas indican lo que hicieron las herramientas fijadas en las ejecuciones de este libro. Cada columna corresponde a una herramienta: pyiceberg para Iceberg, deltalake para Delta Lake y la extensión DuckLake en DuckDB para DuckLake. Las versiones fijadas son pyiceberg 0.12.0, deltalake 1.6.6 y DuckDB 2.0.0. DuckDB 2.0.0 es una versión de soporte a largo plazo, con fecha del 21 de octubre de 2026 (calendario de lanzamientos de DuckDB). DuckLake 1.0 se publicó el 13 de abril de 2026 (calendario de lanzamientos de DuckLake). El catálogo con estas versiones fijadas informa la versión 1.1, y esa es la versión que deben abrir los lectores. La extensión tiene su propia versión: DuckDB informa que su compilación es 417a9117f5, y la extensión se distribuye con DuckDB 2.0.0, así que su versión sigue a la de DuckDB. La última columna nombra el ejemplo o la fuente que respalda cada celda. «No se muestra aquí» significa un vacío en este libro, no una funcionalidad ausente.

ducklake-catalog-version.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Superado
"""Attach a DuckLake catalog and print its catalog version, which readers must open, and the build of the DuckLake extension that DuckDB loaded. The point rests on the first printed line."""from lib.lakehouse import attach_ducklake, connect_ducklake, new_warehousedef main():    with new_warehouse() as wh:        con = connect_ducklake(wh.con)        # the alias also names the catalog's metadata schema, which the next line reads        attach_ducklake(con, "probe", wh.root)        # the version is stored as a key and value row in the metadata table; the one row, first column        version = con.execute("SELECT value FROM __ducklake_metadata_probe.ducklake_metadata WHERE key = 'version'").fetchall()[0][0]        print("ducklake catalog version:", version)        # a build hash, not a release number        extension = con.execute("SELECT extension_version FROM duckdb_extensions() WHERE extension_name = 'ducklake'").fetchall()[0][0]        print("ducklake extension version:", extension)if __name__ == "__main__":    main()
Salidapython ducklake-catalog-version.py
ducklake catalog version: 1.1
ducklake extension version: 417a9117f5

Escritura y lectura de versiones

Versiones y lecturas pyiceberg deltalake DuckLake Se muestra en
Escribir filas como commits Sí Sí Sí Tres horas de aterrizaje
Leer un commit anterior por número Sí, por snapshot Sí, por versión Sí, por snapshot Iceberg, Delta y DuckLake
Crear la versión de formato 3 No, genera un error — — Ejemplo
Renombrar una columna Sí, por ID de campo No, una operación sin efecto y sin aviso No se muestra aquí Iceberg, deltalake
Mapeo de columnas al crear — Sí — deltalake

Cambios y limpieza

Cambios y limpieza pyiceberg deltalake DuckLake Se muestra en
Eliminar filas Reescribe archivos Reescribe archivos Escribe archivos de eliminación Capítulo 5
Archivos de eliminación escritos Ninguno Ninguno Sí, salvo que estén incrustados Versiones de formato, comprobación de funciones, DuckLake, incrustados
Upsert o fusión Upsert, varias instantáneas No se muestra aquí MERGE INTO Upserts, MERGE
Cambiar el particionamiento Los archivos antiguos conservan la especificación antigua Sobrescribir con modo de esquema Cambiar con ALTER TABLE Capítulo 4, otros formatos
Compactar archivos pequeños Sin método; sobrescribir la tabla optimize.compact() Fusionar archivos adyacentes Iceberg, deltalake, DuckLake
Expirar instantáneas Por ID o older_than; no elimina archivos Vacuum según retención Expirar y luego limpiar Iceberg, deltalake, DuckLake
ducklake-delete-files.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Superado
"""Load six hours into a DuckLake table with data inlining off, then count the delete files that a small and a large delete write. The point rests on the delete-file line after the small delete."""from lib.lakehouse import DUCKLAKE_ALIAS, NAMESPACE, TABLE, connect_ducklake, create_ducklake_table, new_warehouse, read_cut_hourLOW_VIEWS = 180  # few rows of hour 02 fall below thisVERY_LOW_VIEWS = 1000  # most of the table's rows fall below thisdef delete_files(con):    # one row per data file, so the rows with a delete file count the files a delete touched    return con.execute(f"SELECT count(*) FROM ducklake_list_files('{DUCKLAKE_ALIAS}', '{TABLE}', schema => '{NAMESPACE}') "                       "WHERE delete_file IS NOT NULL").fetchall()[0][0]def main():    with new_warehouse() as wh:        con = connect_ducklake(wh.con)        # 0 turns inlining off, so a delete is written as a delete file rather than kept in the catalog        create_ducklake_table(con, wh.root, inlining_row_limit=0)        table = f"{DUCKLAKE_ALIAS}.{NAMESPACE}.{TABLE}"        for hour in range(6):            con.register("hour", read_cut_hour(hour))            con.execute(f"INSERT INTO {table} SELECT * FROM hour")            con.unregister("hour")        con.execute(f"DELETE FROM {table} WHERE hour_utc = TIMESTAMP '2024-06-03 02:00:00' AND views < {LOW_VIEWS}")        print("rows left after the small delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])        print("delete files after the small delete:", delete_files(con))        # no hour filter, so this delete reaches all six hours        con.execute(f"DELETE FROM {table} WHERE views < {VERY_LOW_VIEWS}")        print("rows left after the large delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])        print("delete files after the large delete:", delete_files(con))if __name__ == "__main__":    main()
Salidapython ducklake-delete-files.py
rows left after the small delete: 2995
delete files after the small delete: 1
rows left after the large delete: 195
delete files after the large delete: 6
ducklake-inlined-delete.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Superado
"""Repeat `ducklake-delete-files` with DuckLake's default inlining, to show that the small delete writes no delete file. The point rests on the delete-file line after the small delete."""from lib.lakehouse import DUCKLAKE_ALIAS, NAMESPACE, TABLE, connect_ducklake, create_ducklake_table, new_warehouse, read_cut_hourLOW_VIEWS = 180  # few rows of hour 02 fall below thisVERY_LOW_VIEWS = 1000  # most of the table's rows fall below thisdef delete_files(con):    # one row per data file, so the rows with a delete file count the files a delete touched    return con.execute(f"SELECT count(*) FROM ducklake_list_files('{DUCKLAKE_ALIAS}', '{TABLE}', schema => '{NAMESPACE}') "                       "WHERE delete_file IS NOT NULL").fetchall()[0][0]def main():    with new_warehouse() as wh:        con = connect_ducklake(wh.con)        # None keeps DuckLake's default inlining; ducklake-delete-files passes 0 to turn it off        create_ducklake_table(con, wh.root, inlining_row_limit=None)        table = f"{DUCKLAKE_ALIAS}.{NAMESPACE}.{TABLE}"        for hour in range(6):            con.register("hour", read_cut_hour(hour))            con.execute(f"INSERT INTO {table} SELECT * FROM hour")            con.unregister("hour")        con.execute(f"DELETE FROM {table} WHERE hour_utc = TIMESTAMP '2024-06-03 02:00:00' AND views < {LOW_VIEWS}")        print("rows left after the small delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])        print("delete files after the small delete:", delete_files(con))        # no hour filter, so this delete reaches all six hours        con.execute(f"DELETE FROM {table} WHERE views < {VERY_LOW_VIEWS}")        print("rows left after the large delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])        print("delete files after the large delete:", delete_files(con))if __name__ == "__main__":    main()
Salidapython ducklake-inlined-delete.py
rows left after the small delete: 2995
delete files after the small delete: 0
rows left after the large delete: 195
delete files after the large delete: 6

Catálogos y DuckDB

Catálogos y DuckDB pyiceberg deltalake DuckLake Se muestra en
Catálogo necesario Sí, un catálogo SQL No, se encuentra por ruta Sí, el archivo de catálogo Capítulo 8, por ruta, archivo de catálogo
DuckDB lo lee A través de Arrow A través de Arrow, desde QueryBuilder De forma nativa Capítulo 1, Capítulo 9, Capítulo 8
DuckDB lo escribe — — De forma nativa, mediante SQL Capítulo 8

La extensión propia de DuckDB delta es una vía distinta a deltalake. Puede escribir tablas de Delta Lake, lo que se aborda en la guía de decisión más abajo.

Regla práctica: Lee cada celda junto con el ejemplo o la fuente que menciona. Una celda sin ejemplo que la respalde es una afirmación que debes contrastar con tus propios lectores, no una en la que debas confiar sin más.

pyiceberg no escribe tablas de la versión 3

Último cambio en la edición 2026.11.7

La sección de la versión 3 de la especificación de Iceberg convierte los vectores de eliminación binarios en el formato de eliminación a nivel de fila. Dice que "los escritores no pueden añadir nuevos archivos de eliminación por posición a tablas v3" (especificación de Iceberg). La misma sección añade el linaje de filas para las filas nuevas, los valores predeterminados de columna, el tipo variant y las marcas de tiempo en nanosegundos.

iceberg-format-versions.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Superado
"""Create a format version 2 Iceberg table, delete rows from it, then ask pyiceberg for format version 3. The point rests on the last printed line, which shows the refusal."""from pyiceberg.expressions import LessThanfrom lib.lakehouse import create_iceberg_table, new_warehouse, read_cut_hour, scan_arrowLOW_VIEWS = 180  # about one row in six of hour 00 falls below thisdef main():    with new_warehouse() as wh:        table = create_iceberg_table(wh, properties={"format-version": "2"})  # table properties are strings, so the version is quoted        table.append(read_cut_hour(0))        print("format version:", table.metadata.format_version)        # scan_arrow reads the current snapshot, so the count moves with each commit        before = scan_arrow(table).num_rows        table.delete(LessThan("views", LOW_VIEWS))        print("rows deleted:", before - scan_arrow(table).num_rows)        # content 0 marks a data file; any other value marks a delete file        contents = table.inspect.files().column("content").to_pylist()        print("delete files after the delete:", sum(1 for content in contents if content != 0))        for number, snapshot in enumerate(table.metadata.snapshots, start=1):            print(f"snapshot {number} operation:", snapshot.summary.operation.value)        # pyiceberg refuses version 3 by raising, so the refusal is caught here and its class printed        try:            create_iceberg_table(wh, identifier="wiki.format_three", properties={"format-version": "3"})        except NotImplementedError as exc:            print("format version 3 create:", type(exc).__name__)        else:            print("format version 3 create: created")if __name__ == "__main__":    main()
Salidapython iceberg-format-versions.py
format version: 2
rows deleted: 82
delete files after the delete: 0
snapshot 1 operation: append
snapshot 2 operation: overwrite
format version 3 create: NotImplementedError

pyiceberg, en esta versión fijada, escribe el formato versión 2. El ejemplo pide la versión 2 e imprime la versión de su tabla, que es 2. Una solicitud del formato versión 3 lanza NotImplementedError, así que ninguna de las funciones de la versión 3 está disponible con este escritor.

pyiceberg elimina reescribiendo los archivos de datos que toca en estas versiones fijadas, aunque el formato versión 2 también admite archivos de eliminación (capítulo 5). La tabla perdió 82 filas y contiene 0 archivos de eliminación. Sus dos instantáneas son una append y, para la eliminación, una overwrite. Mide esa reescritura en una copia de tu propia tabla antes de decidir.

Función Especificación Iceberg v3 pyiceberg en estas versiones fijadas
Vectores de eliminación binarios Formato de eliminación a nivel de fila No se escriben
Archivos de eliminación por posición Heredado, solo en tablas de formato versión 2 No se escriben
Linaje de filas, valores predeterminados, variant, marcas de tiempo en nanosegundos Parte de la versión 3 No disponible: no hay tabla versión 3

Regla práctica: Escribe el formato versión 2 con pyiceberg en estas versiones fijadas, y no prometas una función de la versión 3 a ningún lector. Elige la versión 3 solo cuando el escritor que usas la cree y todos los lectores de tu conjunto la abran, y comprueba ambas cosas con sus propias versiones fijadas.

Los vectores de eliminación requieren una actualización del protocolo

Último cambio en la edición 2026.11.10

El protocolo de Delta Lake, en la etiqueta de versión que indica su enlace, dice que una tabla con vectores de eliminación necesita la versión 3 de lector y la versión 7 de escritor, con la función deletionVectors en ambas listas de funciones. También dice que un lector debe implementar todas las funciones de la lista de lectores antes de leer la tabla (protocolo de Delta). Una función de lector en el protocolo de una tabla Delta es una promesa de que todo lector la gestiona, así que un lector sin ella no puede leer la tabla correctamente.

feature-check.py Python 3.12.15 · deltalake 1.6.6 · duckdb 2.0.0 · pyarrow 26.0.1 · pyiceberg 0.12.0 Superado
"""Turn on deletion vectors in a Delta Lake table, delete the rows below 180 views, and print the protocol the table declares. The point rests on the reader features line, which lists what a reader must implement."""from deltalake import DeltaTable, write_deltalakefrom lib.lakehouse import new_warehouse, read_cut_hour, read_deltaLOW_VIEWS = 180  # about one row in six of hour 00 falls below thisdef deletion_vector_files(path):    """Count files under the table folder that are not Parquet or the Delta log."""    # the log holds JSON commits and checkpoints, not deletion vectors, so it is skipped    return sum(1 for item in path.rglob("*")               if item.is_file() and item.suffix != ".parquet" and "_delta_log" not in item.parts)def main():    with new_warehouse() as wh:        path = wh.root / "dv_table"        # delta.enableDeletionVectors is the table property that turns deletion vectors on, set when the table is written        write_deltalake(str(path), read_cut_hour(0), configuration={"delta.enableDeletionVectors": "true"})        table = DeltaTable(str(path))        protocol = table.protocol()        print("minimum reader version:", protocol.min_reader_version)        print("minimum writer version:", protocol.min_writer_version)        # sorted so the printed list reads the same on every run        print("reader features:", ", ".join(sorted(protocol.reader_features)))        # read_delta reads through deltalake's QueryBuilder, the only Delta read path in this book        before = read_delta(str(path)).num_rows        metrics = table.delete(f"views < {LOW_VIEWS}")        print("rows deleted:", before - read_delta(str(path)).num_rows)        # the delete's num_removed_files metric, which counts the data files it replaced        print("data files rewritten:", metrics["num_removed_files"])        print("rows through QueryBuilder:", read_delta(str(path)).num_rows)        print("deletion vector files:", deletion_vector_files(path))if __name__ == "__main__":    main()
Salidapython feature-check.py
minimum reader version: 3
minimum writer version: 7
reader features: deletionVectors, timestampNtz, variantType
rows deleted: 82
data files rewritten: 1
rows through QueryBuilder: 417
deletion vector files: 0

Activar la opción cambia lo que los lectores deben soportar. Una vez activada, la tabla declara una versión mínima de lector 3 y una versión mínima de escritor 7. Sus funciones de lector son deletionVectors, timestampNtz, variantType, y un lector debe implementar todas ellas. Nosotros solo activamos la opción de vectores de eliminación, así que deltalake añadió las otras dos funciones por su cuenta.

Con esta versión fijada, deltalake declara la función pero sigue eliminando reescribiendo el archivo. La eliminación de las filas por debajo de 180 visualizaciones quitó 82 filas y reescribió 1 archivo de datos, y la tabla contiene 0 archivos de vectores de eliminación. QueryBuilder lee 417 filas después. El libro lee las tablas Delta solo a través de QueryBuilder, como muestra el capítulo 8.

Cada función de la lista importa, no solo el vector de eliminación. Un lector que carece de timestampNtz o de variantType tiene el mismo problema que uno que carece de deletionVectors. Compara las listas de funciones impresas con la lista propia de cada lector después de cada cambio.

Así que activar los vectores de eliminación es un cambio de protocolo para todos los lectores de la tabla, y la escritura tiene éxito antes de que se pruebe a ningún lector. Actívalos solo cuando cada lector de tu conjunto implemente la función deletionVectors. En caso contrario, mantén la copia en escritura.

Una comprobación de lector, en el sentido que se usa aquí, abre la tabla a través de la propia interfaz del lector, antes de la primera escritura en producción. Para la copia de Delta Lake del caso, esa comprobación es una lectura a través de QueryBuilder y una lectura del protocolo, ambas en el ejemplo de comprobación de funciones.

Regla práctica: Activa los vectores de eliminación solo después de comprobar el soporte de funciones de cada lector en su propia versión. Vuelve a leer el protocolo de la tabla después de cada cambio, y mantén la copia en escritura para cualquier tabla que abra un lector fuera de tu conjunto probado.

Una lista de verificación para una tabla nueva

Usa esta lista antes de crear una tabla que más de una herramienta vaya a abrir. Cada punto cierra un riesgo que mostraron la matriz de compatibilidad y la sección de vectores de eliminación.

  1. Enumera cada lector y cada escritor, con su versión. Una herramienta que dejes fuera de la lista es un lector que no has probado, y será el que falle.
  2. Para cada característica que necesite la tabla, mide su soporte en cada herramienta, como hacen los ejemplos de este capítulo. Mide el lector, no solo el escritor, porque una escritura exitosa solo demuestra que el escritor puede producir los archivos.
  3. Fija a propósito la versión del formato y el protocolo. Vuelve a imprimirlos y lee la tabla desde cada lector. No aceptes un valor por defecto que tú no hayas elegido.
  4. Rechaza cualquier versión de formato o característica que un lector del conjunto no soporte. Una tabla que un lector no puede abrir es una interrupción del servicio, por buenas que sean las características para los demás lectores.
  5. Promete un cambio de nombre solo cuando el soporte medido lo permita. Iceberg cambia el nombre usando el ID del campo. deltalake no tiene cambio de nombre con estas versiones fijadas, así que planifica una reescritura en su lugar y revisa los nombres de las columnas después.
  6. Mantén una ruta sencilla de copia al escribir (copy-on-write) para las eliminaciones, a menos que todos los lectores hayan sido probados con vectores de eliminación. La copia al escribir cuesta archivos reescritos, pero se abre en todas partes.
  7. Planifica cualquier actualización en este orden: primero los lectores, luego los escritores y por último el protocolo. Lee la tabla después de cada paso y detente si falla un lector.
  8. Vuelve a ejecutar las mediciones cada vez que cambien las versiones fijadas, y registra las nuevas versiones en la tabla de lectores.

Regla práctica: Guarda la lista junto con la nota de diseño de la tabla, para que la siguiente persona que añada un lector parta del mismo registro. Una lista mantenida al día cuesta menos que una reconstruida después de una lectura fallida.

Elige un formato según tus lectores

Usa esta guía después de haber medido a tus lectores. La primera columna es la situación, no el formato. Asocia un conjunto de lectores medido con un formato, y no sustituye a las mediciones.

Si tu situación es Elige Por qué
pyiceberg y DuckDB leen la tabla Iceberg, versión de formato 2 pyiceberg la lee, y DuckDB consulta su salida
Varios lectores, y necesitas renombrar sobre la propia tabla Iceberg Los renombrados conservan el ID del campo, como muestra el capítulo 3
DuckDB es el único motor, y quieres cambios en SQL DuckLake Las eliminaciones, las fusiones y los cambios de partición se ejecutan como SQL
Ya existen tablas Delta y deltalake las lee Mantén Delta Lake, sin promesa de renombrado Cambia las particiones por sobrescritura y vuelve a leer tras cada cambio
Quieres que DuckDB modifique una tabla Delta No con estas versiones fijadas DuckDB solo puede añadir filas; usa deltalake para las actualizaciones y las eliminaciones

La extensión delta de DuckDB puede escribir tablas Delta Lake. La documentación de DuckDB para la versión fijada, 2.0.0, indica que puede crear tablas y añadir datos a ellas, y enumera UPDATE, DELETE, MERGE INTO, ALTER TABLE y DROP TABLE como no soportados (documentación de delta de DuckDB, Limitaciones). Ningún ejemplo de este libro ejecuta la extensión. Los ejemplos no instalan nada en tiempo de ejecución y usan la biblioteca propia de cada formato, de modo que el lector ve la misma biblioteca que escribe la tabla, y nada se descarga mientras un ejemplo se ejecuta.

Lee la tabla fila por fila. Cuando dos filas apuntan en direcciones distintas, deciden los lectores. Primero elige el formato que abre cada lector de tu conjunto medido y, después, elige las funciones que todos ellos soportan.

Aplica la guía al caso que seguimos a lo largo del libro. El panel y la canalización abren la tabla pageviews con pyiceberg o DuckDB, lo que apunta a Iceberg, versión de formato 2. El trabajo de archivo lee una copia en Delta Lake, así que la fila de Delta se aplica solo a esa copia, y la copia mantiene sus eliminaciones como copy-on-write.

Recomendamos Iceberg, versión de formato 2, como opción predeterminada para una tabla que leen varias herramientas, porque pyiceberg la escribe, DuckDB lee su salida y los ejemplos miden ambos. Sus costes con estas versiones: cada eliminación reescribe los archivos de datos que toca, la tabla necesita un catálogo y pyiceberg no tiene una llamada de compactación ni de limpieza de archivos huérfanos. Recomendamos DuckLake cuando DuckDB es el único motor, porque el lector y el escritor comparten una misma superficie SQL. Sus costes: los lectores se limitan a DuckDB, la versión del catálogo está ligada a la versión de DuckDB, y las eliminaciones pequeñas se almacenan en línea en el catálogo salvo que desactives el almacenamiento en línea. Elige otra cosa cuando las comprobaciones de este capítulo muestren que un lector no puede hacer lo que necesitas.

Regla práctica: Elige el formato que abre cada lector de tu conjunto medido y, después, elige solo las funciones que ese conjunto soporta. Si ningún formato cubre todas las necesidades, divide la tabla o cambia los lectores. No prometas a un lector una función que las mediciones no cubren.

Qué sale mal en producción

Último cambio en la edición 2026.11.7

La mayoría de los fallos de formato en un lakehouse compartido provienen de una herramienta que el escritor no probó, no de un error del formato. Cada fallo aquí es uno que una sección anterior midió o citó, así que puedes buscarlo en tus propias tablas.

Elegir según las afirmaciones del proveedor. Una página de soporte describe un motor, a menudo en una versión distinta a la tuya. Úsala para saber qué probar, no como respuesta. Verifica la afirmación con tus propias versiones fijadas.

Probar solo un motor. Una tabla puede escribirla una biblioteca y leerla otra que no admite la misma característica. La escritura tiene éxito en una herramienta, y el fallo aparece cuando una segunda herramienta abre la tabla. Ejecuta la comprobación de lectura para cada herramienta del conjunto antes de la primera escritura.

Una característica que el lector no implementa. La opción de vectores de eliminación añade a la tabla una característica de lectura, y el protocolo exige que los lectores la implementen. Un lector fuera de tu conjunto puede abrir la tabla y fallar al hacerlo. Averígualo en el registro del protocolo, que imprime el ejemplo de comprobación de características, y no por un error de consulta posterior.

Un cambio de nombre que no hace nada. Con estas fijaciones, la llamada set_column_metadata de deltalake devuelve el control sin error y aumenta la versión, pero los nombres de las columnas siguen igual. El capítulo 3 muestra la trampa. La comprobación consiste en leer los nombres de las columnas después del cambio.

Actualizar en el orden incorrecto. Un escritor que avanza antes que sus lectores puede producir una tabla que los lectores no pueden abrir, y la primera señal es una lectura fallida en el trabajo de otro equipo. El orden de la lista de verificación mantiene a cada lector capaz de abrir la tabla en cada paso.

Juzgar una tabla por su escritura. Una escritura exitosa demuestra que el escritor puede producir los archivos. No demuestra que otra herramienta pueda leerlos. La comprobación de vectores de eliminación de este capítulo escribe, elimina y luego cuenta las características del lector precisamente por esta razón.

Contar filas en un borrado de DuckLake. Con la inserción en línea predeterminada de DuckLake, un borrado pequeño de unas pocas filas no escribe ningún archivo de eliminación, mientras que el mismo borrado con la inserción en línea desactivada sí lo escribe. Una comprobación que cuenta filas dice que el borrado funcionó en ambos casos. Cuenta también los archivos de eliminación, como hace el ejemplo de borrado de DuckLake.

Una versión del catálogo que cambia con DuckDB. El catálogo de DuckLake en estas versiones fijadas indica la versión 1.1, y la extensión que lo abre indica la compilación 417a9117f5. La documentación de DuckLake indica la versión de DuckDB que requiere la versión 1.1 (documentación de DuckLake). Una versión anterior de DuckDB podría no abrir ese catálogo, así que una actualización puede romper un lector que no cambió.

Regla práctica: Mide cada lector con su propia versión fijada antes de escribir, actualizar o confiar en una afirmación del proveedor. Cuando actualices un escritor o un catálogo, mantén la versión anterior disponible hasta que todos los lectores hayan abierto el resultado.

Decisiones que tomó este capítulo

  • Recomendamos el formato 2 de Iceberg con pyiceberg en estas versiones fijadas. No prometemos a ningún lector el formato 3, y no fijamos una fecha para cuando eso cambie. La versión fijada decide, y la medición lo muestra.
  • Presentamos la matriz tal como se midió con estas versiones fijadas, y cada celda remite a un ejemplo o a una fuente citada.
  • Mantenemos los vectores de eliminación fuera de las tablas que un lector fuera del conjunto probado vaya a abrir.
  • No prometemos un renombrado en una tabla de deltalake con estas versiones fijadas.
  • Contamos los archivos de eliminación de DuckLake además de las filas.
  • Tratamos una característica no medida como no compatible, porque los fallos de este capítulo surgieron todos de una característica que alguien dio por supuesta.
  • Indicamos la versión del catálogo de DuckLake por separado de la versión de la extensión. La versión del catálogo decide qué lectores pueden abrirlo, y la versión de la extensión sigue a DuckDB.
  • Elegimos una matriz medida en lugar de la página de compatibilidad de un proveedor, porque las versiones fijadas son las que deciden qué se puede abrir.
  • El valor por defecto del formato 2 de Iceberg es un criterio, y así está señalado. Las mediciones que lo respaldan son los ejemplos, y son la parte que conviene volver a ejecutar.
  • El libro no ejecuta ninguna extensión delta o iceberg de DuckDB. Sus ejemplos no instalan nada en tiempo de ejecución y usan la biblioteca propia de cada formato. La extensión delta de DuckDB puede escribir tablas de Delta Lake, como describe su documentación.

Este capítulo, en esta edición

Edición 2026.11.10Ejemplos verificados el 20 de nov de 2026Superan la prueba 5 de 5 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 10 de 10: Elige un formato según lo que admiten tus herramientas

  1. Mide el soporte antes de elegir
  2. Lea qué hicieron las herramientas fijadas
  3. Escritura y lectura de versiones
  4. Cambios y limpieza
  5. Catálogos y DuckDB
  6. pyiceberg no escribe tablas de la versión 3
  7. Los vectores de eliminación requieren una actualización del protocolo
  8. Una lista de verificación para una tabla nueva
  9. Elige un formato según tus lectores
  10. Qué sale mal en producción
  11. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos