Why advanced testing catches subtle data issues in dbt - See It in Action

Why advanced testing catches subtle data issues

📖 Scenario: Imagine you work with a sales database. You want to make sure the data is clean and correct before using it for reports. Simple checks catch obvious mistakes, but some problems are hidden and need smarter tests.

🎯 Goal: You will create a small sales data table, add a configuration for a threshold, write an advanced test to find subtle data issues, and then display the test results.

📋 What You'll Learn

Create a dbt model with sample sales data

Add a config variable for minimum valid sales amount

Write a custom test to find sales below the threshold or with missing customer IDs

Run the test and show the results

💡 Why This Matters

🌍 Real World

In real companies, data often has hidden problems that simple checks miss. Advanced testing helps catch these early to keep reports accurate.

💼 Career

Data analysts and engineers use advanced tests in dbt to ensure data quality before analysis or reporting.

1

Create a dbt model with sample sales data

Create a dbt model called sales_data.sql with a table containing these exact rows: (1, 'Alice', 100), (2, 'Bob', 50), (3, NULL, 30), (4, 'Dana', 0), (5, 'Eve', 200). The columns should be sale_id, customer_name, and amount.

dbt

-- Create the sales_data model with the specified rows
-- Your code here

Hint

Use a CTE with union all to create the rows exactly as shown.

2

Add a config variable for minimum valid sales amount

In the same model file, add a variable called min_valid_amount and set it to 10. This will be used to check for subtle data issues later.

dbt

with sales as (
    select 1 as sale_id, 'Alice' as customer_name, 100 as amount union all
    select 2, 'Bob', 50 union all
    select 3, null, 30 union all
    select 4, 'Dana', 0 union all
    select 5, 'Eve', 200
)

-- Add a variable min_valid_amount set to 10
-- Your code here

Hint

Use a second CTE named config to hold the variable.

3

Write a custom test to find subtle data issues

Create a dbt test SQL file called test_subtle_issues.sql that selects rows from sales_data where amount is less than min_valid_amount or customer_name is NULL. Use a join with the config CTE to get min_valid_amount. Use exact column names sale_id, customer_name, and amount.

dbt

-- Create a test query to find sales with amount < min_valid_amount or customer_name is NULL
-- Your code here

Hint

Use a cross join with config to access min_valid_amount in the WHERE clause.

4

Run the test and show the results

Write a SQL statement to run the test query and print the rows that fail the test. Use select sale_id, customer_name, amount from and the test query from Step 3.

dbt

-- Print the rows that fail the test
-- Your code here

Hint

The output should show rows with sale_id 3 and 4 because they have subtle data issues.

Practice

1. Why is advanced testing important in dbt for data quality?

easy

A. It makes the data load faster.

B. It reduces the size of the database.

C. It finds subtle data issues that simple tests might miss.

D. It automatically fixes all data errors.

Solution

1. Step 1: Understand the role of advanced testing

   Advanced testing is designed to catch hidden or subtle data problems that basic tests do not detect.

2. Step 2: Compare with other options

   The other options describe unrelated or incorrect effects of advanced testing.

3. Final Answer:

   It finds subtle data issues that simple tests might miss. -> Option C

4. Quick Check:

   Advanced testing = finds subtle issues [OK]

Hint: Advanced tests catch hidden problems, not speed or size [OK]

Common Mistakes:

• Thinking advanced tests speed up data loading
• Assuming advanced tests reduce database size
• Believing advanced tests fix errors automatically

2. Which of the following is the correct syntax to define a custom test in dbt?

easy

A. tests:
unique_test:
test: unique
column_name: id

B. tests:
- unique_test:
column_name: id

C. tests:
- name: unique_test
test: unique
column_name: id

D. tests:
- name: unique_test
test: unique
column_name: id
severity: error

Solution

1. Step 1: Review dbt test YAML syntax

   Custom tests in dbt are defined with a name, test type, column, and optional severity in a list format.

2. Step 2: Identify correct structure

   tests: - name: unique_test test: unique column_name: id severity: error correctly uses a list item with name, test, column_name, and severity keys.

3. Final Answer:

   tests:\n - name: unique_test\n test: unique\n column_name: id\n severity: error -> Option D

4. Quick Check:

   Correct YAML list with keys = tests: - name: unique_test test: unique column_name: id severity: error [OK]

Hint: Custom tests need name, test, column, and optional severity [OK]

Common Mistakes:

• Using incorrect YAML indentation
• Missing the 'name' key for the test
• Not using a list for multiple tests

3. Given this dbt test SQL snippet, what will be the output if the table has duplicate user_ids?

SELECT user_id, COUNT(*)
FROM {{ ref('users') }}
GROUP BY user_id
HAVING COUNT(*) > 1

medium

A. A list of user_ids that appear more than once

B. An error because COUNT(*) cannot be used with GROUP BY

C. An empty result if no duplicates exist

D. A count of all user_ids in the table

Solution

1. Step 1: Understand the SQL query

   The query groups rows by user_id and selects those with count greater than 1, meaning duplicates.

2. Step 2: Determine output when duplicates exist

   If duplicates exist, the query returns user_ids with more than one occurrence.

3. Final Answer:

   A list of user_ids that appear more than once -> Option A

4. Quick Check:

   GROUP BY + HAVING COUNT(*) > 1 = duplicates list [OK]

Hint: HAVING COUNT(*) > 1 finds duplicates [OK]

Common Mistakes:

• Thinking COUNT(*) can't be used with GROUP BY
• Expecting total count instead of filtered duplicates
• Confusing empty result with error

4. You wrote a dbt test to check for nulls in the email column, but it always passes even when nulls exist. What is the likely issue?

medium

A. The test is running on the wrong model reference.

B. The test is using COUNT(email) instead of COUNT(*)

C. The test is written as a schema test instead of data test.

D. The test SQL is missing a WHERE clause to filter nulls.

Solution

1. Step 1: Analyze why nulls are not detected

   COUNT(email) only counts non-null values, so tests relying on it will miss nulls and pass incorrectly.

2. Step 2: Check other options

   The other options cause different issues, like running on wrong data or incorrect test type.

3. Final Answer:

   The test is using COUNT(email) instead of COUNT(*) -> Option B

4. Quick Check:

   COUNT(email) ignores nulls [OK]

Hint: COUNT(column) ignores nulls [OK]

Common Mistakes:

• Using COUNT(column) which ignores nulls
• Confusing schema and data tests
• Referencing wrong model in test

5. You want to create an advanced dbt test that checks if the order_date is always before the ship_date. Which approach best catches subtle data issues?

hard

A. Write a SQL test that selects rows where order_date >= ship_date.

B. Use a built-in unique test on order_date.

C. Create a schema test to check order_date is not null.

D. Add a test that counts total rows in the orders table.

Solution

1. Step 1: Define the data rule to test

   The rule is order_date must be before ship_date, so invalid rows have order_date >= ship_date.

2. Step 2: Choose the test that finds violations

   A SQL test selecting rows where order_date >= ship_date will catch subtle errors where dates are reversed or equal.

3. Final Answer:

   Write a SQL test that selects rows where order_date >= ship_date. -> Option A

4. Quick Check:

   Test selects invalid date order rows [OK]

Hint: Test selects rows violating the date order rule [OK]

Common Mistakes:

• Using unique test which doesn't check date order
• Checking only for nulls misses order errors
• Counting rows doesn't validate date logic