К содержимому
Войти

Python Road Map

🧭 NoSQL и ClickHouse

Postgres закрывает большую часть задач бэкенда, но не все. Аналитика по миллиардам событий, документы с меняющейся структурой, счётчики на сотни тысяч запросов в секунду — тут берут другие базы, и у каждой своя цена. В вакансиях Go чаще всего из этой страницы просят ClickHouse: он есть примерно в каждой пятой вакансии мидла и в 29% вакансий сеньора по нашему срезу. В вакансиях Node.js-мидлов впереди MongoDB с 12%, ClickHouse — около 6%. Знать на собеседовании все базы не требуют. Спрашивают, почему в этой задаче Postgres, а в той другая база. Цифры ниже сняты на одном ноутбуке: PostgreSQL 16 и MongoDB 5.0 в Docker, ClickHouse 26.9 через встроенный движок chDB

🧭 Какие бывают базы

Словом NoSQL называют всё, что не реляционная таблица со строками. Под ним четыре семейства, и устроены они по-разному

ТипКак хранитСильная сторонаСлабое местоПримеры
Key-valueзначение по ключу, база не знает, что внутричтение и запись по ключу за доли миллисекундынет запросов по содержимомуRedis, etcd
ДокументнаяJSON-подобные документы, у каждого своя структураобъект читается и пишется целиком, схема меняется без миграцийсвязи между документами, joinMongoDB
Широкие колонкистроки по ключу партиции, разложенные по многим узламзапись масштабируется добавлением узловзапросы только по заранее продуманному ключуCassandra, ScyllaDB
Колоночная аналитическаякаждая колонка отдельно и сжатаагрегаты по миллиардам строк за секундыточечные изменения и чтение одной строкиClickHouse

Redis подробно разобран в модуле про кэш. Здесь — две базы, которые чаще встречаются рядом с Postgres в бэкенде: ClickHouse для аналитики и MongoDB для документов

📊 ClickHouse: почему аналитика летает

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

Одни и те же 10 млн событий с пятью полями:

PostgreSQL 16ClickHouse 26.9
Размер на диске651 МБ76 МБ
group by event_type с count и avg630–780 мс23–26 мс

Агрегат быстрее в 25–30 раз, данные меньше в 8. Сильнее всех сжалась колонка user_id: с 38 МБ до 235 КБ, потому что после сортировки каждое значение идёт подряд около сотни раз. Кроме того, ClickHouse обрабатывает значения пачками, а не по строке, и раскладывает запрос по всем ядрам

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

Сортировка вместо индексов

Таблицу ClickHouse создают с движком MergeTree и ключом сортировки:

create table events (
    user_id    UInt32,
    ts         DateTime,
    event_type LowCardinality(String),
    url        String,
    duration_ms UInt32
) engine = MergeTree
order by (user_id, ts);

Строки на диске лежат отсортированными по (user_id, ts). Индекс тут разреженный: одна запись не на строку, а на гранулу из 8192 строк. Для 10 млн строк это 1221 запись, весь индекс помещается в память. По условию на user_id ClickHouse бинарным поиском находит нужные гранулы и читает только их

Что показывает explain indexes = 1 для двух фильтров:

where user_id = 4242            Granules: 1/1221   Search Algorithm: binary search
where event_type = 'purchase'   Granules: 1221/1221

Фильтр по первому полю ключа читает одну гранулу, не больше 8192 строк из 10 млн. Фильтр по полю, которого нет в начале ключа, читает все гранулы. Поэтому ключ сортировки выбирают под главные запросы, как составной индекс в Postgres, только он у таблицы один

Вставка пачками

Каждый insert создаёт на диске новый кусок (part) со своими файлами колонок и индексом. Фоновые слияния склеивают куски в крупные. Если вставлять по строке, кусков становится больше, чем успевают слияния, и ClickHouse начинает отвечать ошибкой Too many parts

В тесте слияния остановили и сделали 1000 отдельных insert по одной строке: получилось 1000 кусков за 2 секунды, и это без сети. Те же 1000 строк одним insert — один кусок за 2,7 мс. Когда кусков в одной партиции больше 1000, ClickHouse искусственно замедляет вставки, больше 3000 — отклоняет их. Документация советует пачки от 1000 строк, лучше 10–100 тысяч, и не чаще одного запроса в секунду

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

