StackPractices
advanced Por Mathias Paulenko

dbt: Modelos, Tests, Macros y Materializaciones

Aprende dbt para transformaciones de datos: modelos, tests, macros, materializaciones, seeds, snapshots y patrones de producción.

Temas: data

Introducción

dbt (data build tool) transforma los datos dentro de tu warehouse usando SQL puro. Los datos crudos llegan primero al warehouse (la parte E-L de ELT) y luego dbt se encarga de la T: escribes sentencias SELECT como modelos, dbt los compila en tablas y vistas, resuelve las dependencias y ejecuta todo en el orden correcto.

También trae disciplina de ingeniería de software a la analítica: control de versiones, tests automatizados, entornos, documentación y código reutilizable — todo lo que nunca tuvieron los scripts SQL sueltos en una carpeta compartida. El trade-off es real, eso sí: dbt solo transforma. No ingiere datos (eso es Fivetran, Airbyte o tus propios loaders) y tampoco orquesta el pipeline completo (eso es Airflow, Dagster o los schedules de dbt Cloud).

dbt viene en dos sabores. dbt Core es el CLI open source que instalas con pip y ejecutas tú mismo. dbt Cloud es la plataforma gestionada construida encima — IDE en el navegador, scheduling de jobs, CI y hosting de la documentación. Todo lo de esta guía funciona en ambos; el código es idéntico, solo cambia el runtime.

Conceptos Clave

Antes de tocar código, ancla el vocabulario. Todo proyecto dbt se construye con las mismas primitivas:

Model: Una sentencia SQL SELECT que dbt compila en una tabla o vista
Source: Una referencia a una tabla del warehouse de la que dbt lee
Seed: Un CSV cargado al warehouse como tabla (para datos de referencia estáticos)
Snapshot: Slowly Changing Dimension tipo 2 — sigue la historia de filas que cambian
Test: Una aserción SQL que devuelve filas que no deberían existir (test que falla)
Macro: Un bloque Jinja reutilizable para generar SQL
Materialization: Cómo se almacena un modelo (view, table, incremental, ephemeral)
Ref: Una función para referenciar otro modelo, construyendo el grafo de dependencias
Schema.yml: Archivo de configuración que define sources, modelos, tests y documentación

Dos de ellas hacen el trabajo pesado. ref() no es solo un resolvedor de nombres — cada llamada a ref() es una arista del DAG (grafo acíclico dirigido) que dbt construye a partir de tus modelos. El DAG es lo que permite a dbt ejecutar los modelos en el orden correcto, paralelizar los hermanos y documentar el linaje. source() es el equivalente para las tablas crudas: se declara una vez en YAML y además alimenta el monitoreo de frescura.

DAG de dbt: los sources crudos alimentan los modelos staging, que se unen en un modelo intermedio y aterrizan en marts orientados al negocio.

Estructura del Proyecto

Los proyectos dbt siguen una convención en capas que mantiene limpios los datos crudos, las transformaciones y la lógica de negocio:

dbt_project/
├── dbt_project.yml          # Configuración del proyecto
├── profiles.yml             # Conexión al warehouse (normalmente en ~/.dbt/)
├── models/
│   ├── staging/             # Crudo → limpio (1:1 con tablas fuente)
│   │   ├── stg_orders.sql
│   │   ├── stg_customers.sql
│   │   ├── sources.yml
│   │   └── schema.yml
│   ├── intermediate/        # Joins y transformaciones sobre staging
│   │   ├── int_orders_enriched.sql
│   │   └── schema.yml
│   ├── marts/               # Modelos orientados al negocio
│   │   ├── core/
│   │   │   ├── fct_orders.sql
│   │   │   ├── dim_customers.sql
│   │   │   └── schema.yml
│   │   └── finance/
│   │       ├── fct_revenue.sql
│   │       └── schema.yml
├── macros/                  # Macros Jinja reutilizables
│   ├── cents_to_dollars.sql
│   └── date_spine.sql
├── seeds/                   # CSVs cargados como tablas
│   └── country_codes.csv
├── snapshots/               # Snapshots SCD tipo 2
│   └── snap_customers.sql
├── tests/                   # Tests de datos personalizados
│   └── assert_positive_revenue.sql
├── analyses/                # Análisis SQL puntuales (no materializados)
└── packages.yml             # Paquetes dbt externos

