Data quality и контракты данных: проверки, SLA и валидация

Восемь видов дефекта в партии заказов против тестов dbt и ожиданий Great Expectations: что ловит каждый набор, что пропускают оба, сколько плохих и хороших строк доходит до витрины, если проверка останавливает сборку, только предупреждает или отправляет строки в карантин, и что ловит контракт модели dbt — а что проходит мимо него. Всё — счётом против эталона генератора

Сломанный сервис виден сразу — он отдаёт ошибки. Сломанные данные молчат: пайплайн зелёный, отчёт построился, просто в нём неверные числа, потому что источник начал слать пустые значения или перешёл с копеек на рубли. Защита — проверки на границах и контракт между тем, кто данные производит, и тем, кто их потребляет. Вопрос в том, что именно ловит каждая проверка и что делать, когда она сработала.

Эта статья отвечает на него счётом. Генератор строит партию заказов за день и подсаживает в неё один дефект за раз, зная, какие строки он испортил. Над партией работают два набора проверок: тесты dbt и ожидания Great Expectations. Счёт — что упало, сколько плохих строк указано, сколько плохих и хороших строк дошло до витрины.

Часть серии «Data engineering на практике». Проверки здесь стоят на входе в хранилище из батч-пайплайна; наблюдение за данными, которое не требует заранее заданных правил, — в следующей статье.

Ретрофутуристский инженерный лист: детали-цилиндры едут по конвейеру слева направо. Над лентой ряд ламп-луп на кронштейнах, каждая осматривает одну деталь. Дальше весы взвешивают целый лоток деталей, стрелка шкалы ушла в оранжевую зону. Сразу за весами несколько деталей с оранжевыми бирками уходят по боковому жёлобу в ящик с надписью «карантин», а основная лента продолжает движение

В статье

Стенд

PostgreSQL 18, база dwh: партия заказов в raw, модели dbt в staging и marts, карантин — в quarantine. dbt-core 1.12 с dbt-postgres 1.11 и Great Expectations 1.24 работают в одном контейнере. Партия — около 300 заказов за 10.09.2026 и справочник из 200 клиентов. Время выгрузки партии ставится от текущего момента базы: «свежая» партия — час назад, устаревшая — три дня назад, иначе свежесть зависела бы от даты прогона.

Проверки dbt — то, что обычно пишут в schema.yml: unique, not_null, relationships, accepted_values, сингулярный тест диапазона суммы и source freshness с порогом в 24 часа. Набор Great Expectations — те же правила по строкам (кроме ссылки на справочник: в ядре GE нет ожидания на внешний ключ между таблицами), плюс две проверки партии целиком:

# checks/ge_suite.py
        ("mean:amount", E.ExpectColumnMeanToBeBetween(column="amount", min_value=HIST_MEAN * 0.8,
                                                      max_value=HIST_MEAN * 1.2)),
        ("rows:batch", E.ExpectTableRowCountToBeBetween(min_value=200, max_value=400)),

Что чем ловится

Постановка. Восемь видов дефекта, по одному на партию. Контроль — чистая партия. В скобках — сколько строк указала проверка.

дефект плохих строк dbt Great Expectations
чистая партия (контроль) 0 — —
пустой клиент 15 not_null (15) не пусто (15)
повтор заказа 10 unique (10) уникально (20)
отрицательная сумма 12 тест диапазона (12) в диапазоне (12)
неизвестный статус 8 accepted_values (1) из списка (8)
клиента нет в справочнике 9 relationships (9) —
партия выгружена 3 дня назад 287 source freshness —
треть сумм в рублях вместо копеек 95 — среднее суммы
в партии 30 строк вместо ~300 30 — число строк

Контроль сошёлся: на чистой партии не упала ни одна проверка.

