dbt in zes lessen
Van je eerste model tot een project dat je durft te deployen. Modellen en de afhankelijkheidsgraaf, materialisaties, tests, snapshots, documentatie en CI/CD, met voorbeelden die je direct kunt draaien.
Les 1: Wat is dbt en waarom gebruik je het?
SQL met de gereedschappen van een softwareteam
dbt staat voor data build tool. Het is geen database en geen pipeline-tool: het is de laag waarin je de transformaties van je datawarehouse schrijft, in gewone SQL, met versiebeheer, tests en documentatie eromheen.
Je schrijft een SELECT, dbt maakt daar een view of tabel van in je warehouse. Het verschil met honderd losse SQL-scripts zit in wat eromheen gebeurt: dbt kent de onderlinge afhankelijkheden, draait alles in de goede volgorde, test de uitkomsten en genereert documentatie uit je eigen code.
De T van ELT
dbt doet uitsluitend de transformatie. Het haalt geen data op en het verplaatst niets. Je laadt je ruwe data eerst in Snowflake, BigQuery, Databricks, Redshift of Postgres, met Fivetran, Airbyte, Snowpipe of je eigen script, en dbt werkt daarna binnen dat warehouse.
Wat je ervoor terugkrijgt
- Afhankelijkheden die kloppen. Je zegt nergens in welke volgorde iets moet draaien; dbt leidt dat af uit je verwijzingen.
- Tests naast je modellen. Een sleutel die uniek hoort te zijn, test je met drie regels configuratie in plaats van een los controlescript.
- Documentatie die niet veroudert. De beschrijvingen staan bij de modellen, en de afhankelijkheidsgraaf wordt uit de code gegenereerd.
- Omgevingen zonder kopieerwerk. Dezelfde code draait naar jouw ontwikkelschema of naar productie, afhankelijk van je profiel.
Hoe een project eruitziet
mijn_project/
dbt_project.yml # naam, paden, standaardinstellingen
profiles.yml # verbinding; hoort NIET in git
models/
staging/ # een op een met de bron, licht opgeschoond
_bronnen.yml # brondefinities en tests
stg_orders.sql
intermediate/ # tussenstappen, niet voor eindgebruikers
marts/ # waar rapportage op draait
_marts.yml
fct_omzet.sql
tests/ # eigen tests als SQL
macros/ # herbruikbare stukjes Jinja
seeds/ # kleine CSV's, bijvoorbeeld een mappingtabel
snapshots/ # historie van langzaam wijzigende dimensies
Houd profiles.yml buiten je repository
Daar staan je inloggegevens in. Standaard zoekt dbt het bestand in ~/.dbt/, buiten je project. Zet het nooit in git, ook niet in een privérepository: wachtwoorden horen in een secret store of in omgevingsvariabelen via env_var().
De commando's die je dagelijks gebruikt
dbt debug # werkt de verbinding?
dbt deps # pakketten ophalen die in packages.yml staan
dbt run # alle modellen bouwen
dbt test # alle tests draaien
dbt build # run + test per model, in afhankelijkheidsvolgorde
dbt docs generate # documentatie opbouwen
dbt docs serve # documentatie lokaal bekijken
# Alleen wat je nodig hebt, dat scheelt veel tijd
dbt run --select stg_orders # een model
dbt run --select stg_orders+ # dat model en alles erna
dbt run --select +fct_omzet # dat model en alles ervoor
dbt run --select marts.* # alles in die map
dbt build --select state:modified+ # alleen wat je wijzigde, en de rest erachter
Oefening: past dbt hier?
Situatie: een team heeft 60 SQL-scripts die elke nacht in een vaste volgorde draaien via een scheduler. Niemand weet precies welk script van welk ander afhangt. Twee keer per maand loopt het mis omdat iemand een kolom hernoemde.
Opdracht:
- Welke twee problemen uit dit verhaal lost dbt op, en welke niet?
- dbt haalt geen data op. Wat heeft dit team daarnaast nodig?
- Waarom zou je niet alle 60 scripts in een keer omzetten?
- Met welke laag zou je beginnen?
Richting: dbt lost de onbekende volgorde op, want die leidt het af uit je verwijzingen, en het vangt hernoemde kolommen af met tests. Wat het niet oplost is het ophalen van de data zelf; daar blijft hun bestaande laadproces of een tool als Fivetran voor nodig. Alles tegelijk omzetten betekent dat je maandenlang niets oplevert en overal tegelijk fouten introduceert. Begin met de staginglaag: dunne modellen die een op een op de bron zitten. Die zijn snel gemaakt en leveren meteen tests op de bron op.
Les 2: Modellen, ref() en de afhankelijkheidsgraaf
Een model is een bestand met een SELECT
Elk .sql-bestand in je models-map is een model. De bestandsnaam wordt de naam van de view of tabel in je warehouse. Je schrijft geen CREATE TABLE en geen DROP: dbt regelt dat.
with bron as (
select * from {{ source('erp', 'orders') }}
),
opgeschoond as (
select
order_id::bigint as order_id,
klant_id::bigint as klant_id,
order_datum::date as besteldatum,
bedrag::numeric(12,2) as bedrag,
lower(trim(status)) as status,
case when status = 'GEANNULEERD' then true else false end as is_geannuleerd
from bron
where order_id is not null
)
select * from opgeschoond
ref() is het hart van dbt
Verwijs je naar een ander model, dan doe je dat met ref() en nooit met een harde tabelnaam. Dat doet twee dingen tegelijk: dbt weet nu dat er een afhankelijkheid is, en de naam wordt vertaald naar het juiste schema voor de omgeving waarin je draait.
Waarom je nooit hardcodeert
Schrijf je from analytics.stg_orders, dan weet dbt niet dat dit model van dat andere afhangt. Je bouwvolgorde klopt dan niet meer en je draait in ontwikkeling per ongeluk tegen productie aan. Een enkele ref() voorkomt beide.
with orders as (
select * from {{ ref('stg_orders') }}
),
klanten as (
select * from {{ ref('stg_klanten') }}
),
samengevoegd as (
select
o.besteldatum,
k.klant_id,
k.segment,
k.regio,
sum(o.bedrag) as omzet,
count(*) as aantal_orders
from orders o
inner join klanten k on k.klant_id = o.klant_id
where not o.is_geannuleerd
group by 1, 2, 3, 4
)
select * from samengevoegd
Drie lagen die zich bewijzen
Staging zit een op een op een bron: hernoemen, types zetten, licht opschonen. Een stagingmodel per brontabel, niet meer. Intermediate bevat tussenstappen die je in meerdere marts hergebruikt. Marts is waar rapportage op draait: feiten en dimensies, in de taal van de business.
Naamgeving die zichzelf uitlegt
Gebruik stg_, int_, dim_ en fct_ als voorvoegsel. In de documentatiegraaf zie je dan in een oogopslag welke laag je voor je hebt, en in je warehouse weet iedere analist meteen waar hij aan toe is.
Configuratie centraal regelen
name: mijn_project
version: '1.0.0'
profile: mijn_project
models:
mijn_project:
staging:
+materialized: view # staging als view: goedkoop en altijd actueel
+schema: staging
intermediate:
+materialized: ephemeral # bestaat alleen als CTE in het volgende model
marts:
+materialized: table # marts als tabel: snel voor rapportage
+schema: marts
Oefening: een graaf die niet klopt
Situatie: een collega schreef een mart die rechtstreeks from analytics_staging.stg_orders gebruikt. In ontwikkeling werkt het, maar dbt run bouwt de mart soms voor het stagingmodel en dan is de uitkomst verouderd. In de documentatiegraaf staat de mart los van de rest.
Opdracht:
- Wat is de oorzaak van beide symptomen tegelijk?
- Hoe herschrijf je die verwijzing?
- Hoe controleer je of er elders in het project nog meer harde verwijzingen staan?
- Waarom werkt het in ontwikkeling wel en in productie niet?
Richting: een oorzaak voor allebei: de harde tabelnaam. Zonder ref() kent dbt de afhankelijkheid niet, dus noch de volgorde noch de graaf klopt. Vervang de verwijzing door ref('stg_orders'). Zoek de rest met een grep op je schemanamen in de models-map, of draai dbt ls --select stg_orders+ en kijk of de mart erin staat. In ontwikkeling werkt het toevallig omdat het hardgecodeerde schema daar bestaat en gevuld is; in een andere omgeving wijst diezelfde naam naar iets anders of naar niets.
Les 3: Materialisaties
Vier manieren om hetzelfde model te bouwen
Dezelfde SELECT kan op vier manieren in je warehouse terechtkomen. De keuze bepaalt wat je betaalt bij bouwen en wat je betaalt bij bevragen.
| Materialisatie | Wat dbt doet | Wanneer |
|---|---|---|
view | Maakt een view | Staging, kleine modellen, data die altijd actueel moet zijn |
table | Bouwt elke run de hele tabel opnieuw | Marts waarop veel bevraagd wordt |
incremental | Voegt alleen nieuwe of gewijzigde rijen toe | Grote feitentabellen waar volledig herbouwen te lang duurt |
ephemeral | Niets; wordt een CTE in het volgende model | Tussenstappen die niemand apart hoeft te bevragen |
Begin bij table of view
Incrementeel maken is de meest voorkomende voorbarige optimalisatie in dbt. Het voegt echte complexiteit toe en levert pas iets op als volledig herbouwen te traag of te duur wordt. Meet eerst hoe lang je model draait.
Incrementele modellen
Bij een incrementeel model draait dbt de eerste keer alles, en daarna alleen het deel binnen je is_incremental()-blok. Jij bepaalt wat nieuw betekent.
{{ config(
materialized='incremental',
unique_key='event_id',
incremental_strategy='merge',
on_schema_change='append_new_columns'
) }}
select
event_id,
gebruiker_id,
event_type,
gebeurd_op,
bedrag
from {{ ref('stg_events') }}
{% if is_incremental() %}
-- Alleen bij een incrementele run. De marge van een uur vangt
-- data op die met vertraging binnenkomt; de merge op unique_key
-- zorgt dat dat geen dubbelingen oplevert.
where gebeurd_op > (select dateadd(hour, -1, max(gebeurd_op)) from {{ this }})
{% endif %}
Zonder unique_key krijg je dubbelingen
Bij strategie append plakt dbt de nieuwe rijen er simpelweg achter. Komt een rij een tweede keer langs, dan staat hij twee keer in je tabel. Met een unique_key en strategie merge werkt dbt bestaande rijen bij in plaats van ze toe te voegen. Dat is bijna altijd wat je wilt.
Als je toch opnieuw moet beginnen
# Logica van het model gewijzigd? Dan moet de hele tabel opnieuw,
# anders blijven oude rijen met de oude berekening staan.
dbt run --select fct_events --full-refresh
# Voorkomen dat iemand dat per ongeluk op een enorme tabel doet:
# zet full_refresh=false in de config van het model.
Oefening: een materialisatie kiezen
Situatie: vier modellen in een project:
stg_klanten, 50.000 rijen, een op een op de bronint_order_regels_verrijkt, tussenstap, alleen gebruikt door een martfct_omzet_dag, 2 miljoen rijen, basis voor alle dashboardsfct_clickstream, 1,4 miljard rijen, groeit met 20 miljoen per dag
Opdracht:
- Kies per model een materialisatie en onderbouw het.
- Welke configuratie geef je het clickstreammodel mee, en welke strategie?
- Je wijzigt de berekening van een kolom in dat clickstreammodel. Wat moet er dan gebeuren, en waarom is dat vervelend?
- Wat zou je doen om dat laatste draaglijk te houden?
Richting: staging als view, de tussenstap als ephemeral zodat hij niet als los object in het warehouse belandt, de dagomzet als table omdat twee miljoen rijen snel herbouwen en veel bevraagd worden, en clickstream als incremental met een unique_key en strategie merge. Wijzig je de logica, dan is een volledige herbouw nodig; op 1,4 miljard rijen is dat uren werk. Houd dat draaglijk door zulke modellen te partitioneren op datum zodat je gericht een periode kunt herbouwen, en door logicawijzigingen te bundelen in plaats van ze los door te voeren.
Les 4: Tests en datakwaliteit
Een test is een query die rijen teruggeeft
Het testmodel van dbt is verrassend eenvoudig: een test is een query die de rijen teruggeeft die fout zijn. Geeft hij nul rijen terug, dan slaagt de test.
Er zijn vier ingebouwde tests die je met een paar regels YAML aanzet, en die dekken het meeste af.
version: 2
models:
- name: stg_orders
description: "Orders uit het ERP, opgeschoond en getypeerd."
columns:
- name: order_id
description: "Unieke order. Primaire sleutel."
tests:
- unique
- not_null
- name: klant_id
description: "Verwijzing naar de klant."
tests:
- not_null
- relationships:
to: ref('stg_klanten')
field: klant_id
- name: status
tests:
- accepted_values:
values: ['nieuw', 'verzonden', 'geleverd', 'geannuleerd']
Test eerst je bronnen
De meeste problemen komen binnen via de bron, niet uit je eigen SQL. Een unique en not_null op de sleutels van je brontabellen vangt verreweg de meeste ellende af, en kost je vijf minuten per bron.
Eigen tests
Red je het niet met de ingebouwde tests, dan schrijf je er zelf een als SQL-bestand in de map tests/. Alles wat die query teruggeeft, geldt als fout.
-- Slaagt als deze query niets teruggeeft
select
besteldatum,
sum(omzet) as dagomzet
from {{ ref('fct_omzet') }}
group by besteldatum
having sum(omzet) < 0
Hoe hard moet een test zijn?
Niet elke afwijking hoort je pipeline stil te leggen. Met severity bepaal je of een test een fout of een waarschuwing oplevert, en met drempels bepaal je vanaf hoeveel foute rijen het echt menens wordt.
models:
- name: fct_omzet
columns:
- name: klant_id
tests:
- not_null:
config:
severity: warn # waarschuwen, niet stoppen
warn_if: "> 0"
error_if: "> 100" # meer dan honderd: nu wel stoppen
Bewaar wat er faalt
Met dbt test --store-failures schrijft dbt de foute rijen weg naar een tabel in je warehouse. Dat scheelt enorm bij onderzoeken: je ziet welke tien rijen het probleem veroorzaken in plaats van alleen dat er tien zijn.
Oefening: tests die niet helpen
Situatie: een project heeft 340 tests. De nachtelijke run faalt bijna elke dag op dezelfde drie not_null-tests, waarna niemand nog naar de uitkomst kijkt. De echte fout, een mart die twee weken lang dubbele rijen bevatte, werd pas ontdekt door een analist.
Opdracht:
- Wat is hier het eigenlijke probleem, los van die drie tests?
- Wat doe je met tests die structureel falen op bekende brondata?
- Welke test had die dubbele rijen gevangen, en waarom stond die er waarschijnlijk niet?
- Hoe zorg je dat een echte fout opvalt tussen 340 tests?
Richting: het probleem is niet dat er tests falen maar dat falen normaal is geworden; dan is je testsuite ruis in plaats van signaal. Zet die drie structurele gevallen op severity: warn met een drempel, zodat ze zichtbaar blijven zonder de run te laten klappen, en los de brondata-oorzaak apart op. De dubbele rijen waren gevangen met een unique op de sleutel van die mart; die staat er vaak niet omdat mensen alleen staging testen. Laat de run hard falen op fouten en alleen waarschuwen op bekende afwijkingen, en stuur de uitkomst naar een kanaal waar iemand hem werkelijk leest.
Les 5: Sources, snapshots en seeds
Sources: je bronnen benoemen
Een source is een tabel die buiten dbt is geladen. Je legt hem vast in YAML en verwijst er daarna naar met source(). Daarmee komt de bron in je graaf te staan, kun je er tests op zetten, en kun je bewaken of hij nog wel ververst wordt.
version: 2
sources:
- name: erp
database: raw
schema: erp_productie
description: "Dagelijkse export uit het ERP-systeem."
freshness:
warn_after: {count: 12, period: hour}
error_after: {count: 24, period: hour}
loaded_at_field: geladen_op
tables:
- name: orders
columns:
- name: order_id
tests: [unique, not_null]
- name: klanten
freshness: null # deze tabel verandert zelden, geen bewaking
Versheid bewaken scheelt veel verwarring
Draai dbt source freshness voor je run. Is de bron niet bijgewerkt, dan weet je dat meteen, in plaats van dat iemand zich de volgende dag afvraagt waarom de cijfers gisteren stil zijn blijven staan. Dit is een van de goedkoopste controles die je kunt inbouwen.
Snapshots: historie van wat overschreven wordt
Veel bronsystemen overschrijven gewoon. Verandert een klant van segment, dan is de oude waarde weg. Een snapshot legt bij elke run vast wat er veranderd is en bouwt zo een slowly changing dimension van het type 2, met een geldig-van en geldig-tot.
{% snapshot klanten_snapshot %}
{{ config(
target_schema='snapshots',
unique_key='klant_id',
strategy='check',
check_cols=['segment', 'regio', 'status']
) }}
select klant_id, naam, segment, regio, status
from {{ source('erp', 'klanten') }}
{% endsnapshot %}
Twee strategieën
Met timestamp kijkt dbt naar een kolom die aangeeft wanneer de rij voor het laatst gewijzigd is. Dat is de voorkeur als je bron zo'n kolom betrouwbaar bijhoudt. Met check vergelijkt dbt de waarden van de kolommen die je opgeeft. Dat werkt altijd, maar is zwaarder.
Een snapshot kun je niet opnieuw opbouwen
Modellen bouw je net zo vaak opnieuw als je wilt. Een snapshot niet: de historie bestaat alleen doordat je hem hebt vastgelegd. Mis je een run, dan mis je die wijziging voorgoed. Draai snapshots daarom voor je modellen en bewaak dat ze slagen.
Seeds: kleine tabellen uit je repository
Een seed is een CSV in je project dat dbt als tabel in je warehouse zet. Bedoeld voor kleine, handmatig beheerde lijstjes: een mapping van landcodes, een indeling van kostenplaatsen, een lijst met testaccounts die je uit je cijfers wilt houden.
Gebruik seeds niet voor echte data. Alles boven een paar duizend rijen of iets wat regelmatig verandert, hoort via je laadproces binnen te komen en niet via git.
Oefening: historie die ontbreekt
Situatie: de directie wil omzet kunnen analyseren per klantsegment zoals dat gold op het moment van de bestelling. Het ERP overschrijft het segment bij elke wijziging, en er is geen historie. Daarnaast klaagt het team dat de cijfers soms een dag achterlopen zonder dat iemand dat merkt.
Opdracht:
- Welk dbt-onderdeel heb je nodig voor die segmenthistorie?
- Welke strategie kies je, en waar hangt dat van af?
- Kun je de historie van voor vandaag nog terughalen? Waarom wel of niet?
- Wat zet je in om dat achterlopen op te merken?
- Het team wil een lijst met twaalf testaccounts uitsluiten. Hoe pak je dat aan?
Richting: een snapshot op de klantentabel. Heeft het ERP een betrouwbare kolom met het wijzigingsmoment, kies dan timestamp; zo niet, dan check op segment. De historie van voor vandaag is niet terug te halen: een snapshot legt alleen vast wat hij ziet vanaf het moment dat je hem draait. Hoe eerder je hem inricht, hoe beter. Het achterlopen vang je met freshness op de source plus dbt source freshness voor elke run. De twaalf testaccounts horen in een seed, want dat is klein, handmatig beheerd en je wilt wijzigingen terug kunnen zien in git.
Les 6: Documentatie, CI/CD en deployment
Documentatie die uit je code komt
Beschrijvingen die je in YAML vastlegt, worden samen met de afhankelijkheidsgraaf tot een doorzoekbare site verwerkt. Omdat het uit dezelfde bestanden komt als je modellen, veroudert het niet zoals een losse wiki dat doet.
Jinja en macro's
dbt-modellen zijn SQL met Jinja erin. Dat geeft je variabelen, voorwaarden en lussen. Gebruik het met mate: SQL die vol sjabloonlogica zit, leest niemand meer.
{% macro bedrag_in_euro(kolom, valuta_kolom) %}
case
when {{ valuta_kolom }} = 'EUR' then {{ kolom }}
when {{ valuta_kolom }} = 'USD' then {{ kolom }} * 0.92
when {{ valuta_kolom }} = 'GBP' then {{ kolom }} * 1.17
else null
end
{% endmacro %}
-- Gebruik in een model:
-- select {{ bedrag_in_euro('bedrag', 'valuta') }} as bedrag_eur
CI: testen voordat je samenvoegt
De winst van dbt komt pas echt binnen als elke wijziging automatisch gebouwd en getest wordt voordat hij naar productie gaat. Met state:modified+ bouw je alleen wat je wijzigde plus alles wat daarvan afhangt; dat scheelt bij een groot project enorm veel tijd.
name: dbt CI
on:
pull_request:
branches: [main]
jobs:
bouwen-en-testen:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.11'
- name: Installeren
run: pip install dbt-snowflake==1.8.3
- name: Pakketten ophalen
run: dbt deps
- name: Alleen gewijzigde modellen bouwen en testen
run: dbt build --select state:modified+ --defer --state ./prod-artifacts
Wat defer doet
Met --defer pakt dbt voor modellen die je niet wijzigde de productieversie, in plaats van ze in jouw omgeving opnieuw te bouwen. Je test dus je wijziging tegen echte data zonder het hele project te hoeven draaien. Je hebt er wel de artefacten van de laatste productierun voor nodig.
Omgevingen scheiden
mijn_project:
target: dev # standaard veilig: je eigen schema
outputs:
dev:
type: snowflake
warehouse: DEV_WH
database: ANALYTICS_DEV
schema: dbt_jouwnaam # ieder zijn eigen schema
threads: 4
prod:
type: snowflake
warehouse: PROD_WH
database: ANALYTICS
schema: marts
threads: 8
Zet dev als standaard
Staat target op prod, dan draait iemand die dbt run typt zonder na te denken rechtstreeks op productie. Laat de standaard altijd je ontwikkelomgeving zijn en dwing productie af met een expliciete vlag, bij voorkeur alleen vanuit je CI.
Oefening: klaar om te deployen
Situatie: een project met 180 modellen, waarvan een volledige run 50 minuten duurt. Vier mensen werken eraan. Nu wordt er met de hand gedeployd: iemand draait 's avonds dbt run op productie. Twee keer is er al een kapot model live gegaan.
Opdracht:
- Waarom is een volledige run in je CI geen werkbare oplossing bij 180 modellen?
- Welke selectie gebruik je in plaats daarvan, en wat heb je daarvoor nodig?
- Hoe voorkom je dat vier mensen elkaars tabellen overschrijven tijdens het ontwikkelen?
- Welke instelling voorkomt dat iemand per ongeluk op productie draait?
- Welk commando zet je in de nachtelijke productierun, en waarom dat en niet
dbt rungevolgd doordbt test?
Richting: 50 minuten per pull request maakt dat niemand meer op de uitkomst wacht; gebruik dbt build --select state:modified+ --defer met de artefacten van de laatste productierun. Geef iedere ontwikkelaar een eigen schema. Zet dev als standaarddoel. Draai in productie dbt build: dat test elk model direct nadat het gebouwd is, zodat een kapot model de modellen erachter niet meer bereikt. Bij run gevolgd door test is alles al gebouwd voordat je de eerste fout ziet.