Implementare un Semantic Layer con dbt: guida pratica

Configurare il tuo progetto dbt

Di solito, dbt si appoggia a data warehouse cloud come Snowflake o Google BigQuery. Tuttavia, per semplicità in questo tutorial ci collegheremo in locale a un database DuckDB.

1. Prerequisiti

• Installa Python sulla tua macchina se non è già installato.

2. Installare gli strumenti necessari

Usa pip per installare la CLI di dbt:

pip install dbt-coreOfferto da

Installa DuckDB tramite pip:

pip install duckdbOfferto da

Installa l’adapter DuckDB tramite pip:

pip install dbt-duckdbOfferto da

3. Inizializzare il progetto dbt

Crea un nuovo progetto dbt:

dbt init project_nameOfferto da

Questo comando creerà un progetto nella tua directory corrente, con questa struttura:

project_name/
├── analyses/
├── logs/
├── macros/
├── models/
├── seeds/
├── snapshots/
├── tests/
├── .gitignore
├── dbt_project.ymlOfferto da

4. Configurare la connessione a DuckDB

Modifica il file profiles.yml, di solito presente nella cartella ~/.dbt/. Se non esiste, creane uno:

project_name:  # This matches the name in dbt_project.yml file
  target: dev
  outputs:
    dev:
      type: duckdb
      path: path/to/demo_database.duckdb  
      threads: 1Offerto da

Il profiles.yml contiene il riferimento alla posizione del file di database .duckdb, che dovresti indicare nel campo path. 

Puoi creare un nuovo database oppure scaricarne uno piccolo di esempio da qui. Nella prossima sezione userò il file duckdb-demo.duckdb dallo stesso sito. 

Per creare un nuovo file di database duckDB, esegui semplicemente quanto segue:

import duckdb
duckdb.connect('/path/to/your/duckdb/database.duckdb')Offerto da

5. Testare la connessione

Ora possiamo testare eseguendo dbt debug per verificare che tutto funzioni. Assicurati di essere nella cartella del progetto prima di eseguire il comando:

cd /path/to/your/project/
dbt debugOfferto da

Se tutto è configurato correttamente, otterrai un output simile (tutti i percorsi sono oscurati per motivi di privacy):

15:20:00  Running with dbt=1.9.1
15:20:00  dbt version: 1.9.1
15:20:00  python version: 3.11.5
15:20:00  python path: ...
15:20:00  os info: Windows-10-10.0.22631-SP0
15:20:00  Using profiles dir at ....
15:20:00  Using profiles.yml file at ...
15:20:00  Using dbt_project.yml file at ...
15:20:00  adapter type: duckdb
15:20:00  adapter version: 1.9.1
15:20:00  Configuration:
15:20:00    profiles.yml file [OK found and valid]
15:20:00    dbt_project.yml file [OK found and valid]
15:20:00  Required dependencies:
15:20:00   - git [OK found]

15:20:00  Connection:
15:20:00    database: demo_database
15:20:00    schema: main
15:20:00    path: ...
15:20:00    config_options: None
15:20:00    extensions: None
15:20:00    settings: {}
15:20:00    external_root: .
15:20:00    use_credential_provider: None
15:20:00    attach: None
15:20:00    filesystems: None
15:20:00    remote: None
15:20:00    plugins: None
15:20:00    disable_transactions: False
15:20:00  Registered adapter: duckdb=1.9.1
15:20:01    Connection test: [OK connection ok]Offerto da

Creare un Semantic Layer con dbt

Complimenti per essere arrivato fin qui! Hai configurato con successo il tuo primo progetto dbt.

Ora vediamo come creare un semantic layer sopra un database. Per farlo, puoi importare i tuoi dati da CSV in DuckDB oppure scaricare un piccolo database di esempio (5 MB) da qui.

Poi possiamo scrivere un semplice script Python per esplorare il contenuto di questo file di database:

import duckdb

# Connect to the database
conn = duckdb.connect("duckdb-demo.duckdb")

# Get list of tables
tables = conn.execute(
    "SELECT table_name FROM information_schema.tables WHERE table_schema='main'"
).fetchall()

print(f"\nNumber of tables in database: {len(tables)}")

print("Table names:")
for t in tables:
    print(f"- {t[0]}")

