Optionen für Datentransformationen
Wie zwischen SQL, nativen Plattformfunktionen, Notebooks, Dataflows, Stored Procedures, klassischen ETL-Werkzeugen und dbt gewählt wird, ohne aus einer Toolentscheidung die Architektur zu machen.
Die Transformationstechnologie ist eine Designentscheidung und nicht die Architektur
Transformation (SQL, dbt, Notebook, Dataflow) setzt Geschäftsregeln um — die Wahl des Werkzeugs ist Design, nicht die Architektur selbst.
Zwei Teams bauen dieselbe Storno-Regel: eines in dbt, eines in einem Spark-Notebook. Beide liefern abweichende Nettoumsatz-Zahlen, weil Verantwortung und Vertrag nie festgelegt wurden.
Jede Plattform braucht Transformationen. Keine Verantwortlichkeit legt automatisch fest, ob SQL, Stored Procedure, Notebook, Dataflow, native Funktion, ETL oder dbt nötig ist.
Dieselbe gültige Geschäftsregel kann auf mehreren technisch tragfähigen Wegen umgesetzt werden:
SQL View
Geplanter Tabellenaufbau
Stored Procedure
Low-Code-Dataflow
Python- oder Spark-Notebook
Native deklarative Pipeline
Klassisches ETL-Mapping
dbt-Modell und Datentest
Die Architektur wird fragil, wenn das Unternehmen mit dem Tool statt mit der Verantwortung beginnt.
Eine typische Tool-first-Diskussion klingt so:
„Wir haben Fabric, deshalb gehört jede Transformation in ein Notebook.“
„Wir nutzen Snowflake, deshalb muss jede Pipeline eine Dynamic Table sein.“
„Wir haben dbt eingeführt, deshalb muss jedes SQL migriert werden.“
„Das Qlik-Skript funktioniert bereits, deshalb bleibt es die führende Implementierung.“
„Der Fachanwender bevorzugt einen Dataflow, deshalb gehört die Regel dauerhaft dorthin.“
Jede Aussage kann für einen konkreten Workload sinnvoll sein. Keine davon ist eine allgemeine Architekturregel.
Kapitel 7, Ein Datenprodukt, mehrere Nutzer, hat gezeigt, dass Qlik, Power BI, Excel, APIs und KI dieselbe governte fachliche Wahrheit über unterschiedliche Verträge konsumieren können. Dieses Kapitel beantwortet die nächste Frage: Wo soll die Transformation ausgeführt werden, die diese Wahrheit erzeugt?
Wähle den einfachsten Transformationsmechanismus, der die Anforderungen von Workload, Team und Governance erfüllt. Gib jeder gemeinsamen Geschäftsregel eine führende Implementierung und eine verantwortliche Person.
Produktrollen vor dem zusätzlichen Baustein klären
| Aufgabe | Möglicher Weg | Entscheidender Nachweis |
|---|---|---|
| Quellen übernehmen | Fivetran bei passendem Connector oder vorhandene Integration | Löschung, Wiederanlauf und Schemaänderung am gewählten Quell-/Zielpaar testen |
| Wiederverwendbar transformieren | dbt, natives SQL oder KNIME als führende Implementierung | Gleicher Prüfbestand, Regelversion und erwartetes Ergebnis |
| Daten virtuell bereitstellen | Denodo, wenn der Zugriff ohne vollständige Replikation zum Fall passt | Quelllast, Ausfallverhalten, Berechtigung und gegebenenfalls Cache testen |
Diese Wege können unabhängig sinnvoll sein. Ein KNIME-Workflow braucht keine Denodo-Anbindung. Fivetran ersetzt nicht die fachliche Definition einer Transformationsregel. Wähle zuerst einen führenden Ort für die Regel; zusätzliche Komponenten benötigen eine konkrete, noch ungelöste Aufgabe.
Vergleiche für den Piloten auch Änderungsdauer, Wiederanlauf und laufende Betreuung. Ein kurzer Erstaufbau ist kein ausreichender Kostennachweis.
Herstellerreferenzen: KNIME, Fivetran, dbt, Denodo. Der konkrete Connector-, Editions- und Deploymentumfang muss im Pilot geprüft werden.
Nächster Arbeitsschritt: Entscheidung im bestehenden Fachkapitel konkretisieren.
Architekturprinzip: eine Transformationsverantwortung, eine führende Implementierung
Eine Transformationsarchitektur sollte zuerst Verantwortlichkeiten definieren und erst danach Technologien zuordnen.
Die zentralen Fragen lauten:
Welche fachliche Bedeutung wird erzeugt?
Mit welcher Granularität wird das Ergebnis veröffentlicht?
Welche Quellabhängigkeiten bestehen?
Wer verantwortet die Korrektheit?
Wie wird die Regel getestet?
Wie wird die Implementierung geprüft und versioniert?
Wie wird sie geplant und überwacht?
Welche Nutzer hängen von ihr ab?
Wie werden Breaking Changes kommuniziert?
Wo werden fehlerhafte Datensätze und Qualitätsnachweise gespeichert?
Eine hilfreiche Einordnung ist:
| Art der Logik | Bevorzugter Architekturort |
|---|---|
| Gemeinsame Bereinigung und Standardisierung | Governte Transformationsschicht |
| Wiederverwendbare Geschäftsregeln | Eine führende governte Implementierung |
| Schlüsselauflösung und Historisierung | Governter Kern oder Datenproduktschicht |
| Datenqualitätsvalidierung | Ausführbare Regel plus persistenter Ergebnisnachweis |
| Plattformspezifische Performanceoptimierung | Native Plattformimplementierung, als technisches Verhalten dokumentiert |
| Qlik-Assoziationen, Section Access oder Set Analysis | Schlankes Qlik-Nutzungsmodell, wenn das Verhalten tatsächlich Qlik-spezifisch ist |
| Power-BI-Filterkontext und Berichts-Measures | Semantisches Modell, wenn das Verhalten tatsächlich modellspezifisch ist |
| Excel-Layout, Kommentare und kontrollierte Annahmen | Arbeitsmappe oder Planungsprozess, getrennt von governten Ist-Daten |
| Temporäre Exploration | Notebook oder Sandbox mit explizitem Überführungspfad |
Diese Trennung verhindert zwei gegensätzliche Fehler.
Der erste Fehler besteht darin, alles zu zentralisieren, auch Logik, die nur innerhalb einer bestimmten Analyse-Engine sinnvoll ist. Der zweite besteht darin, jedem Tool eine eigene Version gemeinsamer fachlicher Bedeutung zu erlauben.

