Elige un formato según lo que admiten tus herramientas
Unos 20 minutos de lectura, con 5 ejemplos en 11 secciones.
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
En esta página
- Mide el soporte antes de elegir
- Lea qué hicieron las herramientas fijadas
- Escritura y lectura de versiones
- Cambios y limpieza
- Catálogos y DuckDB
- pyiceberg no escribe tablas de la versión 3
- Los vectores de eliminación requieren una actualización del protocolo
- Una lista de verificación para una tabla nueva
- Elige un formato según tus lectores
- Qué sale mal en producción
- Decisiones que tomó este capítulo
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
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.
1"""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."""23from lib.lakehouse import attach_ducklake, connect_ducklake, new_warehouse456def main():7 with new_warehouse() as wh:8 con = connect_ducklake(wh.con)9 # the alias also names the catalog's metadata schema, which the next line reads10 attach_ducklake(con, "probe", wh.root)11 # the version is stored as a key and value row in the metadata table; the one row, first column12 version = con.execute("SELECT value FROM __ducklake_metadata_probe.ducklake_metadata WHERE key = 'version'").fetchall()[0][0]13 print("ducklake catalog version:", version)14 # a build hash, not a release number15 extension = con.execute("SELECT extension_version FROM duckdb_extensions() WHERE extension_name = 'ducklake'").fetchall()[0][0]16 print("ducklake extension version:", extension)171819if __name__ == "__main__":20 main()
python ducklake-catalog-version.pyducklake 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 |
1"""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."""23from lib.lakehouse import DUCKLAKE_ALIAS, NAMESPACE, TABLE, connect_ducklake, create_ducklake_table, new_warehouse, read_cut_hour45LOW_VIEWS = 180 # few rows of hour 02 fall below this6VERY_LOW_VIEWS = 1000 # most of the table's rows fall below this789def delete_files(con):10 # one row per data file, so the rows with a delete file count the files a delete touched11 return con.execute(f"SELECT count(*) FROM ducklake_list_files('{DUCKLAKE_ALIAS}', '{TABLE}', schema => '{NAMESPACE}') "12 "WHERE delete_file IS NOT NULL").fetchall()[0][0]131415def main():16 with new_warehouse() as wh:17 con = connect_ducklake(wh.con)18 # 0 turns inlining off, so a delete is written as a delete file rather than kept in the catalog19 create_ducklake_table(con, wh.root, inlining_row_limit=0)20 table = f"{DUCKLAKE_ALIAS}.{NAMESPACE}.{TABLE}"21 for hour in range(6):22 con.register("hour", read_cut_hour(hour))23 con.execute(f"INSERT INTO {table} SELECT * FROM hour")24 con.unregister("hour")2526 con.execute(f"DELETE FROM {table} WHERE hour_utc = TIMESTAMP '2024-06-03 02:00:00' AND views < {LOW_VIEWS}")27 print("rows left after the small delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])28 print("delete files after the small delete:", delete_files(con))2930 # no hour filter, so this delete reaches all six hours31 con.execute(f"DELETE FROM {table} WHERE views < {VERY_LOW_VIEWS}")32 print("rows left after the large delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])33 print("delete files after the large delete:", delete_files(con))343536if __name__ == "__main__":37 main()
python ducklake-delete-files.pyrows 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
1"""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."""23from lib.lakehouse import DUCKLAKE_ALIAS, NAMESPACE, TABLE, connect_ducklake, create_ducklake_table, new_warehouse, read_cut_hour45LOW_VIEWS = 180 # few rows of hour 02 fall below this6VERY_LOW_VIEWS = 1000 # most of the table's rows fall below this789def delete_files(con):10 # one row per data file, so the rows with a delete file count the files a delete touched11 return con.execute(f"SELECT count(*) FROM ducklake_list_files('{DUCKLAKE_ALIAS}', '{TABLE}', schema => '{NAMESPACE}') "12 "WHERE delete_file IS NOT NULL").fetchall()[0][0]131415def main():16 with new_warehouse() as wh:17 con = connect_ducklake(wh.con)18 # None keeps DuckLake's default inlining; ducklake-delete-files passes 0 to turn it off19 create_ducklake_table(con, wh.root, inlining_row_limit=None)20 table = f"{DUCKLAKE_ALIAS}.{NAMESPACE}.{TABLE}"21 for hour in range(6):22 con.register("hour", read_cut_hour(hour))23 con.execute(f"INSERT INTO {table} SELECT * FROM hour")24 con.unregister("hour")2526 con.execute(f"DELETE FROM {table} WHERE hour_utc = TIMESTAMP '2024-06-03 02:00:00' AND views < {LOW_VIEWS}")27 print("rows left after the small delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])28 print("delete files after the small delete:", delete_files(con))2930 # no hour filter, so this delete reaches all six hours31 con.execute(f"DELETE FROM {table} WHERE views < {VERY_LOW_VIEWS}")32 print("rows left after the large delete:", con.execute(f"SELECT count(*) FROM {table}").fetchall()[0][0])33 print("delete files after the large delete:", delete_files(con))343536if __name__ == "__main__":37 main()
python ducklake-inlined-delete.pyrows 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
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.
1"""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."""23from pyiceberg.expressions import LessThan45from lib.lakehouse import create_iceberg_table, new_warehouse, read_cut_hour, scan_arrow67LOW_VIEWS = 180 # about one row in six of hour 00 falls below this8910def main():11 with new_warehouse() as wh:12 table = create_iceberg_table(wh, properties={"format-version": "2"}) # table properties are strings, so the version is quoted13 table.append(read_cut_hour(0))14 print("format version:", table.metadata.format_version)1516 # scan_arrow reads the current snapshot, so the count moves with each commit17 before = scan_arrow(table).num_rows18 table.delete(LessThan("views", LOW_VIEWS))19 print("rows deleted:", before - scan_arrow(table).num_rows)20 # content 0 marks a data file; any other value marks a delete file21 contents = table.inspect.files().column("content").to_pylist()22 print("delete files after the delete:", sum(1 for content in contents if content != 0))23 for number, snapshot in enumerate(table.metadata.snapshots, start=1):24 print(f"snapshot {number} operation:", snapshot.summary.operation.value)2526 # pyiceberg refuses version 3 by raising, so the refusal is caught here and its class printed27 try:28 create_iceberg_table(wh, identifier="wiki.format_three", properties={"format-version": "3"})29 except NotImplementedError as exc:30 print("format version 3 create:", type(exc).__name__)31 else:32 print("format version 3 create: created")333435if __name__ == "__main__":36 main()
python iceberg-format-versions.pyformat 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
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.
1"""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."""23from deltalake import DeltaTable, write_deltalake45from lib.lakehouse import new_warehouse, read_cut_hour, read_delta67LOW_VIEWS = 180 # about one row in six of hour 00 falls below this8910def deletion_vector_files(path):11 """Count files under the table folder that are not Parquet or the Delta log."""12 # the log holds JSON commits and checkpoints, not deletion vectors, so it is skipped13 return sum(1 for item in path.rglob("*")14 if item.is_file() and item.suffix != ".parquet" and "_delta_log" not in item.parts)151617def main():18 with new_warehouse() as wh:19 path = wh.root / "dv_table"20 # delta.enableDeletionVectors is the table property that turns deletion vectors on, set when the table is written21 write_deltalake(str(path), read_cut_hour(0), configuration={"delta.enableDeletionVectors": "true"})22 table = DeltaTable(str(path))23 protocol = table.protocol()24 print("minimum reader version:", protocol.min_reader_version)25 print("minimum writer version:", protocol.min_writer_version)26 # sorted so the printed list reads the same on every run27 print("reader features:", ", ".join(sorted(protocol.reader_features)))2829 # read_delta reads through deltalake's QueryBuilder, the only Delta read path in this book30 before = read_delta(str(path)).num_rows31 metrics = table.delete(f"views < {LOW_VIEWS}")32 print("rows deleted:", before - read_delta(str(path)).num_rows)33 # the delete's num_removed_files metric, which counts the data files it replaced34 print("data files rewritten:", metrics["num_removed_files"])35 print("rows through QueryBuilder:", read_delta(str(path)).num_rows)36 print("deletion vector files:", deletion_vector_files(path))373839if __name__ == "__main__":40 main()
python feature-check.pyminimum 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
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
deltaoicebergde DuckDB. Sus ejemplos no instalan nada en tiempo de ejecución y usan la biblioteca propia de cada formato. La extensióndeltade 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.