Dos archivos lo controlan todo. dbt_project.yml define el nombre del proyecto, las rutas y los defaults que aplicas por directorio — fijar +materialized y +schema a nivel de carpeta evita repetir la configuración en cada archivo:

# dbt_project.yml
name: analytics
version: '1.0.0'
profile: analytics

model-paths: ["models"]
seed-paths: ["seeds"]
macro-paths: ["macros"]
test-paths: ["tests"]
target-path: "target"

models:
  analytics:
    staging:
      +materialized: view
      +schema: staging
    intermediate:
      +schema: intermediate
    marts:
      +materialized: table
      +schema: marts

profiles.yml guarda la conexión al warehouse. Vive en ~/.dbt/ (fuera del repo) para que las credenciales nunca lleguen al control de versiones. El target elige qué entorno estás construyendo:

# ~/.dbt/profiles.yml
analytics:
  target: dev
  outputs:
    dev:
      type: snowflake
      account: acme.us-east-1
      user: dbt_dev
      password: "{{ env_var('DBT_SNOWFLAKE_PASSWORD') }}"
      role: transformer
      warehouse: compute_wh
      database: analytics_dev
      schema: dbt_dev
      threads: 4
    prod:
      type: snowflake
      account: acme.us-east-1
      user: dbt_prod
      password: "{{ env_var('DBT_SNOWFLAKE_PASSWORD') }}"
      role: transformer
      warehouse: compute_wh
      database: analytics_prod
      schema: analytics
      threads: 8

Modelos

Un modelo es un único archivo .sql con una sentencia SELECT — nada de DDL ni stored procedures, solo una consulta que dbt envuelve con el CREATE adecuado. La convención en capas es donde los proyectos se salvan o se hunden:

  • Staging (stg_): un modelo por tabla fuente. Renombrar columnas, casteo de tipos, trim de strings — y nada más. Sin joins, sin lógica de negocio.
  • Intermediate (int_): joins y transformaciones complejas entre staging y marts. Donde ocurre el trabajo duro.
  • Marts (fct_ / dim_): lo que analistas y dashboards consultan de verdad. Facts para eventos y medidas, dimensions para entidades.

Modelos staging

-- models/staging/stg_orders.sql — Limpiar datos crudos
SELECT
    order_id,
    customer_id,
    CAST(created_at AS TIMESTAMP) AS created_at,
    CAST(updated_at AS TIMESTAMP) AS updated_at,
    CAST(subtotal AS DECIMAL(10, 2)) AS subtotal,
    CAST(tax AS DECIMAL(10, 2)) AS tax,
    CAST(shipping AS DECIMAL(10, 2)) AS shipping,
    TRIM(status) AS status,
    TRIM(currency) AS currency
FROM {{ source('raw', 'orders') }}
WHERE order_id IS NOT NULL

La llamada {{ source('raw', 'orders') }} necesita un sources.yml que declare qué significa “raw” — y opcionalmente reglas de frescura que permiten a dbt avisar cuando los loaders de origen se retrasan:

# models/staging/sources.yml
version: 2

sources:
  - name: raw
    database: raw
    schema: public
    tables:
      - name: orders
        loaded_at_field: _loaded_at
        freshness:
          warn_after: { count: 12, period: hour }
          error_after: { count: 24, period: hour }
      - name: customers
      - name: payments

Modelos intermediate

-- models/intermediate/int_orders_enriched.sql — Join de modelos staging
SELECT
    o.order_id,
    o.customer_id,
    o.created_at,
    o.status,
    o.subtotal + o.tax + o.shipping AS total_amount,
    c.country,
    c.customer_tier,
    CASE
        WHEN c.customer_tier = 'premium' THEN 0.10
        WHEN c.customer_tier = 'gold' THEN 0.05
        ELSE 0.00
    END AS discount_rate
