CommunityPesquisa e Análise de Dadosgithub.com

Construção de Tabelas Iceberg

Projete e opere tabelas Apache Iceberg — particionamento e particionamento oculto, evolução de partição/esquema, snapshots e viagem no tempo, compactação e limpeza de arquivos pequenos, e MERGE/upsert para tabelas lakehouse no Spark, Flink, Trino ou Snowflake.

O que é Construção de Tabelas Iceberg?

Esta skill orienta a criação e manutenção de tabelas Apache Iceberg em lakehouses. Ela cobre práticas essenciais como particionamento por colunas de filtro usando transformações ocultas (e.g., `days(ts)`), upserts idempotentes com `MERGE INTO`, e evolução de partições ou esquemas sem reescrita de dados. A skill também aborda a compactação de arquivos pequenos via `rewrite_data_files`, expiração de snapshots antigos e remoção de arquivos órfãos para evitar o crescimento excessivo de metadados. Inclui padrões de código para Spark, Flink, Trino ou Snowflake, e alerta sobre armadilhas comuns como a falta de compactação em tabelas de streaming e o excesso de particionamento.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Unknown-333/awesome-data-engineering-skills/tree/main/skills/building-iceberg-tables

Installed? Explore more Pesquisa e Análise de Dados skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que Construção de Tabelas Iceberg faz?

Quando usar

  • Criar ou manter tabelas Apache Iceberg em um lakehouse.
  • Escolher particionamento, ou evoluir particionamento/esquema sem reescritas.
  • Gerenciar snapshots, viagem no tempo, compactação e arquivos pequenos.
  • NÃO usar para trabalhos específicos do Delta (use engineering-databricks-pipelines).

Fluxo de trabalho

- [ ] Particionar por colunas de filtro de consulta; usar transformações de partição ocultas
- [ ] Usar MERGE para upserts idempotentes
- [ ] Agendar compactação (rewrite_data_files) para corrigir arquivos pequenos
- [ ] Expirar snapshots antigos + remover arquivos órfãos para controlar metadados/armazenamento
- [ ] Evoluir particionamento/esquema por ID de campo (sem reescrita de dados)
  1. Particionar por colunas de filtro usando transformações de partição ocultas (days(ts), bucket(N, id)), para que consultas podem podar sem que usuários adicionem colunas derivadas de partição.
  2. Escritas idempotentes via MERGE INTO chaveado pela chave de negócio.
  3. Compactar regularmente — escritas em lote/streaming criam muitos arquivos pequenos; rewrite_data_files restaura o desempenho de leitura.
  4. Manter metadados — expirar snapshots antigos e remover arquivos órfãos, caso contrário o histórico de snapshots e o armazenamento crescem sem limites.
  5. Evoluir livremente — Iceberg rastreia colunas/partições por ID, então adicionar/remover/renomear e até mesmo alterações na especificação de partição não necessitam de reescrita de dados.

Padrões

Criar com particionamento oculto + upsert MERGE:

CREATE TABLE lake.db.orders (order_id BIGINT, customer_id BIGINT, amount DECIMAL, ordered_at TIMESTAMP)
USING iceberg PARTITIONED BY (days(ordered_at));

MERGE INTO lake.db.orders t USING staging s ON t.order_id = s.order_id
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *;

Manutenção (procedimentos Spark):

CALL lake.system.rewrite_data_files('db.orders');       -- compactar arquivos pequenos
CALL lake.system.expire_snapshots('db.orders', TIMESTAMP '2026-08-01 00:00:00');
CALL lake.system.remove_orphan_files(table => 'db.orders');

Viagem no tempo — ler um snapshot anterior para auditoria ou recuperação: SELECT * FROM lake.db.orders VERSION AS OF <snapshot_id>.

Evolução de partição — ALTER TABLE ... ADD PARTITION FIELD bucket(16, customer_id) aplica-se apenas a novos dados; dados antigos permanecem válidos.

