DBT (Data Build Tool): Data Transformatie voor het Moderne Data Team

Wat is DBT?

DBT (Data Build Tool) is een open-source command line tool die data analysts en engineers helpt bij het transformeren van data in hun warehouse door simpelweg select statements te schrijven. DBT voert de transformatielogica uit (de T in ELT) en maakt het mogelijk om software engineering best practices toe te passen op data pipelines.

Waarom DBT gebruiken?

DBT brengt software engineering principes naar data transformaties:

• Versiebeheer: Integratie met Git voor change tracking
• Modulaire code: Herbruikbare SQL modellen
• Automatische documentatie: Genereren van data lineage docs
• Data testing: Ingebouwde validatie mogelijkheden
• Dependency management: Automatische volgordebepaling

DBT Project Structuur

Een typisch DBT project heeft de volgende structuur:

dbt_project/
├── dbt_project.yml       # Project configuratie
├── models/               # SQL modellen
│   ├── staging/          # Bron-specifieke transformaties
│   ├── marts/            # Business-specifieke modellen
│   └── schema.yml        # Documentatie en tests
├── seeds/                # Seed data voor lookup tabellen
├── snapshots/            # Type 2 Slowly Changing Dimensions
├── macros/               # Jinja macros voor herbruikbare code
├── tests/                # Aangepaste data tests
└── target/               # Gecompileerde SQL en logs

DBT Kernconcepten

1. Modellen (Models)

Modellen zijn SQL-bestanden die een enkele data transformatie definiëren:

-- models/marts/dim_customers.sql
WITH customer_orders AS (
  SELECT
    customer_id,
    MIN(order_date) AS first_order_date,
    MAX(order_date) AS most_recent_order_date,
    COUNT(order_id) AS number_of_orders
  FROM {{ ref('stg_orders') }}
  GROUP BY customer_id
)

SELECT
  c.customer_id,
  c.first_name,
  c.last_name,
  co.first_order_date,
  co.most_recent_order_date,
  COALESCE(co.number_of_orders, 0) AS number_of_orders
FROM {{ ref('stg_customers') }} c
LEFT JOIN customer_orders co ON c.customer_id = co.customer_id

2. Bronnen (Sources)

Definieer je raw data tabellen in YAML:

# models/sources.yml
version: 2

sources:
  - name: jaffle_shop
    database: raw
    schema: jaffle_shop
    tables:
      - name: orders
      - name: customers

3. Tests

Data kwaliteit controleren met ingebouwde tests:

# models/schema.yml
version: 2

models:
  - name: dim_customers
    columns:
      - name: customer_id
        tests:
          - unique
          - not_null
      - name: first_order_date
        tests:
          - relationships:
              to: ref('stg_orders')
              field: order_date

4. Documentatie

Genereer automatisch data documentatie:

# models/schema.yml
version: 2

models:
  - name: dim_customers
    description: "Klantdimensietabel met historische orders"
    columns:
      - name: customer_id
        description: "Unieke identifier voor de klant"
      - name: first_name
        description: "Voornaam van de klant"

DBT Workflow in Praktijk

Stap 1: Staging Modellen

Transformeer raw data naar gestandaardiseerde staging tabellen:

-- models/staging/stg_customers.sql
SELECT
  id AS customer_id,
  first_name,
  last_name,
  email
FROM {{ source('jaffle_shop', 'customers') }}

Stap 2: Business Modellen

Bouw business-specifieke datamarts:

-- models/marts/customer_metrics.sql
SELECT
  c.customer_id,
  c.first_name,
  c.last_name,
  COUNT(o.order_id) AS order_count,
  SUM(p.amount) AS total_spend
FROM {{ ref('stg_customers') }} c
LEFT JOIN {{ ref('stg_orders') }} o ON c.customer_id = o.customer_id
LEFT JOIN {{ ref('stg_payments') }} p ON o.order_id = p.order_id
GROUP BY 1, 2, 3

Stap 3: Uitvoeren en Testen

Voer je modellen uit en test de data kwaliteit:

# Voer alle modellen uit
dbt run

# Voer tests uit
dbt test

# Genereer documentatie
dbt docs generate
dbt docs serve

Geavanceerde DBT Functies

Jinja Templating

Maak dynamische SQL met Jinja:

-- models/marts/payment_methods.sql
{% set payment_methods = ['credit_card', 'coupon', 'bank_transfer', 'gift_card'] %}

SELECT
  order_id,
  {% for payment_method in payment_methods %}
  SUM(CASE WHEN payment_method = '{{ payment_method }}' THEN amount ELSE 0 END) AS {{ payment_method }}_amount
  {% if not loop.last %},{% endif %}
  {% endfor %}
FROM {{ ref('stg_payments') }}
GROUP BY order_id

Macros

Herbruikbare code voor veelvoorkomende patronen:

-- macros/generate_schema_name.sql
{% macro generate_schema_name(custom_schema_name, node) -%}
    {%- if custom_schema_name is none -%}
        {{ target.schema }}
    {%- else -%}
        {{ custom_schema_name | trim }}
    {%- endif -%}
{%- endmacro %}

Snapshots

Track historische veranderingen in je data:

-- snapshots/customer_snapshot.sql
{% snapshot customer_snapshot %}

{{
    config(
      target_schema='snapshots',
      unique_key='customer_id',
      strategy='timestamp',
      updated_at='updated_at',
    )
}}

SELECT * FROM {{ source('jaffle_shop', 'customers') }}

{% endsnapshot %}

DBT Cloud vs DBT Core

Best Practices

• Houd modellen klein en gericht op één doel
• Gebruik duidelijke naamconventies (stg_, dim_, fct_)
• Test zowel op rijniveau als op kolomniveau
• Documenteer elk model en belangrijke kolommen
• Implementeer incrementele modellen voor grote tabellen

Conclusie

DBT heeft zich bewezen als een essentieel tool voor moderne data teams. Door het combineren van SQL met software engineering best practices zoals versiebeheer, testing en documentatie, stelt DBT teams in staat om betrouwbaardere en onderhoudbaardere data pipelines te bouwen.

Of je nu een data analyst bent die meer controle wil over transformaties, of een data engineer die schaalbare data modellen wil bouwen, DBT biedt de tools om je workflow te verbeteren.

Wil je zelf direct met DBT aan de slag? Bekijk dan mijn complete praktische dbt-handleiding (€7), inclusief voorbeelden, projectstructuur en geavanceerde technieken. Perfect voor data engineers en BI-professionals die hun data pipelines willen professionaliseren.