$ python3 scripts/run-detect.py shift
{"variant": "shift", "outcome": "match", "detail": "плохих строк 95 из 287; dbt: —; GE: mean:amount"}
$ python3 scripts/run-detect.py orphans
{"variant": "orphans", "outcome": "match", "detail": "плохих строк 9 из 287; dbt: relationships; GE: —"}

Построчные дефекты — пустые значения, повторы, недопустимые суммы и статусы — ловят оба набора: правила одни и те же. Считают они по-разному: тест dbt возвращает строки своего запроса — для unique это 10 повторяющихся значений, для accepted_values одно недопустимое значение статуса; ожидание GE считает строки — 20 строк с повторами и 8 строк с чужим статусом. Для тревоги это неважно, для оценки масштаба — важно. Дальше наборы расходятся, и это главное.

Только dbt поймал заказы с несуществующим клиентом и устаревшую партию: у него есть relationships и freshness источника, а набор GE без них. Только GE поймал сдвиг распределения и провал объёма — потому что в нём есть проверки партии целиком. Сдвиг особенно показателен: у трети заказов суммы в рублях вместо копеек, каждое значение по отдельности допустимо, и ни одно построчное правило — ни в dbt, ни в GE — его не видит. Ловит только среднее, которое ушло за коридор. Провал объёма — 30 строк вместо трёхсот — тоже допустим по строкам: каждая из 30 строк правильная.

Вывод не в том, что один инструмент лучше: dbt мог бы проверить объём пакетом тестов, а GE — свежесть ожиданием на максимум времени. Вывод в том, что построчные проверки отвечают на вопрос «нет ли плохих строк», а не «похожа ли партия на обычную». Нужны оба вида.

Что делать с плохой партией

Постановка. Партия, в которой 15 строк из 287 плохие трёх видов: пустой клиент, отрицательная сумма, неизвестный статус — 5% партии. Три реакции:

  • fail — тест с severity: error: dbt build останавливает всё, что ниже;
  • warn — тот же тест с severity: warn: сборка продолжается;
  • карантин — те же правила построчно в модели: хорошие строки идут в витрину, плохие — в отдельную таблицу.

Карантин — это флаг строки и два потребителя флага:

-- dbt/models/staging/stg_orders_flagged.sql
select o.*,
       coalesce(o.customer_id is not null
         and c.customer_id is not null
         and o.status in ('paid', 'cancelled', 'refunded')
         and o.amount between 1 and 100000000
         and count(*) over (partition by o.id) = 1, false) as is_valid
from {{ ref('stg_orders') }} o
left join {{ ref('stg_customers') }} c on c.customer_id = o.customer_id

Витрина берёт where is_valid, таблица карантина — where not is_valid. coalesce здесь не украшение. В SQL сравнение с NULL даёт не false, а NULL: строка с пустым статусом или пустой суммой получает is_valid = NULL и не проходит ни одно из двух условий (трёхзначная логика). Первая версия флага на стенде была без coalesce — партия, где у шести заказов пустой статус и у шести пустая сумма:

$ python3 scripts/run-reaction.py split-naive
{"variant": "split-naive", "outcome": "mismatch", "detail": "строк 287: валидных до бизнес-фильтров 275, в карантин 0, никуда 12; плохих 12, из них в карантине 0"}
$ python3 scripts/run-reaction.py split-fixed
{"variant": "split-fixed", "outcome": "match", "detail": "строк 287: валидных до бизнес-фильтров 275, в карантин 12, никуда 0; плохих 12, из них в карантине 12"}

Без coalesce 12 плохих строк исчезли: их нет ни среди валидных, ни в карантине, и счёт карантина показывает ноль — будто брака нет. Защита от этого — не только сам coalesce, но и контроль сохранения строк на разделении: валидные строки до бизнес-фильтров и агрегации плюс строки карантина должны давать всю партию. Сравнивать с готовой витриной нельзя: она дальше отбрасывает отменённые заказы и сворачивает строки в итоги дня. Без этого контроля любая ошибка в правилах разделения незаметна.

