Data Modelleren met dbt

dbt (data build tool) is een open-source tool waarmee data engineers SQL-modellen schrijven die dbt omzet naar geteste, gedocumenteerde tabellen en views in je datawarehouse. dbt handelt de T in ELT — het transformeren van data — af binnen het warehouse zelf.

Waarom dbt?

• SQL-first: data engineers werken in een vertrouwde taal
• Ingebouwde tests (unique, not_null, accepted_values, relationships)
• Automatische documentatie met lineage graph
• Modulaire modellen via ref() en source()
• Werkt met Snowflake, BigQuery, Databricks, Redshift, DuckDB en meer

Adapter kiezen en installeren

# Virtuele omgeving aanmaken (aanbevolen)
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate

# Installeer dbt met de gewenste adapter
pip install dbt-core dbt-snowflake       # voor Snowflake
pip install dbt-core dbt-databricks      # voor Databricks
pip install dbt-core dbt-duckdb          # voor lokaal testen

# Controleer installatie
dbt --version
# dbt Core: 1.8.x  |  Adapter: dbt-snowflake: 1.8.x

# Nieuw project aanmaken
dbt init mijn_project
# → kies je adapter en vul de verbindingsgegevens in

cd mijn_project
dbt debug    # test de verbinding met je datawarehouse

Een dbt project heeft een vaste mappenstructuur. Begrijpen wat elke map doet is essentieel voor een schaalbaar project.

mijn_project/
├── dbt_project.yml          # Projectconfiguratie (naam, versie, paths)
├── profiles.yml             # Verbindingsinstellingen (buiten repo!)
├── packages.yml             # dbt packages (dbt_utils, dbt_expectations)
│
├── models/                  # SQL-transformaties — de kern van dbt
│   ├── staging/             # 1-op-1 mapping van bronnen
│   │   └── stg_orders.sql
│   ├── intermediate/        # Tussenliggende logica
│   │   └── int_orders_enriched.sql
│   └── marts/               # Eindproducten voor BI tools
│       ├── core/
│       │   └── dim_customers.sql
│       └── finance/
│           └── fct_revenue.sql
│
├── seeds/                   # Kleine CSV bestanden → tabellen in DWH
│   └── country_codes.csv
│
├── tests/                   # Singular tests (custom SQL assertions)
│   └── assert_orders_positive.sql
│
├── macros/                  # Herbruikbare Jinja functies
│   └── cents_to_euros.sql
│
├── snapshots/               # SCD Type 2 snapshots
│   └── orders_snapshot.sql
│
└── analyses/                # Ad-hoc analyses (niet materialiseerd)

dbt_project.yml configureren

name: 'mijn_project'
version: '1.0.0'
config-version: 2

profile: 'mijn_project'

model-paths: ["models"]
seed-paths:  ["seeds"]
test-paths:  ["tests"]
macro-paths: ["macros"]
snapshot-paths: ["snapshots"]

target-path: "target"
clean-targets: ["target", "dbt_packages"]

models:
  mijn_project:
    staging:
      +materialized: view       # stagings zijn views
      +schema: staging
    intermediate:
      +materialized: ephemeral  # geen tabel, inline CTE
    marts:
      +materialized: table      # eindproducten zijn tabellen
      core:
        +schema: core
      finance:
        +schema: finance

Een dbt model is een .sql bestand met een SELECT statement. dbt wikkelt dit automatisch in een CREATE TABLE of CREATE VIEW op basis van de materialisatie.

Eenvoudig model met ref()

-- Config block bovenaan het bestand (optioneel, overschrijft dbt_project.yml)
{{
  config(
    materialized = 'table',
    schema       = 'core',
    tags         = ['daily', 'finance']
  )
}}

with orders as (

  select * from {{ ref('stg_orders') }}   -- verwijzing naar een ander model

),

customers as (

  select * from {{ ref('dim_customers') }}

),

final as (

  select
    o.order_id,
    o.order_date,
    o.status,
    o.amount_cents / 100.0 as amount_euros,
    c.customer_name,
    c.country
  from orders o
  left join customers c on o.customer_id = c.customer_id

)

select * from final

Jinja variabelen en if-statements

Sources zijn ruwe tabellen in je datawarehouse die door externe processen worden geladen (bijv. Fivetran, ADF, Airbyte). Je declareert ze in een schema.yml bestand.

Staging model met source()

Incrementele modellen verwerken alleen nieuwe of gewijzigde records bij elke run. Dit spaart rekentijd bij grote tabellen.

Volledige refresh forceren

Met dbt snapshots implementeer je Slowly Changing Dimension Type 2 — historische versies van records worden bewaard met dbt_valid_from en dbt_valid_to kolommen.

Snapshot uitvoeren

Resulterende kolommen in snapshot tabel

dbt heeft twee soorten tests: generic tests (gedeclareerd in YAML) en singular tests (custom SQL bestanden).

Generic tests in schema.yml

Singular test (custom SQL)

Tests uitvoeren

dbt genereert automatisch een documentatie website met een interactieve lineage graph. Beschrijvingen voeg je toe in schema.yml.

Documentatie genereren en bekijken

Automatiseer je dbt runs met GitHub Actions zodat elk pull request getest wordt en productie alleen wordt bijgewerkt na goedgekeurd code review.

• dbt geïnstalleerd met juiste adapter
• dbt debug toont geen fouten
• profiles.yml buiten de git repository
• .gitignore bevat target/, dbt_packages/, .env

• Sources gedeclareerd in schema.yml met freshness checks
• Staging modellen doen alleen casting en hernoemingen
• ref() gebruikt in plaats van directe tabelnamen
• Incrementele modellen hebben een unique_key

• Alle primaire sleutels hebben unique + not_null tests
• Alle foreign keys hebben relationships tests
• dbt test passeert zonder fouten
• dbt source freshness geeft geen errors

• Alle modellen hebben een description in schema.yml
• dbt docs generate werkt zonder fouten
• GitHub Actions workflow actief op pull requests
• Productie secrets als GitHub Secrets opgeslagen