CommunityRecherche & Datenanalysegithub.com

Iceberg-Tabellen erstellen

Apache Iceberg-Tabellen entwerfen und betreiben – Partitionierung und versteckte Partitionierung, Schema- und Partitionsentwicklung, Snapshots und Zeitreisen, Kompaktierung und Bereinigung kleiner Dateien sowie MERGE/Upsert für Lakehouse-Tabellen auf Spark, Flink, Trino oder Snowflake.

Was ist Iceberg-Tabellen erstellen?

Diese Fähigkeit unterstützt Sie bei der Erstellung und Wartung von Apache Iceberg-Tabellen in einem Lakehouse. Sie deckt die Auswahl von Partitionierungsstrategien ab (einschließlich versteckter Partitionierung mit `days(ts)` oder `bucket(N, id)`), die idempotente Datenverarbeitung mittels `MERGE INTO` auf Basis eines Geschäftsschlüssels sowie die Kompaktierung (`rewrite_data_files`) zur Behebung von Problemen mit vielen kleinen Dateien, die durch Streaming oder Batch-Writes entstehen. Darüber hinaus werden regelmäßige Wartungsaufgaben wie das Ablaufenlassen alter Snapshots und das Entfernen verwaister Dateien beschrieben, um Speicher- und Metadatenexplosion zu vermeiden. Die Fähigkeit betont die flexible Entwicklung von Partitionen und Schemata ohne Datenneuschreibung, was ein Kernmerkmal von Iceberg ist. Sie ist für alle gängigen Iceberg-Plattformen (Spark, Flink, Trino, Snowflake) geeignet und sollte nicht für Delta-spezifische Arbeiten verwendet werden (dafür ist `engineering-databricks-pipelines` vorgesehen).

Funktioniert mit~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 Recherche & Datenanalyse skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Iceberg-Tabellen erstellen?

Wann verwenden

  • Erstellen oder Verwalten von Apache Iceberg-Tabellen auf einem Lakehouse.
  • Auswahl der Partitionierung oder Entwicklung der Partitionierung / des Schemas ohne Neuschreibung.
  • Verwalten von Snapshots, Zeitreisen, Kompaktierung und kleinen Dateien.
  • NICHT verwenden für Delta-spezifische Arbeiten (dafür engineering-databricks-pipelines nutzen).

Arbeitsablauf

- [ ] Partitionierung nach Abfrage-Filterspalten; versteckte Partitionstransformationen verwenden
- [ ] MERGE für idempotente Upserts verwenden
- [ ] Kompaktierung (rewrite_data_files) planen, um kleine Dateien zu beheben
- [ ] Alte Snapshots ablaufen lassen + verwaiste Dateien entfernen, um Metadaten/Speicher zu kontrollieren
- [ ] Partitionierung / Schema nach Feld-ID entwickeln (keine Datenneuschreibung)
  1. Partitionierung auf Filterspalten mittels versteckter Partitionstransformationen (days(ts), bucket(N, id)), sodass Abfragen bereinigen, ohne dass Benutzer abgeleitete Partitionsspalten hinzufügen müssen.
  2. Idempotente Schreibvorgänge via MERGE INTO mit dem Geschäftsschlüssel.
  3. Regelmäßig kompaktieren – Streaming-/Kleinstbatch-Schreibvorgänge erzeugen viele kleine Dateien; rewrite_data_files stellt die Leseleistung wieder her.
  4. Metadaten pflegen – alte Snapshots ablaufen lassen und verwaiste Dateien entfernen, sonst wachsen Snapshot-Verlauf und Speicher unbegrenzt.
  5. Frei entwickeln – Iceberg verfolgt Spalten/Partitionen per ID, sodass Hinzufügen/Löschen/Umbenennen und sogar Partitionsspezifikationsänderungen keine Datenneuschreibung erfordern.

Muster

Erstellen mit versteckter Partitionierung + MERGE-Upsert:

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 *;

Wartung (Spark-Prozeduren):

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

Zeitreisen – einen früheren Snapshot für Audit oder Wiederherstellung lesen: SELECT * FROM lake.db.orders VERSION AS OF <snapshot_id>.

Partitionsentwicklung – ALTER TABLE ... ADD PARTITION FIELD bucket(16, customer_id) gilt nur für neue Daten; alte Daten bleiben gültig.

Häufige Fallstricke

  • Keine Kompaktierung bei Streaming-Tabellen – Explosion kleiner Dateien senkt die Lesegeschwindigkeit drastisch.
  • Snapshots nie ablaufen lassen – Metadaten und Speicher wachsen unbegrenzt; planen Sie das Ablaufen innerhalb Ihrer Zeitreise-Aufbewahrungsfrist.
  • Übermäßige Partitionierung (z. B. stündlich bei geringem Volumen) – zu viele winzige Partitionen; Granularität an die Datenmenge anpassen.
  • Explizite abgeleitete Partitionsspalten hinzufügen – hebelt den Sinn der versteckten Partitionierung aus; Transformationen verwenden.
  • Blindes Überschreiben statt MERGE – verliert Idempotenz; MERGE nach Schlüssel.
  • Verwaiste Dateien mit zu kurzem Zeitfenster entfernen – kann Dateien löschen, die von aktiven Schreibern noch benötigt werden; einen sicheren Grenzwert verwenden.

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.

Verwandte Skills