реакция витрина хороших заказов в витрине плохих в витрине в карантине
чистая партия (контроль) построена 259 из 259 0 —
fail: тест останавливает сборку не построена 0 из 245 0 —
warn: тест предупреждает построена 245 из 245 15 —
карантин: построчные правила построена 245 из 245 0 15

Контроль сошёлся: на чистой партии витрина полная во всех режимах.

$ python3 scripts/run-reaction.py fail
{"variant": "fail", "outcome": "mismatch", "detail": "витрина не построена: заказов 0, хороших по эталону 245; плохих в витрине 0; в карантине —"}
$ python3 scripts/run-reaction.py warn
{"variant": "warn", "outcome": "mismatch", "detail": "витрина построена: заказов 260, хороших по эталону 245; плохих в витрине 15; в карантине —"}
$ python3 scripts/run-reaction.py quarantine
{"variant": "quarantine", "outcome": "match", "detail": "витрина построена: заказов 245, хороших по эталону 245; плохих в витрине 0; в карантине 15"}

Остановка защищает витрину от плохих строк ценой всех хороших: 5% брака задержали 95% данных. «Витрина не построена» в таблице — следствие постановки: перед каждым режимом витрины удалены. В жизни перед остановкой обычно была успешная загрузка, и это меняет исход:

$ python3 scripts/run-reaction.py fail-kept
{"variant": "fail-kept", "outcome": "mismatch", "detail": "сборка остановлена; витрина не пересобрана, осталась от прошлой загрузки: заказов 259 — прошлая загрузка 259, хороших в новой партии 245"}

Витрина-таблица не пересобрана и отдаёт прошлую загрузку. Отчёт не пуст — он устарел, и потребитель этого не видит: в самих числах ничего не говорит, что партия за день не прошла. Остановке нужна парная проверка — свежести витрины (время последней успешной сборки против обещанного срока), иначе она тихо превращается в «старые данные под видом текущих». Предупреждение пропускает плохие строки в витрину — тест отработал, но кроме строки в журнале ничего не изменилось. Карантин делает то, что обычно и нужно: хорошие строки на месте, плохие отделены и ждут разбора, их число видно сразу. Цена карантина — правила надо выразить построчно, а не тестом над таблицей, и кто-то должен отвечать за то, что лежит в карантине.

Выбор зависит от того, что хуже для потребителя: неполные данные или неверные. Для финансовой отчётности — остановка; для дашборда активности — карантин и тревога, если брака больше порога.

Контракт: схема, а не смысл

Контракт данных — договорённость между производителем и потребителем: какие колонки, каких типов, что они значат и как свежи. Часть, которую в этом опыте проверяет машина, — схема: в dbt это contract: {enforced: true} у модели — сборка падает, если имена или типы колонок не совпали с объявленными (контракты моделей).

Постановка. Модель с контрактом и модель select * без него, над каждой — витрина выручки. Источник меняет схему тремя способами.

источник модель с контрактом модель без контракта витрина над ней выручка среднее GE
исходная схема (контроль) строится строится строится ×1,00 в норме
сумма стала numeric ошибка строится строится ×1,00 в норме
колонку суммы удалили ошибка строится ошибка — —
рубли вместо копеек, тип тот же строится строится строится ×0,01 упало

Контроль сошёлся: на исходной схеме строится всё.

$ python3 scripts/run-contract.py units
{"variant": "units", "outcome": "mismatch", "detail": "с контрактом: success; без контракта: модель success, витрина success, выручка ×0.0100 от контроля; среднее GE упало"}

Смену типа контракт остановил на своей модели, а без контракта она прошла незаметно — здесь безвредно, значения те же, но следующая смена типа может оказаться не такой безобидной. Удалённую колонку модель без контракта проглотила, а сломалась витрина уровнем ниже: ошибка всплыла не там, где изменилась схема. Контракт останавливает такие изменения на границе.

