dbt Labs dbt-Analytics-Engineering Exam With Confidence Using Practice Dumps

model_a contains an in-model config explicitly setting:

{{ config(materialized = "view") }}

In dbt, in-model config overrides project-level config, including folder-level defaults. Even though the staging/ folder is configured as:

staging:

+materialized: ephemeral

…this does not apply because the in-file config has higher precedence.

So model_a is materialized as a view.

A view in dbt is not persisted as data; instead, it stores the SQL definition. When a downstream query selects from that view, the database executes the underlying SQL at query time. As a result:

Queries run slower than selecting from a table, because the underlying computation happens each time.

But the data is always up to date, because views read directly from the current underlying tables.

This matches Option C.

Why the other options are wrong

A & D describe table behavior (faster queries, data only as fresh as last run). model_a is not materialized as a table.

B is incorrect because views are fully queryable; no error occurs.

In dbt, Jinja runs at compile time and operates only on Python objects that exist in the Jinja context (variables, lists, dictionaries, etc.). The tasks inside your with clause:

with tasks as (

select * from {{ ref('stg_tasks') }}

)

defines a SQL CTE named tasks, not a Jinja variable. Jinja cannot iterate over a SQL CTE; it can only loop over a Python iterable that has been created or passed into the template. Because there is no Jinja variable named tasks defined with something like:

{% set tasks = ['task_a', 'task_b', 'task_c'] %}

the for task in tasks loop has nothing to iterate over. As a result, the entire loop body is effectively skipped during compilation, and the compiled SQL only contains:

select

user_id,

with no generated case when expressions.

Option A is incorrect because loop.last is only needed for formatting (e.g., commas), not for the loop to render. Option B is wrong because Jinja control structures correctly use {% %}, while {{ }} is for output. Option D is irrelevant to compilation; missing columns would cause a runtime database error, not an empty compiled block.

Therefore, the problem is that no Jinja variable tasks was defined, making C the correct answer.

The behavior described—dbt running the orders model as a view despite being explicitly configured as a table—indicates that dbt is not correctly detecting or applying the model-level configuration during compilation. dbt relies heavily on the target-path directory to write compiled SQL, manifest files, and run artifacts. If the target-path is misconfigured, pointing to a location that dbt does not handle correctly or that overlaps with another folder used internally, dbt may fail to load the correct configuration from the merged project settings.

When dbt cannot locate the compiled configuration for a model, it defaults to its standard materialization type, which is view. This explains why the logs show:

“Finished running 1 view model”

even though the dbt_project.yml clearly declares:

materialized: table.

Additionally, the logs indicate no warnings or parsing errors, meaning dbt ran successfully but with incorrect settings—another indicator of configuration metadata being overridden or misplaced due to an incorrect target-path.

By resolving the target-path issue, dbt will successfully load the model configuration and materialize the orders model as a table as intended.