← Все статьи

Сервис бронирования: как предотвратить двойную запись на одно время

· 14 мин чтения

Решение задачи двойного бронирования через уникальные индексы PostgreSQL. Разобранный сценарий гонок, SQL-скрипты, обработка ошибок и сравнение стратегий защиты данных при конкурентном доступе.

Два пользователя одновременно нажимают кнопку «Забронировать» на один и тот же час в спортзале. Оба получают сообщение «Успех», но в базе появляются две записи на одно время. Клиент звонит в поддержку, потому что ему назначили занятие, которое уже занято другим человеком. Это классическая проблема гонки условий (race condition). В высоконагруженных системах бронирования она возникает регулярно, если защита построена только на проверке наличия свободного места перед вставкой строки. Цель этой статьи — показать, как настроить схему данных и логику приложения так, чтобы база данных гарантированно отклоняла вторую запись, независимо от скорости реакции клиентов. Мы рассмотрим, почему стандартные проверки недостаточны, как правильно спроектировать индексы в PostgreSQL 16 и как обрабатывать исключения в приложении, чтобы пользователь видел понятные сообщения об ошибке, а не сырые технические коды.

Природа проблемы: TOCTOU

Ошибка называется Time-of-check to time-of-use (TOCTOU). Система сначала проверяет состояние («слот свободен?»), а затем изменяет его («вставляем бронь»). Между этими двумя действиями проходит время. Если два процесса выполняют проверку одновременно, оба видят слот свободным, и оба пытаются его занять. Простая логика «SELECT, IF empty THEN INSERT» небезопасна в многопользовательской среде. Гарантировать отсутствие двойной записи можно только на уровне базы данных, используя механизмы, которые делают операцию атомарной относительно других процессов. Изоляция транзакций определяет, какие данные видит каждая транзакция, но сама по себе она не предотвращает конфликт при одновременной записи. Нам нужен механизм, который делает невозможным успешное завершение второго INSERT с теми же ключевыми атрибутами. Важно понимать, что изоляция уровней READ COMMITTED или REPEATABLE READ не защищает от гонок при записи. Только SERIALIZABLE может, но он приводит к частым ошибкам сериализации, которые требуют сложной логики повторов. Уникальные ограничения работают на всех уровнях изоляции и являются более предсказуемым инструментом.

Схема данных для защиты

Для корректной работы нам нужны три основные таблицы. Таблица slots содержит предопределённые временные интервалы. Таблица bookings хранит сами брони. Критически важным элементом является уникальный индекс, который физически запрещает создание второй записи с одинаковыми ключевыми атрибутами. Мы используем PostgreSQL 16, который поддерживает частичные индексы, позволяющие применять ограничения только к определенному подмножеству строк. Это позволяет нам иметь множество исторических записей для одного слота, но только одну активную. Если бы мы использовали обычный уникальный индекс на slot_id, мы не смогли бы повторно бронировать слот после отмены предыдущей брони, так как старая запись оставалась бы в таблице. Частичный индекс решает эту проблему, игнорируя неактивные записи при проверке уникальности.

-- PostgreSQL 16. Ресурс имеет вместимость один.
-- Каталог слотов неизменяем после начала бронирования.
CREATE EXTENSION IF NOT EXISTS btree_gist;
CREATE TABLE slots (
    id BIGINT PRIMARY KEY,
    resource_id INT NOT NULL,
    start_time TIMESTAMPTZ NOT NULL,
    end_time TIMESTAMPTZ NOT NULL,
    CHECK (end_time > start_time),
    EXCLUDE USING gist (
        resource_id WITH =,
        tstzrange(start_time, end_time, '[)') WITH &&
    )
);
CREATE TABLE bookings (
    id BIGSERIAL PRIMARY KEY,
    slot_id BIGINT NOT NULL REFERENCES slots(id) ON DELETE RESTRICT,
    user_id INT NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
    CHECK (status IN ('ACTIVE', 'CANCELLED'))
);
CREATE UNIQUE INDEX idx_unique_active_booking
ON bookings (slot_id) WHERE status = 'ACTIVE';
Этот подход гарантирует, что даже если два процесса пройдут проверку логики, база данных отклонит вторую вставку с ошибкой нарушения уникальности. Это самый надежный метод, так как он работает на уровне хранилища, независимо от сложности клиентского кода или сетевых задержек. Индекс строится только на строках, удовлетворяющих условию WHERE, что делает его компактным и быстрым. При поиске коллизий движок базы данных сканирует только активные записи, что значительно ускоряет операцию по сравнению с полным сканированием таблицы.