insert into events settings async_insert = 1, wait_for_async_insert = 1
values (4242, now(), 'view', '/p/1', 120);

С wait_for_async_insert = 1 клиент получает ответ, только когда буфер записан на диск. Ноль быстрее, но об ошибке записи клиент уже не узнает

Обновления и дубли

ClickHouse не меняет строки на месте. alter table ... update и alter table ... delete — мутации: асинхронно переписывают каждый затронутый кусок и не откатываются. Лёгкий delete from дешевле: помечает строки скрытой колонкой, а физически удаляет при слиянии. В последних версиях есть и лёгкий update, но и он рассчитан на исправление до 10% таблицы, а не на поток изменений

Для данных, которые меняются, берут ReplacingMergeTree: при слиянии из строк с одинаковым ключом сортировки остаётся последняя версия. Когда случится слияние, неизвестно, поэтому дубли видны в запросах:

create table users (id UInt32, name String, ver UInt32)
engine = ReplacingMergeTree(ver) order by id;

insert into users values (1, 'Анна', 1);
insert into users values (1, 'Анна Петрова', 2);

select count() from users;        -- 2
select count() from users final;  -- 1, «Анна Петрова»

final схлопывает дубли во время запроса и стоит лишнего чтения. Другой способ — агрегат argMax(name, ver) с group by id, он тоже вернул «Анна Петрова». Документация прямо пишет, что движок не гарантирует отсутствие дублей. Если нужна точная уникальность, это не та база

📄 MongoDB: документ вместо join

В MongoDB единица хранения — документ, JSON с вложенными объектами и массивами, до 16 МБ. Заказ с позициями и адресом доставки — один документ, а не три таблицы:

db.orders.insertOne({
  _id: 1001,
  userId: 42,
  status: "new",
  total: 2200,
  address: { city: "Казань", street: "Баумана, 1" },
  items: [
    { sku: "A-1", qty: 2, price: 500 },
    { sku: "B-7", qty: 1, price: 1200 }
  ]
})

Запись одного документа атомарна, даже если меняет несколько вложенных полей. Добавить позицию и пересчитать сумму можно одной операцией без транзакции, а условие status: "new" в фильтре не даст поменять уже оплаченный заказ:

db.orders.updateOne(
  { _id: 1001, status: "new" },
  { $push: { items: { sku: "C-3", qty: 1, price: 300 } }, $inc: { total: 300 } }
)

Главный вопрос моделирования — вкладывать или ссылаться. Вкладывают то, что читается и меняется вместе с родителем и растёт ограниченно: позиции заказа, адрес. Ссылаются, когда детей неограниченно много, они живут сами по себе или часто меняются отдельно: отзывы к товару, сообщения в чате. Документ, в который бесконечно дописывают массив, однажды упрётся в 16 МБ. В тесте в массив дописывали по мегабайту: 15 раз прошло, на шестнадцатый сервер ответил Resulting document after update is larger than 16777216

Рядом с вложением почти всегда идёт денормализация: имя пользователя копируют в его заказы, чтобы не делать join при каждом чтении. Join в MongoDB есть ($lookup в агрегации), но платить им за каждое чтение — значит потерять то, ради чего брали документную базу. Цена денормализации — копии надо обновлять при изменении оригинала. Редко меняемое копируют спокойно, часто меняемое держат ссылкой

Транзакции на несколько документов в MongoDB тоже есть: на реплика-сете с версии 4.0, на шардированном кластере с 4.2. Документация сама предупреждает, что они дороже записи одного документа и не заменяют продуманную схему

Когда Mongo, а когда Postgres с JSONB

Postgres хранит JSON в колонке jsonb, индексирует его через GIN и ищет по вложенным полям. Если документы — только часть данных, а рядом есть связанные таблицы с транзакциями, обычно хватает jsonb, и вторая база не нужна. MongoDB выигрывает, когда документы — вся модель, схема часто меняется, а горизонтальное шардирование нужно из коробки

🧩 Как выбирают базу

