SQL или NoSQL: как выбрать базу данных на собеседовании по системному дизайну

Как выбрать между SQL и NoSQL на system design интервью: документные, key-value, wide-column и графовые базы, транзакции, масштабирование и готовые решения для типовых задач.

16 мин чтениясистемный дизайн · базы данных · собеседования

Коротко

МодельПримерыСильна вСлаба в
РеляционнаяPostgreSQL, MySQLСвязи, ограничения, транзакции, гибкие запросыЗапись сверх одной машины без шардирования
Key-valueRedis, DynamoDB, MemcachedЧтение и запись по ключу за миллисекундыЛюбой запрос не по ключу
ДокументнаяMongoDB, CouchbaseАгрегат целиком в одном документеСвязи многие-ко-многим, джойны
Wide-columnCassandra, ScyllaDB, HBaseОгромный поток записей, выборки по партицииAd hoc запросы, транзакции между партициями
ГрафоваяNeo4j, Amazon NeptuneОбход связей на несколько шаговМассовые агрегаты и простые CRUD
  • Выбирают не «SQL или NoSQL», а модель данных под конкретные запросы. Начните с того, какие операции система выполняет чаще всего.
  • Реляционная база по умолчанию — нормальный ответ. Уходить от неё нужно с причиной: объём записи, форма данных или требования к задержке.
  • «NoSQL масштабируется, SQL нет» — упрощение. Почти любая база масштабируется шардированием, вопрос в том, кто за это платит: база или ваша команда.
  • В одной системе обычно несколько хранилищ: Postgres для заказов, Redis для сессий, Cassandra для событий. Это нормально, если каждое решение обосновано.

Почему вопрос сформулирован неправильно

«NoSQL» — не одна технология, а зонтик для очень разных систем. У Redis и Neo4j общего меньше, чем у Neo4j и PostgreSQL. Поэтому ответ «возьмём NoSQL, потому что масштабируется» звучит для интервьюера как «возьмём язык программирования, потому что он быстрый».

Полезнее раскладывать выбор по трём осям:

  1. Модель данных. Как выглядят сущности и связи между ними: таблицы, вложенные документы, пары ключ-значение, граф.
  2. Паттерн доступа. Какие запросы самые частые, по какому ключу, с какой сортировкой, какое соотношение чтений и записей.
  3. Гарантии. Где нужны транзакции и строгая согласованность, а где допустимо прочитать слегка устаревшие данные.

Если вы проговорили эти три пункта, название базы почти выбирает себя само. Если нет — любое название будет выглядеть угаданным.

Реляционная модель: что вы получаете бесплатно

Реляционная база хранит данные нормализованно: каждая сущность в своей таблице, связи через внешние ключи. Её главное достоинство в том, что вы не обязаны заранее знать все запросы. Новый отчёт, новая выборка, новый фильтр — это новый SQL, а не переделка схемы хранения.

Что ещё идёт в комплекте:

  • Транзакции по нескольким строкам и таблицам. Перевод денег, списание остатка на складе и создание заказа — одной атомарной операцией.
  • Ограничения. UNIQUE, FOREIGN KEY, CHECK проверяет сама база, а не каждый сервис по отдельности.
  • Джойны и вторичные индексы. Любой столбец можно проиндексировать и искать по нему. Как индексы устроены и когда они мешают записи, разобрано в статье про индексы в базах данных.

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

import sqlite3 db = sqlite3.connect(":memory:") db.execute("""CREATE TABLE accounts ( id INTEGER PRIMARY KEY, balance INTEGER NOT NULL CHECK (balance >= 0) )""") db.executemany("INSERT INTO accounts VALUES (?, ?)", [(1, 100), (2, 0)]) db.commit() def transfer(src, dst, amount): try: with db: # BEGIN ... COMMIT, при исключении ROLLBACK db.execute("UPDATE accounts SET balance = balance + ? WHERE id = ?", (amount, dst)) db.execute("UPDATE accounts SET balance = balance - ? WHERE id = ?", (amount, src)) except sqlite3.IntegrityError as e: print("откат:", e) transfer(1, 2, 70) transfer(1, 2, 70) # денег не хватит print(db.execute("SELECT id, balance FROM accounts").fetchall()) # откат: CHECK constraint failed: balance >= 0 # [(1, 30), (2, 70)]

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

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

Отдельно стоит помнить: современный PostgreSQL умеет хранить JSON в jsonb и индексировать его. Поэтому «у нас гибкая схема» само по себе не причина уходить в документную базу.