Атомарная операция создания брони

Логика приложения должна обрабатывать ошибку конфликта. Мы не можем просто «проверить и вставить», так как это оставляет окно для гонок. Вместо этого мы пытаемся вставить данные напрямую. Если слот занят, база данных вернёт ошибку, которую мы перехватываем и показываем пользователю понятное сообщение. Этот паттерн часто называют «Optimistic Concurrency Control» (Оптимистичный контроль конкурентности), хотя технически он опирается на жесткие ограничения целостности. Приложение должно быть готовым к тому, что большинство операций завершатся успехом, но часть из них упадёт с ошибкой уникальности. Это нормальное поведение, а не сбой системы. Код приложения должен содержать блок try-catch (или аналог в вашем языке программирования), который перехватывает конкретный код ошибки базы данных (например, 23505 в PostgreSQL) и преобразует её в пользовательский интерфейс.

INSERT INTO bookings (slot_id, user_id, status)
VALUES (:slot_id, :user_id, 'ACTIVE')
RETURNING id;
Если этот запрос завершается ошибкой 23505 (unique_violation), это означает, что кто-то другой успел забронировать этот слот первым. Важно понимать разницу между изоляцией транзакций и атомарностью операции. Изоляция определяет, какие данные видит транзакция, но сама по себе она не предотвращает конфликт при записи. Атомарность записи обеспечивается уникальным ограничением. Даже в режиме изоляции SERIALIZABLE лучше явно обрабатывать ошибки уникальности, так как сериализация может приводить к повторным попыткам (serialization failure), что усложняет логику клиента и увеличивает нагрузку на базу данных. Обработка ошибки должна быть быстрой, чтобы не держать соединение открытым слишком долго.

Разбор учебного сценария

Рассмотрим ситуацию с двумя клиентами: Алисой и Бобом. Они хотят забронировать зал №1 на 14:00. В таблице slots существует запись с id=101 для этого времени. Этот сценарий иллюстрирует, как работает защита на уровне ядра СУБД. Мы проследим хронологию событий с точностью до миллисекунд, чтобы увидеть, где именно происходит конфликт. Обратите внимание, что ни один из пользователей не выполняет SELECT перед INSERT. Они просто отправляют POST-запрос на создание брони. Вся проверка происходит неявно при выполнении INSERT-запроса. Это ключевой момент: мы доверяем базе данных, а не своему коду проверки.

  1. 14:00:00.100 — Алиса отправляет запрос на бронирование. Транзакция T1 начинает работу. Движок БД резервирует ресурсы для операции.
  2. 14:00:00.105 — Боб отправляет запрос. Транзакция T2 начинает работу. Обе транзакции выполняются параллельно.
  3. 14:00:00.110 — T1 выполняет INSERT. Запись создаётся успешно. Индекс обновляется, фиксируя, что слот 101 теперь занят.
  4. 14:00:00.115 — T2 выполняет INSERT с тем же slot_id=101. База данных видит конкурирующую запись для слота 101. Если T1 ещё не завершилась, T2 ждёт её исхода: при commit возникнет конфликт, при rollback вставка может продолжиться.
  5. 14:00:00.130 — После успешного COMMIT T1 транзакция T2 получает ошибку ERROR: duplicate key value violates unique constraint "idx_unique_active_booking". Транзакция T2 откатывается.
  6. 14:00:00.135 — Приложение ловит ошибку в T2 и возвращает Бобу сообщение: «Это время только что стало недоступным. Пожалуйста, выберите другое.»

