dbt: Modelos, Tests, Macros y Materializaciones
Aprende dbt para transformaciones de datos: modelos, tests, macros, materializaciones, seeds, snapshots y patrones de producción.
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.
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ón | Coste de build | Frescura de datos | Ideal para |
|---|---|---|---|
view | ~cero | Siempre actual | Staging, datos que cambian rápido |
table | Rebuild completo por run | Por ejecución | Dimensiones, marts pequeños |
incremental | Solo el delta | Por ejecución | Facts grandes, tablas de eventos |
ephemeral | Inlineada 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_devoanalytics_dev, prod escribe enanalytics— mismo código, aislado por los targets deprofiles.yml. Los desarrolladores nunca tocan datos de prod. dbt builden CI en cada PR. Constate: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_expectationsy 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 generateproduce 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 freshnessfalla 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_, intermediateint_, factsfct_, dimensionsdim_ - Testea cada modelo — como mínimo
uniqueynot_nullen las primary keys - Usa materialización incremental para tablas de hechos grandes — evita rebuilds completos
- Usa
ephemeralpara modelos intermedios pequeños — ahorra almacenamiento - Documenta cada modelo y columna en
schema.yml—dbt docs servegenera 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: trueen 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 buildde prod, tu CI era decorativo. Corredbt 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
- Proyecto dbt de ejemplo en GitHub — mini proyecto ejecutable con modelos, tests, macros, seeds y snapshots
- Documentación oficial de dbt
- Guía Completa de Arquitectura de Pipelines de Datos
- Guía Completa de Calidad de Datos
- Receta de transformaciones de modelos dbt
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.
Recursos Relacionados
Pipelines de Datos: Batch, Streaming, Lambda y Kappa
Diseñá pipelines de datos batch y streaming: código funcional con Airflow, Flink y dbt, diferencias entre Lambda y Kappa, y tabla para elegir ETL o ELT.
GuideApache Airflow: DAGs, Operadores y Scheduling
Domina Apache Airflow: DAGs, operadores, sensores, XCom, scheduling, backfilling, connections, variables y patrones de producción para pipelines.
GuideGuía de Calidad de Datos: Validación, Profiling, Monitoreo
Domina la calidad de datos: frameworks de validación, profiling, schemas, detección de anomalías y checks en pipelines con Great Expectations, Pandera y Soda.
RecipeTransformar datos en el warehouse con dbt
Cómo usar dbt para transformaciones de datos en SQL con modelos, tests, materializaciones, macros y carga incremental en un data warehouse.
DocPlantilla de Documento de Diseño de Data Pipeline
Una plantilla para documentar sources, transforms, sinks, scheduling, error handling y monitoring de data pipelines con schema definitions.
GuideGuía Completa de Optimización de Consultas SQL
Detecta y corrige consultas SQL lentas: lee planes EXPLAIN, indexa bien, elimina consultas N+1 y aplica particionamiento, pooling y caché en PostgreSQL y MySQL.