Viele gültige Wege für Datentransformationen
Die wichtigsten Transformationsoptionen überschneiden sich. Sie schließen sich nicht gegenseitig aus, und die meisten realen Plattformen verwenden mehr als eine davon.
SQL-Skripte, Views und materialisierte Tabellen
SQL ist häufig der einfachste Ausgangspunkt, wenn sich die Daten bereits in einer relationalen Datenbank, einem Warehouse oder einem per SQL zugänglichen Lakehouse befinden.
Geeignete Einsatzfelder sind:
- Joins, Filter und Aggregationen;
- dimensionale Modelle und Reporting Views;
- deterministische Geschäftsregeln;
- Datenbereinigung und Standardisierung;
- materialisierte Tabellen für reproduzierbare Performance;
- inkrementelle Verarbeitung, sofern die Plattform passende Muster unterstützt;
- Veröffentlichung stabiler Nutzer-Verträge.
Vorteile:
- verbreitetes Skillset;
- Ausführung in der Nähe der Daten;
- transparente Abfragelogik;
- geringe zusätzliche Toolkosten;
- einfache Integration mit Schedulern und BI-Nutzern.
Risiken:
- unkontrollierte Ketten von Views;
- dupliziertes SQL in mehreren Jobs;
- schwache Deployment-Disziplin;
- verborgene Abhängigkeiten, wenn Objektreferenzen nicht katalogisiert werden;
- plattformspezifische Syntax, die spätere Migrationen erschwert.
Eine SQL-Implementierung ist nicht automatisch primitiv. Eine kleine, getestete Menge aus Views und geplanten Tabellen kann wartbarer sein als eine anspruchsvolle Toolchain, die das Team nicht zuverlässig betreiben kann.
Stored Procedures und Funktionen
Stored Procedures sind sinnvoll, wenn die Transformation kontrollierte prozedurale Ausführung, Transaktionsbehandlung, Verzweigungen, wiederverwendbare Datenbankroutinen oder eine explizite Schrittfolge benötigt.
Geeignete Einsatzfelder sind:
- komplexes Merge-Verhalten;
- Batch-Steuerungslogik;
- parametrisierte Verarbeitung;
- operative Fehlerbehandlung;
- datenbanknative Performanceoptimierung;
- kontrollierte Veröffentlichungsprozeduren.
Das Hauptrisiko ist fehlende Transparenz. Eine große Stored Procedure kann zu einer monolithischen Anwendung innerhalb der Datenbank werden. Werden Prozeduren eingesetzt, müssen sie weiterhin versioniert, geprüft, getestet, dokumentiert und mit sichtbaren Laufmetadaten verbunden werden.
Native Plattformfunktionen
Moderne Plattformen stellen integrierte Transformations- und Orchestrierungsfunktionen bereit. Beispiele sind Warehouse SQL, geplante Jobs, Tasks, deklarative Tabellen, Pipelines, materialisierte Views, native Quality Expectations und Plattformmonitoring.
Native Funktionen sind häufig die beste Option, wenn sie:
- die Anforderung bereits erfüllen;
- vom Betriebsteam verstanden werden;
- in Sicherheit, Zeitplanung und Monitoring integriert sind;
- externe Infrastruktur reduzieren;
- die erforderliche Performance und Zuverlässigkeit liefern.
Native-first bedeutet nicht native-only. Eine native Funktion sollte nur so lange die führende Implementierung bleiben, wie sie die fachlichen und Governance-Anforderungen weiterhin erfüllt.
Dataflows und klassische ETL-Werkzeuge
Low-Code-Dataflows und etablierte ETL-Werkzeuge bleiben gültige Transformationsmechanismen.
Sie sind besonders geeignet für:
- breite Connector-Abdeckung;
- visuelle Source-to-Target-Mappings;
- standardisierte operative Integration;
- Teams mit starken ETL- oder Power-Query-Kenntnissen;
- kontrollierte Datei- und API-Ingestion;
- Workflows, die Datenbewegung, Transformation und Orchestrierung verbinden.
Die Architekturanforderung ist dieselbe wie bei Code: Mappings benötigen Verantwortung, Versionierung, Reviews, Tests, Deployment-Disziplin und sichtbare Abhängigkeiten.
Eine visuelle Oberfläche dokumentiert sich nicht automatisch selbst. Komplexe Dataflows können ohne Konventionen und klare Komponentengrenzen genauso schwer verständlich werden wie komplexer Code.
Notebooks, Python und Spark
Notebooks sind wertvoll für Transformationen, die Python, Spark, erweiterte Bibliotheken, komplexe Datenstrukturen, Machine-Learning-Vorbereitung oder explorative Entwicklung benötigen.
Sie eignen sich für:
- umfangreiche verteilte Transformationen;
- Verarbeitung semistrukturierter Daten;
- Feature Engineering;
- fortgeschrittene Algorithmen;
- wiederverwendbare Python-Bibliotheken;
- Batch- und Streaming-Workloads;
- Untersuchungen, bevor eine stabile produktive Implementierung ausgewählt wird.
Ein Notebook wird riskant, wenn seine interaktive Form mit einem Betriebsmodell verwechselt wird. Produktive Notebooks benötigen Parameter, modularen Code, Dependency Management, automatisierte Tests, kontrollierte Umgebungen, Zeitplanung, Monitoring und einen klaren verantwortliche Person.
dbt
Ein dbt-Modell ist primär ein Transformationsmodell, das in der Zieldatenplattform ausgeführt wird. dbt ergänzt SQL und abhängig von der Plattformunterstützung Python um ein strukturiertes Projektmodell: Abhängigkeiten, Umgebungen, Materialisierungen, Tests, Dokumentation, Metadaten und Deployment-Workflows.
dbt kann deutlichen Mehrwert schaffen, wenn das Team Folgendes benötigt:
- viele voneinander abhängige SQL-Modelle;
- einheitliche Projektkonventionen;
- Git-basierte Zusammenarbeit und Reviews;
- automatisierte Datentests;
- generierte Dokumentation und Lineage-Metadaten;
- reproduzierbare Entwicklungs- und Produktionsumgebungen;
- modularen Wiedergebrauch über Referenzen und Macros;
- CI/CD für Analytics Engineering.
dbt liefert weniger Mehrwert, wenn:
- nur wenige stabile SQL Views existieren;
- das Team keine Kapazität für eine weitere Betrieb und ein weiteres Repository besitzt;
- die native Plattformentwicklung bereits ausreichende Reviews, Tests und Deployments ermöglicht;
- der größte Teil der Transformationen Python, Spark, Streaming oder operative Integration statt SQL-zentrierter Modellierung ist;
- dbt eine bestehende führende Implementierung duplizieren würde.
Die richtige Frage lautet nicht „Nutzen wir dbt?“, sondern „Welche konkreten Probleme würde dbt besser lösen als die aktuelle Methode?“
Die einfachste sinnvolle Umsetzung
Eine governte Transformationsschicht benötigt weder eine neue Cloud-Plattform noch ein neues Transformationsprodukt.
Eine minimale Umsetzung kann Folgendes verwenden:
Für ein Customer-Datenprodukt kann die erste Version folgende Objekte enthalten:
staging.customer_source
core.customer
quality.customer_rule_result
control.customer_publication
Die Transformation kann zunächst eine View sein:
create view core.customer as
select
trim(customer_id) as customer_id,
upper(trim(country_code)) as country_code,
cast(updated_at as timestamp) as updated_at,
case when active_flag = 'Y' then 1 else 0 end as is_active,
source_system,
ingestion_timestamp
from staging.customer_source;
Ein separater Qualitätsschritt bewertet die Veröffentlichungsregel:
select
customer_id,
'ACTIVE_CUSTOMER_REQUIRED_FIELDS' as rule_id,
case
when customer_id is null then 'MISSING_CUSTOMER_ID'
when country_code is null then 'MISSING_COUNTRY'
when updated_at is null then 'MISSING_UPDATED_AT'
when updated_at < current_timestamp - interval '30' day then 'STALE_UPDATED_AT'
else 'PASSED'
end as rule_result
from core.customer
where is_active = 1;
Die konkrete Datumsarithmetik und die Datentypen unterscheiden sich je nach SQL-Dialekt. Das Architekturmuster bleibt gleich:
- Quelle in eine kontrollierte Kundenstruktur transformieren;
- Geschäftsregel explizit auswerten;
- Fehler und Ausführungsmetadaten persistieren;
- nur entsprechend einer vereinbarten Qualitätsrichtlinie veröffentlichen;
- Ergebnis über einen stabilen Vertrag für Nutzer bereitstellen.
Diese Implementierung kann jahrelang ausreichen. Weitere Tools sollten nur eingeführt werden, wenn Skalierung, Zusammenarbeit, Tests, Lineage, Sprache oder Betriebsanforderungen sie rechtfertigen.
Nach Workload und Team entscheiden
Keine Transformationsmethode ist für jeden Workload die beste.

