---
title: Modellen in dbt doorlichten met SQLfluff
description: Ontdek hoe SQLFluff beknopte en leesbare SQL-query's vereenvoudigt voor verbeterde samenwerking en onderhoud in analytische engineering met dbt.
---

[DDBM Blog ](https://www.ddbm.com/blog)

# [Modellen in dbt doorlichten met SQLfluff](https://www.ddbm.com/blog/modellen-in-dbt-doorlichten-met-sqlfluff)

 Geschreven door [Atzmon Ben Binyamin](https://www.ddbm.com/blog/author/atzmon-ben-binyamin) | 28 Feb, 2024

SQL is de hoeksteen van databasebeheer en gegevensmanipulatie. Als data engineers en analisten besteden we een groot deel van onze tijd aan het maken van SQL queries om gegevens te extraheren, te transformeren en te analyseren. Op het gebied van analytics engineering, vooral met tools zoals dbt, is het onderhouden van schone en leesbare SQL-code cruciaal voor samenwerking, begrip en onderhoud. Dit is waar *SQLFluff* te hulp schiet en onze dbt-modellen beknopt en leesbaar maakt.

## **Enter *****SQLFluff***

[*SQLFluff*](https://docs.sqlfluff.com/en/stable/index.html) is een open-source linting tool voor SQL-code. Het analyseert SQL-query's en geeft feedback over problemen met syntaxisfouten, inconsistenties in de opmaak en het naleven van coderingsconventies. Zie het als een spellingscontrole voor SQL - het helpt ervoor te zorgen dat uw SQL-code de best practices volgt en consistent is binnen uw projecten.

## **Waarom *****SQLFluff*****gebruiken **** met dbt?**

dbt is een krachtige tool voor het beheren van het datatransformatieproces in analytische projecten. Je kunt er datamodellen, tests en documentatie mee definiëren met SQL-gebaseerde syntaxis. Echter, naarmate projecten complexer worden en er meerdere medewerkers bij betrokken zijn, wordt het onderhouden van een schone en consistente codebase een steeds grotere uitdaging.

*SQLFluff* is al geïmplementeerd in dbt cloud waar je eenvoudig en naadloos je sql-modellen kunt linten. We willen graag hetzelfde resultaat bereiken met dbt core...

Het linten van je sql zal je op verschillende manieren helpen:

- **Consistentie**: *SQLFluff* dwingt een consistente coderingsstijl af in je dbt projecten. Door vast te houden aan een consistente stijlgids, maakt u het makkelijker voor teamleden om de code te begrijpen en samen te werken aan de codebase. Denk aan boven/onder sleutelwoorden, leidende/volgende komma's, inspringen, aliasing regels, etc.
- **Leesbaarheid**: Schone en goed geformatteerde code is gemakkelijker te lezen en te begrijpen. *SQLFluff* helpt ervoor te zorgen dat je SQL-modellen in dbt gemakkelijk te begrijpen zijn, waardoor er minder tijd nodig is voor het inwerken van nieuwe teamleden of het herzien van oude code.
- **Onderhoudbaarheid**: Consistente opmaak en coderingsconventies maken uw SQL modellen beter onderhoudbaar. Bij het maken van wijzigingen of het debuggen van problemen vereenvoudigt een gestandaardiseerde codebase het proces en vermindert het risico op het introduceren van fouten.
- **Geautomatiseerde controles**: *SQLFluff* kan worden geïntegreerd in uw dbt ontwikkel workflow, zodat u uw SQL modellen automatisch kunt controleren op problemen voordat ze worden vastgelegd in uw versiebeheersysteem. Dit helpt om potentiële fouten vroeg in het ontwikkelproces op te sporen.

## **Aan de slag met *****SQLFluff***** en dbt**

*SQLFluff* integreren in je dbt workflow is vrij eenvoudig. Als je als enige ontwikkelaar werkt, dan heb je duidelijk voor ogen hoe je je code wilt stijlen. Als je met een team werkt, moet je eerst communiceren en uitleggen waarom het belangrijk is om bepaalde stijlregels te hebben.

Een goed resultaat van deze discussie is het opstellen van een eerste set afgesproken regels om je aan te houden. Daarnaast kun je overwegen om deze regels te implementeren voor een specifiek deel van het project, vooral als het omvangrijk is en meerdere dbt-projecten omvat.

Rekening houdend met het feit dat je al een dbt project hebt, laten we de nodige pakketten installeren:  
`$ pip install sqlfluff sqlfluff-templater-dbt`

Je kunt de installatie bevestigen door *SQLFluff* het versienummer te laten tonen:  
`$ sqlfluff versie`

*SQLFluff* is een configureerbare SQL linter, wat betekent dat u uw eigen lintingregels kunt configureren. Om dit te bereiken maken we een configuratiebestand aan met de naam .sqlfluff en plaatsen dit in de hoofdmap van je dbt project. Nu moeten we *SQLFluff* vertellen welk soort dialect te gebruiken en de gewenste parameters voor onze regels afstemmen.

### **dbtonic linting regels**

dbt labs levert een .sqlfluff configuratiebestand dat hun aanpak toont (hieronder geplakt). Je kunt het gebruiken voor jouw project of het naar eigen smaak aanpassen. In de voorbeeldconfiguratie hieronder heb ik dialect = [snowflake](https://www.theinformationlab.nl/technologie/snowflake/) gebruikt, je kunt elk willekeurig magazijn gebruiken waar je bekend mee bent. Voer het sqlfluff dialects commando uit, dat een lijst zal weergeven van de huidige dialecten die beschikbaar zijn op uw installatie van *SQLFluff*.

```
[sqlfluff] dialect = snowflake templater = dbt runaway_limit = 10 max_line_length = 80 indent_unit = space [sqlfluff:indentation] tab_space_size = 4 [sqlfluff:layout:type:comma] spacing_before = touch line_position = trailing [sqlfluff:rules:capitalisation.trefwoorden] kapitalisatie_beleid = lager [sqlfluff:rules:aliasing.table] aliasing = expliciet [sqlfluff:rules:aliasing.column] aliasing = expliciet [sqlfluff:rules:aliasing.expression] allow_scalar = False [sqlfluff:rules:capitalisation.identifiers] extended_capitalisation_policy = lower [sqlfluff:rules:capitalisation.functions] capitalisation_policy = lower [sqlfluff:rules:capitalisation.literals] capitalisation_policy = lower [sqlfluff:rules:ambiguous.column_references] # Aantal in groep door group_by_and_order_by_style = impliciet
```

## **Bestanden negeren in *****SQLFluff***

Het .sqlfluffignore bestand (ook in de hoofdmap van uw dbt project) biedt een handige manier om het *SQLFluff*linting proces aan te passen en de efficiëntie te verbeteren bij het analyseren van SQL code binnen uw project.

Door de bestanden of mappen in het .sqlfluffignore bestand op te sommen, kun je het gedrag van *SQLFluff*aanpassen aan de specifieke behoeften van je project. Dit helpt bij het richten van het linting proces op relevante code terwijl irrelevante of gegenereerde bestanden, testgegevens of andere bestanden die niet bedoeld zijn voor linting worden uitgesloten.

## ***SQLFluff*****gebruiken **

Om een gevoel te krijgen voor het gebruik van *SQLFluff*, laten we eens kijken naar dit sql-model:

```
met klanten als ( select * from ), fct_orders als ( select * from ), customer_orders als ( select

klant_id , MIN(order_date) AS eerste_order_datum, MAX(order_date) AS last_order_date , count(order_id) AS cnt_orders, sum(amount_usd) AS lifetime_value_usd from fct_orders GROUP BY 1 ), final as ( select customers.customer_id , customers.first_name , customers.last_name , customer_orders.first_order_date , customer_orders.last_order_date , coalesce(customer_orders.cnt_orders, 0) als cnt_orders , customer_orders.lifetime_value_usd from customers left join customer_orders on customers.customer_id = customer_orders.customer_id ) select * from final
```

Om dit model te testen met *SQLFluff*, laten we de onderstaande opdracht uitvoeren en de resultaten controleren:  
`$ sqlfluff lint models/marts/core/dim_customers.sql`

```
=== [dbt templater] Nodes sorteren... === [dbt templater] Dbt project compileren... === [dbt templater] Project gecompileerd. == [models/marts/core/dim_customers.sql] FAIL L: 11 | P: 11 | LT01 | Onnodige witruimte. | [layout.spacing] L: 13 | P: 9 | LT04 | Komma ',' gevonden. Verwacht alleen regeleindes. [L: 13 | P: 27 | CP01 | Trefwoorden moeten kleine letters zijn. | Hoofdlettergebruik.trefwoorden] L: 14 | P: 9 | LT04 | Komma ',' gevonden. Verwacht alleen komma's in de buurt van regeleinden. [L: 14 | P: 27 | CP01 | Trefwoorden moeten kleine letters zijn. | kapitalisatie.trefwoorden] L: 15 | P: 9 | LT04 | Komma ',' gevonden. Verwacht alleen komma's in de buurt van regeleinden. [Opmaak.komma's] Gereed 📜 🎉!
```

Nu we dat sql-model hebben gefixeerd en de regels hebben toegepast, kunnen we een fix-commando uitvoeren:  
`$ sqlfluff fix models/marts/core/dim_customers.sql`

```
==== fix schendingen ==== 30 fixeerbare linting schendingen gevonden Weet u zeker dat u wilt proberen om deze te repareren? [J/N] ... Proberen te repareren... Wijzigingen aanhouden... == [models/marts/core/dim_customers.sql] FIXED Done. Controleer uw bestanden ter bevestiging. Alles voltooid 📜 🎉!
```

en voila! We hebben het sql-model aangepast aan onze stijl en dit is het nieuwe model:

```

met klanten als ( select * from ), fct_orders als ( select * from ), customer_orders als ( selectklant_id, MIN(order_date) als eerste_order_datum,MAX(order_date) als laatste_order_datum, COUNT(order_id) als cnt_orders, SUM(amount_usd) als lifetime_value_usduit fct_orders groep door 1 ), definitief als ( selecteer klanten.klant_id, klanten.voornaam, klanten.achternaam, klant_bestellingen.first_order_date, customer_orders.last_order_date, customer_orders.lifetime_value_usd, COALESCE(customer_orders.cnt_orders, 0) als cnt_orders uit customers left join customer_orders op customers.customer_id = customer_orders.customer_id ) select * uit final
```

Door deze stappen te volgen, kun je SQL fluff gebruiken om de kwaliteit en consistentie van je SQL-modellen in dbt te verbeteren, wat uiteindelijk de onderhoudbaarheid en leesbaarheid van je analytische codebase verbetert.

Probeer SQL fluff eens uit in je dbt-projecten en ervaar zelf de voordelen!

[Volledig bericht weergeven](https://www.ddbm.com/blog/modellen-in-dbt-doorlichten-met-sqlfluff)

```json
{
  "@context" : "http://schema.org",
  "@type" : "BlogPosting",
  "author" : {
    "@type" : "Person",
    "name" : "Atzmon Ben Binyamin"
  },
  "dateModified" : "2026-01-09T15:18:37.136Z",
  "datePublished" : "2024-02-28T15:15:00Z",
  "headline" : "Modellen in dbt doorlichten met SQLfluff",
  "image" : {
    "@type" : "ImageObject",
    "height" : 535,
    "url" : "https://go.theinformationlab.nl/hubfs/Imported_Blog_Media/edvard-alexander-rolvaag-E75ZuAIpCzo-unsplash-1-2.png",
    "width" : 805
  },
  "mainEntityOfPage" : "https://www.ddbm.com/blog/modellen-in-dbt-doorlichten-met-sqlfluff",
  "publisher" : {
    "@type" : "Organization",
    "logo" : {
      "@type" : "ImageObject",
      "height" : 60,
      "url" : "/hs/hsstatic/content_shared_assets/static-1.4092/img/default-amp-logo.png",
      "width" : 60
    },
    "name" : "DDBM Blog"
  }
}
```