Armadilhas comuns

  • Sem compactação em tabelas de streaming — explosão de arquivos pequenos prejudica velocidade de leitura.
  • Nunca expirar snapshots — metadados e armazenamento crescem indefinidamente; agende expiração dentro de sua retenção de viagem no tempo.
  • Particionamento excessivo (ex.: por hora em baixo volume) — muitas partições minúsculas; ajuste a granularidade ao tamanho dos dados.
  • Adicionar colunas de partição derivadas explícitas — anula o propósito do particionamento oculto; use transformações.
  • Sobrescrita cega em vez de MERGE — perde idempotência; use MERGE por chave.
  • Remover arquivos órfãos com janela muito curta — pode deletar arquivos que escritores ainda precisam; use um limite seguro.

Individual skills in this repo

This repo contains 9 individual skills — each has its own dedicated page.

Unknown-333/authoring-airflow-dags

Write production-grade Apache Airflow DAGs using the TaskFlow API — idempotent tasks, correct scheduling and catchup, retries/SLAs, connections/variables, and avoiding top-level code. Use when creating or reviewing Airflow DAGs, scheduling pipelines, wiring task dependencies, configuring retries/backfills, or fixing non-idempotent tasks.

Unknown-333/building-dagster-assets

Build Dagster pipelines using software-defined assets — asset dependencies, partitions, resources and IO managers, asset checks, and schedules/sensors. Use when creating Dagster assets or jobs, modeling data as assets, adding partitions or backfills, wiring resources/IO managers, or migrating from task-based orchestration to assets.

Unknown-333/building-dbt-models

Build well-structured dbt models — staging/intermediate/marts layers, ref() and source(), materializations, and incremental models with the right strategy. Use when creating or refactoring dbt models, choosing table vs view vs incremental, structuring a dbt project, or writing incremental logic.

Unknown-333/building-feature-pipelines

Build ML feature pipelines and feature stores — point-in-time-correct joins to avoid label leakage, offline/online parity, feature freshness and backfills, and materialization with tools like Feast. Use when engineering features for ML, preventing train/serve skew or data leakage, building a feature store, or backfilling historical features for training.

Unknown-333/building-ingestion-pipelines

Build batch and incremental data ingestion (extract-load) pipelines — full vs incremental extraction, change data capture (CDC), watermarks and high-water marks, API pagination and rate limits, and choosing managed EL tools (Fivetran, Airbyte) vs custom code. Use when ingesting data from databases, APIs, files, or SaaS into a warehouse/lake, or designing incremental extraction and CDC.

Unknown-333/building-kafka-consumers

Build reliable Apache Kafka consumers and producers — consumer groups and partition assignment, offset commit strategy, at-least-once vs exactly-once, idempotent/transactional producers, rebalancing, and dead-letter handling. Use when writing Kafka consumers/producers, configuring offset commits or consumer groups, tuning throughput, or handling rebalances and poison messages.

Unknown-333/debugging-data-pipelines

Systematically root-cause data pipeline failures and data incidents — job errors, wrong or missing data, duplicates, and freshness misses — by tracing lineage upstream, isolating the failing stage, reconciling against source, and planning a safe fix and backfill. Use when a pipeline fails, numbers look wrong, data is missing or duplicated, a dashboard is stale, or a stakeholder reports a data discrepancy.

Unknown-333/designing-backfills-and-replays

Plan and run safe data backfills and replays — idempotent reprocessing of historical windows, partition-by-partition execution, isolating backfill compute from production, verifying results, and avoiding double-counting or changed history. Use when backfilling a new or fixed model, reprocessing after a bug, replaying events, or loading history for a new pipeline without corrupting existing data.

Unknown-333/designing-data-contracts

Define and enforce data contracts between producers and consumers — explicit schema, semantics, ownership, SLAs, and versioning — to prevent silent upstream changes from breaking downstream pipelines. Use when a producer schema change could break consumers, defining an interface between teams/services and the warehouse, or adding schema enforcement at ingestion.

Habilidades Relacionadas