🥇Обзор гибких методологий проектирования DWH

Разработка хранилища — дело долгое и серьезное.

Многое в жизни проекта зависит от того, насколько хорошо продумана объектная модель и структура базы на старте.

Общепринятым подходом были и остаются различные варианты сочетания схемы “звезда” с третьей нормальной формой. Как правило, по принципу: исходные данные — 3NF, витрины — звезда. Этот подход, проверенный временем и подкрепленный большим количеством исследований — первое (а иногда и единственное), что приходит в голову опытному DWH-шнику при мысле о том, как должно выглядеть аналитическое хранилище.

С другой стороны — бизнесу в целом и требованиям заказчика в частности свойственно быстро меняться, а данным — расти как “вглубь”, так и “вширь”. И вот тут проявляется основной недостаток звезды — ограниченная гибкость.

И если в вашей тихой и уютной жизни DWH-разработчика внезапно:

возникла задача “сделать быстро хоть что-то, а потом посмотрим”;
появился бурно развивающийся проект, с подключением новых источников и переделкой бизнес-модели минимум раз в неделю;
появился заказчик, который не представляет как система должна выглядеть и какие функции выполнять в конечном итоге, но готов к экспериментам и последовательному уточнению желаемого результата с последовательным же приближением к нему;
заглянул менеджер проектов с радостной вестью: “А теперь у нас аджайл!”.

Или если вам просто интересно узнать как еще можно строить хранилища — вэлкам под кат!

Что значит «гибкость»

Для начала давайте определимся, какими свойствами должна обладать система, чтобы ее можно было назвать “гибкой”.

Отдельно стоит оговориться, что описываемые свойства должны относиться именно к системе, а не к процессу ее разработки. Поэтому если вы хотели почитать про Agile как методологию разработки, лучше ознакомиться с другими статьями. Например, тут же, на Хабре, есть масса интересных материалов (как обзорных и практических, так и проблемных).

Это не значит, что процесс разработки и структура ХД совсем никак не связаны. В целом разрабатывать по Agile хранилище гибкой архитектуры должно быть существенно легче. Однако на практике чаще встречаются варианты и с разработкой по Agile классического DWH по Кимбалу и DataVault — по вотэрфолу, чем счастливые совпадения гибкости в двух ее ипостасях на одном проекте.

И так, какими же возможностями должно обладать гибкое хранилище? Тут можно выделить три пункта:

Ранняя поставка и быстрая доработка — это значит, что в идеале первый бизнес-результат (например, первые работающие отчеты) должен быть получен как можно раньше, то есть еще до того, как полностью спроектирована и внедрена система целиком. При этом каждая следующая доработка тоже должна занимать как можно меньше времени.
Итеративная доработка — это значит, что каждая следующая доработка в идеале не должна затрагивать уже работающий функционал. Именно этот момент часто становится самым большим кошмаром на крупных проектах — рано или поздно отдельные объекты начинают обрастать таким количеством связей, что становится проще полностью повторить логику в копии рядом, чем добавить поле в существующую таблицу. И если вас удивляет, что анализ влияния доработки на существующие объекты может занимать больше времени, чем сама доработка — вы скорее всего ещё не работали с крупными ХД в банкинге или телекоме.
Постоянная адаптация к меняющимся требованиям бизнеса — общая объектная структура должна быть спроектирована не просто с учетом возможного расширения а с расчетом на то, что направление этого очередного расширения не могло бы вам даже присниться на этапе проектирования.

И да, соответствие всем этим требованиям в одной системе возможно (разумеется, в определенных случаях и с некоторыми оговорками).

Ниже я рассмотрю две самых популярных для ХД методологии гибкого проектирования — Anchor model и Data Vault. За скобками остаются такие прекрасные приемы, как например EAV, 6NF(в чистом виде) и всё, относящееся к NoSQL решениям — не потому, что они чем-то хуже, и даже не потому, что в этом случае статья грозила бы приобрести объем среднестатистического дисера. Просто всё это относится к решениям несколько другого класса — либо к приемам, которые вы можете применять в специфических случаях, независимо от общей архитектуры вашего проекта (как EAV), либо к глобально другим парадигмам хранения информации (как, например, графовые БД и другие варианты NoSQL).

