Наследование в базах данных: три способа и цена каждого
Содержание
В объектных моделях есть наследование, а в реляционных базах данных его нет, и каждое приложение, отображающее одно на другое, должно решить, как это сделать. Есть три стандартных ответа плюс один, который PostgreSQL предлагает встроенно, и выбор влечёт последствия для ограничений, запросов, индексов и объектно-реляционного отображения (ORM), которое будет работать поверх. Я хочу разложить их ясно, потому что это решение обычно принимается по умолчанию, а через год о нём жалеют.
Возьмём обычный пример. У Vehicle есть id, owner и registration. Car добавляет doors; Truck добавляет payload_kg.
Наследование в одной таблице
Одна таблица хранит всё, со столбцом, который говорит, к какому виду относится строка:
(
id SERIAL PRIMARY KEY,
kind TEXT NOT NULL CHECK (kind IN ('car', 'truck')),
owner TEXT NOT NULL,
registration TEXT NOT NULL UNIQUE,
doors INTEGER,
payload_kg INTEGER
);
Запросы тривиальны. Каждое транспортное средство — одна строка в одной таблице; «все транспортные средства владельца X» — одно сканирование, а «все грузовики» — фильтр по kind. Полиморфная загрузка не требует соединений.
Ограничения слабые. doors должен быть NULL для грузовика и NOT NULL для легковушки, и схема не может этого выразить без check-ограничения на каждый столбец подкласса:
CHECK ((kind = 'car') = (doors IS NOT NULL)),
CHECK ((kind = 'truck') = (payload_kg IS NOT NULL))
Для двух подклассов это работает. Для двадцати, по десять столбцов в каждом, таблица в основном состоит из NULL, а check-ограничения превращаются в стену текста. Потерянное место редко бывает проблемой; проблема — потеря схемы как документации.
Индексы общие. Индекс по payload_kg индексирует и NULL каждой легковушки. Частичные индексы (WHERE kind = 'truck') решают это там, где база данных их поддерживает.
Это любимец ORM, потому что его проще всего реализовать, и это правильный выбор, когда подклассы различаются несколькими столбцами, а запросы по всей иерархии идут постоянно.
Наследование «таблица на класс»
Одна таблица на каждый класс, причём таблицы подклассов хранят только свои столбцы и внешний ключ на строку родителя:
(
id SERIAL PRIMARY KEY,
owner TEXT NOT NULL,
registration TEXT NOT NULL UNIQUE
);
(
id INTEGER PRIMARY KEY REFERENCES vehicle(id) ON DELETE CASCADE,
doors INTEGER NOT NULL
);
(
id INTEGER PRIMARY KEY REFERENCES vehicle(id) ON DELETE CASCADE,
payload_kg INTEGER NOT NULL
);
Ограничения точны. Каждый столбец NOT NULL там, где должен, схема читается как диаграмма классов, а внешний ключ на vehicle(id) означает «любое транспортное средство», тогда как ключ на car(id) означает «легковушка». Это нормализованный ответ, и именно его нарисует на доске человек, разбирающийся в базах данных.
Запросам нужны соединения. Загрузка легковушки — это vehicle JOIN car. Загрузка «всех транспортных средств с данными их подклассов» — это LEFT JOIN к каждой таблице подкласса или по запросу на подкласс и слияние в приложении. Вставка легковушки — две вставки в одной транзакции. Ничто из этого не сложно; всё это больше работы на строку, чем с одной таблицей, и ORM будет скрывать это от вас до того дня, когда вы заглянете в журнал запросов.
Одного схема выразить не может: что у строки vehicle ровно одна строка подкласса — не ноль и не две. Обеспечить это можно триггером или добавив столбец kind в vehicle и соответствующий столбец в каждый подкласс с составным внешним ключом. Большинство людей не утруждаются, и большинство в конце концов находят сироту.
Наследование «таблица на конкретный класс»
Одна таблица на каждый конкретный класс, каждая несёт все унаследованные столбцы, и родительской таблицы нет вовсе:
(
id SERIAL PRIMARY KEY,
owner TEXT NOT NULL,
registration TEXT NOT NULL UNIQUE,
doors INTEGER NOT NULL
);
(
id SERIAL PRIMARY KEY,
owner TEXT NOT NULL,
registration TEXT NOT NULL UNIQUE,
payload_kg INTEGER NOT NULL
);
Каждая таблица самодостаточна, что быстро для запросов внутри класса и приятно для класса, который почти никогда не рассматривается как свой родитель.
Родитель исчезает. Таблицы vehicle нет, поэтому другой таблице не на что сослаться, когда она имеет в виду «любое транспортное средство». UNIQUE на registration действует в пределах таблицы, так что легковушка и грузовик могут иметь один и тот же номер, и чтобы это исправить, нужен триггер или внешняя таблица. «Все транспортные средства» — это UNION ALL по всем таблицам подклассов, и добавление подкласса означает изменение каждого такого запроса. Две последовательности SERIAL к тому же выдают пересекающиеся id, так что один id больше не идентифицирует транспортное средство; нужен (kind, id), о чём у ORM будет своё мнение.
Используйте это, когда классы разделяют интерфейс в коде, но в данных действительно являются отдельными сущностями. Это неправильный выбор в тот момент, когда что-то должно указывать на родителя.
Встроенный вариант PostgreSQL
В PostgreSQL наследование таблиц встроено:
(
id SERIAL PRIMARY KEY,
owner TEXT NOT NULL,
registration TEXT NOT NULL UNIQUE
);
(doors INTEGER NOT NULL) INHERITS (vehicle);
(payload_kg INTEGER NOT NULL) INHERITS (vehicle);
SELECT * FROM vehicle возвращает и строки car и truck со столбцами родителя, а SELECT * FROM ONLY vehicle — только строки, вставленные непосредственно в родителя. Хранение — как в «таблице на конкретный класс» (каждый потомок хранит свои полные строки); запросы — как в одной таблице (родитель видит всё). Выглядит как лучшее из обоих миров.
Подвох в том, что не наследуется. Ограничения уникальности, первичные ключи и внешние ключи действуют в пределах таблицы. UNIQUE (registration) на vehicle не мешает легковушке и грузовику иметь один номер, а внешний ключ REFERENCES vehicle(id) из другой таблицы не примет id легковушки, потому что строки легковушки нет в индексе vehicle. Check-ограничения и NOT NULL наследуются; индексы — нет, и их надо создавать на каждом потомке. Это задокументировано, и именно поэтому эта возможность используется гораздо чаще для секционирования, чем для моделирования.
Что с вами сделает ORM
Каждое объектно-реляционное отображение поддерживает первые две стратегии, и большинство — третью; Hibernate называет их SINGLE_TABLE, JOINED и TABLE_PER_CLASS. Два предупреждения из опыта.
По умолчанию ORM почти всегда выбирает одну таблицу, потому что так проще всего для ORM. Это не то же самое, что правильно для ваших данных.
И ORM будет генерировать полиморфные запросы за вас, а значит, вы не увидите LEFT JOIN к двенадцати таблицам подклассов, пока он не станет медленным. Выбирайте стратегию, глядя на запросы, которые вы действительно будете выполнять, напишите два из них вручную для каждой схемы и выбирайте с планом запроса перед глазами.
Правило, которым я пользуюсь
Одна таблица — когда подклассы мало различаются и преобладают запросы по всей иерархии. Таблица на класс — когда схема должна быть правильной, а соединения по карману, то есть в большинстве случаев. Таблица на конкретный класс — когда классы разделяют только код. INHERITS из PostgreSQL — для секций, а для моделирования — только дважды перечитав абзац о том, что не наследуется.