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.

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

Here is the correct sequence:

Correct Order

sources:

- name: blue (source definition)

tables:

- name: yellow (table definition)

columns:

- name: red (column definition + tests)

In dbt, source documentation follows a strict YAML hierarchy. At the top level, the sources: key declares that you are defining source metadata. Inside this block, each source is listed as an item beginning with - name:. Therefore, the snippet describing the source ( blue ) must come immediately after sources:.

Next, dbt requires a tables: block inside each source to define the raw tables belonging to that source. Thus, the snippet containing tables: must follow the source definition. The table description ( yellow ) is then placed directly under this key because it represents a table within that source.

Finally, dbt allows column-level metadata under a columns: block inside a table definition. Therefore, columns: appears next, followed by the snippet defining a specific column ( red ) which includes both a description and tests (unique, not_null).

Arranging the YAML in this hierarchical order ensures dbt can correctly assign documentation to the source object, the table object, and the individual column. Misordering these snippets would break the structure and prevent dbt from generating documentation properly.

Information Type

Retrieved From

Singular tests

C. .sql files

Column data types

A. Data platform information schema

Generic tests

B. .yml configuration

SQL code

C. .sql files

Column descriptions

B. .yml configuration

Model dependencies

C. .sql files

The dbt docs command compiles metadata about your project by gathering information from three primary sources: your warehouse’s information schema , your YAML configuration files , and your SQL model files . Understanding which metadata comes from which source is essential for debugging and for effective documentation practices.

Singular tests live inside .sql files within the /tests directory. Since dbt renders these tests directly from SQL files, their definitions appear in documentation sourced from that location.

Column data types come from the warehouse itself. dbt introspects the data platform information schema to retrieve actual types because dbt does not infer or define column types—only the warehouse does.

Generic tests (e.g., unique, not_null, accepted_values) are declared in .yml files. These YAML definitions contain test configurations, descriptions, and parameters, which dbt uses to document and execute these tests.

SQL code for models is naturally sourced from .sql files where the models are defined. This includes logic such as SELECT statements, CTEs, and transformations.

Column descriptions are written exclusively in .yml files. dbt never extracts descriptions from SQL comments—only from YAML.

Model dependencies come from the ref() and source() calls inside .sql model files, which dbt parses to build the DAG.

The true root cause is not related to run hooks or regular expressions. The warning clearly indicates that dbt found a configuration path that does not match any actual model path inside the project. In this case, the config block uses the key models.jaffle-shop, which is incorrect because dbt model paths must match the folder structure and cannot contain hyphens unless the folder itself contains a hyphen. Since the project folder is named jaffle_shop (with an underscore), dbt cannot map the configuration to any model.

dbt evaluates configuration paths based on directory names under the models/ folder. A mismatch between the folder name and the configuration key causes dbt to ignore the configuration entirely. This results in the warning:

“Configuration paths exist in your dbt_project.yml file which do not apply to any resources.”

This warning is specifically triggered when dbt identifies unused configuration paths due to typos, incorrect nesting, or invalid identifiers. dbt does not interpret hyphens (-) as valid Python identifiers for resource names, so a config path like models.jaffle-shop will never be applied.

Therefore, the assertion that the cause is a " run hook with an incorrect regular expression " is incorrect . The actual root cause is that the configuration path uses the wrong name (jaffle-shop instead of jaffle_shop).

dbt model contracts enforce that the column names, data types, and number of columns defined in the contract exactly match the columns produced by the compiled SQL. If any column appears in one location (the contract or the SQL) but not in the other, dbt raises an enforcement error.

In this scenario, the error message shows:

ORDER_ID is missing in the model definition , meaning the SQL no longer contains a column named order_id, but the contract still expects it.

ORDER_KEY is missing in the contract , meaning the model SQL now contains a new column, but this column has not been added to the contract.

To fix the mismatch, you must remove columns from the contract that no longer exist in the SQL and add to the contract any new columns that now appear in the SQL .

Therefore:

Option A — Remove order_id from the contract — is correct because the column no longer exists in the model SQL.

Option D — Add order_key to the contract — is correct because the SQL now produces this column.

Options B and C incorrectly alter the wrong side of the definition, and Option E would create a mismatch in the opposite direction.

Thus, the correct fixes are A and D .

The only correct statement is Option C , because dbt allows you to override the schema for a package’s models directly within your project’s dbt_project.yml file. Packages behave just like subfolders within your own project, and therefore the standard configuration pattern applies:

models:

timeformat:

+schema: timeseries

This correctly overrides the package’s default schema, allowing all models within the timeformat package to be built into the timeseries schema.

Why the other options are incorrect

Option A

Local packages can be added using a path reference, but that is not what a private Git repository refers to. A private repo must be added using git: plus SSH/HTTPS URL, not local: unless the developer literally cloned the repo into a local directory. The question specifically describes a private repository , so this is not the correct statement.

Option B

Packages are installed using dbt deps , not dbt build.

dbt build only runs models, tests, and snapshots; it does not install dependencies.

Option D

Including a version or revision is allowed for private Git-based packages. You can specify branches, tags, or commit hashes safely in packages.yml.

(branch)

(commit)

(pull request)

In dbt development workflows, version control using Git is essential for ensuring collaborative, safe, and trackable changes to analytics code. The correct first step when making updates—such as adding new models—is to create a new Git branch . This isolates development work from the production (main) branch, preventing incomplete or experimental logic from affecting deployed transformations. Branching supports dbt’s modular development approach and aligns with best practices for analytics engineering.

Once the branch is created, the developer modifies SQL models, tests, macros, or documentation as required. To permanently record these modifications in Git, the developer must commit the changes. A commit serves as a snapshot of progress and creates an auditable history of transformations made to the project, enabling rollbacks, diffs, and peer review.

After development is complete, the developer submits a pull request (PR) . The pull request triggers CI checks—often including dbt build, schema tests, and contract validations—to ensure code quality and identify impacts on downstream models. PRs allow team members to review and comment before changes merge into the main branch, enforcing governance, consistency, and reliability. This workflow embodies the engineering rigor dbt encourages: modular development, testing, versioning, and peer review.

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: < name > or dbt run --select +exposure: < name > , 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.

The correct answer is D: dbt run --select +1 my_model .

In dbt’s selection syntax, the + operator is used to include parents (upstream) and/or children (downstream) of a given node. When used as +my_model or my_model+, it means “include all ancestors” or “all descendants” respectively, with no limit on depth.

To limit how many levels of parents or children are included, dbt allows a numeric depth between the + and the resource name. +1 my_model (or my_model+1) means:

Select my_model

Plus only its first-degree parents (direct dependencies), and no further ancestors.

Because you want to materialize the models, you must use dbt run, not dbt compile. dbt compile only compiles SQL and does not create or update relations in the data platform.

So:

Option A (dbt run --select +my_model) would include all upstream ancestors, not just first-degree parents.

Options B and E use compile, so they don’t materialize.

Option C is just syntactically wrong.

Therefore, the only command that both runs models and limits selection to my_model plus its first-degree parents is dbt run --select +1 my_model .