В этом сценарии ни Алиса, ни Боб не увидели «чистого» состояния до попытки записи. Безопасность обеспечила база данных, а не приложение. Если бы мы использовали проверку SELECT COUNT(*) FROM bookings WHERE slot_id=101 AND status='ACTIVE' перед вставкой, оба могли бы увидеть count=0 и оба попытались бы вставить. При успешной фиксации первой активной брони индекс запрещает фиксацию второй активной брони того же слота. При откате первой попытки вторая может завершиться успешно. Это фундаментальный принцип: не доверяйте проверкам состояния, доверяйте ограничениям структуры данных. Данный подход устраняет необходимость в распределенных блокировках и упрощает архитектуру микросервисов.

Обработка отмены и освобождения слота

Когда пользователь отменяет бронь, статус меняется с ACTIVE на CANCELLED. Поскольку наш уникальный индекс построен частично (WHERE status = 'ACTIVE'), отменённая запись перестает участвовать в проверке уникальности. Это позволяет другому пользователю немедленно забронировать освободившийся слот. Этот механизм критически важен для систем с высокой оборачиваемостью ресурсов. Если бы индекс был полным, отмена брони навсегда заблокировала бы слот, так как запись осталась бы в таблице и нарушала бы уникальность для любой новой попытки. Частичный индекс динамически изменяет набор строк, участвующих в проверке, что позволяет гибко управлять жизненным циклом броней.

UPDATE bookings
SET status = 'CANCELLED', updated_at = NOW()
WHERE id = :booking_id AND user_id = :current_user_id AND status = 'ACTIVE';

Здесь важна осторожность. Если мы просто удаляли бы запись (DELETE), мы бы потеряли историю. Использование статуса позволяет сохранять аудит-трейл. Однако нужно учитывать, что если у нас есть сложные правила (например, нельзя отменять бронь меньше чем за 2 часа до начала), эти проверки должны выполняться в том же атомарном блоке или через триггеры, чтобы избежать состояний, где слот считается занятым, но фактически доступен. Также важно, чтобы обновление статуса происходило в рамках транзакции, чтобы исключить промежуточные состояния. Обновление должно быть идемпотентным: повторная отмена уже отменённой брони не должна изменять её состояние. Авторизацию и принадлежность брони проверяют на сервере независимо от результата обновления.

Сравнение стратегий защиты

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

СтратегияЧто обеспечиваетУсловие корректностиКонфликт
SELECT перед INSERTПроверяет доступность в момент чтенияСам по себе не закрывает гонкуДве попытки могут увидеть свободный слот
Частичный UNIQUEНе более одной ACTIVE-брони на slot_idNOT NULL, ограниченный набор статусов, единый каталогОжидание конкурента и ошибка при его commit
Версия строки слотаОтклоняет обновление устаревшей версииВсе пути записи проверяют и меняют версию атомарноПовторное чтение и новая попытка
SELECT FOR UPDATEСериализует работу с заблокированным слотомВсе писатели берут ту же блокировку до проверкиОжидание либо согласованный отказ
Внешняя блокировкаКоординирует участников при соблюдении протоколаНужна защита от истёкшей аренды и согласование с БДПоведение зависит от протокола, UNIQUE остаётся защитой
Уникальный индекс — наиболее предпочтительный вариант для простых сценариев, так как он не требует дополнительных компонентов и гарантирует консистентность данных в самой базе. Пессимистические блокировки могут привести к замедлению системы при высокой нагрузке, так как другие пользователи будут ждать освобождения блокировки. Использование Redis добавляет сеть-зависимость и проблему согласованности между кэшем и основной базой данных. Недоступность Redis или истечение аренды требует явно выбранного поведения; сам по себе внешний ключ не защищает запись в основной БД от владельца просроченной блокировки. Поэтому для критически важных финансовых или медицинских систем локальная гарантия в RDBMS предпочтительнее распределенных механизмов.