Проблемы “классического” подхода и их решения в гибких методологиях

Под “классическим” подходом подразумеваю старую добрую звезду (независимо от конкретной реализации нижележащих слоёв, да простят меня адепты Кимбола, Инмона и CDM).

1. Жесткая кардинальность связей

В основу такой модели закладывается четкое разделение данных на измерения (Dimension) и факты (Fact). И это, черт побери, логично — ведь анализ данных в подавляющем большинстве случаев сводится именно к анализу определенных численных показателей (фактов) в определенных разрезах (измерениях).

При этом связи между объектами закладываются в виде связей между таблицами по внешнему ключу. Это выглядит вполне естественно, но сразу же приводит к первому ограничению гибкости — жесткому определению кардинальности связей.

Это значит, что на этапе проектирования таблиц вы должны точно определить для каждой пары связанных объектов могут ли они относиться как многие-ко-многим, или только 1-ко-многим, и “в какую сторону”. От этого напрямую зависит в какой из таблиц будет первичный ключ а в какой — внешний. Изменение этого отношения при получении новых требований с большой вероятностью приведет к переработке базы.

Например, проектируя объект “кассовый чек” вы, опираясь на клятвенные заверения отдела продаж, заложили возможность действия одной промо-акции на несколько чековых позиций (но не наоборот):

А через некоторое время, коллеги ввели новую маркетинговую стратегию, в которой на одну и ту же позицию могут действовать несколько промо-акций одновременно. И теперь вам надо доработать таблицы, выделив связь в отдельный объект.

(Все производные объекты, в которых происходит джойн чека на промо, теперь тоже нуждаются в доработке).

Связи в Data Vault и Anchor Model

Избежать такой ситуации оказалось довольно просто: не надо верить отделу продаж для этого достаточно все связи изначально хранить в отдельных таблицах и обрабатывать как многие-ко-многим.

Такой подход был предложен Дэном Линстедтом (Dan Linstedt) как часть парадигмы Data Vault и полностью поддержан Ларсом Рённбэком (Lars Rönnbäck) в Якорной Модели (Anchor Model).

В итоге получаем первую отличительную особенность гибких методологий:

Связи между объектами не хранятся в атрибутах родительских сущностей, а представляют собой отдельный тип объектов.

В Data Vault такие таблицы-связки называются Link, а в Якорной Модели — Tie. На первый взгляд они очень похожи, хотя названием их различия не исчерпываются (о чем пойдет разговор ниже). В обеих архитектурах таблицы-связки могут связывать любое количество сущностей (не обязательно 2).

Эта на первый взгляд избыточность дает существенную гибкость при доработках. Такая структура становится толерантной не только к изменению кардинальностей существующих связей, но и к добавлению новых — если теперь у чековой позиции появится ещё и ссылка на пробившего ее кассира, появление такой связки станет просто надстройкой над существующими таблицами без влияния на какие-либо существующие объекты и процессы.

2. Дублирование данных

Вторая проблема, решаемая гибкими архитектурами, менее очевидна и свойственна в первую очередь измерениям типа SCD2 (медленно меняющиеся измерения второго типа), хотя и не только им.

В классическом хранилище измерение обычно представляет собой таблицу, которая содержит суррогатный ключ (в качестве PK) а также набор бизнес-ключей и атрибутов в отдельных колонках.

Если измерение поддерживает версионность, к стандартному набору полей добавляются границы времени действия версии, а на одну строку в источнике появляется несколько версий в хранилище (по одной на каждое изменение версионных атрибутов).