Die Entscheidung sollte mindestens acht Dimensionen berücksichtigen.
1. SQL-Anteil
Sind die meisten Transformationen relational, mengenorientiert und werden bereits in einem Warehouse ausgeführt, sind SQL Views, geplante Tabellen, native SQL-Jobs oder dbt natürliche Kandidaten.
Ein hoher SQL-Anteil rechtfertigt dbt nicht automatisch. Entscheidend sind die Anzahl der Modelle, die Komplexität der Abhängigkeiten, der Entwicklungsworkflow und die Governance-Anforderungen.
2. Python- oder Spark-Anteil
Wenn Transformationen stark von Python-Bibliotheken, verteilter Verarbeitung, unstrukturierten Daten oder fortgeschrittenen Algorithmen abhängen, können Notebooks oder native Python-/Spark-Pipelines die klarere führende Implementierung sein.
dbt kann parallel dazu SQL-zentrierte nachgelagerte Modelle übernehmen. Es sollte nicht gezwungen werden, Workloads zu verantworten, für die eine andere Engine und ein anderes Entwicklungsmodell besser geeignet sind.
3. Teamgröße und Verantwortungsmodell
Ein kleines Team mit zehn stabilen Transformationen kann mit SQL und einem vorhandenen Scheduler gut bedient sein.
Ein größeres Team mit Hunderten Modellen, mehreren Domänen und häufigen parallelen Änderungen benötigt stärkere Konventionen, isolierte Entwicklungsumgebungen, Code Reviews, automatisierte Tests und sichtbare Abhängigkeiten. dbt oder ein ausgereiftes natives Entwicklungsframework kann dann wesentlichen Mehrwert bieten.
4. Anforderungen an Git, Reviews und CI/CD
Transformationscode sollte unabhängig von der Technologie versioniert werden.
Die eigentliche Frage lautet, wie umfangreich der Entwicklungsworkflow sein muss:
- individuelle Versionshistorie;
- Pull Requests und Peer Reviews;
- automatisierte Kompilierung und Tests;
- Produktfreigabe zwischen Umgebungen;
- Rückbau;
- Deployment-Nachweise;
- Trennung von Entwicklungs- und Produktionszugängen.
Unterstützt die native Plattform diese Anforderungen ausreichend, kann eine weitere Schicht unnötig sein. Tut sie es nicht, kann dbt oder ein externer Engineering-Workflow eine wichtige Lücke schließen.
5. Low-Code-Anteil
Dataflows sind geeignet, wenn Business Technologists oder ETL-Spezialisten eine visuelle Entwicklungsoberfläche benötigen und die Transformationen in dieser Form verständlich bleiben.
Low-Code darf nicht Low-Governance bedeuten. Das Unternehmen benötigt weiterhin Namenskonventionen, wiederverwendbare Komponenten, Reviews, Deployments, Laufhistorie und Verantwortung.
6. Batch, Near-Real-Time und Streaming
Ein täglicher Dimensionsaufbau hat andere Anforderungen als ein kontinuierlicher Stream.
- Batch-Workloads können Views, geplantes SQL, Prozeduren, dbt oder ETL-Jobs verwenden;
- Near-Real-Time-Workloads können inkrementelle Jobs, Plattform-Tasks oder deklarative Tabellen einsetzen;
- Streaming-Workloads benötigen in der Regel natives Streaming oder Spark-basierte Verarbeitung;
- ereignisgetriebene operative Logik kann Streams, Trigger, Queues oder spezialisierte Services erfordern.
Ein batchorientiertes Transformationsframework sollte nicht zur einzigen Antwort auf eine Streaming-Anforderung gemacht werden.
7. Anforderungen an Tests und Dokumentation
Alle Ansätze können getestet werden. Aufwand und integrierte Unterstützung unterscheiden sich.
Eine kleine SQL-Implementierung kann eigene Assertions und eine Ergebnistabelle verwenden. dbt stellt ein standardisiertes Modell für Datentests und Dokumentation bereit. Native Plattformen können Quality Expectations, Monitoring und Lineage liefern. ETL-Werkzeuge können Validierungskomponenten und Laufmetadaten anbieten.
Der korrekte Vergleich lautet nicht, ob Tests theoretisch möglich sind. Entscheidend ist, ob das Team den erforderlichen Nachweis konsequent implementieren und betreiben kann.
8. Betriebsaufwand und Kosten
Jedes zusätzliche Framework erzeugt Betriebsverantwortung:
Betrieb
Credentials
Repositories
Paket- und Adapterversionen
Deployment-Pipelines
Jobplanung
Monitoring
Behandlung von Störungen
Training
Hersteller- oder Community-Support
Ein Tool, das die Entwicklung verbessert, aber einen nicht unterstützten Betriebsaufwand erzeugt, ist keine nachhaltige Architektur.
Ein kompakter Vergleich ist:
| Option | Besonders geeignet | Wichtigstes Risiko |
|---|---|---|
| SQL Views und Skripte | Relationale Transformationen, kleine bis mittlere Modellmenge, vorhandenes Warehouse | View-Wildwuchs, duplizierte Skripte, schwache Deployment-Disziplin |
| Materialisierte Tabellen und Prozeduren | Performance, kontrollierte Batches, prozedurale Logik | Monolithen, intransparente Abhängigkeiten, Datenbankkopplung |
| Native Plattformfunktionen | Integrierte Zeitplanung, Monitoring, Sicherheit und Skalierung | Plattformkopplung und funktionsspezifische Grenzen |
| Dataflows und ETL-Werkzeuge | Connector-intensive Integration, Low-Code-Teams, operative Mappings | Visuelle Komplexität, schwache Wiederverwendung, proprietäres Deployment-Modell |
| Notebooks und Python/Spark | Komplexe Algorithmen, große Datenmengen, semistrukturierte Daten, Streaming | Interaktiver Code wird ohne Production Engineering produktiv gesetzt |
| dbt | SQL-zentrierte Modellnetze, Git-Reviews, Tests, Dokumentation und Teamzusammenarbeit | Zusätzliche Betrieb, Konventionen und mögliche Duplizierung nativer Fähigkeiten |
Eine Transformation, eine verantwortliche Person
Das schädlichste Transformationsproblem ist meist nicht das falsche Tool, sondern duplizierte Verantwortung.
Ein verbreitetes Fehlmuster sieht so aus:
Dataflow Ersetzt fehlendes Land durch „DE“
Notebook Ersetzt fehlendes Land durch den Standard des Quellsystems
Stored Procedure Lehnt den Datensatz ab
Qlik-Skript Mappt fehlendes Land auf „Unknown“
dbt-Modell Nutzt das Rechnungsland als Fallback
Alle fünf Implementierungen können technisch sinnvoll sein. Gemeinsam erzeugen sie fünf verschiedene Customer-Definitionen.

