Наследование в базах данных: три способа и цена каждого

Содержание
  1. Наследование в одной таблице
  2. Наследование «таблица на класс»
  3. Наследование «таблица на конкретный класс»
  4. Встроенный вариант PostgreSQL
  5. Что с вами сделает ORM
  6. Правило, которым я пользуюсь

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

Возьмём обычный пример. У Vehicle есть id, owner и registration. Car добавляет doors; Truck добавляет payload_kg.

Наследование в одной таблице

Одна таблица хранит всё, со столбцом, который говорит, к какому виду относится строка:

CREATE TABLE vehicle (
    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, потому что его проще всего реализовать, и это правильный выбор, когда подклассы различаются несколькими столбцами, а запросы по всей иерархии идут постоянно.

Наследование «таблица на класс»

Одна таблица на каждый класс, причём таблицы подклассов хранят только свои столбцы и внешний ключ на строку родителя:

CREATE TABLE vehicle (
    id            SERIAL PRIMARY KEY,
    owner         TEXT NOT NULL,
    registration  TEXT NOT NULL UNIQUE
);

CREATE TABLE car (
    id     INTEGER PRIMARY KEY REFERENCES vehicle(id) ON DELETE CASCADE,
    doors  INTEGER NOT NULL
);

CREATE TABLE truck (
    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 и соответствующий столбец в каждый подкласс с составным внешним ключом. Большинство людей не утруждаются, и большинство в конце концов находят сироту.

Наследование «таблица на конкретный класс»

Одна таблица на каждый конкретный класс, каждая несёт все унаследованные столбцы, и родительской таблицы нет вовсе:

CREATE TABLE car (
    id            SERIAL PRIMARY KEY,
    owner         TEXT NOT NULL,
    registration  TEXT NOT NULL UNIQUE,
    doors         INTEGER NOT NULL
);

CREATE TABLE truck (
    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 наследование таблиц встроено:

CREATE TABLE vehicle (
    id            SERIAL PRIMARY KEY,
    owner         TEXT NOT NULL,
    registration  TEXT NOT NULL UNIQUE
);

CREATE TABLE car (doors INTEGER NOT NULL) INHERITS (vehicle);
CREATE TABLE truck (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 — для секций, а для моделирования — только дважды перечитав абзац о том, что не наследуется.