Машинная часть контракта в этом опыте — объявленные колонки и типы:

# dbt/models/contract/schema.yml
  - name: orders_contracted
    config:
      contract: {enforced: true}
    columns:
      - {name: id, data_type: bigint}
      - {name: customer_id, data_type: int}
      - {name: status, data_type: text}
      - {name: amount, data_type: bigint}
      - {name: created_at, data_type: timestamp}

Смену единиц контракт не видит: тип тот же, имя то же — и выручка в витрине стала в 100 раз меньше. Контракт этого опыта проверяет имена и типы, и смена единиц при сохранённой схеме остаётся незамеченной. Контракты dbt умеют и ограничения — для PostgreSQL, например, not_null и check, — и условие вроде «сумма не меньше 100 копеек» поймало бы часть рублёвых значений; но ограничение проверяет каждую строку, а не распределение. Смысл ловят проверки значений — здесь ожидание среднего — и человеческая часть контракта: описание единиц, владелец данных, порядок изменений, как у контрактов событий.

SLA: что обещано потребителю

Проверки и контракт отвечают «плохая ли партия». SLA отвечает на другое: что потребитель получит и когда, если партия плохая. Это договорённость, а не настройка, и у витрины выручки из этой статьи она могла бы выглядеть так:

пункт пример для витрины выручки чем проверяется на стенде
срок готовности данные за день — к 06:00 следующего дня на стенде не проверяется: нужна проверка, что витрина с партией за этот день успешно построена до срока. Freshness источника (порог 24 часа) — отдельный сигнал: источник, загруженный в 02:00, свеж и в 07:00, когда срок витрины уже нарушен
допустимая неполнота не больше 5% строк партии в карантине, витрина помечена как неполная счёт карантина
что считается браком правила из schema.yml и построчные правила карантина тесты dbt, флаг is_valid
смысл полей сумма в копейках, тип bigint контракт — тип; смысл — только проверка распределения
владелец команда источника заказов — за партию, команда хранилища — за витрину —
восстановление исправленная партия перезагружается целиком, витрина пересобирается, карантин разбирается в течение рабочего дня —

Половина пунктов на стенде проверяется машиной, половина — нет: владелец и порядок восстановления существуют только как договорённость. Без них сработавшая проверка — это сообщение, которое некому прочитать.

Как выбирать

что на стенде что делать
построчные правила ловят оба набора одинаково писать там, где уже живёт трансформация
распределение и объём построчные правила их не видят проверки партии целиком: среднее, число строк, по истории
ссылочная целостность и свежесть в наборе GE их не было relationships и freshness источника или их аналоги
разделение строк флаг без coalesce потерял 12 строк с NULL coalesce(..., false) и контроль: валидные до бизнес-фильтров + карантин = партия
реакция fail задерживает все данные и оставляет прошлую витрину, warn пропускает брак остановка — когда неверные данные опаснее задержки публикации, и вместе с проверкой свежести витрины; карантин — когда допустима явно обозначенная неполнота
контракт ловит смену типа и удаление колонки контракт на границе с источником
смена смысла контракт из имён и типов не видит проверки значений, ограничения контракта, договорённость о единицах

Чего эти результаты не значат

  • Наборы проверок — типичные, а не исчерпывающие. dbt с пакетами расширений проверяет и объём, GE — свежесть; стенд сравнивает то, что обычно пишут, а не возможности инструментов.
  • Один дефект за раз на оси 1. Несколько дефектов сразу — только в партии оси 2.
  • Коридор среднего задан вручную (±20% от среднего чистых партий); подбор порогов по истории и поиск аномалий без правил — тема статьи про наблюдаемость данных.
  • Версии: dbt-core 1.12.5, dbt-postgres 1.11.0, Great Expectations 1.24.0, PostgreSQL 18.6.

Ссылки

Обсуждение в Telegram

Присоединиться →