🛠️ dbt & Modern Data Stack Vocabulary
0 / 45 completed
1 / 45
A dbt model contains the expression {{ ref('stg_orders') }}.
What does the ref() function do in dbt?
ref() = dbt's cross-model reference function:
| What ref() does | Benefit |
|---|---|
| Auto-compiles correct schema name per environment | dev/staging/prod schema isolation |
| Registers model dependency in the DAG | Correct dbt run execution order |
Powers dbt docs lineage graph | Visualise model dependencies |
Key vocabulary: model dependency, DAG compile, target schema, ref() vs. source() function.
2 / 45
The CI pipeline reports: "dbt tests failed: not_null on orders.customer_id."
What does this test failure indicate?
dbt tests — data assertions that run against actual data:
| Generic test | What it checks |
|---|---|
not_null | No NULL values in the column |
unique | No duplicate values |
accepted_values | Values are in an allowed set |
relationships | Referential integrity check |
A test failure = data quality issue detected in the actual data, not a compile error. Key vocabulary: data test vs. schema test, test severity (warn vs. error), custom test.
3 / 45
A data team says: "The team uses dbt's source freshness check to monitor upstream pipelines."
What does source freshness monitoring in dbt detect?
dbt source freshness — monitoring upstream EL pipeline health:
| Configuration | Behaviour |
|---|---|
freshness.warn_after: {count: 12, period: hour} | Warning if no new data in 12 hours |
freshness.error_after: {count: 24, period: hour} | Error if no new data in 24 hours |
Compares max(loaded_at_field) to current time. Alerts when upstream source has stopped updating. Key vocabulary: source freshness SLO, freshness warning vs. error, loaded_at_field, upstream EL pipeline monitoring.
4 / 45
A team says: "We follow the staging → intermediate → mart dbt project structure."
What is the purpose of the staging layer in dbt?
dbt layered architecture:
| Layer | Purpose | Contains |
|---|---|---|
| Staging | Clean raw source data | Rename, cast, deduplicate — no business logic |
| Intermediate | Business logic combinations | Joins, aggregations, derived fields |
| Mart | Analytics-ready output | Business-facing, stable interface |
Key vocabulary: source-aligned model, column renaming, type casting, deduplication in staging, mart as the business-facing model.
5 / 45
A pull request note says: "The dbt project enforces a data contract on the fct_orders model."
What is a data contract in a dbt context?
dbt contracts (dbt 1.5+) — compile-time schema guarantees:
| Feature | What it does |
|---|---|
contract: enforced: true | Enables compile-time contract checking |
columns: with name/type | Declares the expected output schema |
| Compile fails on mismatch | Prevents accidental schema changes breaking consumers |
Key vocabulary: contract enforced, breaking schema change prevention, downstream consumer stability, column-level contract.
6 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
7 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
8 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.9 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.10 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
11 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
12 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
13 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.14 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.15 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
16 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
17 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
18 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.19 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.20 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
21 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
22 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
23 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.24 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.25 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
26 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
27 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
28 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.29 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.30 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
31 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
32 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
33 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.34 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.35 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
36 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
37 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
38 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.39 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.40 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
41 / 45
Sarah: "Hey team, I'm getting a lot of warnings in the dbt run logs about 'invalid column name'. It seems like some of our source tables are using backticks for identifiers, but we're not doing that in our models. Should I add a transformation to normalize those names?"This scenario reflects a common issue when connecting to sources where backticks are used for identifiers. The 'invalid column name' warning indicates a mismatch between the expected naming convention in dbt (typically without backticks) and the actual names in the source tables. Adding transformations to normalize these names is a valid solution, but it's important to investigate *why* the sources use backticks initially – this might point to a deeper problem with data governance or upstream tooling that needs addressing. The key here is understanding the root cause of the warning, not just applying a blanket transformation.
42 / 45
{{ ref('stg_customers') }} expression. While it works, are we sure this isn't an anti-pattern? Shouldn't we be explicitly defining how we want to join data from the staging layer rather than implicitly through a reference?' What is Alex raising concerns about regarding the use of `ref()` in this scenario?Alex's concern highlights a potential anti-pattern: excessive reliance on `ref()` without explicit data transformation logic. While `ref()` simplifies dependency management by automatically updating references to upstream models, it can make the model less understandable and more susceptible to issues if the staging layer changes unexpectedly. Explicitly defining joins and transformations promotes maintainability and reduces coupling – a core principle of robust dbt development. Option D is incorrect because caching mechanisms are designed to mitigate this issue.
43 / 45
Liam's comment highlights important considerations regarding dbt's `lookup()` function. While
auto is a convenient way to fetch an entire table, it can lead to less readable queries and potentially unnecessary data retrieval if only specific columns are needed. CTEs (Common Table Expressions) offer a cleaner and more maintainable approach for complex transformations, allowing developers to explicitly define the required columns and improve query readability. The key takeaway is that dbt encourages efficient and well-structured SQL, and Liam's feedback aims to achieve this.44 / 45
unique constraint to a dbt model, as suggested by Alice?
The
unique constraint forces dbt and the database engine to optimize query plans more effectively. When a filter is applied on customer_id, the database can avoid full table scans because it knows there are no duplicates—this drastically reduces query execution time. Options A and D misrepresent how constraints influence query optimization; B focuses on data quality, not performance directly, and C is too general. Adding a unique constraint triggers index creation or suggests more efficient indexing strategies.45 / 45
During a standup update, David says: 'We're using dbt's `select` macro to filter our sales data based on specific criteria. It's great because we can easily control exactly which columns are included in the final mart table.' Maria asks, 'But what happens if the source tables change and new columns appear? Will our
select macro automatically adapt?' What potential challenge is Maria highlighting regarding using the `select` macro in this way?Maria correctly identifies a key vulnerability: the `select` macro's static nature. dbt's transformations, particularly those relying on macros like this, don't inherently adapt to schema evolution in upstream tables without manual intervention. This can lead to broken downstream models if source columns are added or renamed unexpectedly, highlighting the need for more robust change management strategies within the data stack.
Frequently Asked Questions
What does the "dbt & Modern Data Stack Vocabulary" exercise practise?
Practice English for dbt: ref() function, dbt tests, source freshness, staging layers, and data contracts vocabulary for data engineers using the modern data stack.
How many questions are in this exercise?
This exercise has 45 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Intermediate. If the vocabulary feels difficult, browse the Data Engineering Language category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "dbt & Modern Data Stack Vocabulary" part of a larger series?
Yes — it's one exercise in the Data Engineering Language category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Data Engineering Language category page for related exercises, or browse the main Exercises hub for other IT English topics.