Если измерение содержит хотя бы один часто изменяющийся версионный атрибут, количество версий такого измерения будет внушительным (даже если остальные атрибуты не версионные, или никогда не изменяются), а если таких атрибутов несколько — количество версий может расти в геометрической прогрессии от их количества. Такое измерение может занимать существенный объем дискового пространства, хотя большая часть хранящихся в нем данных — просто дубли значений неизменных атрибутов из других строк.

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

Как правило, это приводит к тому, что одна и та же информация хранится одновременно в нескольких местах. Например, информация о регионе проживания и принадлежности категории клиента может одновременно храниться в измерениях “Клиент”, и фактах “Покупка”, “Доставка” и “Обращения в колл-центр”, а также в таблице-связке “Клиент — Клиентский менеджер”.

В целом описанное выше относятся и к обычным (не версионным) измерениям, но в версионных могут иметь иной масштаб: появление новой версии объекта (особенно задним числом), приводит не просто к обновлению всех связанных таблиц, а к каскадному появлению новых версий связанных объектов — когда Таблица 1 используется при построении Таблицы 2, а Таблица 2 — при построении Таблицы 3 и т.д. Даже если ни один атрибут Таблицы 1 не участвует в построении Таблицы 3 (а участвуют другие атрибуты Таблицы 2, полученные из иных источников), версионное обновление этой конструкции как минимум приведет к дополнительным накладным расходам, а как максимум — к лишним версиям в Таблице 3, которая тут вообще “не при чем” и далее по цепочке.

3. Нелинейная сложность доработки

При этом каждая новая витрина, строящаяся на основании другой, увеличивает количество мест, в которых данные могут “разойтись” при внесении изменений в ETL. Это, в свою очередь, приводит к возрастанию сложности (и длительности) каждой следующей доработки.

Если вышеописанное касается систем с редко дорабатываемыми ETL-процессами, жить в такой парадигме можно — достаточно просто следить за тем, чтобы новые доработки корректно вносились во все связанные объекты. Если же доработки происходят часто, вероятность случайно “упустить” несколько связей существенно возрастает.

Если вдобавок учесть, что “версионный” ETL существенно сложнее, чем “не версионный”, избежать ошибок при частой доработке всего этого хозяйства становится достаточно сложно.

Хранение объектов и атрибутов в Data Vault и Anchor Model

Подход, предлагаемый, авторами гибких архитектур, можно сформулировать так:

Необходимо отделить то, что изменяется, от того, что остается неизменным. То есть хранить ключи отдельно от атрибутов.

При этом не стоит путать не версионный атрибут с неизменным: первый не хранит историю своего изменения, но может меняться (например, при исправлении ошибки ввода или получении новых данных) второй — не меняется никогда.

Точки зрения на то, что именно можно считать неизменным в Data Vault и Якорной модели расходятся.

С точки зрения архитектуры Data Vault, неизменным можно считать весь набор ключей — натуральные (ИНН организации, код товара в системе-источнике и т.п) и суррогатные. При этом остальные атрибуты можно разделить по группам по источнику и/или частоте изменений и для каждой группы вести отдельную таблицу с независимым набором версий.

В парадигме же Anchor Model неизменным считается только суррогатный ключ сущности. Всё остальное (включая натуральные ключи) — просто частный случай его атрибутов. При этом все атрибуты по умолчанию независимы друг от друга, поэтому для каждого атрибута должна быть создана отдельная таблица.

В Data Vault таблицы, содержащие ключи сущностей, называются Хабами (Hub). Хабы всегда содержат фиксированный набор полей:

Натуральные ключи сущности
Суррогатный ключ
Ссылку на источник
Время добавления записи

Записи в Хабах никогда не изменяются и не имеют версий. Внешне хабы очень похожи на таблицы типа ID-map, применяемые в некоторых системах для генерации суррогатов, однако в качестве суррогатов в Data Vault рекомендуется применять не целочисленный сиквенс, а хэш от набора бизнес-ключей. Такой подход упрощает загрузку связей и атрибутов из источников (не надо джойниться на хаб для получения суррогата, достаточно просто посчитать хэш от натурального ключа), но может вызвать другие проблемы (связанные, например, с коллизиями, регистром и непечатными символами в строковых ключах и т.п.), поэтому не является общепринятым.

