dbt-Analytics-Engineering Exam Dumps - dbt Labs Analytics Engineers Questions and Answers

The correct answers are B and E.

The dbt retry command was introduced to help developers quickly re-run only what failed in the prior dbt invocation. According to dbt documentation, dbt retry examines metadata from the previous execution, including the run results and the manifest.json, to determine which nodes failed. This aligns with Option E, as dbt uses the manifest to identify the models, tests, and other nodes that errored or were not executed successfully.

Option B is also correct because dbt retry works only when the previous run failed due to execution errors (e.g., a warehouse failure or a logic error in SQL). If the failure was due to a syntax error that prevented dbt from compiling, there will be no valid manifest produced, so retry cannot execute. Thus, dbt retry can only re-run models when the previous failure occurred after successful compilation.

Options A and C are incorrect because retry does not run all nodes nor does it automatically pick up exactly where an execution stopped — instead, it runs failed and downstream unbuilt nodes as determined by the manifest. Option D is also incorrect; retry uses the execution metadata, not selectors, to determine what should run.

Update int_order_items by replacing:

{{ source('tpch', 'orders') }} → {{ ref('stg_tpch_orders') }}

{{ source('tpch', 'lineitem') }} → {{ ref('stg_tpch_line_items') }}

In dbt’s recommended modeling pattern, sources should be referenced only in the staging layer. Downstream models (intermediate and mart/fact models) should reference staging models via ref(), not the raw source() directly. This keeps all raw-to-clean logic centralized in the staging layer and makes refactoring and documentation easier.

In the original DAG, int_order_items depends directly on tpch.orders and tpch.lineitem via source(), and staging models also depend on those same sources. That creates parallel paths from the sources and breaks the clean layered architecture.

By updating the int_order_items SQL to use:

from {{ ref('stg_tpch_orders') }}

join {{ ref('stg_tpch_line_items') }} ...

instead of:

from {{ source('tpch', 'orders') }}

join {{ source('tpch', 'lineitem') }} ...

you ensure that int_order_items sits entirely downstream of the staging layer. The new DAG becomes linear: sources → staging → intermediate (int_order_items) → any further marts. This improves modularity, reusability of cleaned logic, and makes the DAG easier to reason about and maintain.

The correct answer is B: Refer to a manifest and utilize the --defer and --state flags.

According to dbt’s official documentation, the --defer flag enables developers to defer the resolution of model references (ref(), source()) to an existing manifest—commonly the one generated from a production run. When this flag is used along with --state, dbt reads the prior project state and uses the already-built production models instead of rebuilding upstream dependencies. This is essential because production models are typically large and compute-intensive. By deferring to production artifacts, developers can test only the models they have modified, dramatically reducing warehouse costs and speeding up development cycles.

This approach is foundational to dbt’s recommended development workflow, especially when working with CI/CD or large DAGs. It preserves the integrity of the dependency graph while avoiding unnecessary recomputation.

Option A violates dbt best practices by removing dependency awareness. Option C is unnecessary operational overhead and does not integrate with dbt’s state management. Option D is incomplete because --state alone does not prevent upstream model execution—--defer is required to substitute those models with existing artifacts.

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.

In dbt, source freshness can be defined at the source level (affecting all tables) or overridden at the individual table level. When freshness is declared at the source root, dbt applies the freshness policy to every table within that source unless a specific table opts out. The official dbt documentation states that setting:

freshness: null

at the table level disables freshness checks for that specific table, even when the source itself defines default freshness rules. This is the only documented way to exclude an individual table from a source freshness policy.

Option B is incorrect because tables can override and disable freshness even when the parent source defines it. dbt’s configuration hierarchy supports overriding child-level settings on a per-resource basis.

Option C (loaded_at_field: null) does not disable freshness—it simply removes the loaded_at_field, which would cause dbt to error because a freshness check requires a timestamp field to operate.

Option D (error_after: null) only removes the error threshold but does not disable freshness. The table would still participate in freshness checks and could trigger warnings.

Thus, the correct and dbt-supported method to exclude a table from freshness is to explicitly set:

freshness: null

making A the correct answer.

For models not stored under finance:

✔ reporter and bi

For models inside the finance folder:

✔ finance, reporter, bi, and public

In dbt, grants configured at the root level apply to all models unless overridden by a more specific folder- or model-level configuration.

The root-level grant is:

+grants:

+select: ['reporter', 'bi']

