Why advanced testing catches subtle data issues in dbt

Introduction

Advanced testing helps find hidden problems in data that simple checks might miss. This keeps data accurate and trustworthy.

When you want to ensure data quality beyond basic checks

Before making important decisions based on data

When data comes from many sources and might have hidden errors

To catch rare or complex data problems early

When you want to automate data quality checks in your workflow

Syntax

dbt

tests:
  - unique
  - not_null
  - accepted_values:
      values: ['value1', 'value2']
  - relationships:
      to: ref('other_model')
      field: id

dbt tests are defined in YAML files inside your models or separately.

You can use built-in tests or write custom SQL tests for complex checks.

Examples

Checks that all values in a column are unique.

dbt

tests:
  - unique

Ensures no missing values in a column.

dbt

tests:
  - not_null

Checks that column values are only from a specific list.

dbt

tests:
  - accepted_values:
      values: ['active', 'inactive']

Verifies foreign key relationships between tables.

dbt

tests:
  - relationships:
      to: ref('users')
      field: user_id

Sample Program

This dbt schema file defines advanced tests for the 'orders' table. It checks that order IDs are unique and not missing, status values are valid, and user IDs link to existing users.

dbt

version: 2
models:
  - name: orders
    columns:
      - name: order_id
        tests:
          - unique
          - not_null
      - name: status
        tests:
          - accepted_values:
              values: ['pending', 'shipped', 'delivered', 'cancelled']
      - name: user_id
        tests:
          - relationships:
              to: ref('users')
              field: id

Important Notes

Advanced tests can catch subtle issues like invalid references or unexpected values.

Custom SQL tests let you write any logic to find complex data problems.

Running tests regularly helps keep data reliable over time.

Summary

Advanced testing finds hidden data problems that simple checks miss.

dbt supports built-in and custom tests for thorough data validation.

Using these tests improves trust in your data and decisions.

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