O que é o dbt (data build tool) e como utilizá-lo na Engenharia de Dados

O que é o dbt?

O dbt (data build tool) é uma ferramenta de linha de comando que permite aos analistas e engenheiros de dados transformar dados em seus warehouses de forma mais eficiente. Criado pela Fishtown Analytics (agora dbt Labs), o dbt se tornou o padrão da indústria para transformação de dados usando SQL.

Em essência, o dbt permite que você:

• Escreva transformações de dados usando SQL
• Organize seu código em modelos reutilizáveis
• Teste automaticamente a qualidade dos seus dados
• Documente suas transformações
• Versione e colabore em projetos de dados

Por que o dbt é importante?

Tradicionalmente, as transformações de dados eram feitas através de ETL tools complexos ou scripts Python/R dispersos. O dbt trouxe uma abordagem mais simples e padronizada:

1. ELT ao invés de ETL

O dbt segue o paradigma ELT (Extract, Load, Transform), onde os dados são extraídos das fontes, carregados no data warehouse, e então transformados. Isso aproveita o poder computacional dos warehouses modernos como Snowflake, BigQuery e Redshift.

2. Desenvolvimento baseado em SQL

Como a maioria dos analistas já conhece SQL, o dbt reduz significativamente a curva de aprendizado comparado a ferramentas de ETL tradicionais.

3. Controle de versão e colaboração

Projetos dbt são apenas código SQL em arquivos de texto, facilitando o uso de Git para versionamento e colaboração em equipe.

Conceitos Fundamentais do dbt

Models

Um model no dbt é um arquivo SQL que representa uma transformação. Cada model gera uma tabela ou view no seu data warehouse.

-- models/staging/stg_orders.sql
{{ config(materialized='view') }}

select
    order_id,
    customer_id,
    order_date,
    case 
        when status = 'completed' then 'complete'
        when status = 'shipped' then 'shipped'
        else 'pending'
    end as order_status,
    order_total
from {{ source('raw_data', 'orders') }}
where order_date >= '2023-01-01'

Sources

Sources representam as tabelas raw no seu data warehouse. Elas são definidas em arquivos YAML:

-- models/staging/sources.yml
version: 2

sources:
  - name: raw_data
    description: Raw data from our application database
    tables:
      - name: orders
        description: Raw orders data
        columns:
          - name: order_id
            description: Primary key for orders

Materializations

Define como o dbt deve construir o model no warehouse:

• Table: Cria uma tabela física
• View: Cria uma view
• Incremental: Adiciona apenas novos registros
• Ephemeral: Existe apenas como CTE

Configurando seu primeiro projeto dbt

1. Instalação

# Instalar dbt via pip
pip install dbt-core

# Para BigQuery
pip install dbt-bigquery

# Para Snowflake
pip install dbt-snowflake

# Para Postgres
pip install dbt-postgres

2. Inicializando um projeto

# Criar novo projeto
dbt init meu_projeto_dados

# Navegar para o diretório
cd meu_projeto_dados

3. Configuração do profiles.yml

Configure a conexão com seu data warehouse no arquivo ~/.dbt/profiles.yml:

meu_projeto_dados:
  target: dev
  outputs:
    dev:
      type: bigquery
      method: service-account
      project: meu-projeto-gcp
      dataset: analytics_dev
      keyfile: /path/to/keyfile.json
    prod:
      type: bigquery
      method: service-account
      project: meu-projeto-gcp
      dataset: analytics_prod
      keyfile: /path/to/keyfile.json

Estrutura de um projeto dbt

meu_projeto_dados/
├── dbt_project.yml         # Configuração do projeto
├── models/                   # Modelos SQL
│   ├── staging/            # Modelos de staging
│   ├── intermediate/       # Modelos intermediários
│   └── marts/              # Modelos finais para análise
├── tests/                    # Testes personalizados
├── macros/                   # Macros reutilizáveis
└── seeds/                    # Arquivos CSV pequenos

Exemplo prático: Pipeline de análise de vendas

1. Staging layer

-- models/staging/stg_customers.sql
select
    customer_id,
    lower(trim(first_name)) as first_name,
    lower(trim(last_name)) as last_name,
    lower(trim(email)) as email,
    created_at
from {{ source('raw_data', 'customers') }}

2. Intermediate layer

-- models/intermediate/int_customer_orders.sql
select
    c.customer_id,
    c.first_name,
    c.last_name,
    o.order_id,
    o.order_date,
    o.order_total