Четыре семейства NoSQL

Key-value

Самая простая модель: ключ — непрозрачное значение. Операции get, put, delete, иногда атомарный инкремент и TTL. Взамен база отвечает очень быстро и легко шардируется: ключ однозначно определяет узел, например через консистентное хеширование.

Где уместно:

Ограничение жёсткое: найти что-то не по ключу нельзя без полного перебора или отдельного индекса, который вы поддерживаете сами. DynamoDB формально key-value и документная одновременно: у неё есть ключ партиции, ключ сортировки и вторичные индексы, но запросы всё равно проектируются от ключей.

Документные

Документ — это JSON-подобная структура со вложенными объектами и массивами. Ключевая идея: хранить агрегат целиком. Заказ вместе со строками, адресом доставки и статусами — один документ, который читается одним запросом без джойнов.

{ "_id": "order_812", "user_id": "u_42", "status": "paid", "items": [ { "sku": "book-17", "qty": 1, "price": 990 }, { "sku": "pen-03", "qty": 3, "price": 120 } ], "shipping": { "city": "Казань", "street": "Баумана, 1" } }

Это удобно, когда данные действительно образуют дерево и читаются вместе: карточки товаров с разными атрибутами, профили, CMS, настройки. Схема гибкая: у телефона и у книги разные поля, и это не требует миграций.

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

Практическое правило «встраивать или ссылаться»:

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

Последняя строка часто решает спор. Цена товара в заказе должна быть зафиксирована на момент покупки, поэтому копия внутри документа — не денормализация «ради скорости», а правильная модель предметной области.

Wide-column

Cassandra, ScyllaDB, HBase и Bigtable хранят данные как таблицы, но устроены иначе, чем Postgres. Главное понятие — ключ партиции: он определяет узел, на котором лежат строки. Внутри партиции строки отсортированы по ключу кластеризации. Отсюда правило, которое удивляет новичков: в такой базе таблицу проектируют под запрос, а не под сущность.

Хотите читать последние сообщения чата — делаете таблицу с партицией chat_id и сортировкой по времени. Хотите историю пользователя — вторую таблицу с партицией user_id. Одна запись в приложении превращается в две записи в базу. Модель в миниатюре:

from bisect import insort from collections import defaultdict

Каждая «таблица» — partition key -> отсортированный по clustering key список

messages_by_chat = defaultdict(list) # (chat_id) -> [(ts, user_id, text)] messages_by_user = defaultdict(list) # (user_id) -> [(ts, chat_id, text)]

def send(chat_id, user_id, ts, text): # Денормализация: одна запись приложения = две записи в базу insort(messages_by_chat[chat_id], (ts, user_id, text)) insort(messages_by_user[user_id], (ts, chat_id, text))

def last_in_chat(chat_id, limit): # Одна партиция, данные уже отсортированы: читаем хвост return messages_by_chat[chat_id][-limit:]

def user_history(user_id, limit): return messages_by_user[user_id][-limit:]

send("general", "ann", 1, "привет") send("general", "bob", 2, "здравствуй") send("random", "ann", 3, "кто на обед?") send("general", "ann", 4, "созвон в 12")

print(last_in_chat("general", 2))

[(2, 'bob', 'здравствуй'), (4, 'ann', 'созвон в 12')]

print(user_history("ann", 10))

[(1, 'general', 'привет'), (3, 'random', 'кто на обед?'), (4, 'general', 'созвон в 12')]


Запрос «все сообщения со словом "обед"» в этой модели не поддержан никак: ни одна таблица не разбита по словам. В Cassandra такой запрос либо запрещён, либо требует полного сканирования кластера. Для поиска рядом ставят Elasticsearch или OpenSearch.

Зато запись дешёвая: LSM-дерево превращает её в дописывание в лог и память, а партиции раскладываются по десяткам и сотням узлов. Поэтому wide-column берут для логов, метрик, IoT, лент событий и истории сообщений. Discord, например, хранит сообщения в такой модели: сначала перешёл с MongoDB на Cassandra, а позже с Cassandra на ScyllaDB, сохранив партицию по каналу и временному окну.

Типичная ловушка — партиция без ограничения роста. Канал с миллионом сообщений в одной партиции превращается в горячую точку, поэтому ключ делают составным: `(chat_id, месяц)`.

### Графовые