FROM {{ ref('stg_orders') }} o
LEFT JOIN {{ ref('stg_customers') }} c
    ON o.customer_id = c.customer_id

Modelos mart (fact y dimension)

-- models/marts/core/dim_customers.sql — Tabla de dimensión
{{ config(materialized='table') }}

SELECT
    customer_id,
    first_name,
    last_name,
    email,
    country,
    customer_tier,
    created_at,
    COALESCE(first_order_date, '2099-12-31') AS first_order_date
FROM {{ ref('stg_customers') }}
LEFT JOIN (
    SELECT
        customer_id,
        MIN(created_at) AS first_order_date
    FROM {{ ref('stg_orders') }}
    GROUP BY 1
) first_orders USING (customer_id)
-- models/marts/core/fct_orders.sql — Tabla de hechos
{{ config(materialized='incremental', unique_key='order_id') }}

SELECT
    o.order_id,
    o.customer_id,
    o.created_at,
    o.status,
    o.total_amount,
    o.discount_rate,
    ROUND(o.total_amount * (1 - o.discount_rate), 2) AS net_amount,
    d.country,
    d.customer_tier
FROM {{ ref('int_orders_enriched') }} o
LEFT JOIN {{ ref('dim_customers') }} d
    ON o.customer_id = d.customer_id
{% if is_incremental() %}
WHERE o.created_at > (SELECT MAX(created_at) FROM {{ this }})
{% endif %}

El guard is_incremental() es la parte sutil: en la primera ejecución {{ this }} todavía no existe, así que el WHERE se salta y se carga todo el histórico. En las ejecuciones siguientes solo se añaden o combinan las filas nuevas. Para un modelo dbt ejecutable de principio a fin, mira la receta de transformaciones de modelos dbt.

Materializaciones

La materialización controla cómo aterriza un modelo en el warehouse. Elegir mal es la causa más común de proyectos dbt lentos:

-- View (default): SQL compilado como vista en el warehouse
{{ config(materialized='view') }}

-- Table: materializado como tabla física (reconstruida en cada run)
{{ config(materialized='table') }}

-- Incremental: solo inserta filas nuevas desde la última ejecución
{{ config(
    materialized='incremental',
    unique_key='order_id',
    incremental_strategy='merge'  -- o 'append', 'delete+insert'
) }}

-- Ephemeral: no se materializa; se inlinea como CTE en los modelos dependientes
{{ config(materialized='ephemeral') }}
MaterializaciónCoste de buildFrescura de datosIdeal para
view~ceroSiempre actualStaging, datos que cambian rápido
tableRebuild completo por runPor ejecuciónDimensiones, marts pequeños
incrementalSolo el deltaPor ejecuciónFacts grandes, tablas de eventos
ephemeralInlineada en dependientes—Transformaciones pequeñas reutilizadas

Estrategias incremental

-- Append: la más rápida, pero duplica si la fuente tiene updates
{{ config(materialized='incremental', incremental_strategy='append') }}
SELECT * FROM {{ source('raw', 'events') }}
{% if is_incremental() %}
WHERE event_time > (SELECT MAX(event_time) FROM {{ this }})
{% endif %}
-- Merge: upsert basado en unique_key (sin duplicados)
{{ config(materialized='incremental', unique_key='order_id', incremental_strategy='merge') }}
SELECT * FROM {{ ref('stg_orders') }}
{% if is_incremental() %}
WHERE created_at > (SELECT MAX(created_at) FROM {{ this }})
{% endif %}
-- Delete+insert: borra la partición y luego inserta los datos frescos
{{ config(
    materialized='incremental',
    incremental_strategy='delete+insert',
    partition_by={'field': 'created_at', 'data_type': 'date'}
) }}
SELECT * FROM {{ ref('stg_orders') }}
{% if is_incremental() %}
WHERE created_at >= DATE_SUB(CURRENT_DATE(), INTERVAL 1 DAY)
{% endif %}