from {{ ref('stg_customers') }} c
left join {{ ref('stg_orders') }} o
    on c.customer_id = o.customer_id

3. Marts layer

-- models/marts/customer_lifetime_value.sql
select
    customer_id,
    first_name,
    last_name,
    count(order_id) as total_orders,
    sum(order_total) as lifetime_value,
    avg(order_total) as avg_order_value,
    min(order_date) as first_order_date,
    max(order_date) as last_order_date
from {{ ref('int_customer_orders') }}
where order_id is not null
group by 1, 2, 3

Testes no dbt

O dbt permite criar testes para garantir a qualidade dos dados:

-- models/staging/schema.yml
version: 2

models:
  - name: stg_customers
    columns:
      - name: customer_id
        tests:
          - unique
          - not_null
      - name: email
        tests:
          - unique
  
  - name: stg_orders
    columns:
      - name: order_id
        tests:
          - unique
          - not_null
      - name: order_total
        tests:
          - not_null
          - positive_values

Comandos essenciais do dbt

# Executar todos os modelos
dbt run

# Executar apenas um modelo específico
dbt run --select stg_customers

# Executar modelos downstream
dbt run --select +customer_lifetime_value

# Executar testes
dbt test

# Gerar documentação
dbt docs generate
dbt docs serve

# Debug de conexão
dbt debug

Macros e Jinja

O dbt usa Jinja para tornar o SQL mais dinâmico:

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

Exemplo de macro personalizada

-- macros/currency_conversion.sql
{% macro convert_currency(column_name, from_currency, to_currency='USD') %}
    case 
        when {{ from_currency }} = 'EUR' then {{ column_name }} * 1.1
        when {{ from_currency }} = 'GBP' then {{ column_name }} * 1.3
        else {{ column_name }}
    end
{% endmacro %}

Modelos incrementais

Para tabelas grandes, use modelos incrementais que processam apenas novos dados:

-- models/marts/daily_sales.sql
{{ config(
    materialized='incremental',
    unique_key='date'
) }}

select
    date(order_date) as date,
    sum(order_total) as total_sales,
    count(distinct customer_id) as unique_customers
from {{ ref('stg_orders') }}

{% if is_incremental() %}
    where order_date > (select max(date) from {{ this }})
{% endif %}

group by 1

Melhores práticas

1. Estruture em camadas

• Staging: Limpeza e padronização básica
• Intermediate: Joins e transformações complexas
• Marts: Modelos finais para análise

2. Use nomenclatura consistente

• Staging: stg_
• Intermediate: int_
• Marts: nomes descritivos

3. Documente tudo

version: 2

models:
  - name: customer_lifetime_value
    description: 'Análise de valor vitalício do cliente'
    columns:
      - name: customer_id
        description: 'ID único do cliente'
      - name: lifetime_value
        description: 'Valor total gasto pelo cliente'
        tests:
          - not_null

4. Use seeds para dados de referência

-- seeds/country_codes.csv
country_code,country_name
US,United States
BR,Brazil
CA,Canada

Integração com ferramentas de BI

Os modelos dbt podem ser conectados diretamente a ferramentas como:

• Looker
• Tableau
• Power BI
• Metabase

dbt Cloud vs dbt Core

dbt Core (gratuito):

• Ferramenta de linha de comando
• Requer configuração manual
• Ideal para desenvolvedores

dbt Cloud (pago):

• Interface web
• Scheduler integrado
• IDE web
• Colaboração em equipe

Monitoramento e alertas

Configure alertas para falhas nos modelos:

-- models/marts/schema.yml
version: 2

models:
  - name: customer_lifetime_value
    tests:
      - dbt_utils.expression_is_true:
          expression: 'lifetime_value >= 0'
      - dbt_utils.recency:
          datepart: day
          field: last_order_date
          interval: 30

Conclusão

O dbt revolucionou a forma como fazemos transformação de dados, trazendo práticas de engenharia de software para o mundo dos dados. Com ele, você pode:

• Criar pipelines de dados mais confiáveis
• Colaborar efetivamente em equipe
• Documentar e testar suas transformações
• Manter seu código organizado e versionado

Se você está começando na área de dados ou quer modernizar seus processos de transformação, o dbt é uma ferramenta essencial para dominar. Comece com um projeto simples e vá expandindo conforme ganha experiência.

Próximos passos:

1. Instale o dbt em seu ambiente
2. Conecte com seu data warehouse
3. Crie seu primeiro modelo
4. Explore a documentação oficial do dbt
5. Participe da comunidade dbt no Slack