This means all models by default are selectable by:

reporter

bi

Now the finance folder contains its own override:

finance:

+grants:

+select: ['finance']

When dbt merges grants, overrides do not replace the entire list—they add onto inherited grants unless explicitly cleared. Therefore, models inside the finance folder inherit the parent grants and add the finance grant.

So models under finance are accessible to:

finance

reporter

bi

and public (implicit default in most warehouses unless denied)

Models not inside finance use only the root grants:

reporter

bi

Thus the correct dropdown answers are:

reporter and bi

finance, reporter, bi, and public

The correct answer is C: Underlying data must be accessible on your data platform.

dbt does not perform data ingestion or data loading. Instead, dbt operates after raw data is already available in your warehouse. This means that before dbt can build any models—whether staging, intermediate, or mart-layer models—the underlying source data must already exist and be accessible in the connected data platform (Snowflake, BigQuery, Redshift, Databricks, etc.). dbt uses SQL to transform existing relations; therefore, if the data platform cannot access the underlying tables or external sources, model execution will fail.

Option A is incorrect because sources do not need to be defined before building models. Models can be built without using sources at all. Source definitions are optional metadata and lineage declarations, not prerequisites.

Option B is incorrect because service accounts are not required; dbt can connect through any credential mechanism supported by the warehouse (OAuth, user accounts, tokens, etc.).

Option D is incorrect because dbt itself performs transformations on raw data—cleaning raw data beforehand is not required; in fact, that is one of dbt’s main responsibilities.

Thus, the only true prerequisite is that the warehouse must contain accessible underlying data.

Check your terminal or log file for the output from the most recent dbt run.

Look for specific error messages associated with the models that failed.

3️⃣ Isolate the problem by dbt run --select model_name to run a single model and confirm whether the issue is localized to that model.

4️⃣ Use dbt run --select model_name+ to run the model and its downstream dependencies, ensuring that your fix works across the DAG.

Brief Explanation

First, you always inspect the latest run output (step 1).

Then, identify the exact failing models and error messages (step 2).

Next, you reproduce the issue on the individual model to be sure the fix works locally (step 3).

Finally, you re-run the model plus its downstream dependencies to validate the fix across the DAG (step 4).

Will always point to the latest version of the source schema

Correct Match: ✔ defer

Allows to use objects built in the target schema with any downstream tool

Correct Match: ✔ dbt clone

3️⃣ Allows to safely modify objects built in the target schema

Correct Match: ✔ defer

4️⃣ Is a point-in-time operation

Correct Match: ✔ dbt clone

defer and dbt clone serve very different purposes in dbt, and understanding their behavior is essential for choosing the right command.

The --defer flag tells dbt to use already-built objects from a previous environment (often production) instead of rebuilding them. Because it always references the existing target schema’s most recent objects, it “always points to the latest version of the source schema.” Since no objects are overwritten when using defer, it also “allows safely modifying objects built in the target schema”—your development environment uses production objects without altering them.

By contrast, dbt clone creates a point-in-time copy of existing relations. This cloned schema is static; it does not auto-update when source data changes. Therefore, clone is classified as a “point-in-time operation.” Since clone copies physical tables/views into a new schema, downstream tools (BI dashboards, ML pipelines) can safely query the cloned environment without affecting production, making “allows to use objects built in the target schema with any downstream tool” the correct match.

Thus, defer is used for logic substitution without copies, while clone is used for replicable, point-in-time snapshots.

dbt Python models support a limited set of materializations because they rely on execution within the data platform’s Python compute engine (such as Snowpark for Snowflake, Dataproc for BigQuery, or Spark). These engines require models to materialize into actual relations—tables or views—in order to persist the results of Python-based transformations.

The ephemeral materialization, however, is fundamentally incompatible with this behavior. Ephemeral models do not create relations in the warehouse; instead, dbt inlines their SQL logic directly into downstream models. Since Python models cannot be inlined (they execute Python code, not SQL), dbt does not allow ephemeral Python models. dbt requires Python model outputs to be materialized as either:

table

view

incremental

Therefore, ephemeral is not supported for Python models, and attempting to configure a Python model as ephemeral will result in a compilation error.

The reason is straightforward: ephemeral logic depends on SQL compilation, while Python models depend on executing Python code in the data platform. Because these mechanisms are incompatible, dbt restricts Python models to relational materializations only.

Thus, the correct answer is No — ephemeral is not supported for Python models.