Eine führende Implementierung sollte Folgendes definieren:
| Kontrolle | Erforderlicher Inhalt |
|---|---|
| Fachlicher verantwortliche Person | Verantwortliche Person für Bedeutung und Akzeptanzkriterien |
| Technical Custodian | Team für Implementierung und Betrieb |
| Regel-ID | Stabiler Name wie ACTIVE_CUSTOMER_REQUIRED_FIELDS |
| Input-Vertrag | Erforderliche Quellfelder, Granularität und Aktualität |
| Output-Vertrag | Veröffentlichte Felder, Schlüssel, Granularität und Statusverhalten |
| Implementierungsort | View, Prozedur, Notebook, Dataflow, dbt-Modell oder native Pipeline |
| Tests | Erwartete Assertions, Grenzwerte und Fehlerverhalten |
| Qualitätsnachweis | Persistente fehlerhafte Datensätze und Ausführungsmetadaten |
| Abhängigkeiten | Vorgelagerte Quellen und nachgelagerte Nutzer |
| Änderungsprozess | Review, Versionierung, Kommunikation und Deprecation |
| Serviceerwartung | Zeitplan, Aktualität, Monitoring und Wiederherstellung |
„Ein verantwortliche Person“ bedeutet nicht, dass nur eine Person die Transformation bearbeiten darf. Es bedeutet, dass es ein eindeutiges Verantwortungsmodell und eine Implementierung gibt, die für die gemeinsame Regel autoritativ ist.
Migration aus duplizierten Implementierungen
Ein sicheres Konsolidierungsmuster ist:
Alte Qlik-Mappings, Notebook-Zellen oder Excel-Formeln sollten nach Abnahme des governten Ersatzes nicht „zur Sicherheit“ bestehen bleiben. Ruhende Duplikate werden beim nächsten Incident oder bei einer dringenden Änderung häufig wieder aktiviert.
Native zuerst oder dbt?
Native-first und dbt-gestützte Transformation sind beide gültige Strategien.