Ограничения и крайние случаи

Даже с уникальным индексом существуют нюансы. Во-первых, если время слота определяется не дискретными значениями, а диапазоном (например, «любое время во вторник»), логика становится сложнее. В таком случае уникальный индекс на конкретный start_time не защитит от перекрытия диапазонов. Для диапазонов PostgreSQL поддерживает ограничение EXCLUDE с оператором пересечения. Расширение btree_gist позволяет сочетать сравнение идентификатора ресурса и диапазона в одном GiST-ограничении. Это ограничение исключения, а не уникальный индекс. В нашем DDL оно запрещает пересекающиеся слоты одного ресурса; полуоткрытый диапазон [) позволяет соседние интервалы без общей занятости в точке границы. Подробности приведены в документации PostgreSQL о диапазонах.

Во-вторых, важно различать «двойную запись» и «двойное подтверждение». Если пользователь случайно нажал кнопку дважды быстро, фронтенд должен блокировать повторные клики. Однако backend всё равно должен быть защищён, так как HTTP-запрос может быть повторён клиентом или посредником после потери ответа, или пользователь может открыть две вкладки браузера. Защита на уровне БД должна быть последней линией обороны, а не первой. Это особенно важно для мобильных приложений, где соединение нестабильно и повторные запросы — норма. Фронтенд может скрывать кнопку после первого клика, но это UX-оптимизация, а не мера безопасности. Backend должен оставаться устойчивым к любым формам повторения запросов.

Инструменты для проектирования

При проектировании такой схемы удобно использовать визуальные инструменты. Схема данных может быть описана в формате DBML или визуализирована через PlantUML. Это помогает команде понять, какие именно индексы создают ограничения. Например, в PlantUML можно указать, что связь между Bookings и Slots имеет ограничение уникальности для активных записей. Такая визуализация облегчает ревью архитектуры и помогает новичкам быстрее разобраться в структуре данных. Документирование этих ограничений в коде и в схемах предотвращает случайное удаление важных индексов при миграциях. Когда разработчики видят на диаграмме, что существует уникальный индекс, они понимают, что не могут просто удалить поле status или изменить его значения без последствий для целостности данных. Это способствует более осознанному проектированию и снижению количества багов, связанных с нарушением целостности.

@startuml
!define TABLE_COLOR #F9F9F9

entity "slots" {
 * id : bigint
 --
 * resource_id : int
 * start_time : timestamptz
 * end_time : timestamptz
}

entity "bookings" {
 * id : bigserial
 --
 * slot_id : bigint
 * user_id : int
 * status : varchar
}

