Built-in Macros in dbt: What They Are and How They Work

In dbt, built-in macros are pre-written reusable code snippets that help automate common tasks in your data transformations. They simplify writing SQL by providing ready-made functions you can call inside your models or other macros.

How It Works

Think of built-in macros in dbt like handy kitchen tools in a cooking set. Instead of chopping vegetables by hand every time, you use a pre-made tool that does it quickly and consistently. Similarly, dbt provides built-in macros as ready-made pieces of code that perform common tasks, so you don't have to write the same SQL repeatedly.

These macros are written in Jinja, a templating language, and can be called inside your dbt models or other macros. When dbt runs, it replaces the macro calls with the actual SQL code they generate. This makes your project cleaner, easier to maintain, and less error-prone.

Example

This example shows how to use the built-in macro ref(), which helps you refer to other models safely.

jinja

{{ ref('my_model') }}

Output

"my_schema"."my_model"

When to Use

Use built-in macros whenever you want to simplify your SQL code or follow best practices without writing complex logic yourself. For example, use ref() to reference other models, config() to set model configurations, or adapter.get_relation() to get metadata about tables.

They are especially helpful in large projects where consistency and maintainability are important. Instead of repeating code, you rely on these tested macros to reduce errors and speed up development.

Key Points

• Built-in macros are reusable code snippets provided by dbt.
• They are written in Jinja and generate SQL dynamically.
• Common macros include ref(), config(), and adapter-specific macros.
• Using them improves code clarity and reduces repetition.

Key Takeaways

Built-in macros in dbt are pre-made reusable code snippets that simplify SQL writing.

They help automate common tasks like referencing models and setting configurations.

Using built-in macros improves project maintainability and reduces errors.

Macros are written in Jinja and expand into SQL during dbt runs.