Dos trampas que conviene conocer pronto. ephemeral empuja el cómputo hacia cada modelo dependiente — bien para lógica pequeña, doloroso cuando un modelo ephemeral envuelve un join pesado que luego se compila dentro de diez consultas (y algunos warehouses topan con límites de CTEs). Y los modelos incremental se desactualizan en silencio cuando cambia el esquema de la fuente; reconstrúyelos periódicamente con dbt run --full-refresh tras cualquier cambio de origen.

Tests

Los tests de dbt son consultas SQL que deberían devolver cero filas. Si un test devuelve algo, falla. Hay dos tipos: los genéricos, declarados en YAML sobre columnas, y los singulares, escritos como archivos SQL independientes.

Tests de esquema

# models/staging/schema.yml
version: 2

models:
  - name: stg_orders
    description: Orders limpias y tipadas desde la fuente cruda
    columns:
      - name: order_id
        tests:
          - unique
          - not_null
      - name: customer_id
        tests:
          - not_null
          - relationships:
              to: ref('stg_customers')
              field: customer_id
      - name: status
        tests:
          - accepted_values:
              values: ['pending', 'processing', 'shipped', 'completed', 'cancelled']
      - name: total_amount
        tests:
          - dbt_utils.expression_is_true:
              expression: ">= 0"

  - name: stg_customers
    columns:
      - name: customer_id
        tests:
          - unique
          - not_null
      - name: email
        tests:
          - not_null
          - unique

Los cuatro genéricos integrados (unique, not_null, accepted_values, relationships) cubren la mayoría de las necesidades; los paquetes dbt_utils y dbt_expectations añaden decenas más, como comprobaciones de rango:

      - name: discount_rate
        tests:
          - dbt_expectations.expect_column_values_to_be_between:
              min_value: 0
              max_value: 1

Tests singulares personalizados

-- tests/assert_positive_revenue.sql — Test personalizado
SELECT
    order_id,
    total_amount
FROM {{ ref('fct_orders') }}
WHERE total_amount < 0
-- Si devuelve filas, el test falla
-- tests/assert_no_duplicate_daily_revenue.sql
SELECT
    order_date,
    region,
    COUNT(*) as duplicate_count
FROM {{ ref('fct_daily_revenue') }}
GROUP BY 1, 2
HAVING COUNT(*) > 1

Dos configuraciones convierten los tests en algo de producción en lugar de decorativo. +store_failures: true materializa las filas que fallan para poder inspeccionarlas directamente. +severity: warn evita que un test no crítico bloquee un deploy:

# dbt_project.yml
tests:
  +store_failures: true
  +severity: warn

Los tests y la observabilidad son dos caras de la misma moneda — para el marco de calidad completo (métricas, SLAs, monitoreo) mira la Guía Completa de Calidad de Datos.

Macros

Las macros son funciones Jinja que generan SQL — la vía DRY para patrones que de otro modo copiarías y pegarías.

Transformaciones reutilizables

-- macros/cents_to_dollars.sql
{% macro cents_to_dollars(column_name) %}
    ROUND({{ column_name }} / 100.0, 2)
{% endmacro %}

-- Uso en un modelo
SELECT
    order_id,
    {{ cents_to_dollars('subtotal_cents') }} AS subtotal,
    {{ cents_to_dollars('tax_cents') }} AS tax
FROM {{ source('raw', 'orders') }}

Macro de date spine

-- macros/date_spine.sql
{% macro date_spine(start_date, end_date, datepart='day') %}
    WITH RECURSIVE date_spine AS (
        SELECT DATE('{{ start_date }}') AS date_day
        UNION ALL
        SELECT DATE_ADD(date_day, INTERVAL 1 {{ datepart }})
        FROM date_spine
        WHERE date_day < DATE('{{ end_date }}')
    )
    SELECT date_day FROM date_spine
{% endmacro %}