Все остальные атрибуты сущностей хранятся в специальных таблицах, называемых Сателлитами (Satellit). Один хаб может иметь несколько сателлитов, хранящих разные наборы атрибутов.

Распределение атрибутов по сателлитам происходит по принципу совместного изменения — в одном сателлите могут храниться не версионные атрибуты (например, дата рождения и СНИЛС для физ.лица), в другом — редко изменяющиеся версионные (например, фамилия и номер паспорта), в третьем — часто изменяющиеся (например, адрес доставки, категория, дата последнего заказа и.т.п). Версионность при этом ведется на уровне отдельных сателлитов, а не сущности в целом, поэтому распределение атрибутов целесообразно проводить так, чтобы пересечение версий внутри одного сателлита было минимальным (что сокращает общее количество хранимых версий).

Также, для оптимизации процесса загрузки данных, в отдельные сателлиты часто выносятся атрибуты, получаемые из различных источников.

Сателлиты связываются с Хабом по внешнему ключу (что соответствует кардинальности 1-ко-многим). Это значит, что множественные значение атрибутов (например, несколько контактных номеров телефона у одного клиента) поддерживается такой архитектурой “по умолчанию”.

В Якорной модели (Anchor Model) таблицы, хранящие ключи, называются Якорями (Anchor). И хранят они:

Только суррогатные ключи
Ссылку на источник
Время добавления записи

Натуральные ключи с точки зрения Якорной Модели считаются обычными атрибутами. Такой вариант может показаться более сложным для понимания, но он дает намного больше простора для идентификации объекта.

Например, если данные об одной и той же сущности могут поступать из разных систем, в каждой из которых используется свой натуральный ключ. В Data Vault это может приводить к достаточно громоздким конструкциям из нескольких хабов (по одному на источник + объединяющая мастер-версия), в Якорной модели же натуральный ключ каждого источника попадает в свой атрибут и может использоваться при загрузке независимо от всех остальных.

Но тут кроется и один коварный момент: если в одной сущности объединяются атрибуты из различных систем, скорее всего существуют некоторые правила “склейки”, по которым система должна понимать, что записи из разных источников соответствуют одному экземпляру сущности.

В Data Vault эти правила скорее всего будут определять формирование “суррогатного хаба” мастер-сущности и никак не влиять на Хабы, хранящие натуральные ключи источников и их исходные атрибуты. Если в какой-то момент правила склейки поменяются (или придет обновление атрибутов, по которым она производится), достаточно будет переформировать суррогатные хабы.

В Якорной модели же такая сущность скорее всего будет храниться в единственном якоре. Это значит, что все атрибуты, независимо от того, из какого источника они получены, будут привязаны к одному и тому же суррогату. Разделить ошибочно слитые записи и в целом отслеживать актуальность склейки в такой системе может оказаться существенно труднее, особенно, если правила достаточно сложные и часто изменяются, а один и тот же атрибут может быть получен из разных источников (хотя точно возможно, т.к. каждая версия атрибута сохраняет ссылку на свой источник).

В любом случае, если в вашей системе предполагается реализация функционала дедубликации, слияния записей и других элементов MDM, стоит особенно внимательно ознакомиться с аспектами хранения натуральных ключей в гибких методологиях. Вероятно, более громоздкая конструкция Data Vault внезапно окажется более безопасной с точки зрения ошибок слияния.

Якорная модель также предусматривает дополнительный тип объекта, называемый Узлом (Knot) по сути это специальный вырожденный вид якоря, который может содержать всего один атрибут. Узлы предполагается использовать для хранения плоских справочников (например пол, семейное положение, категория обслуживания клиентов и т.п). В отличии от Якоря, Узел не имеет связанных таблиц атрибутов, а его единственный атрибут (название) всегда хранится в одной таблице с ключем. Узлы связываются с Якорями таблицами-связями (Tie) также, как якоря друг с другом.

