Dbt Print Macro Bug: Inconsistent Output In Core Vs Fusion

Alex Johnson

-Oct 7, 2025

Dbt Print Macro Bug: Inconsistent Output In Core Vs Fusion

Hey guys, let's dive into a peculiar bug we've encountered with the print macro in dbt (data build tool). Specifically, we're seeing inconsistent output when using the print macro between dbt Core and dbt Fusion. It's a bit of a head-scratcher, but let's break it down and see what's going on.

The Curious Case of the Inconsistent `print` Macro

The print macro in dbt is a handy tool for debugging and displaying information during your dbt runs. It allows you to output values, messages, and other useful tidbits to the console. However, a bug has surfaced where dbt Fusion, a newer iteration of dbt, wraps the output of the print macro in single quotes, while dbt Core does not. This inconsistency can lead to confusion and potential issues when relying on the output for further processing or analysis. This article helps you understand the issue, reproduce it, and hopefully, see a fix in future releases.

What's the Fuss About Quotes?

You might be thinking, "What's the big deal about a couple of quotes?" Well, in the world of programming and data manipulation, those seemingly insignificant characters can make a world of difference. Extra quotes can break scripts, cause parsing errors, and generally throw a wrench in your workflow. When you expect clean, unquoted output and you get quoted output, you need to adjust how you handle it. This deviation from expected behavior makes your code less portable and harder to maintain. It’s a bit like expecting a perfectly round ball and getting one with a slight bump – it still rolls, but not quite as smoothly.

dbt Core vs. dbt Fusion: A Tale of Two Outputs

The core of the issue lies in the different ways dbt Core and dbt Fusion handle the output of the print macro. dbt Core, the original and widely adopted version, outputs the value passed to the print macro as is, without any modifications. This is the expected behavior for most users. dbt Fusion, on the other hand, unexpectedly wraps the output in single quotes. This difference in behavior can be quite jarring, especially if you're transitioning from dbt Core to dbt Fusion or using both in your development workflow. It also means that outputs you were relying on might suddenly be formatted differently, leading to errors if downstream systems don't expect those single quotes.

Diving Deeper: Reproducing the Bug

Okay, enough talk, let's get our hands dirty and reproduce this bug ourselves. The good news is, it's pretty straightforward to replicate. By following these simple steps, you can see the inconsistent output firsthand.

Setting the Stage: Creating a dbt Macro

First, we need to create a dbt macro file. Macros in dbt are reusable snippets of SQL or Jinja code. They are a powerful way to avoid repetition and make your dbt projects more modular and maintainable. In this case, we'll create a simple macro that uses the print function to output a string. Follow these steps:

Create a new file named test_print.sql inside your macros directory within your dbt project. If you don't have a macros directory, create one.
Add the following code to the test_print.sql file:
```
{% macro test_print() %}
    {% set x = "Hello, World!" %}
    {{- print(x) -}}
{% endmacro %}
```
Let's break down this code snippet:
- {% macro test_print() %}: This line defines a new macro named test_print. The parentheses indicate that it doesn't take any arguments.
- {% set x = "Hello, World!" %}: This line sets a variable named x to the string value "Hello, World!".
- {{- print(x) -}}: This is the key line. It calls the print macro, passing the value of the x variable as an argument. The - characters around the print function are used to strip any leading or trailing whitespace from the output.
- {% endmacro %}: This line marks the end of the macro definition.

Running the Macro: dbt Core vs. dbt Fusion

Now that we have our macro, let's run it using both dbt Core and dbt Fusion and observe the output. We'll use the run-operation command, which allows us to execute macros directly from the command line.

Open your terminal and navigate to your dbt project directory.
Run the following command to execute the macro using dbt Core:
```
dbt --quiet run-operation test_print > dbt_print.txt
```
This command does the following:
- dbt: Invokes the dbt command-line interface.
- --quiet: Suppresses the verbose output, making it easier to see just the printed value.
- run-operation: Specifies that we want to run a macro.
- test_print: The name of the macro to execute.
- > dbt_print.txt: Redirects the output of the command to a file named dbt_print.txt.
Next, run the same macro using dbt Fusion:
```
dbtf --quiet run-operation test_print > dbtf_print.txt
```
This command is identical to the previous one, except it uses dbtf to invoke the dbt Fusion command-line interface.

Observing the Results: A Tale of Two Files

Now that we've run the macro with both dbt Core and dbt Fusion, let's examine the output files and see the discrepancy for ourselves.

