Como criar uma tabela Delta com colunas calculadas em Lakehouse

Criar colunas calculadas persistidas numa tabela Delta no Lakehouse melhora o desempenho e facilita consultas repetidas. Este guia mostra como criar uma tabela Delta com colunas calculadas (dados transformados e armazenados) usando SQL e PySpark, explicando o porquê e apresentando um exemplo prático.

Pré-requisitos

• Conta com acesso ao Microsoft Fabric e um Lakehouse configurado.
• Acesso ao endpoint de SQL analytics ou a um notebook com PySpark.
• Permissões para criar tabelas e escrever ficheiros no Lakehouse.

Passo 1: Entender por que criar colunas calculadas persistidas

Colunas calculadas podem ser expressões derivadas (ex.: datas formatadas, chaves compostas, flags). Se calculares essas colunas na consulta, pagas custo de CPU repetidamente. Persisti-las numa tabela Delta reduz o custo de leitura e acelera as queries, especialmente em relatórios e modelos Power BI.

Passo 2: Planear as colunas calculadas

Decide quais campos derivar e se deverás actualizar essas colunas no futuro (ex.: base raw + transformação). Exemplos comuns: data_particao, is_high_value, customer_region. Planifica também o particionamento e os tipos de dados.

Passo 3: Criar uma tabela Delta a partir de dados brutos (SQL)

Se tiveres um CSV ou tabela raw, cria uma tabela Delta e adiciona colunas calculadas no SELECT. Aqui está um exemplo usando SQL no 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;

Passo 4: Criar/actualizar colunas calculadas com PySpark

Numa notebook PySpark podes ler a fonte, calcular colunas e gravar como Delta. Útil para transformações mais complexas ou 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")

Passo 5: Actualizar colunas calculadas em dados novos (MERGE)

Quando chega nova ingestão, actualiza a tabela Delta para calcular as colunas persistidas usando MERGE (upsert). Assim manténs as colunas 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 *;

Passo 6: Boas práticas e erros comuns

Usa tipos de dados apropriados (date, boolean) para reduzir espaço. Evita recalcular colunas já persistidas nas queries. Se a lógica de cálculo mudar, faz uma migração controlada: cria nova coluna, popula, valida e depois remove a antiga. Erro comum: particionar por muitas colunas calculadas pequenas — isso cria muitos ficheiros pequenos.

Verificar o resultado

Confirma que as colunas existem e contêm os valores esperados com consultas simples. Verifica também o plano de execução para observar melhoria nas queries que usavam a expressão em runtime.

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

Para validar o desempenho, compara o tempo da query antes (sem colunas persistidas) e depois (com colunas). Usa EXPLAIN para ver se a expressão foi removida do runtime.

Conclusão

Persistir colunas calculadas em tabelas Delta no Lakehouse reduz custo e acelera consultas, especialmente em relatórios e ETL recorrente. Próximos passos: automatizar a actualização com pipelines (Delta Live Tables ou um orchestrator) e monitorizar espaço e desempenho. Dica: começa por persistir apenas as colunas mais dispendiosas de calcular — qual é a primeira coluna que vais persistir na tua tabela?