Cómo crear una tabla Delta con columnas calculadas en Lakehouse

João Barros 01 de October de 2026 4 min de lectura

Crear columnas calculadas persistidas en una tabla Delta en el Lakehouse mejora el rendimiento y facilita consultas repetidas. Esta guía muestra cómo crear una tabla Delta con columnas calculadas (datos transformados y almacenados) usando SQL y PySpark, explicando por qué y presentando un ejemplo práctico.

Requisitos previos

Cuenta con acceso a Microsoft Fabric y un Lakehouse configurado.
Acceso al endpoint de SQL analytics o a un notebook con PySpark.
Permisos para crear tablas y escribir archivos en el Lakehouse.

Paso 1: Entender por qué crear columnas calculadas persistidas

Las columnas calculadas pueden ser expresiones derivadas (p. ej.: fechas formateadas, claves compuestas, flags). Si calculas esas columnas en la consulta, pagas coste de CPU repetidamente. Persistirlas en una tabla Delta reduce el coste de lectura y acelera las consultas, especialmente en informes y modelos Power BI.

Paso 2: Planificar las columnas calculadas

Decide qué campos derivar y si deberás actualizar esas columnas en el futuro (p. ej.: raw + transformación). Ejemplos comunes: data_particao, is_high_value, customer_region. Planifica también el particionado y los tipos de datos.

Paso 3: Crear una tabla Delta a partir de datos crudos (SQL)

Si tienes un CSV o tabla raw, crea una tabla Delta y añade columnas calculadas en el SELECT. Aquí tienes un ejemplo usando SQL en el endpoint de SQL analytics.

CREATE OR REPLACE TABLE lakehouse.catalog.schema.sales_delta AS SELECT   sale_id,   customer_id,   amount,   sale_date,   CAST(date_trunc('day', sale_date) AS date) AS sale_day,   CASE WHEN amount > 1000 THEN true ELSE false END AS is_high_value,   concat(customer_id, '-', year(sale_date)) AS customer_year_key FROM lakehouse.catalog.schema.raw_sales;

Paso 4: Crear/actualizar columnas calculadas con PySpark

En un notebook PySpark puedes leer la fuente, calcular columnas y escribir como Delta. Útil para transformaciones más complejas o pipelines programáticos.

from pyspark.sql import functions as F

raw = spark.read.format("delta").table("lakehouse.catalog.schema.raw_sales")

transformed = raw.withColumn("sale_day", F.to_date(F.trunc("sale_date", "DAY"))) \
                  .withColumn("is_high_value", F.col("amount") > 1000) \
                  .withColumn("customer_year_key", F.concat(F.col("customer_id"), F.lit("-"), F.year(F.col("sale_date"))))

transformed.write.format("delta").mode("overwrite").saveAsTable("lakehouse.catalog.schema.sales_delta")

Paso 5: Actualizar columnas calculadas en datos nuevos (MERGE)

Cuando llega nueva ingestión, actualiza la tabla Delta para calcular las columnas persistidas usando MERGE (upsert). Así mantienes las columnas sincronizadas.

MERGE INTO lakehouse.catalog.schema.sales_delta AS target
USING (SELECT * FROM lakehouse.catalog.schema.raw_sales_stage) AS src
ON target.sale_id = src.sale_id
WHEN MATCHED THEN UPDATE SET
  target.amount = src.amount,
  target.sale_date = src.sale_date,
  target.sale_day = CAST(date_trunc('day', src.sale_date) AS date),
  target.is_high_value = CASE WHEN src.amount > 1000 THEN true ELSE false END,
  target.customer_year_key = concat(src.customer_id, '-', year(src.sale_date))
WHEN NOT MATCHED THEN INSERT *;

Paso 6: Buenas prácticas y errores comunes

Usa tipos de datos apropiados (date, boolean) para reducir espacio. Evita recalcular columnas ya persistidas en las consultas. Si la lógica de cálculo cambia, haz una migración controlada: crea nueva columna, poblala, valida y luego elimina la antigua. Error común: particionar por muchas columnas calculadas pequeñas — esto crea muchos archivos pequeños.

Verificar el resultado

Confirma que las columnas existen y contienen los valores esperados con consultas simples. Verifica también el plan de ejecución para observar mejora en las consultas que usaban la expresión en tiempo de ejecución.

SELECT sale_id, amount, sale_date, sale_day, is_high_value, customer_year_key
FROM lakehouse.catalog.schema.sales_delta
LIMIT 20;

Para validar el rendimiento, compara el tiempo de la consulta antes (sin columnas persistidas) y después (con columnas). Usa EXPLAIN para ver si la expresión fue eliminada del runtime.

Conclusión

Persistir columnas calculadas en tablas Delta en el Lakehouse reduce coste y acelera consultas, especialmente en informes y ETL recurrente. Próximos pasos: automatizar la actualización con pipelines (Delta Live Tables o un orchestrator) y monitorizar espacio y rendimiento. Consejo: empieza por persistir solo las columnas más costosas de calcular — ¿cuál es la primera columna que vas a persistir en tu tabla?