Delta Lake
Rendimiento de MERGE en Delta Lake: patrones para tablas grandes
Por qué el rendimiento de MERGE en Delta se degrada en tablas grandes y cómo mantenerlo: orígenes limpios, poda, menos archivos afectados, concurrencia segura y alternativas.
En este artículo
MERGE es la herramienta de upsert por defecto para las tablas Delta, y también uno de los motivos más habituales por los que un pipeline que tardaba cuatro minutos el trimestre pasado ahora tarda cuarenta. La instrucción parece una operación a nivel de fila. Físicamente es una operación a nivel de archivo: Delta encuentra los archivos que contienen filas coincidentes y escribe versiones nuevas de ellos. La mayor parte del trabajo de rendimiento de MERGE consiste en reducir ese conjunto de archivos y en asegurarte de que el trabajo restante se dedique a filas que realmente han cambiado.
Los ejemplos usan PySpark y Spark SQL y se ejecutan en notebooks de Microsoft Fabric o en cualquier entorno Spark con Delta Lake.
Qué hace realmente MERGE
Un MERGE tiene un origen (las filas nuevas o modificadas), un destino (la tabla Delta), una condición de coincidencia y un conjunto de cláusulas WHEN. Conceptualmente, Delta lo ejecuta en dos pasadas:
- Encontrar los archivos afectados. Delta combina el origen con el destino según la condición de coincidencia para averiguar qué archivos del destino contienen al menos una fila coincidente. Esta pasada solo necesita las columnas usadas en la condición, así que es relativamente ligera, salvo que la condición la obligue a leer toda la tabla.
- Reescribir. Para cada archivo afectado, Delta genera el contenido nuevo: filas actualizadas, filas eliminadas retiradas y filas sin cambios copiadas tal cual. Las inserciones se escriben como archivos nuevos. Después, el commit marca los archivos antiguos como eliminados y los nuevos como añadidos en el registro de transacciones.
La parte costosa son las filas «copiadas tal cual». Con el copy-on-write clásico, un archivo de 512 MB que contiene una sola fila actualizada se reescribe entero; 2.000 actualizaciones repartidas en 2.000 archivos suponen 2.000 archivos reescritos. Dos funcionalidades cambian esa aritmética:
- Low shuffle merge, activado por defecto en todos los runtimes de Spark de Fabric, excluye las filas no modificadas del costoso shuffle de la segunda pasada. Aun así se escriben, por separado y en su orden original, lo que puede generar hasta el doble de archivos de salida.
- Los vectores de eliminación (deletion vectors) permiten que una actualización o un borrado marque filas antiguas como eliminadas en un pequeño archivo auxiliar en lugar de reescribir el archivo de datos. Fabric los activa por defecto para las tablas nuevas a partir de Spark Runtime 2.0 (Delta 4.1). El costo se traslada a los lectores hasta que la compactación reescribe los archivos.
Ninguna de las dos funcionalidades elimina la necesidad de una buena poda (pruning). Ambas abaratan un archivo afectado; ninguna hace desaparecer un escaneo completo de la tabla.
Mide antes de ajustar
Cada commit de MERGE registra métricas de la operación en el historial de Delta. Léelas antes de cambiar nada:
from delta.tables import DeltaTable
target = DeltaTable.forName(spark, "silver_orders")
history = (
target.history(20)
.filter("operation = 'MERGE'")
.select("version", "timestamp", "operationParameters.predicate", "operationMetrics")
)
for row in history.collect():
m = row["operationMetrics"]
changed = int(m["numTargetRowsUpdated"]) + int(m["numTargetRowsInserted"]) + int(m["numTargetRowsDeleted"])
copied = int(m["numTargetRowsCopied"])
print({
"version": row["version"],
"source_rows": m["numSourceRows"],
"changed_rows": changed,
"copied_rows": copied,
"copy_ratio": round(copied / changed, 1) if changed else None,
"files_added": m["numTargetFilesAdded"],
"files_removed": m["numTargetFilesRemoved"],
})Las señales útiles:
numTargetRowsCopiedfrente a las filas modificadas. Es la amplificación de escritura. Una proporción de 500 significa que MERGE escribió 500 filas sin cambios por cada fila que cambió. Ese es el número que hay que reducir.numTargetFilesRemoved. Cuántos archivos afectó el MERGE. Si se acerca al número total de archivos de la tabla, la condición de coincidencia no está podando nada.numSourceRowsfrente a las filas modificadas. Si el origen tiene 10 millones de filas y cambiaron 30.000, la mayor parte del origen fue trabajo inútil. Filtrar el origen es más barato que dejar que MERGE descubra que nada ha cambiado.numTargetFilesAddedfrente a los eliminados. Un MERGE que elimina 40 archivos y añade 4.000 está fragmentando la tabla y haciendo más lenta la siguiente ejecución.
Registra estos valores junto con la duración de cada ejecución. Una tendencia a lo largo de semanas te dice más que cualquier ejecución aislada, y la interfaz de Spark muestra en qué emplea el tiempo una ejecución: escaneo del destino, join o escritura.
Patrón 1: corrige primero el origen
Muchos problemas de MERGE son problemas del origen.
Claves duplicadas en el origen. Si dos filas del origen coinciden con la misma fila del destino, Delta no puede decidir qué actualización prevalece y falla con un error que indica que varias filas del origen coincidieron e intentaron modificar la misma fila del destino. Incluso cuando los duplicados solo llegan a la rama de inserción, insertan duplicados de forma silenciosa. Deduplica de forma determinista antes del MERGE, conservando la versión más reciente por clave:
from pyspark.sql import Window
from pyspark.sql import functions as F
latest_per_key = Window.partitionBy("order_id").orderBy(
F.col("source_updated_at").desc(),
F.col("ingestion_id").desc(),
)
source = (
raw_changes
.withColumn("rn", F.row_number().over(latest_per_key))
.filter("rn = 1")
.drop("rn", "ingestion_id")
)La segunda columna de ordenación sirve para desempatar. Sin ella, dos filas con la misma marca de tiempo producen un ganador no determinista, y las reejecuciones pueden dar resultados distintos. Eliminarla después mantiene el esquema del origen igual al del destino, lo que importa para INSERT * y para la evolución del esquema más adelante.
Filas sin cambios. Las extracciones completas suelen reenviar filas que no han cambiado. Actualizarlas reescribe archivos para nada. Un hash de fila hace que la detección de cambios sea barata y evita largas cadenas de OR:
tracked = ["status", "amount", "currency", "customer_id"]
source = source.withColumn(
"row_hash",
F.sha2(F.concat_ws("||", *[F.coalesce(F.col(c).cast("string"), F.lit("<null>")) for c in tracked]), 256),
)Guarda también row_hash en el destino y usa WHEN MATCHED AND t.row_hash IS DISTINCT FROM s.row_hash THEN UPDATE. Usa la comparación segura frente a NULL: con un simple <>, una fila del destino cuyo hash sigue siendo NULL (por ejemplo, filas cargadas antes de que añadieras la columna) se compara como desconocida y nunca se actualiza. Ten claro qué te aporta esa condición: evita que se actualicen las filas sin cambios, pero una fila coincidente sigue arrastrando su archivo al conjunto que se reescribe. Al volver a fusionar un lote sin cambios en una prueba local con Delta 3.2, se informaron cero filas actualizadas y, aun así, se eliminaron y volvieron a añadir todos los archivos afectados. Para no tocar esos archivos en absoluto, elimina las filas sin cambios del origen antes del MERGE, por ejemplo con un anti-join contra una proyección estrecha (order_id, row_hash) del destino en la misma ventana incremental, y mantén la condición de la cláusula como red de seguridad.
Cardinalidad del merge. Una fila del origen debe coincidir como máximo con una fila del destino, según la clave de negocio. Si una clave es única por convención y no por validación, revisa el destino periódicamente: una coincidencia silenciosa de varios a uno es un error de corrección antes que un problema de rendimiento.
Patrón 2: acota el destino con la condición de coincidencia
Por defecto, MERGE busca coincidencias en todo el destino. La primera recomendación de ajuste de la documentación de Delta es reducir ese espacio de búsqueda añadiendo restricciones conocidas a la condición de coincidencia. Esas restricciones solo podan archivos si Delta puede evaluarlas contra los metadatos de los archivos —valores de partición o estadísticas mín./máx. por archivo— antes de leer los datos.
La forma más fiable es calcular los límites a partir del origen e inyectarlos como literales:
bounds = source.agg(
F.min("order_date").alias("min_d"),
F.max("order_date").alias("max_d"),
).first()
if bounds["min_d"] is None:
print("Empty source, nothing to merge")
else:
condition = (
"t.order_id = s.order_id "
f"AND t.order_date >= DATE'{bounds['min_d']}' "
f"AND t.order_date <= DATE'{bounds['max_d']}'"
)
(
target.alias("t")
.merge(source.alias("s"), condition)
.whenMatchedUpdate(
condition="t.row_hash IS DISTINCT FROM s.row_hash",
set={c: f"s.{c}" for c in tracked + ["row_hash", "order_date", "source_updated_at"]},
)
.whenNotMatchedInsertAll()
.execute()
)Esto solo tiene sentido cuando order_date es inmutable para un order_id dado. Si una fila puede pasar de una fecha a otra, una condición acotada por fecha no encontrará la versión antigua e insertará un duplicado. Elige una columna de poda que sea estable durante toda la vida de la clave.
El mismo patrón en Spark SQL, con los límites proporcionados como parámetros por el pipeline:
MERGE INTO silver_orders AS t
USING staged_orders AS s
ON t.order_id = s.order_id
AND t.order_date >= DATE'2026-10-01'
AND t.order_date <= DATE'2026-10-07'
WHEN MATCHED AND t.row_hash IS DISTINCT FROM s.row_hash THEN
UPDATE SET *
WHEN NOT MATCHED THEN
INSERT *UPDATE SET * e INSERT * requieren que el origen contenga todas las columnas del destino. Es cómodo para una tabla de staging con el mismo esquema, y arriesgado en otros casos; consulta la sección sobre el esquema más abajo.
Cuándo ayuda realmente el particionamiento a MERGE
«Particiona la tabla y MERGE irá más rápido» solo es cierto en condiciones concretas:
- La columna de partición aparece en la condición de coincidencia con valores que Delta puede resolver antes de leer los datos: literales o expresiones que se reducen a un conjunto fijo de particiones. Una igualdad de join como
t.order_date = s.order_datepor sí sola puede no podar el destino, porque los valores coincidentes solo se conocen después de leer el origen. - Los cambios están concentrados en unas pocas particiones. Si cada lote diario actualiza filas repartidas en tres años de fechas, el MERGE afecta de todos modos a la mayoría de las particiones, y el particionamiento añade sobrecarga de directorios y archivos sin reducir el trabajo.
- Cada partición es lo bastante grande. La recomendación de Fabric es apuntar a al menos 1 GB por partición y mantener una cardinalidad de baja a moderada. Particionar por fecha una tabla modesta crea miles de particiones pequeñas, lo que hace más lento cada escaneo, incluida la pasada de coincidencia.
Fabric presenta ahora el particionamiento sobre todo como una forma de aislar escritores concurrentes, y recomienda liquid clustering (clustering líquido) para la organización de lectura a partir de Runtime 2.0. Para MERGE: particiona por una columna estable y de baja cardinalidad a la que todos los MERGE apunten explícitamente y que separe los trabajos concurrentes; en caso contrario, apóyate en el clustering y las estadísticas.
Cuándo ayudan las estadísticas de archivos
Sin particiones, Delta puede omitir archivos usando las estadísticas mín./máx. por archivo de las columnas de la condición, pero solo si un rango de claves está en pocos archivos. Si los valores de order_id son UUID aleatorios repartidos por todos los archivos, el mín./máx. de cada archivo cubre casi todo el espacio de claves y no se omite nada. El clustering por las columnas del merge (liquid clustering u OPTIMIZE ... ZORDER BY) y las claves que siguen el orden de llegada (fechas, identificadores crecientes) hacen que funcione la poda basada en estadísticas.
Patrón 3: diseña el predicado para la poda, no por comodidad
Pequeños detalles de la cláusula ON deciden si se produce la poda:
- No envuelvas las columnas del destino en funciones.
CAST(t.order_id AS STRING) = s.order_idoto_date(t.created_at) = ...pueden impedir la omisión de archivos en esa columna. Convierte el lado del origen y corrige las discrepancias de tipos en el esquema. - Evita
ORentre columnas distintas en la condición de coincidencia; convierte una búsqueda selectiva en un escaneo amplio. Dos instrucciones MERGE específicas o una clave normalizada suelen ser mejores. - Reserva la cláusula
ONpara la identidad y la poda. La detección de cambios y las reglas de negocio van en las condicionesWHEN. - Haz que los límites sean deterministas. Expresiones como
current_date()en la condición hacen que las reejecuciones dependan del reloj. Pasa la ventana como parámetro desde el pipeline para que una reejecución de la carga de ayer pode los datos de ayer; Parámetros de notebooks en Microsoft Fabric explica ese patrón. - Ten cuidado con
WHEN NOT MATCHED BY SOURCE. Actualiza o elimina las filas del destino que no tienen coincidencia en el origen, lo que significa que tiene que considerar todo el destino salvo que lo acotes. Añade siempre una condición, como la misma ventana de fechas, a la cláusulaWHEN NOT MATCHED BY SOURCE.
Patrón 4: reduce los archivos que tocas
Una vez que la condición de coincidencia poda correctamente, el costo restante es proporcional al número de archivos afectados y a su tamaño.
- Alinea la organización con la clave del merge. Si las actualizaciones llegan para pedidos recientes, una organización agrupada por fecha de pedido mantiene esas filas en un número reducido de archivos recientes. Una organización agrupada por cliente reparte los cambios de un día por toda la tabla.
- Usa vectores de eliminación cuando el compromiso en lectura sea aceptable. Para actualizaciones pequeñas y frecuentes son mucho más baratos que reescribir archivos grandes; programa la compactación para que los lectores no paguen por una pila de vectores cada vez mayor.
- No ejecutes MERGE en un bucle. Un MERGE por entidad o por lote diminuto multiplica las lecturas de snapshot, los joins, los commits y los archivos de salida pequeños. Fusiona cada tabla una sola vez por ejecución.
Patrón 5: controla el tamaño de los archivos y los archivos pequeños
MERGE escribe a través de un shuffle, así que el número de archivos de salida depende del paralelismo del shuffle. La documentación de Delta indica que spark.sql.shuffle.partitions controla tanto el paralelismo como el número de archivos de salida, y que un valor más alto produce más archivos y más pequeños. En las tablas particionadas, un MERGE puede escribir muchos más archivos que particiones de shuffle, porque cada tarea puede escribir en varias particiones; la mitigación documentada es spark.databricks.delta.merge, que reparticiona la salida por las columnas de partición antes de escribir.
# Size shuffle parallelism to the data actually being rewritten, not to the cluster
spark.conf.set("spark.sql.shuffle.partitions", "64")
# For partitioned targets: repartition MERGE output by partition columns before writing
spark.conf.set("spark.databricks.delta.merge.repartitionBeforeWrite.enabled", "true")Trata estos valores como puntos de partida que hay que probar. La ejecución adaptativa de consultas (adaptive query execution) y las optimizaciones de escritura de Fabric también influyen en el número de archivos, así que mide los archivos añadidos por MERGE antes y después de un cambio. Los MERGE frecuentes siguen fragmentando una tabla con el tiempo, lo que hace más lenta la siguiente pasada de coincidencia, así que la compactación forma parte del rendimiento de MERGE:
-- Compact recent data and co-locate rows by the merge key
OPTIMIZE silver_orders
WHERE order_date >= DATE'2026-09-01'
ZORDER BY (order_id);La cláusula WHERE de OPTIMIZE debe hacer referencia a columnas de partición, así que esta forma encaja con una tabla particionada por order_date. En una tabla con liquid clustering, ejecuta un OPTIMIZE simple sin ZORDER BY y deja que el clustering decida la organización. La compactación puede entrar en conflicto con un MERGE concurrente sobre los mismos archivos, así que prográmala fuera de la ventana del MERGE.
Patrón 6: evolución del esquema sin sorpresas
MERGE valida que el origen encaje con el esquema del destino. Con UPDATE SET * e INSERT *, el origen debe contener todas las columnas del destino, y las columnas adicionales del origen se ignoran salvo que la evolución del esquema esté activada.
Hay dos formas de activarla. La configuración de sesión spark.databricks.delta.schema se aplica a todas las escrituras de la sesión, lo que es más amplio de lo que pretenden la mayoría de los pipelines. Delta Lake 3.2 y posteriores también ofrecen withSchemaEvolution() en el builder de merge, que limita la evolución a una sola instrucción:
(
target.alias("t")
.merge(source.alias("s"), condition)
.withSchemaEvolution()
.whenMatchedUpdateAll(condition="t.row_hash IS DISTINCT FROM s.row_hash")
.whenNotMatchedInsertAll()
.execute()
)Comprueba qué versión de Delta incluye tu runtime antes de depender del método del builder. Los riesgos aparecen en los mismos trabajos: una errata en una columna del origen se convierte en una columna nueva permanente, un cambio de tipo aguas arriba hace fallar el trabajo o se convierte en silencio, y los lectores ven columnas que nadie ha revisado. Haz evolucionar el esquema mediante cambios revisados y reserva la evolución automática para los casos en que las columnas nuevas son esperadas e inofensivas.
Patrón 7: concurrencia y commits optimistas
Delta usa control de concurrencia optimista. Un escritor lee un snapshot, escribe archivos nuevos y, en el momento del commit, valida que nada de lo que leyó haya sido modificado por otro commit. Dos operaciones MERGE pueden entrar en conflicto si leen o modifican los mismos archivos; un INSERT no puede entrar en conflicto con otro INSERT, pero un MERGE puede entrar en conflicto con casi cualquier cosa que añada archivos a los datos que leyó.
La sorpresa más habitual es ConcurrentAppendException cuando dos trabajos fusionan regiones o fechas distintas en la misma tabla. Parecen independientes, pero si la condición de coincidencia no restringe explícitamente cada trabajo a su porción, cada trabajo lee toda la tabla y entra en conflicto con los archivos nuevos del otro. La documentación de Delta y la de Fabric describen la misma solución: particionar por la columna que separa los trabajos y poner valores literales de esa columna en la condición de coincidencia de cada trabajo:
MERGE INTO sales_orders AS t
USING staged_orders_emea AS s
ON t.order_id = s.order_id
AND t.region = 'EMEA'
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *Sin particionamiento, o sin el literal en la condición, los trabajos pueden entrar en conflicto aunque modifiquen filas distintas. Cuando los trabajos no se pueden separar limpiamente, serialízalos en el orquestador. Antes de añadir reintentos ante conflictos, haz que el MERGE sea idempotente: una deduplicación y una detección de cambios deterministas hacen que un reintento produzca el mismo estado de la tabla.
Cómo medir bien un cambio
Cada ejecución ve un origen distinto, así que compara las variantes con la misma entrada: captura un lote representativo, ejecuta la referencia y el cambio sobre una copia del destino en la misma versión, y compara la duración además de los archivos eliminados, los archivos añadidos y las filas copiadas. Después ejecuta el lote del día siguiente tras cada variante, porque un cambio que acelera el MERGE de hoy escribiendo miles de archivos pequeños a menudo hace más lento el de mañana. Un cambio es real cuando reduce las filas copiadas o los archivos afectados para las mismas filas modificadas; una ejecución más rápida con la misma proporción de copia suele significar que el clúster estaba más tranquilo.
Cuándo MERGE no es la herramienta adecuada
MERGE es la herramienta adecuada cuando en cada ejecución cambia una minoría de las filas del destino y necesitas semántica de upsert a nivel de fila. Es la herramienta equivocada en varias situaciones habituales:
- Eventos de solo anexado. Los logs y los hechos inmutables necesitan anexados, no upserts. Si el origen reenvía duplicados, usa un MERGE de solo inserción acotado a una ventana reciente, o deduplica aguas abajo.
- La mayor parte de la porción cambia de todos modos. Si una ejecución modifica el 60 % de las filas de un rango de fechas, MERGE paga por la coincidencia y luego reescribe casi todo. Reconstruye la porción.
- Las instantáneas completas de dimensiones pequeñas o medianas quedan más claras como sobrescritura que como un MERGE que compara cada fila.
- Los agregados recalculados. Las tablas Gold derivadas por completo de Silver son más fáciles de reconstruir para la ventana afectada que de actualizar mediante upsert.
Para reconstruir una ventana, la sobrescritura selectiva de Delta reemplaza de forma atómica las filas que cumplen un predicado y deja intacto el resto de la tabla. En SQL (Delta Lake 2.4 y posteriores) es INSERT ... REPLACE WHERE; los writers de DataFrame exponen la misma funcionalidad mediante la opción replaceWhere:
INSERT INTO gold_daily_sales
REPLACE WHERE order_date >= DATE'2026-10-01' AND order_date <= DATE'2026-10-07'
SELECT * FROM rebuilt_windowPor defecto, Delta valida que cada fila escrita cumpla el predicado y, si no, hace fallar la escritura, lo que te protege de escribir por accidente fuera de la ventana. Los lectores ven o la ventana antigua o la nueva, nunca un estado a medio escribir.
Ventanas incrementales y datos tardíos
Los trabajos incrementales deben acotar ambos lados: filtrar el origen a la ventana de cambios y acotar la condición del destino al rango que esos cambios pueden afectar. Acotar solo el origen sigue permitiendo que MERGE escanee todo el destino. Para los datos tardíos, añade un margen de retroceso (lookback): si los registros llegan con hasta tres días de retraso, cada ejecución procesa [watermark - 3 days, now] y el límite del destino coincide con ese rango. Con detección de cambios, el solapamiento cuesta poco. Guarda el watermark en una tabla de control y pasa la ventana como parámetro para que las reejecuciones y las recargas históricas (backfills) usen la misma lógica que las ejecuciones programadas.
Lista de comprobación para producción
- Origen deduplicado por clave de negocio con un desempate determinista; filas sin cambios eliminadas.
- Límites de poda literales en la condición de coincidencia, sobre columnas que nunca cambian para una clave; ninguna función sobre columnas del destino.
WHEN NOT MATCHED BY SOURCEacotado, si se usa.- Organización alineada con la clave del merge o con el patrón de llegada; particionamiento solo para columnas de baja cardinalidad que separan escritores.
- Número de archivos de salida medido y compactación programada.
- Evolución del esquema limitada a la instrucción, no activada para toda la sesión.
- Trabajos concurrentes separados mediante literales de partición explícitos, o serializados.
operationMetricsy duración registrados y con seguimiento de tendencia.- Anexado o reconstrucción de la ventana cuando cambia la mayor parte de la porción.
Recomendación
Empieza cualquier investigación de un MERGE por las métricas del historial, no por la configuración de Spark. Si las filas copiadas superan con creces a las modificadas, trabaja la poda y la organización. Si los archivos añadidos crecen en cada ejecución, trabaja el dimensionamiento de la salida y la compactación. Si las ejecuciones fallan por concurrencia, haz explícita la separación en la condición de coincidencia. Y si la mayoría de los datos de la ventana cambia en cada ejecución, deja de usar MERGE y reconstruye la ventana.
Para ver dónde encaja MERGE en un diseño más amplio, Arquitectura Medallion explicada muestra qué capas suelen necesitar upserts, Lakehouse o Warehouse en Microsoft Fabric explica cuándo encaja mejor un MERGE de T-SQL en un Warehouse, y Cómo acelerar los notebooks de Microsoft Fabric cubre el lado de Spark de los trabajos lentos. La lista de comprobación de particionamiento de Delta Lake es una referencia rápida para decidir si merece la pena una columna de partición.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Sigue aprendiendo
- Guía rápidaLeer y escribir tablas DeltaLee y escribe tablas Delta con PySpark usando patrones seguros de append, overwrite, merge, evolución del esquema, particionamiento y mantenimiento para pipelines de datos en producción.Abrir guía rápida
- Hoja de rutaFabric Performance at ScalePor qué el rendimiento de MERGE en Delta se degrada en tablas grandes y cómo mantenerlo: orígenes limpios, poda, menos archivos afectados, concurrencia segura y alternativas.Ver hoja de ruta
¿Qué debería crear después?
Estoy construyendo Javi Builds alrededor de problemas reales que enfrentan los ingenieros de datos. Dime qué tema te gustaría ver después.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.