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.

6
Lessen
6
Praktijkoefeningen
Nederlands
Taal
100%
Gratis

Les 1: Wat is dbt en waarom gebruik je het?

Beginner Met voorbeelden

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

Hoe een project eruitziet

Mappenstructuur

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

Shell - dbt_commandos.sh

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:

  1. Welke twee problemen uit dit verhaal lost dbt op, en welke niet?
  2. dbt haalt geen data op. Wat heeft dit team daarnaast nodig?
  3. Waarom zou je niet alle 60 scripts in een keer omzetten?
  4. 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

Beginner Met SQL-voorbeelden

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.

SQL - models/staging/stg_orders.sql

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.

SQL - models/marts/fct_omzet.sql

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

YAML - dbt_project.yml

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:

  1. Wat is de oorzaak van beide symptomen tegelijk?
  2. Hoe herschrijf je die verwijzing?
  3. Hoe controleer je of er elders in het project nog meer harde verwijzingen staan?
  4. 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

Gemiddeld Met SQL-voorbeelden

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.

MaterialisatieWat dbt doetWanneer
viewMaakt een viewStaging, kleine modellen, data die altijd actueel moet zijn
tableBouwt elke run de hele tabel opnieuwMarts waarop veel bevraagd wordt
incrementalVoegt alleen nieuwe of gewijzigde rijen toeGrote feitentabellen waar volledig herbouwen te lang duurt
ephemeralNiets; wordt een CTE in het volgende modelTussenstappen 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.

SQL - models/marts/fct_events.sql

{{ 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

Shell - full_refresh.sh

# 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 bron
  • int_order_regels_verrijkt, tussenstap, alleen gebruikt door een mart
  • fct_omzet_dag, 2 miljoen rijen, basis voor alle dashboards
  • fct_clickstream, 1,4 miljard rijen, groeit met 20 miljoen per dag

Opdracht:

  1. Kies per model een materialisatie en onderbouw het.
  2. Welke configuratie geef je het clickstreammodel mee, en welke strategie?
  3. Je wijzigt de berekening van een kolom in dat clickstreammodel. Wat moet er dan gebeuren, en waarom is dat vervelend?
  4. 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

Gemiddeld Met YAML-voorbeelden

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.

YAML - models/staging/_bronnen.yml

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.

SQL - tests/omzet_niet_negatief.sql

-- 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.

YAML - severity.yml

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:

  1. Wat is hier het eigenlijke probleem, los van die drie tests?
  2. Wat doe je met tests die structureel falen op bekende brondata?
  3. Welke test had die dubbele rijen gevangen, en waarom stond die er waarschijnlijk niet?
  4. 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

Gemiddeld Met voorbeelden

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.

YAML - models/staging/_bronnen.yml

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.

SQL - snapshots/klanten_snapshot.sql

{% 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:

  1. Welk dbt-onderdeel heb je nodig voor die segmenthistorie?
  2. Welke strategie kies je, en waar hangt dat van af?
  3. Kun je de historie van voor vandaag nog terughalen? Waarom wel of niet?
  4. Wat zet je in om dat achterlopen op te merken?
  5. 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

Gevorderd Met YAML-voorbeelden

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.

SQL - macros/bedrag_in_euro.sql

{% 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.

YAML - .github/workflows/dbt-ci.yml

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

YAML - profiles.yml

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:

  1. Waarom is een volledige run in je CI geen werkbare oplossing bij 180 modellen?
  2. Welke selectie gebruik je in plaats daarvan, en wat heb je daarvoor nodig?
  3. Hoe voorkom je dat vier mensen elkaars tabellen overschrijven tijdens het ontwikkelen?
  4. Welke instelling voorkomt dat iemand per ongeluk op productie draait?
  5. Welk commando zet je in de nachtelijke productierun, en waarom dat en niet dbt run gevolgd door dbt 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.