dbt Labs dbt-Analytics-Engineering Dumps

The correct answers are B: writing and using dbt macros and D: using dbt packages.

dbt strongly encourages DRY (Don't Repeat Yourself) principles, and two of the core mechanisms that support reusable logic are macros and packages. Macros allow you to write Jinja-powered reusable functions that can generate SQL statements dynamically, reducing duplication across models, tests, and project logic. Macros can encapsulate filters, joins, auditing logic, timestamps, and more—allowing developers to centralize logic in one place while referencing it across many models.

Packages extend this concept even further by allowing entire sets of macros, models, tests, and utilities to be imported into a project. Packages like dbt-utils contain widely used generic macros that help standardize transformations and testing. Using packages ensures consistent logic across teams and eliminates the need to rewrite common transformations.

Option A contradicts DRY principles because copy/pasting increases maintenance burden. Option C is not a mechanism for reusing logic; singular tests validate logic but do not reduce duplication. Option E simply changes a model’s materialization and does not support code reuse.

Thus, macros and packages are the only correct dbt mechanisms that provide reusable, modular, DRY logic.

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.

The requirement is:

Select all models that have been modified → this uses the state selector:state:modified

But only those modified models that are materialized as views → this uses the config selector:config.materialized:view

Then include upstream and downstream dependencies of those models → this requires adding + around the selectors.

To combine both selectors, dbt uses a comma-separated list within --select, meaning both selectors must match simultaneously.

The correct syntax is:

dbt build --select +state:modified, +config.materialized:view+

This command:

Finds models whose state is modified.

Filters them to only those materialized as views.

Includes upstream (+) and downstream (+) dependencies.

Runs and tests the selected nodes because dbt build includes running models, tests, seeds, and snapshots.

Why the other options are wrong:

A and C use invalid selector syntax (config.materialized:view+ must be prefixed with +).

B only selects modified models but does not filter by materialization type.

D uses materialized:view, which is invalid without the config. prefix.

Thus, only Option E satisfies all conditions and uses correct dbt selector syntax.

The correct answers are A: run-operation and E: snapshot.

According to dbt’s retry documentation, the dbt retry command works by examining the artifacts of a previous invocation (manifest, run results) and then re-running failed nodes for commands that generate node executions. Only commands that write run results and maintain execution state can be retried. These include dbt run, dbt test, dbt seed, dbt snapshot, and dbt run-operation when the operation executes nodes or macros that generate runtime artifacts.

Option A is correct because run-operation supports retry when the macro being run triggers execution tracked in run results. Option E is correct because snapshots execute SQL against the warehouse and record stateful results, meaning dbt can retry failed snapshots using the retry mechanism.

Options B (parse), C (debug), and D (deps) do not create runnable nodes or execution results; they simply validate or install project resources. These commands do not produce retryable artifacts, so dbt retry cannot operate on them.

Thus, the only options that work with dbt retry from the list provided are run-operation and snapshot.

In dbt, the Directed Acyclic Graph (DAG) is created from model dependencies, which dbt identifies only through two mechanisms: the ref() function for referencing dbt models and the source() function for referencing declared sources. These functions are explicitly designed to tell dbt how models relate to each other so that dbt can track lineage, enforce build order, and generate documentation.

Option A, {{ source('source', 'table') }}, correctly references a declared source. Any model using source() establishes an upstream dependency on that source table. dbt will therefore draw a lineage line in the DAG from the source to the model.

Option B, {{ ref('stg_jaffle_shop__customers') }}, is the canonical way to reference another dbt model. ref() ensures dbt determines dependencies at compile time, and thus creates a DAG edge between this model and its parent.

The remaining options do not create lineage:

C directly references a database object, which dbt cannot interpret as a dependency.

D uses a Jinja variable unrelated to lineage.

E is invalid, because source() requires two arguments: a source name and table name, not a dotted string.

Therefore, A and B are the only valid answers.

The correct answers are B: tags and C: enabled.

dbt tests—both generic and singular—support a limited but clearly defined set of configurations. Two of the supported configurations are tags, which allow grouping and selecting tests using dbt’s selector syntax, and enabled, which can be set to true or false to control whether a test should run. These configurations are commonly used to manage large test suites, such as disabling slow tests in development or tagging tests for CI pipelines.

Option A (on_schema_change) is a model-only configuration and cannot be applied to tests.

Option D (materialized) applies only to models, not tests, since tests compile into queries that evaluate failures rather than physical objects.

Option E (persist_docs) applies to models and sources for documentation purposes. Tests do not support persisted documentation properties beyond what appears in test metadata.

dbt’s documentation makes clear that tests inherit only a small subset of configurations compared to models—primarily enabled, tags, severity, and custom test arguments. Among the options provided, only tags and enabled are valid and supported.

Thus, the correct answers are B and C.

The goal in this scenario is:

Select only models, tests, and snapshots that were modified in development, using:state:modified

Use already-built production objects whenever possible, so development does not need to rebuild everything. This is done with:--defer

Compare development code against production artifacts, which requires:--state

Run everything (models + tests + snapshots) in a single command. This is exactly what dbt build does.

dbt build = run models + run tests + run snapshots + run seeds.

Putting it all together, the correct command is:

dbt build --select state:modified --defer --state

This single command satisfies all requirements:

It runs only modified resources.

It uses the production state artifacts for comparison.

It defers to production-built models where possible.

It runs all resource types automatically.

Why the other options are incorrect:

A → Missing --state, so state:modified cannot function.

B → Splits run + test separately; question asks which single command you will invoke.

D → Missing --defer, which defeats the purpose of using production objects.

E → Also missing --defer.

Thus, Option C is the only correct answer.

(new_project)

(models:)

(grants)

(require-dbt-version: '>= 1.0.0' )

The dbt_project.yml file acts as the configuration backbone for every dbt project. dbt requires that project names follow a strict naming convention, allowing only lowercase letters, numbers, and underscores. Therefore, new_project is the only valid name among the choices. Names with spaces or hyphens, such as new project or new-project, violate dbt’s project naming rules.

To configure how models behave—materializations, schemas, tags, or per-directory overrides—dbt uses the models: block inside dbt_project.yml. This block defines configuration inheritance rules and is different from the config() function, which is used inside SQL models, not in YAML files.

When granting permissions on database objects created by dbt, you use the grants configuration. This allows you to define access roles at the model level or project level for downstream BI or analytics tools, ensuring proper data governance and controlled data exposure.

Finally, compatibility with specific dbt versions is set using require-dbt-version. The correct YAML formatting uses quotes, such as '>= 1.0.0', ensuring dbt interprets the value as a string. This prevents accidental mis-parsing and enforces version requirements during dbt run or dbt build.

Operation

Correct Location

Aggregations (booked_hotel, booked_ride)

In a model dedicated to pre-aggregate data for reporting

Standardizing customer_id

In the first layer of models

Selecting customer_name

In the first layer of models

Joining employees

In a model between the first layer and final layer of models

In dbt’s recommended modeling framework, transformations should be centralized according to their purpose and level of abstraction. Basic cleaning and column standardization—such as shortening customers.id using left(customers.id, 12)—belongs in the first layer of models, commonly known as staging models. This layer is responsible for producing clean, consistent, analytics-ready fields. Selecting raw descriptive fields like customers.name also belongs in this layer.

Joins that enrich a dataset by combining cleaned staging outputs across domains—such as joining customers with employees—belong in intermediate models. These models unify business logic that sits between the raw staging layer and the final aggregations used for reporting.

Finally, aggregations like counting types of accommodations (booked_hotel and booked_ride) belong in marts or reporting models, especially when they involve summarization that downstream tools (dashboards, BI reports) will consume. This keeps heavy business logic centralized and reusable.

This error is caused by invalid Jinja syntax, specifically by nesting {{ }} blocks inside another Jinja expression. The expression:

{{ source("{{ env_var('input') }}", 'table_name') }}

compiles to:

{{ source({{ env_var('input') }}, 'table_name') }}

Here, Jinja sees {{ inside another {{ ... }} block. Jinja does not allow nested print statements like this; instead, functions should be called directly inside a single pair of curly braces. The parser encounters an unexpected } where it expects part of a valid expression (hence “expected token ':', got '}'”), which is a classic symptom of mismatched or nested curly braces.

The correct usage is:

select * from {{ source(env_var('input'), 'table_name') }}

In this form, env_var('input') is evaluated first, and its result is passed as the first argument to source() within one Jinja expression.

Option C is therefore the correct debugging approach: inspect your Jinja and look for incorrectly nested curly brackets. Options A and D are generic and don’t address the root cause, while B talks about quoting in SQL, which is not the problem—the error arises before SQL compilation, at Jinja parse time.

The correct answer is A: dbt test --select "orders" --indirect-selection=empty".

In dbt, the --indirect-selection flag controls how dbt handles indirectly related resources during selection, such as tests whose parent models may or may not be selected. By default, dbt may include related resources depending on the selection behavior.

indirect-selection=empty is the strictest form of selection. It means that dbt will not run tests whose parent models are not explicitly selected, even if the tests are indirectly related. This prevents executing tests on models that you did not intend to build or include in your workflow, ensuring test execution is tightly scoped.

Other options behave differently:

Option B (no indirect-selection flag) uses dbt’s default behavior, which does include related tests, meaning tests could run even when their parent models were not selected.

Option C: buildable includes resources that can be built (e.g., when downstream dependencies require them).

Option D: cautious runs tests if their parents are selected transitively through dependencies.

Therefore, to prevent tests from running when parent models are unselected, you must use --indirect-selection=empty, making A the correct choice.

The correct answers are C: Exposures describe a downstream use of your dbt project and E: You can run, test, and list resources that feed into your Exposure.

Exposures in dbt are documentation constructs that describe how the outputs of your dbt project are used downstream—such as dashboards, machine learning models, applications, reporting layers, or external tools. They exist to provide visibility into the final layer of the analytics workflow, making it easier to track lineage from raw data → models → downstream consumers.

Option C is correct because the official dbt documentation explicitly states that exposures define the downstream use cases of dbt models. They create transparency about dependencies outside the dbt DAG itself.

Option E is also correct. Using commands like dbt ls --select +exposure: or dbt run --select +exposure:, dbt enables users to run, test, and inspect the upstream resources feeding into the exposure. This is extremely valuable for impact analysis and CI workflows.

Option A is incorrect because exposures are downstream, not upstream—meaning models feed into exposures, not the other way around.

Option B is incorrect because exposures are not materialized in the warehouse; they are metadata stored in YAML.

Option D is incorrect because exposures are defined in YAML files, not SQL files.

Thus, C and E are the correct statements.

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.

Hook 1

on-run-end: "{{ macro_x() }}"

Answer: macro_1

Hook 2

models:

:

post-hook: "{{ macro_x() }}"

Answer: macro_2

Hook 3

on-run-start: "{{ macro_x() }}"

Answer: macro_3

Hook 4

{{

config(

pre-hook: "{{ macro_x() }}"

)

}}

Answer: macro_4

dbt supports run-level hooks and model-level hooks. Run-level hooks fire once per invocation, while model-level hooks fire around each individual model.

on-run-end is a run-level after hook that executes once after the entire dbt command completes. Because macro_1() must run after every dbt run, it correctly belongs here.

The post-hook configured under the models: section runs after each model in that scope finishes building. This matches the requirement for macro_2() to execute after a model runs.

on-run-start is a run-level before hook and fires once before dbt begins executing any models for that command, making it the right place for macro_3() which must run before every dbt run.

Finally, the pre-hook specified inside a model’s config() block runs before that specific model is built. Since macro_4() must execute before a model runs, it belongs in the pre-hook configuration.

Thus the correct mapping is:

on-run-end → macro_1

model post-hook → macro_2

on-run-start → macro_3

model pre-hook → macro_4.

The dbt compilation error explicitly states that the model fct_tasks depends on a node named stg_tasks, but dbt cannot find any resource with that name in the project. dbt resolves ref('stg_tasks') at compile time by searching for a model, seed, or source named stg_tasks. When no such model exists, dbt raises the exact error shown: “depends on a node named 'stg_tasks' which was not found.”

This error occurs before execution and is unrelated to whether the table exists in the warehouse. For dbt, the existence of a warehouse table is irrelevant during compilation—only the presence of a declared dbt resource matters. Therefore, option C (no table in the warehouse) cannot cause this error.

Option A is incorrect because ephemeral models still count as dbt models, and dbt can resolve ref() to them without problem.

Option D is wrong because defining a model in schema.yml is optional and unrelated to dbt’s ability to find the model. Tests and documentation require YAML entries, but model definitions do not.

Thus, the only correct explanation is that no model file named stg_tasks.sql exists under /models, making Option B the correct choice.

In dbt, the source() function resolves a source by its declared source name and table name, not by the physical schema or identifier in the warehouse. The YAML block defines a source named jaffle_shop, and under that source, a table named orders. The identifier: customer_orders field tells dbt that although the logical table name is orders, the actual physical object in the warehouse is named customer_orders.

dbt always expects the syntax:

{{ source(source_name, table_name) }}

Here, the correct reference uses jaffle_shop as the source name and orders as the table name because these are the logical names assigned in the YAML. dbt internally resolves the physical table name via the identifier field, so the model should not reference customer_orders directly.

Option A and B are incorrect because the first argument is not the schema; dbt does not use schemas in the source() call. Option D is incorrect because customer_orders is the warehouse identifier, not the logical table name recognized by dbt.

Therefore, the correct reference is:

{{ source('jaffle_shop', 'orders') }}

This ensures consistent modeling, dependency tracking, and accurate documentation.

The correct answers are A and C.

dbt clone is a command introduced to efficiently replicate existing relations (tables/views) from one schema/environment to another within the same warehouse without fully rebuilding them. It typically leverages warehouse-level “clone” functionality (e.g., Snowflake zero-copy clone). To know what to clone, dbt needs information about previously built models; this is stored in artifacts like manifest.json. Therefore, A is correct: it requires a reference to a previous manifest/state to know which models and locations to operate on.

C is also correct because cloning a production schema into a development schema enables you to test code changes while pointing downstream tools (like BI dashboards) at the cloned data. That way, BI or ML systems can exercise new dbt logic without impacting real production objects.

Option B describes state:modified / state comparison behavior, but dbt clone does create (or clone) objects, so B is false.

Option D is incorrect because clone works within a warehouse, not across different warehouses.

Option E is wrong: _v# suffixing is for model versioning, not cloning.

Thus, A and C correctly describe the behavior and purpose of dbt clone.

The correct answer is D: Declare the external table as a source using the external configuration.

When data arrives in an external storage system such as S3, many warehouses (like Snowflake, BigQuery, and Databricks) support external tables that reference data stored outside the warehouse. dbt fully supports external tables by allowing them to be declared as sources using the external: configuration block inside sources: in a YAML file. This tells dbt that the upstream object exists outside the warehouse and should not be materialized or transformed by dbt directly. It also enables dbt to include external data in lineage graphs, freshness checks, and downstream model dependencies.

Option A is not ideal because you still need to formally register the external table as a source; simply querying it in a model breaks the data lineage structure. Option B is unnecessary and operationally brittle—temporary tables are not required for external data ingestion. Option C is incorrect because dbt seed is intended for uploading local static CSV files, not files arriving via S3 or controlled by external vendors. Seeds do not support dynamic ingestion patterns.

Thus, the correct and documented method is to declare the external table as a source with the external configuration, allowing dbt to consume the data appropriately while maintaining proper governance and lineage.

Drops and recreates a definition of a query which is executed at the time it's referenced

✅ view

Inserts or updates records of an existing object in the warehouse using a delta

✅ incremental

Code belonging to the model is inserted into the places the model is referenced

✅ ephemeral

Drops and recreates an object in the warehouse as stored results when using dbt run

✅ table