Native-first ist eine starke Wahl, wenn
- die Plattform bereits geeignetes SQL, Tabellen, Pipelines und Zeitplanung bereitstellt;
- die Transformationsmenge klein oder mittelkomplex ist;
- das Team das native Betriebsmodell versteht;
- Sicherheit und Monitoring bereits integriert sind;
- die Deployment-Anforderungen ausreichend abgedeckt sind;
- die meiste Logik plattformspezifisch oder eng mit nativem Streaming und Processing verbunden ist;
- eine weitere Betrieb Qualität oder Liefergeschwindigkeit nicht wesentlich verbessern würde.
Beispiele sind:
- ein bestehendes SQL-Server-Warehouse mit Views, Prozeduren und SQL Agent oder einem anderen Scheduler;
- Fabric Warehouse SQL in Verbindung mit Pipelines, Dataflow Gen2 oder Notebooks, wo erforderlich;
- Snowflake SQL mit Dynamic Tables oder Streams und Tasks für geeignete Workloads;
- Databricks SQL oder Python mit nativen Jobs und Lakeflow Pipelines;
- eine klassische ETL-Plattform, die vom Team bereits zuverlässig betrieben wird.
dbt schafft klaren Mehrwert, wenn
- die Transformationsschicht überwiegend SQL-zentriert ist;
- die Anzahl der Modelle und Abhängigkeiten wächst;
- mehrere Engineers dasselbe Projekt ändern;
- Pull Requests und automatisierte Prüfungen erforderlich sind;
- Tests und Dokumentation gemeinsamen Konventionen folgen sollen;
- Entwicklungs-, Test- und Produktionsumgebungen reproduzierbar sein müssen;
- Lineage und Modellmetadaten über einen großen Transformationsgraphen benötigt werden;
- modulare Referenzen und Macros wiederholtes SQL reduzieren;
- das Team dbt als Produkt betreiben kann und es nicht nur installiert.
dbt entfernt keine Plattformverantwortung
Die Zieldatenplattform führt die Berechnung weiterhin aus. Das Team muss weiterhin Folgendes verstehen:
- Warehouse-Größe und Kosten;
- SQL-Dialekt der Plattform;
- physisches Design und Performance;
- Zugriffskontrolle;
- Zeitplanung und Jobzuverlässigkeit;
- Quell-Ingestion;
- Streaming und operative Integration;
- Incident Management;
- Veröffentlichung von Datenprodukten.
Auch Portabilität muss präzise betrachtet werden. dbt kann Kopplung reduzieren, weil Projektstruktur und Abhängigkeitslogik von der DDL-Orchestrierung getrennt werden. SQL-Funktionen, Datentypen, inkrementelle Strategien und Performanceeinstellungen unterscheiden sich jedoch weiterhin zwischen Plattformen. Eine Migration wird meist einfacher, aber nicht automatisch.
Das Fehlmuster der halben Migration vermeiden
Ein häufiger Fehler ist die Einführung von dbt, ohne festzulegen, was dbt verantwortet:
Einige Modelle liegen in dbt
Andere werden weiterhin durch Prozeduren erzeugt
Ein Notebook überschreibt ein dbt-Ziel
Ein Dataflow ergänzt eine weitere Korrektur
Qlik wiederholt die abschließende Geschäftsregel
Keine Komponente ist eindeutig autoritativ
Eine dbt-Einführung sollte explizite Grenzen definieren:
dbt verantwortet SQL-zentrierte kuratierte Modelle und Datenproduktmodelle
dbt verantwortet nicht Quell-Ingestion, Streaming oder Python-intensive Verarbeitung, sofern nicht explizit vorgesehen
native Plattform verantwortet Compute, Storage, Sicherheit, Scheduling-Integration und Plattformbetrieb
Nutzungswerkzeuge verantworten ausschließlich Tool-spezifische Semantik und Darstellung
Die Grenze kann anders gewählt werden. Sie darf nicht implizit bleiben.
Konkretes Beispiel: Jeder aktive Kunde muss veröffentlichungsfähig sein
Angenommen, das Unternehmen definiert folgende Regel:
Jeder aktive Kunde benötigt eine Customer ID, ein Land und einen Änderungszeitpunkt innerhalb des vereinbarten Aktualitätsfensters.
Für das Beispiel beträgt das Aktualitätsfenster 30 Tage. In einem realen Datenprodukt sollte der Grenzwert konfigurierbar und vom fachlich verantwortliche Rolle für das Kundendatenprodukt freigegeben sein.
Fachlicher Vertrag
| Element | Definition |
|---|---|
| Granularität | Eine Zeile je Kundenquellversion |
| Aktiv-Bedingung | active_flag = 'Y' |
| Erforderlicher Identifikator | customer_id ist nicht null und nicht leer |
| Erforderliches Land | country_code ist nicht null und folgt der freigegebenen Codeliste |
| Aktualität | updated_at ist nicht null und nicht älter als 30 Tage |
| Regel-ID | ACTIVE_CUSTOMER_REQUIRED_FIELDS |
| Fehlerbehandlung | Datensatz, Grund und Ausführungsmetadaten persistieren |
| Veröffentlichungsverhalten | Je nach vereinbarter Schwere warnen, quarantänisieren oder blockieren |
| verantwortliche Person | fachlich verantwortliche Rolle für das Kundendatenprodukt |
| Nutzer | Customer-Datenprodukt, Sales-Datenprodukt, Qlik, Power BI, Excel und APIs |
Die Implementierungstechnologie darf variieren. Die Bedeutung des Ergebnisses muss identisch bleiben.
Option 1: SQL View und geplante Qualitätstabelle
Die Transformations-View standardisiert die Felder:
create view curated.customer as
select
nullif(trim(customer_id), '') as customer_id,
upper(nullif(trim(country_code), '')) as country_code,
cast(updated_at as timestamp) as updated_at,
case when active_flag = 'Y' then 1 else 0 end as is_active,
source_system,
source_record_id,
ingestion_timestamp
from staging.customer_source;
Ein geplantes Statement persistiert Fehler:
insert into quality.customer_rule_result (
execution_id,
rule_id,
source_system,
source_record_id,
customer_id,
failure_reason,
evaluated_at
)
select
:execution_id,
'ACTIVE_CUSTOMER_REQUIRED_FIELDS',
source_system,
source_record_id,
customer_id,
case
when customer_id is null then 'MISSING_CUSTOMER_ID'
when country_code is null then 'MISSING_COUNTRY'
when updated_at is null then 'MISSING_UPDATED_AT'
when updated_at < current_timestamp - interval '30' day then 'STALE_UPDATED_AT'
end,
current_timestamp
from curated.customer
where is_active = 1
and (
customer_id is null
or country_code is null
or updated_at is null
or updated_at < current_timestamp - interval '30' day
);
Dies ist eine gültige Implementierung, wenn vorhandene Datenbank, Scheduler und Monitoring ausreichen.
Option 2: Microsoft Fabric
Mehrere Fabric-Implementierungen können gültig sein:
| Workload | Mögliche führende Implementierung |
|---|---|
| Relationale Warehouse-Transformation | Fabric-Warehouse-T-SQL-View oder geplanter Tabellenaufbau |
| Low-Code-Aufbereitung und connectorintensive Ingestion | Dataflow Gen2 |
| Python, Spark oder komplexe Dateiverarbeitung | Notebook |
| Mehrstufige Orchestrierung | Fabric-Pipeline, die abhängig vom Bedarf SQL, Stored Procedures, Dataflows oder Notebooks aufruft |
Ein minimales Warehouse-SQL-Muster kann dieselbe View- und Qualitätstabellenlogik wie das generische SQL-Beispiel verwenden, angepasst an die unterstützte T-SQL-Syntax.
Eine Dataflow-Gen2-Implementierung kann customer_id, country_code und updated_at standardisieren, gültige Datensätze an das kuratierte Ziel weiterleiten und abgewiesene Datensätze in einem Qualitätsziel persistieren. Ein Notebook ist geeignet, wenn die Regel Teil einer größeren Spark-Transformation ist oder Python-Bibliotheken benötigt.
Die Architekturkontrolle ist nicht der Typ des Fabric-Items. Entscheidend ist, dass ein Item als autoritativ festgelegt wird, Code oder Definition versioniert sind, das Qualitätsergebnis persistiert wird und Qlik oder Power BI die Regel nicht wiederholen.
Option 3: Snowflake
Snowflake kann die Regel mit gewöhnlichen SQL Views und Tabellen, einer Dynamic Table für deklaratives Refresh-Verhalten oder Streams und Tasks für explizites CDC und prozedurale Kontrolle implementieren.
Eine konzeptionelle Dynamic-Table-Implementierung ist:
create or replace dynamic table curated.active_customer
target_lag = '30 minutes'
warehouse = transform_wh
as
select
nullif(trim(customer_id), '') as customer_id,
upper(nullif(trim(country_code), '')) as country_code,
updated_at,
source_system,
source_record_id,
case
when customer_id is null then 'MISSING_CUSTOMER_ID'
when country_code is null then 'MISSING_COUNTRY'
when updated_at is null then 'MISSING_UPDATED_AT'
when updated_at < dateadd(day, -30, current_timestamp()) then 'STALE_UPDATED_AT'
else 'PASSED'
end as quality_status
from staging.customer_source
where active_flag = 'Y';
Ein separater Qualitätsschritt kann fehlerhafte Datensätze mit den für das Governance-Modell erforderlichen Ausführungs- und Regelmetadaten persistieren.
Dynamic Tables sind für deklarative Tabellenpipelines attraktiv. Streams und Tasks bleiben sinnvoll, wenn der Prozess explizite Änderungsverfolgung, getriggerte Verarbeitung, Task-Graphen oder eigene prozedurale Schritte benötigt. Die Auswahl sollte dem Workload folgen und kein plattformweites Mandat sein.
Option 4: Databricks
Databricks kann die Regel in SQL, Python oder einer deklarativen Lakeflow-Pipeline implementieren.
Eine SQL-Implementierung kann eine kuratierte Tabelle oder materialisierte View erzeugen. Eine PySpark-Implementierung ist sinnvoll, wenn die Customer-Transformation Teil einer größeren verteilten Pipeline ist:
from pyspark.sql import functions as F
customer = (
spark.table("staging.customer_source")
.select(
F.when(F.trim("customer_id") == "", None)
.otherwise(F.trim("customer_id"))
.alias("customer_id"),
F.upper(F.when(F.trim("country_code") == "", None)
.otherwise(F.trim("country_code")))
.alias("country_code"),
F.col("updated_at").cast("timestamp").alias("updated_at"),
(F.col("active_flag") == "Y").alias("is_active"),
"source_system",
"source_record_id"
)
)
Der Qualitätsstatus kann anschließend in SQL oder Python abgeleitet und in eine Delta-Tabelle wie quality.customer_rule_result geschrieben werden.
Deklarative Lakeflow-Pipelines sind geeignet, wenn das Unternehmen ein verwaltetes deklaratives Framework für Batch- oder Streaming-Tabellen und Flows in SQL oder Python benötigt. Ein normales Notebook oder ein geplanter Job kann für einen kleinen stabilen Workload weiterhin einfacher sein.
Option 5: dbt-Modell und Tests
Eine dbt-Implementierung kann die Transformation in einem SQL-Modell ablegen:
-- models/curated/customer.sql
select
nullif(trim(customer_id), '') as customer_id,
upper(nullif(trim(country_code), '')) as country_code,
cast(updated_at as timestamp) as updated_at,
case when active_flag = 'Y' then true else false end as is_active,
source_system,
source_record_id,
ingestion_timestamp
from {{ source('staging', 'customer_source') }}
Standardtests können strukturelle Erwartungen validieren:
version: 2
models:
- name: customer
columns:
- name: customer_id
data_tests:
- not_null:
config:
where: "is_active = true"
- name: country_code
data_tests:
- not_null:
config:
where: "is_active = true"
- name: updated_at
data_tests:
- not_null:
config:
where: "is_active = true"
Ein einzelner Datentest kann die vollständige Aktualitätsregel ausdrücken:
-- tests/active_customer_required_fields.sql
select *
from {{ ref('customer') }}
where is_active = true
and (
customer_id is null
or country_code is null
or updated_at is null
or updated_at < current_timestamp - interval '30' day
)
Da ein fehlgeschlagener Test allein nicht immer als operativer Nachweis ausreicht, kann ein separates Audit-Modell fehlerhafte Datensätze im governten Qualitätsschema persistieren:
-- models/quality/customer_rule_result.sql
select
'ACTIVE_CUSTOMER_REQUIRED_FIELDS' as rule_id,
source_system,
source_record_id,
customer_id,
current_timestamp as evaluated_at
from {{ ref('customer') }}
where is_active = true
and (
customer_id is null
or country_code is null
or updated_at is null
or updated_at < current_timestamp - interval '30' day
)
Das genaue SQL bleibt adapter- und plattformabhängig. dbt ergänzt Abhängigkeitsmanagement, Testkonventionen, Dokumentation und Deployment-Workflow. Die fachliche Definition ändert sich nicht.
Option 6: Dataflow oder klassisches ETL-Mapping
Dieselbe Regel kann visuell ausgedrückt werden:
Dies ist vollständig gültig, wenn das Mapping versioniert, geprüft, getestet, überwacht und verantwortet wird. Auf die visuelle Implementierung darf keine weitere undokumentierte Korrektur in einem Notebook oder Qlik-Skript folgen.
Ein Ergebnis über alle Implementierungen
Unabhängig von der Technologie sollte der veröffentlichte Vertrag vergleichbar sein:
customer_id
country_code
updated_at
is_active
quality_status
quality_rule_id
source_system
source_record_id
publication_timestamp
Für denselben Eingabedatensatz muss jede gültige Implementierung dasselbe Ergebnis erzeugen.
Beispiel:
Eingabe
customer_id = C-10042
country_code = null
updated_at = 2026-07-10 09:30:00
active_flag = Y
Erwartetes Ergebnis
quality_status = FAILED
quality_rule_id = ACTIVE_CUSTOMER_REQUIRED_FIELDS
failure_reason = MISSING_COUNTRY
publication = entsprechend der vereinbarten Schweregradrichtlinie
Der parallele Vergleich der Ergebnisse ist die zuverlässigste Methode beim Wechsel der Implementierungstechnologie.
Plattformmuster ohne verpflichtenden Stack
Die vorhandene Plattform sollte die Implementierung beeinflussen, aber nicht die Architektur neu definieren.
| Bestehende Umgebung | Pragmatischer Ausgangspunkt | Mögliche Erweiterung |
|---|---|---|
| Klassisches SQL-Warehouse | Views, Prozeduren, geplante Tabellenaufbauten, Qualitätstabellen | Git-Deployment, stärkere Orchestrierung, dbt bei wachsender Modellzusammenarbeit |
| Microsoft Fabric | Warehouse SQL, Dataflow Gen2, Pipelines oder Notebooks entsprechend dem Workload | dbt für eine größere SQL-zentrierte Modelllandschaft, wenn es klaren Workflow-Mehrwert schafft |
| Snowflake | SQL Views/Tabellen, Dynamic Tables, Streams und Tasks | dbt für modulare SQL-Modellierung, Tests und Zusammenarbeit |
| Databricks | SQL, Notebooks, Jobs oder deklarative Lakeflow-Pipelines | dbt für SQL-zentrierte kuratierte Modelle und Marts neben Python-/Spark-Verarbeitung |
| Vorhandene ETL-Suite | Kontrollierte Mappings und Jobs | Codebasierte Transformationen, wenn Tests, Wiederverwendung oder Skalierung sie rechtfertigen |
| Qlik-zentriertes bestehende Umgebung | Zentrale SQL- oder governte QVD-Transformationsschicht als vorläufige führende Implementierung | Gemeinsame Logik schrittweise in ein plattformneutrales Datenprodukt verschieben und Qlik-Apps schlank halten |
| Kleine On-Premises-Umgebung | Vorhandene Datenbank, Scheduler und Dateischicht | Komponenten erst ergänzen, wenn Betriebsanforderungen die vorhandenen Fähigkeiten übersteigen |
Keine Zeile dieser Tabelle beschreibt einen verpflichtenden Ziel-Stack.
Qlik, Power BI und Excel bleiben Nutzer
Dieses Kapitel behandelt Transformations-Verantwortung und verbietet keine Transformationsfunktionen innerhalb von BI-Tools.
Eine schlanke Qlik-App kann weiterhin:
- das veröffentlichte Customer-Datenprodukt laden;
- erforderliche Assoziationen erzeugen;
- Section Access mit governten Berechtigungsdaten implementieren;
- Set Analysis für selektionsabhängige Vergleiche verwenden;
- Felder für das assoziative Modell optimieren.
Ein semantisches Power-BI-Modell kann weiterhin:
- Beziehungen und Hierarchien definieren;
- DAX-Measures ergänzen, die vom Filterkontext abhängen;
- Row-Level Security anwenden;
- berichtsspezifische Zeitintelligenz bereitstellen.
Eine Excel-Arbeitsmappe kann weiterhin:
- eine kontrollierte Ausgabe für die Nutzbarkeit formen;
- PivotTables, Formatierung und Kommentare bereitstellen;
- klar getrennte Planungsannahmen verwalten.
Keiner dieser Nutzer sollte unabhängig entscheiden, dass ein aktiver Kunde ohne Land zulässig ist oder ein anderes Aktualitätsfenster verwenden darf.
Typische Fehlmuster
Tool-first-Architektur
Das Team wählt das Transformationswerkzeug, bevor es Workload, Verantwortung, Qualität und Betriebsanforderungen versteht.
Dieselbe Regel in mehreren Tools
Ein Dataflow, Notebook, eine Prozedur, ein dbt-Modell und ein Qlik-Skript implementieren jeweils eine Variante derselben Customer- oder Umsatzregel.
Notebook als undokumentierte Produktionsanwendung
Ein exploratives Notebook wird unverändert geplant, hängt von verborgenem Zustand ab und besitzt weder Tests, Paketkontrolle noch verantwortliche Person.
Endlose View-Ketten
Views rufen Views auf, die weitere Views aufrufen, bis Lineage und Performance nicht mehr nachvollziehbar sind.
Monolithische Stored Procedure
Eine Prozedur übernimmt Ingestion, Bereinigung, Historisierung, Qualität, Veröffentlichung und nutzungsspezifische Ausgabe ohne modulare Grenzen.
Low-Code ohne Engineering-Disziplin
Ein visueller Prozess gilt als selbstdokumentierend und wird ohne Review oder Deployment-Kontrolle direkt in Produktion geändert.
dbt als Richtlinie statt als Lösung
Jede Transformation wird nach dbt migriert, obwohl native Funktionen, Python oder vorhandenes SQL einfacher und besser unterstützt wären.
dbt plus native Duplizierung
Das dbt-Modell existiert, aber eine native Pipeline erzeugt dieselbe Business-Tabelle erneut, weil Verantwortung nie geklärt wurde.
Tests ausschließlich in Dashboards
Qualität wird als rote Kennzahl in Power BI oder Qlik beobachtet, aber fehlerhafte Datensätze und Regelausführungen werden nicht zentral persistiert.
Stilles Verwerfen
Ungültige Datensätze werden ohne Fehlergrund, Regel-ID, verantwortliche Person oder Wiederherstellungsprozess ausgefiltert.
„Ein verantwortliche Person“ nur auf dem Papier
Eine Rolle ist dokumentiert, aber kein Team verantwortet Deployment, Monitoring, Incidents und Änderungskommunikation.
Logik läuft in Nutzer aus
Eine temporäre Korrektur in Qlik, Power Query oder Excel wird zur dauerhaften Implementierung gemeinsamer fachlicher Bedeutung.
Entscheidungshilfe
Nutze diese Fragen in der angegebenen Reihenfolge:
| Frage | Konsequenz für die Entscheidung |
|---|---|
| Kann die vorhandene SQL-Plattform die Regel klar und zuverlässig implementieren? | Mit SQL beginnen, bevor ein weiteres Framework ergänzt wird |
| Ist der Workload überwiegend relational und mengenorientiert? | SQL, native Warehouse-Funktionen oder dbt bevorzugen |
| Sind Python, Spark oder semistrukturierte Verarbeitung unverzichtbar? | Notebooks oder native Python-/Spark-Pipelines bevorzugen |
| Benötigt das Team eine visuelle Low-Code-Entwicklung? | Dataflows oder etablierte ETL-Werkzeuge prüfen |
| Gibt es viele abhängige SQL-Modelle und häufige parallele Änderungen? | dbt oder ein ausgereiftes natives Code-Framework kann Mehrwert bieten |
| Sind Git-Reviews, CI/CD, Tests und generierte Dokumentation wesentliche Lücken? | Ein Framework auswählen, das diese Lücken explizit schließt |
| Ist Streaming oder ereignisgetriebene Verarbeitung erforderlich? | Eine für Streaming geeignete Plattform nutzen statt ein Batch-Muster zu erzwingen |
| Ist die Regel bereits an anderer Stelle implementiert? | Verantwortung konsolidieren, bevor eine weitere Version entsteht |
| Reduziert das vorgeschlagene Tool Duplizierung? | Nur fortfahren, wenn die Verantwortung-Grenze explizit ist |
| Erzeugt das Tool neue, nicht unterstützte Betriebsaufgaben? | Entscheidung überdenken oder zuerst ein Betriebsmodell bereitstellen |
| Können fehlerhafte Datensätze und Regelergebnisse persistiert werden? | Design erst veröffentlichen, wenn der Nachweis definiert ist |
| Können Qlik, Power BI und Excel das Ergebnis konsumieren, ohne die Regel neu aufzubauen? | Der Transformationsvertrag ist ausreichend wiederverwendbar |
Eine kompakte Regel lautet:
Vorhandene Fähigkeit löst das Problem → verwenden
Native Funktion verbessert den Betrieb → bewusst verwenden
SQL-Modellnetz benötigt Zusammenarbeit → dbt prüfen
Python/Spark ist Bestandteil des Workloads → Notebook oder native Pipeline verwenden
Low-Code ist die wartbare Teamoberfläche → Dataflow oder ETL-Werkzeug verwenden
Gemeinsame Regel existiert bereits → wiederverwenden, nicht duplizieren
Kein klarer verantwortliche Person oder Testnachweis → Architektur ist nicht bereit
Ein praktikabler Einführungspfad
Die Modernisierung von Transformationen sollte nicht mit der Migration jedes Jobs beginnen.
Beginne mit einer Geschäftsregel, die dupliziert, wichtig und messbar ist.
Gute erste Kandidaten sind:
- Zulässigkeit aktiver Kunden;
- Stornobehandlung;
- Währungsnormalisierung;
- Zuordnung von Produkthierarchien;
- Kunden-Länder-Mapping;
- Klassifikation von Rechnungsstatus;
- eine zentrale Basisdefinition für Umsatz.
Das Ziel der ersten Migration besteht nicht darin, die Überlegenheit eines Tools zu beweisen. Es besteht darin zu zeigen, dass eine governte Implementierung mehrere inkonsistente Varianten ersetzen kann.
Wichtigste Empfehlungen
- Definiere die Transformationsverantwortung, bevor das Tool ausgewählt wird.
- Gib jeder gemeinsamen Geschäftsregel eine führende Implementierung und eine verantwortliche Person.
- Beginne mit vorhandenem SQL, Scheduling und nativen Plattformfähigkeiten, wenn sie ausreichen.
- Nutze Views für einfache wiederverwendbare Logik und materialisiere Ergebnisse, wenn Performance, Publikationsstabilität oder Workload dies erfordern.
- Nutze Stored Procedures für begründetes prozedurales und transaktionales Verhalten und nicht als undokumentierten Plattformmonolithen.
- Nutze Dataflows und klassische ETL-Werkzeuge, wenn ihre Connector-, Low-Code- und Betriebsstärken zum pflegenden Team passen.
- Nutze Notebooks, Python und Spark für Workloads, die diese Fähigkeiten tatsächlich benötigen.
- Überführe Notebooks in einen kontrollierten Produktions-Lebenszyklus, bevor sie zu kritischen Pipelines werden.
- Nutze native Fabric-, Snowflake-, Databricks- oder Datenbankfunktionen, wenn Integration und Betriebswert die Plattformkopplung rechtfertigen.
- Ergänze dbt, wenn modulares SQL, Abhängigkeitsmanagement, Tests, Dokumentation, Reviews und reproduzierbare Umgebungen ein reales Kollaborationsproblem lösen.
- Führe dbt nicht nur ein, weil es in modernen Data Stacks verbreitet ist.
- Berücksichtige, dass dbt in der Ziel-Engine ausgeführt wird und SQL-Dialekt- oder Plattformunterschiede nicht beseitigt.
- Trenne Verantwortungen für Orchestrierung, Transformation, Qualitätsnachweise und Nutzung explizit.
- Persistiere fehlgeschlagene fachliche Regeln, wenn Remediation und Verantwortlichkeit relevant sind.
- Halte Qlik-Skripte, Power Query und DAX frei von duplizierter gemeinsamer Transformationslogik.
- Erlaube Qlik-, Power-BI- und Excel-spezifische Logik nur, wenn der jeweilige Nutzer-Kontext sie benötigt.
- Behandle eine governte QVD-Schicht als gültige bestehende Umgebung-Option und nicht als verpflichtenden unternehmensweiten Vertrag.
- Betreibe native und ablösende Implementierungen nach einer Migration nicht dauerhaft als gleichberechtigte Wahrheiten.
- Entscheide nach Workload, Team und Betriebsmodell statt nach Plattformmode.
- Miss Erfolg an weniger duplizierten Regeln, schnelleren kontrollierten Änderungen, sichtbarer Qualität und geringerem Betriebsrisiko.
Building a Modern Data Warehouse – From First Source to Governed Data Products
Part 8 of 11
View series