Open the dbt_print.txt file. You should see the following content:
```
Hello, World!
```
As expected, dbt Core outputs the string "Hello, World!" without any additional quotes.
Now, open the dbtf_print.txt file. You should see the following content:
```
'Hello, World!'
```
Here's the bug in action! dbt Fusion wraps the output in single quotes, which is inconsistent with dbt Core and potentially problematic.

Expected Behavior: Consistency is Key

The expected behavior of the print macro, regardless of whether you're using dbt Core or dbt Fusion, should be consistent. The output should be the raw value passed to the macro, without any additional formatting or characters. In this case, we expect the output of {{ print(x) }} to be the value of x, which is "Hello, World!", and nothing else. This consistency is crucial for predictability and avoids unexpected issues in downstream processes that consume the output.

Why This Matters: Real-World Implications

This seemingly small inconsistency can have significant implications in real-world dbt projects. Imagine you're using the print macro to output values that are then used in other parts of your dbt project or in external systems. If dbt Fusion unexpectedly adds quotes to the output, it can break those dependencies and lead to errors. This can be particularly problematic in automated workflows where you're not manually inspecting the output of the print macro.

For example, you might be using the print macro to output a list of IDs that are then used in a subsequent SQL query. If dbt Fusion adds quotes around those IDs, the query will likely fail because it will be looking for string values instead of numeric IDs. Similarly, if you're using the print macro to output data that is consumed by an external API, the unexpected quotes can cause parsing errors and prevent the API from functioning correctly.

Potential Causes and Workarounds

While the exact cause of this bug is not publicly documented, we can speculate on some potential reasons. It's possible that dbt Fusion's internal implementation of the print macro differs slightly from dbt Core's, leading to the unexpected quoting. Another possibility is that dbt Fusion has a different default configuration that affects the output formatting of the print macro.

Workarounds: Dealing with the Quotes

In the meantime, while we wait for a fix in dbt Fusion, there are a few workarounds you can use to mitigate the issue:

String Manipulation: If you need to use the output of the print macro in dbt Fusion, you can use Jinja string manipulation functions to remove the quotes. For example, you could use the replace function to replace the single quotes with empty strings:
```
{% set quoted_string = print(x) %}
{% set unquoted_string = quoted_string.replace("'", "") %}
{{ unquoted_string }}
```
This workaround adds complexity to your code and makes it less readable. This approach might be a viable temporary fix, but it adds extra complexity to your dbt code. You'll need to remember to use this string manipulation whenever you're working with the output of print in dbt Fusion, which can be error-prone.
Avoid print in Fusion: The simplest workaround is to avoid using the print macro in dbt Fusion altogether. If you need to debug or output values, you can use alternative methods, such as logging to a file or using a debugger. However, this limits your ability to use the print macro, which is a convenient tool for quick debugging.

This option might be the most straightforward in the short term, but it means you're missing out on the convenience of the print macro when working with dbt Fusion. It also might not be feasible if you have existing code that heavily relies on print.
Conditional Logic: You can use conditional logic to execute different code paths depending on whether you're running dbt Core or dbt Fusion. This allows you to use the print macro in dbt Core and a different method in dbt Fusion. This involves checking the dbt version and adjusting your code accordingly.
```
{% if target.name == 'dbt_core' %}
    {{ print(x) }}
{% else %}
    {# Alternative method for dbt Fusion #}
    {{ log(x) }}
{% endif %}
```
This workaround is more complex but allows you to maintain compatibility with both dbt Core and dbt Fusion. This solution gives you the most flexibility but also adds the most complexity to your dbt project. You'll need to be careful when implementing this approach to avoid introducing new bugs or making your code harder to understand.

Conclusion: A Bug to Be Squashed

The inconsistent output of the print macro between dbt Core and dbt Fusion is a bug that needs to be addressed. While there are workarounds available, they add complexity and reduce the convenience of using the print macro. We hope that the dbt Labs team will address this issue in a future release of dbt Fusion, ensuring consistency and predictability across all dbt platforms.

For now, understanding the issue and its potential workarounds is key to navigating this inconsistency. Whether you choose to manipulate the output strings, avoid using print in Fusion, or implement conditional logic, the goal is to maintain the integrity of your dbt projects and prevent unexpected errors. Remember, those little quotes can have a big impact, so stay vigilant and code on!

For more information about dbt and its macros, you can check the official dbt documentation. Click here to visit the dbt Labs website to learn more about dbt Core and dbt Fusion.