Modellen in dbt doorlichten met SQLfluff

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 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 SQLFluffgebruiken 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 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 SQLFlufflinting 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 SQLFluffaanpassen 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.

SQLFluffgebruiken

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!

Bedankt voor het lezen van deze blog. Bekijk ook onze andere blogpagina voor meer blogs over Power BI, Tableau, Alteryx en Snowflake.

Werk samen met een van onze consultants en maximaliseer de effecten van uw gegevens. Neem contact met ons op en we helpen u meteen verder.