-- Uso
SELECT * FROM ({{ date_spine('2026-01-01', '2026-12-31') }}) AS dates

Macro de división segura

-- macros/safe_divide.sql
{% macro safe_divide(numerator, denominator, default=0) %}
    CASE
        WHEN {{ denominator }} = 0 OR {{ denominator }} IS NULL THEN {{ default }}
        ELSE {{ numerator }} / {{ denominator }}
    END
{% endmacro %}

-- Uso
SELECT
    region,
    {{ safe_divide('revenue', 'order_count', 'NULL') }} AS avg_order_value
FROM {{ ref('fct_daily_revenue') }}

Cuando una macro necesita funcionar en varios warehouses, dbt incluye adapter.dispatch — resuelve la implementación específica del dialecto en tiempo de compilación, que es justo cómo dbt_utils soporta todos los adaptadores. Úsalo antes de escribir lógica IF warehouse == 'snowflake' en tus macros.

Seeds

Los seeds cargan archivos CSV en el warehouse como tablas normales con dbt seed. Sirven para datos de referencia pequeños y estáticos — códigos de país, tasas de impuestos, tablas de mapeo — que viven mejor en el control de versiones que en una tabla del warehouse mantenida a mano:

# seeds/country_codes.csv
country_code,country_name,region
US,United States,North America
CA,Canada,North America
UK,United Kingdom,Europe
DE,Germany,Europe
FR,France,Europe
JP,Japan,Asia
-- Uso en un modelo
SELECT
    o.order_id,
    c.country_name,
    c.region
FROM {{ ref('stg_orders') }} o
JOIN {{ ref('country_codes') }} c
    ON o.country_code = c.country_code

Mantén los seeds pequeños (unos cientos de filas, menos de ~1MB). Cualquier cosa más grande pertenece a un loader de verdad, no a un CSV commiteado en git.

Snapshots

Los snapshots implementan SCD tipo 2: cuando una fila de origen cambia, dbt cierra el registro actual e inserta uno nuevo, manteniendo las columnas dbt_valid_from / dbt_valid_to para poder consultar la historia:

-- snapshots/snap_customers.sql — Seguir los cambios de los datos de clientes
{% snapshot snap_customers %}

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

SELECT
    customer_id,
    first_name,
    last_name,
    email,
    customer_tier,
    updated_at
FROM {{ source('raw', 'customers') }}

{% endsnapshot %}
-- Consultar el historial del snapshot
SELECT
    customer_id,
    customer_tier,
    dbt_valid_from,
    dbt_valid_to,
    CASE WHEN dbt_valid_to IS NULL THEN 'current' ELSE 'historical' END AS record_status
FROM {{ ref('snap_customers') }}
WHERE customer_id = '12345'
ORDER BY dbt_valid_from

Existen dos estrategias. timestamp usa una columna updated_at de la fuente — fiable cuando el loader la mantiene. check hashea una lista de columnas y detecta cualquier cambio — el plan B cuando la fuente no tiene timestamp, al precio de hashear cada fila. Si una tabla es append-only (eventos, logs), no necesitas snapshot: la historia ya está ahí.

Plantillas Jinja

Jinja es lo que convierte el SQL en un lenguaje de programación dentro de dbt — condicionales, bucles, variables y acceso al contexto de ejecución:

-- Lógica condicional
{% if var('is_production', false) %}
    WHERE status = 'completed'
{% else %}
    WHERE status IN ('completed', 'pending')
{% endif %}
-- Bucles
{% set payment_methods = ['credit_card', 'bank_transfer', 'paypal'] %}
SELECT
    order_id,
    {% for method in payment_methods %}
        SUM(CASE WHEN payment_method = '{{ method }}' THEN amount ELSE 0 END)
            AS {{ method }}_amount
        {% if not loop.last %},{% endif %}
    {% endfor %}
