(+351) 21 24 10006  ·  info@bconcepts.pt
Carnaxide, Lisboa

Como fazer streaming incremental de alterações CDC em Databricks

João Barros 19 de November de 2026 4 min de leitura

Este tutorial mostra como fazer streaming incremental de alterações (CDC) em Databricks para aplicar upserts contínuos numa tabela Delta. É útil quando precisa de manter uma base de dados de destino sincronizada com alterações de origem em tempo quase real.

Pré-requisitos

  • Workspace Databricks com cluster em execução.
  • Permissões para ler a origem (por exemplo Kafka, ou um ficheiro de log) e escrever em DBFS/Delta.
  • Conhecimentos básicos de PySpark e Delta Lake.
  • Exemplo de feed de alterações em formato JSON com campos: op (I/U/D), id, payload, timestamp.

Passo 1: Entender o padrão CDC e porque usar Structured Streaming

CDC (Change Data Capture) representa operações de CRUD como eventos. Em Databricks, usar Structured Streaming permite tratar esses eventos continuamente e aplicar MERGE em tabelas Delta com baixa latência. A ideia é ler o stream, normalizar eventos e executar micro-batches com upsert.

Passo 2: Ler o stream de eventos (exemplo com ficheiros JSON em DBFS)

Para aprender, usamos um diretório em DBFS onde são colocados ficheiros JSON com eventos. Structured Streaming vai detetar ficheiros novos e processá-los em micro-batches.

# Exemplo PySpark num notebook Databricks
from pyspark.sql.functions import from_json, col, expr
from pyspark.sql.types import StructType, StructField, StringType, TimestampType

schema = StructType([
    StructField("op", StringType()),     # I, U, D
    StructField("id", StringType()),
    StructField("payload", StringType()),
    StructField("ts", TimestampType())
])

input_path = "/mnt/data/cdc_events/"
raw = spark.readStream.format("json").schema(schema).load(input_path)

Passo 3: Transformar eventos para formato de upsert

Converta o payload JSON em colunas, normalize operações e marque linhas para MERGE. Vamos criar uma coluna _is_deleted para operações D (delete).

from pyspark.sql.functions import from_json, col
from pyspark.sql.types import StructType, StructField, StringType

payload_schema = StructType([
    StructField("name", StringType()),
    StructField("value", StringType())
])

events = raw.withColumn("payload_json", from_json(col("payload"), payload_schema)) \
            .select(
                col("op"),
                col("id"),
                col("ts"),
                col("payload_json.*")
            ) \
            .withColumn("_is_deleted", expr("op = 'D'"))

Passo 4: Fazer upsert incrementais para a tabela Delta usando foreachBatch

Em cada micro-batch, utilizamos foreachBatch para executar MERGE SQL numa tabela Delta. Isto dá controlo para aplicar as alterações de forma transaccional.

target_table = "default.cdc_target"

# Cria tabela alvo se não existir
spark.sql(f"CREATE TABLE IF NOT EXISTS {target_table} (id STRING, name STRING, value STRING, ts TIMESTAMP) USING DELTA")

def upsert_to_delta(batch_df, batch_id):
    batch_df.createOrReplaceTempView("staging_cdc")
    merge_sql = f"""
    MERGE INTO {target_table} AS t
    USING staging_cdc AS s
      ON t.id = s.id
    WHEN MATCHED AND s._is_deleted = true THEN
      DELETE
    WHEN MATCHED THEN
      UPDATE SET name = s.name, value = s.value, ts = s.ts
    WHEN NOT MATCHED AND s._is_deleted = false THEN
      INSERT (id, name, value, ts) VALUES (s.id, s.name, s.value, s.ts)
    """
    spark.sql(merge_sql)

query = events.writeStream.foreachBatch(upsert_to_delta) \
    .outputMode("update") \
    .option("checkpointLocation", "/mnt/checkpoints/cdc_upsert_checkpoint") \
    .start()

Passo 5: Gerir idempotência e ordenação de eventos

Erros comuns: eventos fora de ordem ou duplicados. Para manter idempotência, inclua um campo de versão/timestamp e aplique lógica que compare ts para decidir atualizações. Outra prática é compactar a tabela Delta com OPTIMIZE periodicamente.

# Exemplo simples: só aplica UPDATE/INSERT se ts do event for maior
merge_sql = f"""
MERGE INTO {target_table} AS t
USING (SELECT *, row_number() OVER (PARTITION BY id ORDER BY ts DESC) AS rn FROM staging_cdc) AS s
  ON t.id = s.id
WHEN MATCHED AND s._is_deleted = true AND s.rn = 1 THEN DELETE
WHEN MATCHED AND s.rn = 1 AND s.ts > t.ts THEN
  UPDATE SET name = s.name, value = s.value, ts = s.ts
WHEN NOT MATCHED AND s.rn = 1 AND s._is_deleted = false THEN
  INSERT (id, name, value, ts) VALUES (s.id, s.name, s.value, s.ts)
"""

Verificar o resultado

Para confirmar que o streaming aplica CDC corretamente, consulte a tabela Delta de destino e verifique timestamps, valores e remoções.

-- No notebook (SQL ou PySpark)
spark.sql("SELECT * FROM default.cdc_target ORDER BY ts DESC LIMIT 100").show()

-- Verificar estado do stream
query.isActive
query.status

Conclusão

Seguindo estes passos, ficou um pipeline de CDC em Databricks que lê eventos, normaliza e aplica upserts em Delta com baixa latência. Próximos passos: ligar uma fonte real (Kafka, Debezium), adicionar monitorização e otimizar consistência (compaction, OPTIMIZE). Dica: teste cenários de duplicação e ordenação antes de ir para produção.