slots ||--o{ bookings : "contains"
note right of bookings : Unique index on slot_id where status='ACTIVE'
@enduml
Такая диаграмма помогает архитекторам и разработчикам сразу увидеть критическое место, требующее особого внимания при написании кода. Она также служит документацией для будущих изменений: если кто-то захочет добавить возможность «переноса» брони, он увидит, что уникальность привязана к слоту и статусу. Перенос брони потребует изменения slot_id и, возможно, смены статуса, что должно быть аккуратно обработано в транзакции, чтобы не нарушить уникальность. Визуальное представление делает эти зависимости очевидными, что снижает риск ошибок при модификации схемы.

Частые ошибки реализации

1. Использование DELETE вместо CANCELLED. Если записи удаляются физически, невозможно восстановить историю действий пользователей. Кроме того, удаление может вызвать каскадные эффекты в связанных таблицах, чего хотелось бы избежать для аудита. Сохранение статуса позволяет отслеживать частоту отмен и анализировать поведение пользователей. Аудит-лог необходим для разрешения споров с клиентами и для аналитики эффективности сервиса. Физическое удаление данных затрудняет восстановление информации при технических сбоях и снижает прозрачность системы.

2. Неправильная зона времени. Если start_time хранится без таймзоны, а сервер находится в другом часовом поясе, чем пользователь, логика «одного времени» ломается. Всегда используйте TIMESTAMPTZ для конкретных моментов времени. PostgreSQL сохраняет момент и отображает его в часовой зоне сессии; исходное имя зоны не сохраняется. ISO 8601 с явным смещением — формат передачи в API, а не тип хранения. Это критично для глобальных сервисов. Неправильная обработка часовых поясов приводит к тому, что слоты, которые должны быть разными, оказываются идентичными в базе данных, вызывая ложные конфликты уникальности. Пользователи из разных стран видят разные времена, но система считает их одним и тем же слотом.

3. Игнорирование ошибок сети. Если клиент получил ошибку 500 после отправки запроса, он может повторить запрос. Если первая попытка прошла успешно, а вторая упала из-за таймаута ответа, повторная попытка столкнется с ошибкой уникальности. Клиентское приложение должно уметь отличить «бронь уже создана» от «системная ошибка» и показывать пользователю соответствующее сообщение. Это требует тщательного проектирования API: код ответа должен быть семантически правильным, чтобы клиент мог принять правильное решение. Использование HTTP 409 Conflict для ошибок уникальности является хорошим стандартом, который помогает автоматизировать обработку таких ситуаций на клиенте.

Итог

Предотвращение двойного бронирования — это задача, решаемая на стыке базы данных и приложения. Самый надежный способ — использование частичного уникального индекса в PostgreSQL, который физически блокирует создание второй активной записи для одного слота. Логика приложения должна быть построена вокруг обработки ошибки уникальности, а не вокруг предварительной проверки наличия места. Такой подход обеспечивает консистентность данных даже при высокой конкуренции, снижает сложность клиентского кода и устраняет классическую ошибку TOCTOU. Для сложных сценариев с пересекающимися интервалами потребуются дополнительные механизмы, но для большинства дискретных слотов уникальный индекс является оптимальным решением. Внедрение этих принципов повышает надежность системы и снижает количество обращений в службу поддержки. Рекомендуется начинать с простого подхода и усложнять его только при наличии конкретных требований, которые не могут быть покрыты базовым уникальным ограничением.

Проверка границ гарантии

Для этого примера ресурс имеет вместимость один, а слоты заранее создаются в едином каталоге без пересечений. Поля начала и конца после открытия бронирования менять запрещено: иначе существующая бронь незаметно изменит смысл. Запрет обеспечивается правами роли приложения или отдельным проверяемым обработчиком, а не только договорённостью в интерфейсе. Ограничение EXCLUDE не допускает второй пересекающийся слот для того же ресурса; UNIQUE не допускает вторую активную бронь одного слота. Для ресурса вместимостью три эта модель неприменима без дополнительной модели мест или атомарного счётчика доступности.

Запустите две транзакции одновременно: сначала с успешной фиксацией первой, затем с её откатом. Проверьте отмену и повторное бронирование, NULL в slot_id, неизвестный статус, интервалы с общей границей и попытку создать пересекающийся слот с другим ID. Отдельно проверьте потерю HTTP-ответа: повтор с тем же Idempotency-Key должен вернуть прежнюю бронь, а повтор с другим телом — согласованный конфликт. Уникальный индекс различает занятость слота, но не объясняет, принадлежит ли уже созданная бронь тому же запросу.

SQL-параметры с двоеточием — условные параметры приложения, их значения передают через подготовленный запрос. В статье показана структура защиты, а не готовый API: проверку прав, таблицу идемпотентности и правила отмены нужно согласовать отдельно. Структуру можно обсудить в редакторе PlantUML; принципы модели данных разобраны в обзоре уровней модели данных.