FROM {{ ref('stg_payments') }}
GROUP BY 1
-- Variables (override en runtime: dbt run --vars '{"start_date": "2026-11-01"}')
{% set start_date = var('start_date', '2026-01-01') %}
WHERE created_at >= '{{ start_date }}'
-- Configuración sensible al entorno
{{ config(
    materialized='incremental',
    schema='analytics' if target.name == 'prod' else 'analytics_dev',
    tags=['prod'] if target.name == 'prod' else ['dev'],
) }}

Contexto útil en tiempo de compilación: target.name para ramificar por entorno, var() para parámetros de ejecución con defaults, env_var() para secretos (nunca hardcodees credenciales — ni siquiera en macros) y run_started_at para lógica basada en tiempo.

Ejecución de dbt en Desarrollo y CI

Los comandos principales son pocos; la sintaxis de selección es donde vive la productividad diaria:

dbt deps                    # Instala las dependencias de packages.yml
dbt seed                    # Carga los seeds CSV al warehouse
dbt run                     # Construye todos los modelos
dbt test                    # Ejecuta todos los tests
dbt build                   # Run + test en orden del DAG (recomendado)
dbt snapshot                # Ejecuta los snapshots SCD tipo 2
dbt docs generate           # Genera el sitio de documentación
dbt docs serve              # Sirve los docs con el grafo de linaje
dbt source freshness        # Comprueba la frescura de las tablas crudas
dbt run --full-refresh      # Reconstruye modelos incremental desde cero

La selección de nodos usa + para recorrer el grafo — model+ significa “este modelo y todo lo que depende de él”, +model significa “este modelo y todo lo que necesita”:

dbt run --select stg_orders+        # stg_orders y todos sus dependientes
dbt run --select +fct_orders        # fct_orders y todos sus padres
dbt run --select tag:staging        # Modelos con tag 'staging'
dbt test --select marts             # Tests del directorio marts

Para CI, state:modified+ con --defer es el patrón estándar (“Slim CI”): dbt compara el manifest de tu PR con los artefactos de producción y construye solo lo que cambió más sus hijos — minutos en lugar de horas:

dbt build --select state:modified+ --defer --state prod_artifacts/

Patrones de Producción

Algunos patrones separan los proyectos de hobby de los despliegues dbt fiables:

  • Separación de esquemas por target. Los builds de dev escriben en dbt_dev o analytics_dev, prod escribe en analytics — mismo código, aislado por los targets de profiles.yml. Los desarrolladores nunca tocan datos de prod.
  • dbt build en CI en cada PR. Con state:modified+ solo se construye lo que cambió, cazando SQL roto y tests que fallan antes del merge.
  • Schedular solo el paso T. dbt transforma dentro del warehouse; la ingesta y la orquestación entre sistemas quedan arriba. Planifica las ejecuciones con jobs de dbt Cloud, Apache Airflow (DbtCloudJobOperator o Cosmos) o un simple cron sobre dbt Core.
  • Paquetes en lugar de reinventar. dbt_utils, dbt_expectations y los paquetes específicos por adaptador resuelven la mayoría de las macros que escribirías tú:
# packages.yml
packages:
  - package: dbt-labs/dbt_utils
    version: 1.3.0
  - package: calogica/dbt_expectations
    version: 0.10.0
  • Documentación como artefacto de deploy. dbt docs generate produce un sitio navegable con el grafo de linaje — publícalo en S3/Netlify junto a tus datos; no lo dejes en un portátil.
  • Frescura como monitoreo. Si dbt source freshness falla es un problema de la ingesta upstream, no de dbt — alerta de ello aparte de los tests.

