2026 Valid dbt-Analytics-Engineering FREE EXAM DUMPS QUESTIONS & ANSWERS
Free dbt-Analytics-Engineering Exam Braindumps dbt Labs Pratice Exam
NEW QUESTION # 103
You're considering adding workflow orchestration to manage dependencies between your dbt project, data loading tasks, and the triggering of downstream Bl updates. Which of the following types of tools would be most suitable for this?
- A. Data lineage tools
- B. CI/CD platforms
- C. General-purpose workflow orchestration tools (e.g., Airflow, Prefect)
- D. Data quality monitoring tools
Answer: C
Explanation:
While options B (CIICD) and C (data quality monitoring) are potentially relevant parts of the ecosystem, general-purpose workflow orchestration tools are directly designed to manage dependencies and task sequences across various technologies.
NEW QUESTION # 104
You discover a vulnerability in a third-party lineage-enhancing dbt package you use. Where might you first look for information and potential fixes?
- A. Directly in the manifest.json or packages.yml files within your project
- B. The GitHub repository or documentation of the dbt package.
- C. Only the authors of the dbt package would be able to address the vulnerability.
- D. Centralized dbt documentation or a discussion forum.
Answer: B
Explanation:
The package maintainer is the primary source for updates and vulnerability fixes. However, other resources like A & C might provide additional information or community solutions.
NEW QUESTION # 105
A team member suggests building a dbt package for a set of reusable transformations your team frequently uses. When is this MOST likely a good idea?
- A. You need to limit access to these transformations to a specific team within your organization.
- B. The transformations are relatively simple and could be written as macros.
- C. The transformations are complex and involve domain-specific logic that might be beneficial to others.
- D. The transformations are project-specific but used across multiple models.
Answer: C
Explanation:
Sharing common, complex logic is a key reason for creating packages. Simple logic is better as macros. Project-specificity favors macros or CTEs. Packages arent ideal for access control.
NEW QUESTION # 106
28. Consider this DAG:
* model_a # model_c # model_e
* model_b # model_d # model_f
(With model_c and model_d both feeding into the final layer.)
You execute:
dbt run --fail-fast
in production with 2 threads. During the run, model_b and model_c are running in parallel when model_b returns an error.
Assume there are no other errors in the model files, and model_c was still running when model_b failed.
Which model or models will successfully build as part of this dbt run? Choose 1 option.
- A. model_a, model_c
- B. model_a, model_c, model_d, model_e, model_f
- C. model_a
- D. model_a, model_c, model_e
Answer: A
Explanation:
The --fail-fast flag tells dbt to stop scheduling any new nodes as soon as one node fails. Importantly, dbt does not kill models that are already running; in-flight nodes are allowed to finish.
Here's what happens step by step with 2 threads:
* Roots model_a and model_b start first.
* model_a finishes successfully. That makes model_c eligible to run.
* dbt now runs model_b and model_c in parallel.
* While they are running, model_b fails.
* Because --fail-fast is set, dbt immediately stops scheduling any additional models (like model_d, model_e, or model_f).
* model_c was already running when model_b failed, so it is allowed to complete successfully.
Downstream models of either branch (model_d, model_e, and model_f) never start, because fail-fast prevents any further nodes from being queued after the first failure.
So, the only models that successfully build during this run are:
* model_a (completed before model_b failed)
* model_c (already running at the time of failure and allowed to finish) Hence the correct choice is B: model_a, model_c.
NEW QUESTION # 107
In development, you want to avoid having to re-run all upstream models when refactoring part of your project.
What could you do to save time rebuilding models without spending warehouse credits in your next command?
- A. Refer to a manifest and utilize the --defer and --state flags.
- B. Leverage artifacts from a prior invocation by passing only the --state flag.
- C. Replace your {{ ref() }} functions with hard-coded references.
- D. Clone your upstream models from the production schema to the development schema.
Answer: A
Explanation:
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.
NEW QUESTION # 108
Examine this query:
select *
from {{ ref('stg_orders') }}
where amount_usd < 0
You want to make this a generic test across multiple models.
Which set of two standard arguments should be used to replace {{ ref('stg_orders') }} and amount_usd?
Choose 1 option.
- A. model_name and column_name
- B. model and column_name
- C. source and column
- D. model and field
Answer: B
Explanation:
When converting a model-specific SQL query into a generic test, dbt expects the test macro to accept the two standard arguments used across all generic tests: model and column_name. These arguments allow dbt to automatically pass the correct table and the correct column when the test is applied in YAML.
The argument model represents the actual relation (table/view) being tested. dbt compiles the reference itself-so instead of writing ref('stg_orders'), generic tests always use {{ model }} to represent the referenced relation.
The argument column_name represents the actual column being tested. In this case, the hard-coded column amount_usd becomes the dynamic argument {{ column_name }}, allowing you to apply the logic to any numeric or validated column across multiple models.
So the generic version of your SQL becomes:
select *
from {{ model }}
where {{ column_name }} < 0
The other options are incorrect:
* source is not the standard argument for generic tests.
* model_name is not automatically passed by dbt.
* field is not a recognized standard test argument.
Thus, the two correct standard arguments are model and column_name.
NEW QUESTION # 109
You run this command:
dbt build --select "source_status:fresher+" --state path/to/prod/artifacts Which two need to happen before it can be executed successfully?
Choose 2 options.
- A. Test your sources with dbt test.
- B. Define a freshness block on your source(s).
- C. Invoke either dbt run or dbt build.
- D. Add generic tests to your sources.
- E. Invoke the command: dbt source freshness.
Answer: B,E
Explanation:
The selector source_status:fresher+ depends entirely on freshness metadata created by a previous dbt source freshness run. Source freshness results are stored in artifacts, and the --state flag points dbt to the location where these artifacts were previously generated. Without first running dbt source freshness, dbt has no stored freshness status and therefore cannot filter sources by "fresher" status. This makes option A required.
Additionally, source freshness checks only work when sources include a freshness block in their YAML configuration. This block specifies the loaded_at_field and the warn_after / error_after thresholds. If no freshness block exists, dbt does not compute freshness at all, meaning such sources cannot appear in the source_status:fresher+ selector. Therefore D is also required.
Options B and E are unrelated to source freshness artifacts and do not contribute to the preconditions for this selector. Option C does not impact freshness logic, as generic tests have no role in generating freshness metadata.
Thus, the two prerequisites are:
* Running dbt source freshness (to create freshness metadata).
* Defining a freshness configuration on the relevant sources.
NEW QUESTION # 110
A project relies on multiple external data sources with varying update frequencies (some daily, some hourly, some near real-time). How might you approach designing your dbt environments to efficiently handle these sources?
- A. Consider staging data in your data warehouse with varying materialization strategies, allowing for streamlined transformation logic in dbt.
- B. Utilize incremental models and orchestration features provided by dbt to minimize unnecessary reprocessing of data.
- C. All of the above could contribute to an effective solution.
- D. Use separate dbt targets for each source type based on update frequency to optimize run schedules.
Answer: C
Explanation:
A: Separate targets allow for tailored run schedules and resource usage. B: Data staging techniques give granular control over data freshness. C: Incremental models and orchestration enhance efficiency.
NEW QUESTION # 111
16. Your tests folder looks like:
tests
### generic
### furniture_customers_test.sql
macro_stg_tpch_orders_assert_pos_price.sql
macro_stg_tpch_suppliers_assert_pos_acct_bal.sql
stg_tpch_orders_assert_positive_price.sql
You run the command:
dbt test --select 'test_type:singular'
What will the command run?
Options from screenshot:
- A. macro_stg_tpch_orders_assert_pos_price
macro_stg_tpch_suppliers_assert_pos_acct_bal
stg_tpch_orders_assert_positive_price - B. furniture_customers_test
- C. furniture_customers_test
macro_stg_tpch_orders_assert_pos_price
macro_stg_tpch_suppliers_assert_pos_acct_bal
stg_tpch_orders_assert_positive_price
Answer: A
Explanation:
In dbt, a singular test is any SQL file placed directly inside the tests/ directory-not inside the tests/generic/ folder. Singular tests contain a custom SQL query where returning any rows means failure. They are distinct from generic tests, which are YAML-defined and live inside the generic directory, often referencing macros.
Looking at the folder structure:
In tests/generic/
* furniture_customers_test.sql # This is a generic test, not a singular test.
In the root tests/ directory
* macro_stg_tpch_orders_assert_pos_price.sql # singular test
* macro_stg_tpch_suppliers_assert_pos_acct_bal.sql # singular test
* stg_tpch_orders_assert_positive_price.sql # singular test
When you run:
dbt test --select 'test_type:singular'
dbt selects only singular tests, meaning tests that are individually written SQL files in the top-level tests/ directory.
Therefore, dbt will run:
* macro_stg_tpch_orders_assert_pos_price
* macro_stg_tpch_suppliers_assert_pos_acct_bal
* stg_tpch_orders_assert_positive_price
It will not run furniture_customers_test, because that file is inside tests/generic/, which is reserved for template-based generic tests and is not classified as singular.
Thus, the correct answer is Option C.
NEW QUESTION # 112
You get the following error when compiling a model:ln 'models/marts/sales_report.sql':
- A. Examine your model's SQL and ensure you've defined a column or combination of columns to serve as a unique identifier.
- B. Introduce a unit test to assert that the model's output has no duplicate rows.
- C. Delete the existing model and create a new one with the materialization set to table.
- D. Add a config.get("unique_key") entry within your model configuration in dbt_project.yml.
Answer: A
Explanation:
Incremental models must have a unique key You must address this in the model's logic itself. Changing the materialization or testing wont solve the root cause.
NEW QUESTION # 113
You define a source table and include an override:YAML
- A. The overrides property is not valid for tables within your dbt_project.yml.
- B. You need to create a macro named 'my_project' that contains the specific overriding logic.
- C. The overrides property needs to be defined at the source level, not the table level.
- D. The value 'my_project' is not a recognized keyword by dbt.
Answer: C
Explanation:
While dbt supports overrides, they generally work at higher levels within your project file, not at the model level.
NEW QUESTION # 114
You need to roll out a database migration mid-month. It requires changes to some of your dbt model schemas. How would you manage a smooth transition?
- A. Pause all dbt jobs until after the database migration is fully completed.
- B. Duplicate models, modifying them for the new schema, and switch over in your job configuration.
- C. Use feature branches and environment-aware logic in dbt to allow pre- and post-migration versions to coexist temporarily.
- D. Deploy model changes alongside database changes, accepting potential errors for a period.
Answer: C
Explanation:
C allows for gradual rollout and controlled testing. A' would lead to downtime, B potentially too much downtime, and D increases maintenance overhead.
NEW QUESTION # 115
You've updated a model's description in a YAML file to reflect a new business requirement. You've also added additional context to the column descriptions. After regenerating the documentation, you notice the model description has updated, but the column descriptions have not. What could be the most likely reasons?
- A. You are viewing an older cached version of the documentatiom
- B. The documentation was not configured correctly to display column descriptions.
- C. You forgot to run dbt docs generate after modifying the YAML file.
- D. The model's YAML file has incorrect syntax preventing column descriptions from rendering.
Answer: A,C
Explanation:
Explanation: B:
The dbt docs generate command is essential for updating the documentation website with changes made in the project files. D: Web browsers often cache content; you might need to clear your cache or force a refresh to see the latest changes.
NEW QUESTION # 116
Examine the configuration for the source:
sources:
- name: jaffle_shop
schema: jaffle_shop_raw_current
tables:
- name: orders
identifier: customer_orders
Which reference to the source is correct?
- A. {{ source('jaffle_shop_raw_current', 'orders') }}
- B. {{ source('jaffle_shop', 'orders') }}
- C. {{ source('jaffle_shop_raw_current', 'customer_orders') }}
- D. {{ source('jaffle_shop', 'customer_orders') }}
Answer: B
Explanation:
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.
NEW QUESTION # 117
(Multiple Select)
- A. Anomaly detection platforms.
- B. Data integration testing frameworks (e.g., Great Expectations)
- C. Continuous Integration (Cl) tools.
- D. Tools specializing in schema change detection.
Answer: A,B,D
Explanation:
All of these address different aspects of advanced data validation that complement the basic tests within dbt. Cl tools (D) are involved in running these checks but are not the data validation tools themselves.
NEW QUESTION # 118
......
Prepare For Realistic dbt-Analytics-Engineering Dumps PDF - 100% Passing Guarantee: https://www.examdumpsvce.com/dbt-Analytics-Engineering-valid-exam-dumps.html
Practice Test for dbt-Analytics-Engineering Certification Real 2026 Mock Exam: https://drive.google.com/open?id=1RHn9v7k0EsKM-UYct4FM28vajEml-UwG