Выбор базы на собеседовании объясняют через нагрузку. Помогают четыре вопроса:

  1. Какие запросы главные: по ключу, по связям между сущностями, агрегаты по истории
  2. Сколько записи и как она устроена: дописывание событий или изменение текущего состояния
  3. Нужны ли транзакции на несколько сущностей и строгая уникальность
  4. Сколько данных через год и помещаются ли они на один сервер

Деньги, заказы, пользователи и всё, где нужны транзакции, — Postgres. Аналитика и логи — ClickHouse, и данные туда часто везут через Kafka, чтобы не вставлять по строке из каждого сервиса. Кэш и счётчики — Redis. MongoDB — когда объекты самодостаточны и читаются целиком. Две базы вместо одной — это две системы в эксплуатации, бэкапы, мониторинг и синхронизация между ними, поэтому вторую добавляют, когда первая упёрлась, а не на старте

⚠️ Где ошибаются

Пишут в ClickHouse по одной строке из каждого запроса. Под нагрузкой куски появляются быстрее, чем сливаются: вставки сначала замедляются, потом падают с Too many parts. Нужна пачка в приложении, асинхронная вставка или Kafka перед ClickHouse

Ждут от ReplacingMergeTree уникальности. Отчёт без final считает каждую версию строки, и сумма заказов за день завышена на все неслитые обновления. Либо final и цена чтения, либо агрегат с argMax по версии, либо данные без обновлений

Выбирают ключ сортировки по привычке из Postgres. order by id при запросах «события пользователя за неделю» заставляет читать всю таблицу. Ключ начинают с поля, по которому фильтруют чаще всего

Тащат в MongoDB реляционную модель. Каждая сущность в своей коллекции, связи через $lookup — получается Postgres без внешних ключей и с медленными join. Если данные такие, нужна реляционная база

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

🎯 Вопросы с собеседований

Когда выбрать NoSQL вместо Postgres?

Когда нагрузка не ложится на строки и транзакции: аналитика по миллиардам событий, данные с меняющейся структурой, читаемые целиком, запись, которая не помещается на один сервер. Для денег, заказов и всего со связями и транзакциями остаётся Postgres. Часто вторую базу ставят рядом с Postgres: он держит текущее состояние, ClickHouse хранит историю для отчётов

Почему ClickHouse быстрее Postgres на аналитике?

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

Как устроен первичный ключ в ClickHouse?

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

Почему в ClickHouse нельзя вставлять по одной строке?

Каждая вставка создаёт на диске новый кусок со своими файлами, а фоновые слияния склеивают куски. При частых мелких вставках слияния не успевают, и сервер отвечает Too many parts. Вставляют пачками от тысячи строк, раз в секунду или реже, а если пачку собрать негде, включают async_insert

Как обновить или удалить данные в ClickHouse?

alter table update и alter table delete запускают мутации, которые асинхронно переписывают затронутые куски. Это тяжело и подходит для редких исправлений. Лёгкий delete from помечает строки и удаляет их при слиянии. Если данные меняются регулярно, используют ReplacingMergeTree с колонкой версии и читают с final, а старые данные удаляют целыми партициями

Что такое денормализация и чем за неё платят?

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

В MongoDB вкладывать документ или ссылаться?

Вкладывают то, что принадлежит родителю, читается вместе с ним и растёт ограниченно, например позиции заказа. Ссылаются, когда детей неограниченно много, они нужны отдельно от родителя или часто меняются сами. Ограничение размера документа 16 МБ не даёт вкладывать бесконечный массив

Есть ли в MongoDB транзакции?

Запись одного документа атомарна всегда, даже если меняет несколько вложенных полей. Транзакции на несколько документов есть с версии 4.0 на реплика-сете и с 4.2 на шардированном кластере. Они дороже, поэтому схему строят так, чтобы связанные изменения попадали в один документ

📚 Что почитать

  • A practical introduction to primary indexes in ClickHouse — как разреженный индекс находит гранулы и как порядок полей в ключе определяет, какие запросы будут быстрыми
  • Selecting an insert strategy — размер пачек, куски и асинхронная вставка с настройками по умолчанию
  • ReplacingMergeTree — как движок убирает дубли при слиянии и что делает final
  • Embedded Data Versus References — документация MongoDB о том, когда вкладывать данные, а когда ссылаться