Однозначного мнения по поводу использования Узлов нет. Например, Николай Голов, активно продвигающий применение Якорной модели в России, считает (не безосновательно), что ни для одного справочника нельзя точно утверждать, что он всегда будет статическим и одноуровневым, поэтому для всех объектов лучше сразу использовать полноценный Якорь.

Еще одно важное различие Data Vault и Якорной модели состоит в наличии атрибутов у связей:

В Data Vault Связи являются таким же полноценными объектами, как и Хабы, и могут иметь собственные атрибуты. В Якорной модели Связи используются только для соединения Якорей и собственных атрибутов иметь не могут. Это различие дает существенно разные подходы к моделированию фактов, о чем пойдет речь далее.

Хранение фактов

До этого мы говорили в основном про моделирование измерений. С фактами дело обстоит чуть менее однозначно.

В Data Vault типичный объект для хранения фактов — Связь (Link), в Сателлиты которой складываются вещественные показатели.

Такой подход выглядит интуитивно понятным. Он дает простой доступ к анализируемым показателям и в целом похож на традиционную таблицу фактов (только показатели хранятся не в самой таблице, а в “соседней”). Но есть и подводные камни: одна из типовых доработок модели — расширение ключа факта — вызывает необходимость добавления в Link нового внешнего ключа. А это в свою очередь “ломает” модульность и потенциально вызывает необходимость доработок других объектов.

В Якорной модели Связь не может иметь собственных атрибутов, поэтому такой подход не прокатит — абсолютно все атрибуты и показатели обязаны иметь привязку к одному конкретному якорю. Вывод из этого простой — для каждого факта тоже нужен свой якорь. Для части того, что мы привыкли воспринимать как факты, это может выглядеть естественно — например, факт покупки прекрасно сводится к объекту “заказ” или “чек”, посещение сайта — к сессии и т.п. Но встречаются и факты, для которых найти такой естественный “объект-носитель” не так просто — например, остатки товаров на складах на начало каждого дня.

Соответственно, проблем с модульностью при расширении ключа факта в Якорной модели не возникает (достаточно просто добавить новую Связь к соответствующему Якорю), но проектирование модели для отображения фактов менее однозначно, могут появляться “искусственные” Якоря, отображающие объектную модель бизнеса не очевидно.

Как достигается гибкость

Получившаяся конструкция в обоих случаях содержит существенно больше таблиц, чем традиционное измерение. Но может занимать существенно меньше дискового пространства при том же наборе версионных атрибутов, что и традиционное измерение. Никакой магии тут, естественно, нет — всё дело в нормализации. Распределяя атрибуты по Сателлитам (в Data Vault) или отдельным таблицам (Anchor Model), мы уменьшаем (или совсем исключаем) дублирование значений одних атрибутов при изменении других.

Для Data Vault выигрыш будет зависеть от распределения атрибутов по Сателлитам, а для Якорной модели — практически прямо пропорционален среднему количеству версий на объект измерения.

Однако выигрыш по занимаемому месту — важное, но не главное преимущество отдельного хранения атрибутов. Вместе с отдельным хранением связей, такой подход делает хранилище модульной конструкцией. Это значит, что добавление как отдельных атрибутов, так и целых новых предметных областей в такой модели выглядит как надстройка над существующим набором объектов без их изменения. И это именно то, что делает описанные методологии гибкими.

Также это напоминает переход от штучного производства к массовому — если в традиционном подходе каждая таблица модели уникальна и требует отдельного внимания, то в гибких методологиях — это уже набор типовых “деталей”. С одной стороны, таблиц становится больше, процессы загрузки и выборки данных должны выглядеть сложнее. С другой — они становятся типовыми. А значит, могут быть автоматизированы и управляться метаданными. Вопрос “как будем укладывать?”, ответ на который мог занимать существенную часть работ по проектированию доработок, теперь просто не стоит (как и вопрос о влиянии изменения модели на работающие процессы).