Если главный запрос звучит как «друзья друзей», «кратчайший путь между аккаунтами», «связанные транзакции в радиусе трёх шагов», данные стоит рассматривать как граф. Графовые базы хранят у каждой вершины прямые ссылки на соседей, поэтому шаг обхода стоит примерно одинаково независимо от размера всего графа.

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

```python
import sqlite3

db = sqlite3.connect(":memory:")
db.execute("CREATE TABLE follows (src TEXT, dst TEXT, PRIMARY KEY (src, dst))")
db.executemany("INSERT INTO follows VALUES (?, ?)", [
    ("ann", "bob"), ("bob", "eve"), ("eve", "dan"),
    ("ann", "kim"), ("kim", "eve"), ("dan", "ann"),
])

# Все, до кого можно дойти от ann не больше чем за 3 шага
rows = db.execute("""
WITH RECURSIVE reach(person, depth) AS (
    SELECT 'ann', 0
    UNION
    SELECT f.dst, r.depth + 1
    FROM reach r JOIN follows f ON f.src = r.person
    WHERE r.depth < 3
)
SELECT person, MIN(depth) FROM reach
WHERE person <> 'ann'
GROUP BY person ORDER BY 2, 1
""").fetchall()
print(rows)
# [('bob', 1), ('kim', 1), ('eve', 2), ('dan', 3)]

Каждый шаг рекурсии — это джойн через индекс. Если у вершины в среднем dd соседей, на глубине kk просматривается порядка dkd^k рёбер. При d=200d = 200 уже на третьем шаге это миллионы строк. Графовая база не отменяет эту комбинаторику, но обходит граф по указателям, а не через индекс. К тому же язык запросов (Cypher, Gremlin) короче для таких задач.

Сама логика обхода — обычный BFS, тот же, что в статье про DFS и BFS. На собеседовании графовую базу стоит предлагать, только если обход на несколько шагов — центральный запрос продукта: антифрод, рекомендации, граф знаний. Для «подписчиков пользователя» в ленте хватит обычной таблицы follows с индексом.

Транзакции и согласованность

Популярная схема «SQL = ACID, NoSQL = BASE» устарела. Картина сейчас такая:

БазаАтомарно без дополнительных усилийТранзакции шире
PostgreSQL, MySQLЛюбые строки и таблицыУровни изоляции вплоть до Serializable
MongoDBОдин документМногодокументные транзакции: с 4.0 в replica set, с 4.2 в шардированном кластере
DynamoDBОдин элементTransactWriteItems — до 100 действий за раз
CassandraСтроки внутри одной партицииLightweight transactions (compare-and-set на Paxos), заметно дороже обычной записи
RedisОдна командаMULTI/EXEC и Lua-скрипты, без отката при ошибке команды

Из таблицы два практических вывода.

Первый: моделируйте так, чтобы транзакции не понадобились. В документной базе заказ со строками — один документ, и его обновление атомарно без всяких транзакций. В Cassandra то, что должно меняться вместе, кладут в одну партицию. Если для основной операции продукта вам постоянно нужны транзакции между документами или партициями, вы, скорее всего, выбрали не ту модель.

Второй: транзакции в NoSQL есть, но они дороже и с ограничениями. Они уместны для редких операций, а не для горячего пути. Если же деньги, остатки и бронирования — сердце системы, реляционная база или распределённая SQL-база (Spanner, CockroachDB, YugabyteDB) честнее.

Ещё один уровень — согласованность реплик. Cassandra и DynamoDB позволяют выбирать её на каждый запрос: кворумное чтение или чтение с одной реплики. Как это связано с поведением при разделении сети и почему ярлыки «CP» и «AP» мало что говорят, разобрано в статье про CAP и PACELC. А что конкретно гарантирует транзакция в реляционной базе, зависит от уровня изоляции: об этом статья про уровни изоляции транзакций.

Масштабирование

Тезис «SQL не масштабируется» неверен в обе стороны. Реляционная база масштабируется: репликами на чтение, партициями, а затем шардированием. NoSQL-базы тоже не масштабируются бесплатно: плохой ключ партиции превратит кластер Cassandra из ста узлов в один перегруженный узел и 99 скучающих.

Реальное различие в том, кто делает шардирование:

  • Cassandra, DynamoDB, MongoDB шардируют сами. Вы выбираете ключ, база раскладывает данные и перебалансирует их при добавлении узлов. Но запрос, который не содержит ключа партиции, идёт на все узлы.
  • PostgreSQL и MySQL из коробки — одна машина-лидер. Шардирование делает приложение, прокси или расширение (Vitess, Citus). Это больше работы, но и больше контроля.
  • Распределённые SQL-базы (Spanner, CockroachDB, YugabyteDB, TiDB) шардируют сами и сохраняют SQL с транзакциями. Платите задержкой на консенсус при каждой записи и сложностью эксплуатации.

Как выбирать ключ, бороться с горячими шардами и делать решардинг, подробно в статье про шардирование и репликацию. Здесь важно одно: и в SQL, и в NoSQL ключ шардирования определяет, какие запросы останутся дешёвыми. В Postgres вы потеряете кросс-шардовые джойны, в Cassandra у вас их и не было.

Отдельный момент — вторичные индексы. В одной машине Postgres индекс по любому столбцу — обычное дело. В распределённой базе индекс бывает локальным (на каждом узле только для своих данных, поиск идёт по всем узлам) или глобальным (шардирован по индексируемому полю, но обновляется асинхронно или требует распределённой записи). В DynamoDB глобальные вторичные индексы как раз eventually consistent. Это стоит упомянуть, если интервьюер спрашивает «а как найти заказы по продавцу».

Порядок цифр

Перед выбором посчитайте нагрузку. Грубые ориентиры для разговора, а не для продакшена:

  • один хорошо настроенный Postgres или MySQL держит тысячи, при удачной схеме десятки тысяч записей в секунду и терабайты данных;
  • реплики и кэш закрывают чтения, пока лидер справляется с записью;
  • если по оценке выходит сотни тысяч записей в секунду и сотни терабайт в год, это аргумент за базу с встроенным шардированием или за шардирование с первого дня.

Так и говорите: «это порядок, а не точная цифра, зависит от схемы и железа». Как оценивать нагрузку в целом, описано в статье про подходы к системному дизайну.

Как выбирать: вопросы по порядку

На интервью полезно вслух пройти короткий список. Он занимает минуту и показывает, что выбор осознанный.

  1. Какие три запроса самые частые? Если все они по одному ключу — key-value или wide-column. Если запросы разнообразные и заранее неизвестны — реляционная.
  2. Как устроены связи? Дерево, которое читается целиком, — документ. Много связей многие-ко-многим — таблицы. Обход на несколько шагов — граф.
  3. Где нужны инварианты? Деньги, остатки, уникальность, бронирование мест — транзакции и ограничения, то есть SQL или распределённый SQL.
  4. Какой объём и соотношение записей и чтений? Поток событий в сотни тысяч в секунду, который почти не обновляется, — wide-column. Тысячи записей и много чтений — один лидер, реплики и кэш.
  5. Какая задержка допустима и какая согласованность нужна? Миллисекундный доступ по ключу — Redis или DynamoDB. Можно ли показать слегка устаревшие данные?
  6. Что знает команда? На собеседовании этот пункт редко решающий, но фраза «Postgres мы умеем эксплуатировать» — легитимный аргумент.

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

Примеры решений для типовых задач

ЗадачаОсновное хранилищеПочему
Сокращатель ссылокKey-value (DynamoDB, Cassandra) + кэшЕдинственный горячий запрос — code → url, чтений на порядки больше записей
История сообщений в мессенджереWide-column, партиция (chat_id, окно)Огромный поток записей, чтение последних N сообщений в одном чате
Заказы и платежиPostgreSQL / MySQLТранзакции, уникальность, отчёты, сверки
Каталог товаровДокументная или jsonb в PostgresРазные атрибуты у разных категорий, карточка читается целиком
Лента новостейRedis для готовых лент, SQL/wide-column для постовЛента — список ID по ключу пользователя, посты и подписки хранятся отдельно
Сессии, rate limitingRedisTTL, атомарный инкремент, задержка доли миллисекунды
Антифрод по связям аккаунтовГрафовая + основная SQLПоиск связанных аккаунтов на 3–4 шага
Метрики и логиWide-column или специализированная TSDBТолько дописывание, выборки по диапазону времени
Полнотекстовый поискElasticsearch / OpenSearch рядом с основной базойИнвертированный индекс; это вторичное хранилище, а не источник истины

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

Обратите внимание на последние строки: почти в каждой системе хранилищ несколько. Это называют polyglot persistence. Важно назвать источник истины для каждой сущности и способ синхронизации остальных копий: двойная запись, CDC из лога базы или события через очередь сообщений. Двойная запись из приложения без транзакции — классический источник рассинхронизации, интервьюер почти наверняка спросит, что будет при падении между двумя записями.

Разбор: сервис бронирования билетов

Пройдём вопросы из списка на одной задаче. Условие: продажа билетов на концерты, 10 млн пользователей, обычно спокойно, но в момент старта продаж популярного концерта за минуту приходят сотни тысяч человек.

Запросы. Посмотреть мероприятие и схему зала, забронировать конкретные места на 10 минут, оплатить, посмотреть свои билеты. Плюс поиск мероприятий по городу, дате и артисту.

Инварианты. Одно место нельзя продать дважды. Это центральное требование, и оно сразу говорит: нужна атомарная операция «проверить, что место свободно, и занять его». В SQL это UPDATE seats SET status = 'held', hold_until = ... WHERE id = ? AND status = 'free' и проверка числа изменённых строк. Если бронируется несколько мест сразу, все они меняются в одной транзакции: либо пользователь получает весь ряд, либо ничего.

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

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

Итог.

  • PostgreSQL для мест, бронирований, заказов и платежей. Шардирование, если понадобится, — по event_id, тогда все места концерта остаются в одном шарде и транзакции не становятся распределёнными.
  • Redis для виртуальной очереди, сессий и счётчиков. Истечение брони можно сделать и в Redis через TTL, но источник истины — строка в Postgres с hold_until.
  • Elasticsearch для поиска по мероприятиям, наполняется через CDC.

Заметьте, что NoSQL здесь появился, но не в роли основной базы. Предложить Cassandra для мест было бы ошибкой: lightweight transactions на каждом месте в момент пика — дорогой и медленный путь, а транзакция на несколько мест через партиции в ней не поддерживается.

Как это звучит на собеседовании

Для заказов возьму PostgreSQL: оформление заказа должно атомарно списать остаток, создать заказ и зарезервировать платёж, плюс бизнесу нужны отчёты по произвольным срезам. По оценке пик — около двух тысяч заказов в секунду, это укладывается в один лидер с репликами. Шардировать пока рано, но в ключи сразу закладываю user_id, чтобы потом шардировать по нему. Каталог товаров положу в jsonb в том же Postgres: атрибуты разные, а отдельная база ради этого — лишняя операционная сложность. А вот историю просмотров товаров — сотни тысяч событий в секунду, только дописывание, чтение последних N по пользователю — отправлю в Cassandra с партицией по user_id и сортировкой по времени. Если просмотры будут уходить в Cassandra асинхронно и мы потеряем часть событий при сбое, это допустимо — для рекомендаций это не критично.

За минуту вы назвали запросы, гарантии, цифры, цену решения и момент, когда оно перестанет работать.

Типичные ошибки

  • «NoSQL, потому что масштабируется». Без цифр нагрузки это не аргумент. Интервьюер спросит: какой объём, и почему один Postgres его не выдержит?
  • «MongoDB, потому что гибкая схема». Схема всё равно есть — в коде приложения. И jsonb закрывает многие такие случаи.
  • Документная база для сильно связанных данных. Пользователи, группы, права, подписки многие-ко-многим в документах превращаются в джойны на стороне приложения.
  • Cassandra без разговора о запросах. Назвать wide-column и не назвать ключ партиции — значит не понимать, как она работает.
  • Нереляционная база для денег без плана по атомарности. Если списание и зачисление в разных документах, нужен ответ, что будет при сбое посередине.
  • Одна база на всё — или десять баз на всё. Оба крайних варианта плохи. Каждое дополнительное хранилище — эксплуатация, мониторинг и синхронизация.
  • Растущий массив внутри документа или безразмерная партиция. Комментарии внутри поста и все сообщения канала в одной партиции рано или поздно упрутся в лимиты.

Что спрашивают дальше

ВопросКороткий ответ
Нужен новый запрос, а в Cassandra нет такой таблицыНовая таблица под запрос и бэкфилл, либо отдельный индекс или поисковый движок
Как найти пользователя по email, если шард по idОтдельная таблица или глобальный индекс email → id, шардированный по email
Что будет с джойнами после шардирования PostgresДжойны внутри шарда остаются, между шардами — денормализация или витрины
Когда документ лучше таблицДанные — дерево, читаются и меняются вместе, у разных записей разные поля
Почему не взять Spanner и не думатьМожно, но запись платит задержкой консенсуса, а эксплуатация и стоимость выше
Как синхронизировать Postgres и ElasticsearchCDC из WAL через очередь, а не двойная запись из приложения

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

Потренироваться в спокойной обстановке

Все задачи