Buenas Prácticas

  • Sigue el layering staging → intermediate → marts — cada capa tiene un propósito claro
  • Usa ref() para todas las referencias entre modelos — dbt construye el grafo automáticamente
  • Nombra los modelos staging stg_, intermediate int_, facts fct_, dimensions dim_
  • Testea cada modelo — como mínimo unique y not_null en las primary keys
  • Usa materialización incremental para tablas de hechos grandes — evita rebuilds completos
  • Usa ephemeral para modelos intermedios pequeños — ahorra almacenamiento
  • Documenta cada modelo y columna en schema.yml — dbt docs serve genera los docs
  • Usa macros para patrones SQL repetidos — principio DRY aplicado a SQL
  • Usa snapshots para SCD tipo 2 — sigue la historia de los datos que cambian
  • Activa +store_failures: true en los tests — consulta las filas que fallan para depurar
  • Usa --select state:modified+ en CI — testea solo lo que cambió
  • Versiona tu proyecto dbt con git — la misma estrategia de branching que el código de aplicación

Errores Comunes

  • No usar ref(): hardcodear nombres de tabla rompe el grafo de dependencias y el orden de materialización.
  • Abusar de table: las vistas son más baratas para modelos staging que cambian con frecuencia.
  • Sin tests en las primary keys: los IDs duplicados o nulos rompen los joins de abajo en silencio.
  • Incremental sin unique_key: la estrategia append crea duplicados cuando la fuente actualiza filas.
  • Lógica compleja en marts: la lógica de negocio va en los modelos intermediate; los marts deberían ser joins sencillos.
  • Sin el guard is_incremental(): sin él, los modelos incremental hacen rebuild completo en cada ejecución.
  • Testear solo en producción: si un modelo roto llega al dbt build de prod, tu CI era decorativo. Corre dbt build --select state:modified+ en cada PR.
  • SELECT * en los modelos staging: las columnas explícitas hacen visibles los cambios de esquema en lugar de tragar nuevas columnas en silencio.

See Also

Preguntas frecuentes

¿Qué es dbt?

dbt (data build tool) es una herramienta de transformación centrada en SQL. Escribes sentencias SELECT como modelos y dbt los compila en vistas/tablas dentro de tu warehouse, gestionando dependencias, tests y documentación.

¿Qué son las materializaciones?

Cómo almacena dbt un modelo en el warehouse. view crea una vista, table crea una tabla física (reconstruida en cada ejecución), incremental solo añade filas nuevas, y ephemeral inlinea el modelo como CTE en los modelos dependientes sin materializarlo.

¿Cuál es la diferencia entre sources y refs?

source() referencia una tabla cruda que ya existe en el warehouse antes de que dbt corra. ref() referencia otro modelo de dbt. ref() construye el grafo de dependencias — dbt sabe que tiene que ejecutar primero el modelo referenciado.

¿Qué son los tests de dbt?

Aserciones SQL que devuelven filas que no deberían existir. unique comprueba que no se repiten valores. not_null comprueba que no hay nulos. relationships comprueba la integridad referencial. Si un test devuelve alguna fila, falla.

¿Qué es un snapshot en dbt?

Una Slowly Changing Dimension tipo 2. dbt sigue los cambios de las filas de origen en el tiempo, manteniendo las columnas dbt_valid_from y dbt_valid_to. Así puedes consultar cómo era una fila en cualquier momento.

¿Cuál es la diferencia entre dbt Core y dbt Cloud?

dbt Core es el CLI open source — gratis, instalable con pip, ejecutable en cualquier sitio. dbt Cloud es el SaaS gestionado construido encima: IDE en el navegador, scheduling de jobs, integración con CI y hosting de la documentación. Los proyectos son portables entre ambos.

¿Cuándo conviene incremental en lugar de table?

Cuando el modelo es grande y mayormente append — tablas de eventos, facts de pedidos, logs — y un rebuild completo sería lento o caro. Si el modelo es pequeño o cambia a menudo, quédate con table; incremental añade complejidad y necesita --full-refresh periódicos para mantenerse honesto.

¿Cómo sabe dbt si mis datos de origen están frescos?

Mediante loaded_at_field y los umbrales de frescura en sources.yml. dbt source freshness compara el timestamp de carga de cada tabla cruda con tus límites warn_after/error_after — una comprobación ligera que caza loaders rotos antes de que los datos malos lleguen a los marts.