Это не значит, что аналитики в такой системе совсем не нужны — кто-то все еще должен проработать набор объектов с атрибутами и разобраться откуда и как всё это загружать. Но объем работ, а также вероятность и цена ошибки существенно снижаются. Как на этапе анализа, так и при разработке ETL, которая в существенной части может свестись к редактированию метаданных.

Темная сторона

Всё вышеописанное делает оба подхода действительно гибкими, технологичными и пригодными для итеративной доработки. Разумеется есть и “бочка дегтя”, о которой вы, думаю, уже догадываетесь.

Декомпозиция данных, лежащая в основе модульности гибких архитектур, приводит к увеличению количества таблиц и, соответственно, накладных расходов на джойны при выборке. Для того, чтобы просто получить все атрибуты измерения, в классическом хранилище достаточного одного селекта, а гибкая архитектура потребует целого ряда джойнов. Причем если для отчетов все эти джойны можно написать заранее, то аналитики, привыкшие писать SQL руками, будут страдать вдвойне.

Есть несколько фактов, облегчающих такое положение:

При работе с большими измерениям почти никогда не используются одновременно все его атрибуты. Это значит, что джойнов может быть меньше, чем кажется при первом взгляде на модель. В Data Vault можно также учесть предполагаемую частоту совместного использования при распределении атрибутов по сателлитам. При этом сами Хабы или Якори нужны в первую очередь для генерации и маппинга суррогатов на этапе загрузки и редко используются в запросах (особенно это касается Якорей).

Все джойны — по ключу. Кроме того, более “сжатый” способ хранения данных снижает накладные расходы на сканирование таблиц там, где оно необходимо (например при фильтрации по значению атрибута). Это может приводить к тому, что выборка из нормализованной базы с кучей джойнов будет даже быстрее, чем сканирование одного тяжелого измерения с большим количеством версий на строку.

Например, вот в этой статье есть подробный сравнительный тест производительности Якорной модели с выборкой из одной таблицы.

Многое зависит от движка. У многих современных платформ есть внутренние механизмы оптимизации джойнов. Например, MS SQL и Oracle умеют “пропускать” джойны на таблицы, если их данные не используются нигде, кроме других джойнов и не влияют на финальную выборку (table/join elimination), а MPP Vertica по опыту коллег из Авито, показала себя как прекрасный движок для Якорной модели с учетом некоторой ручной оптимизации плана запроса. С другой стороны, хранить Якорную модель, например, на Click House, имеющем ограниченную поддержку join, пока выглядит не очень хорошей идеей.

Кроме того, для обеих архитектур существуют специальные приемы, облегчающие доступ к данным (как с точки зрения производительности запросов, так и для конечных пользователей). Например, Point-In-Time таблицы в Data Vault или специальные табличные функции в Якорной модели.

Итого

Основная суть рассмотренных гибких архитектур состоит в модульности их “конструкции”.

Именно это свойство позволяет:

После некоторой начальной подготовки, связанной с развертыванием метаданных и написанием базовых алгоритмов ETL, быстро предоставить заказчику первый результат в виде парочки отчетов, содержащих данные всего нескольких объектов источников. Полностью продумывать (даже верхнеуровнево) всю объектную модель для этого не обязательно.
Модель данных может начать работать (и приносить пользу) всего с 2-3 объектами, а потом постепенно разрастаться (относительно Якорной модели Николай применил красивое сравнение с грибницей).
Большинство доработок, включая расширение предметной области и добавление новых источников не затрагивает существующий функционал и не вызывает опасность сломать что-то уже работающее.
Благодаря декомпозиции на стандартные элементы, ETL-процессы в таких системах выглядят однотипно, их написание поддается алгоритмизации и, в конечном счете, автоматизации.

Ценой такой гибкости является производительность. Это не значит, что достигнуть приемлемой производительности на таких моделях невозможно. Чаще всего, вам просто может потребоваться больше усилий и внимания к деталям для достижения нужных метрик.