print("\nTables in database:")
for table in tables:
    print(f"- {table[0]}")

    # Get schema for each table
    schema = conn.execute(f"DESCRIBE {table[0]}").fetchall()
    print("\nSchema:")
    for col in schema:
        print(f"  {col[0]}: {col[1]}")

    # Preview data
    data = conn.execute(f"SELECT * FROM {table[0]} LIMIT 5").fetchall()
    print("\nFirst 5 rows:")
    for row in data:
        print(f"  {row}")
    print("\n---")

# Close connection
conn.close()Offerto da

Output (troncato per brevità):

Number of tables in database: 17
Table names:
- bank_failures
- boxplot
- calendar
- ...

Tables in database:
- bank_failures

Schema:
  c1: BIGINT
  Bank: VARCHAR
  City: VARCHAR
  State: VARCHAR
  Date: DATE
  Acquired by: VARCHAR
  Assets ($mil.): DOUBLE

First 5 rows:
  (1, 'Douglass National Bank', 'Kansas City', 'Missouri', datetime.date(2008, 1, 25), 'Liberty Bank and Trust', 58.5)
  (2, 'Hume Bank', 'Hume', 'Missouri', datetime.date(2008, 3, 7), 'Security Bank', 18.7)
...
…Offerto da

Questo database ha 17 tabelle. Tuttavia, per questo tutorial useremo solo la tabella bank_failures. Questa tabella contiene dettagli finanziari storici di banche fallite negli Stati Uniti.

1. Definire i modelli SQL

I modelli SQL sono la base di qualsiasi progetto dbt. Rappresentano la trasformazione strutturata dei dati grezzi in un formato più analitico. 

Per questo tutorial definiremo due file SQL nella cartella models/. 

Crea un nuovo file nella cartella models del tuo progetto chiamato base_bank_failures.sql:

SELECT *
FROM bank_failuresOfferto da

Questo file estrae direttamente i dati grezzi dalla tabella bank_failures. Funziona come modello base a cui i modelli successivi possono fare riferimento.

Dopodiché, crea un altro file chiamato clean_bank_failures.sql:

SELECT
    State,
    COUNT(*) AS total_failures,
    SUM("Assets ($mil.)" ) AS total_assets
FROM
    {{ ref('base_bank_failures') }}
GROUP BY
    StateOfferto da

Questo file si basa sul modello base_bank_failures (usando la funzione ref()) per aggregare e pulire i dati, preparandoli all’analisi. Riassume i fallimenti totali e gli asset per stato.

2. Creare un file metrics.yml

Il file metrics.yml definisce metriche centralizzate e riutilizzabili che garantiscono coerenza tra analisi e dashboard.

Nel nostro caso descriverà metriche come total_assets e avg_assets_per_failure, rendendole disponibili per l’uso negli strumenti BI e in altre query:

version: 2
models:
  - name: clean_bank_failures
    description: "Aggregated data about bank failures."
    columns:
      - name: State
        tests:
          - unique
      - name: "Assets ($mil.)"
    metrics:
      - name: total_assets
        label: Total Assets
        type: sum
        expression: "Assets ($mil.)"
        description: "Total assets of failed banks, aggregated by state."

      - name: avg_assets_per_failure
        label: Average Assets per Failure
        type: average
        expression: "Assets ($mil.)"
        description: "Average assets for each bank failure."Offerto da

3. Creare un file exposures.yml

Il file exposures.yml collega i tuoi modelli dbt a strumenti esterni come Tableau o Looker. Documenta queste connessioni, garantendo tracciabilità e coerenza.

Questo file specifica che il modello clean_bank_failures è usato in una dashboard Tableau, fornendo dettagli sul proprietario e sulla dipendenza:

exposures:
  - name: tableau_dashboard
    type: dashboard
    url: https://tableau.yourcompany.com/workbook
    owner:
      name: Data Team
      email: datateam@yourcompany.com
    depends_on:
      - ref('clean_bank_failures')Offerto da

Build e test del Semantic Layer

Per validare e costruire correttamente il tuo progetto dbt, ecco alcuni comandi utili:

1. Eseguire il build dei modelli: esegui il comando dbt build per materializzare tutti i modelli, applicare i test ed eseguire seeds e snapshot. Questo comando combina le funzionalità di dbt run e dbt test:

dbt buildOfferto da

2. Testare i modelli: se vuoi solo validare i dati con i test dopo il build, usa il comando dbt test. Garantisce che tutti i test di qualità (ad es. unicità e not-null) siano applicati ai tuoi modelli.

dbt testOfferto da

3. Eseguire modelli o test specifici: per eseguire solo modelli o test specifici, fornisci i loro nomi come argomenti. Per esempio, per eseguire un singolo modello:

dbt run --select clean_bank_failuresOfferto da

Per testare una specifica colonna:

dbt test --select clean_bank_failures.StateOfferto da

Integrazione del Semantic Layer con strumenti BI

Per collegare dbt a strumenti BI come Looker o Tableau, segui questi passaggi per esporre efficacemente il semantic layer e fare in modo che gli strumenti BI possano riferirsi direttamente a modelli e metriche dbt:

1. Abilitare le exposures in dbt

Nel tuo progetto dbt, crea un file exposures.yml nella cartella models, con questo contenuto:

exposures:
  - name: tableau_dashboard
    type: dashboard
    url: https://tableau.yourcompany.com/workbook
    owner:
      name: Your Name
      email: email@yourcompany.com
    depends_on:
      - ref('clean_bank_failures')Offerto da

2. Preparare la connessione al database

• Assicurati che i modelli di dati trasformati siano disponibili nel tuo database (ad es. Snowflake, BigQuery, DuckDB).
• Esegui dbt build per materializzare i modelli dbt nel database.

3. Collegare Tableau ai modelli dbt

• Apri Tableau Desktop e crea una nuova connessione al tuo database.
• Seleziona lo schema in cui sono archiviati i modelli dbt.
• Trascina i modelli dbt (ad es. clean_bank_failures) nell’area di lavoro di Tableau.

4. Definire le metriche in Tableau

• In Tableau, usa direttamente nelle visualizzazioni le metriche definite in dbt come total_assets o avg_assets_per_failure per garantire coerenza.
• Crea campi calcolati se necessario per arricchire le visualizzazioni.

5. Collegare Looker ai modelli dbt

• In Looker, vai al pannello di amministrazione e configura una connessione al tuo database.
• Crea una vista LookML per ciascun modello dbt importando schema e campi.
• Usa le metriche total_assets o avg_assets_per_failure definite in dbt per costruire Explores e dashboard coerenti in Looker.

Best practice per implementare un Semantic Layer con dbt

Ora che hai una panoramica dei passaggi per costruire un semantic layer con dbt, rivediamo alcune best practice. 

Centralizza la logica di business

Definisci tutte le regole di business in dbt per garantire coerenza e manutenibilità. Centralizzando la logica di business, elimini definizioni ridondanti tra gli strumenti, creando una single source of truth che tutti gli stakeholder possono aggiornare e comprendere facilmente. 

Modularizza i modelli

Dividi le trasformazioni in componenti logici e riutilizzabili. Per esempio, crea modelli base per i dati grezzi, modelli intermedi per i dati puliti e trasformati, e modelli finali per i dati pronti all’analisi. 

Questa struttura modulare semplifica la risoluzione dei problemi, promuove il riuso del codice e abilita la collaborazione tra i membri del team, che possono lavorare su componenti individuali senza interrompere l’intera pipeline.

Documenta tutto

Sfrutta la documentazione automatica di dbt per mantenere il tuo semantic layer ben organizzato e trasparente. 

Usa le descrizioni nei file YAML per fornire spiegazioni chiare per modelli, metriche e colonne. 

Aggiorna regolarmente la documentazione per riflettere i cambiamenti e usa i grafi di lineage autogenerati di dbt per visualizzare le relazioni tra i modelli. Questo assicura che il semantic layer rimanga accessibile e facile da navigare per tutti gli utenti.

Strumenti come il pacchetto dbt-utils possono semplificare notevolmente i tuoi workflow dbt, fornendo macro e utility predefinite che facilitano lo sviluppo dei modelli e garantiscono una documentazione accurata.

Conclusione

Implementare un semantic layer con dbt è un approccio potente per colmare il divario tra dati grezzi e insight azionabili. Il data modeling modulare di dbt, le definizioni centralizzate delle metriche, il robusto controllo di versione e l’integrazione con strumenti BI possono aiutarti a garantire dati coerenti, affidabili e accessibili per analisi e reportistica.

Questo tutorial ti ha guidato nella configurazione di un progetto dbt, nella creazione di modelli SQL, nella definizione di metriche riutilizzabili e nell’integrazione del semantic layer con strumenti di visualizzazione come Tableau e Looker.

Per saperne di più su dbt, dai un’occhiata all’ottimo corso Introduction to dbt!