Read Model: отдельная модель под чтение
Read Model: отдельная модель под чтение
Read Model - это представление данных «как удобно читать». Она не обязана быть источником правды - её всегда можно пересобрать из write-модели.
Зачем отдельная модель для чтения
Типичная проблема: UI требует данные из трёх-пяти таблиц. Каждый запрос - это JOIN, агрегация, форматирование. На 10 000 записей терпимо, на 1 000 000 - уже больно.
Без Read Model: С Read Model:
────────────────── ──────────────────
SELECT l.*, p.*, t.* SELECT * FROM track_lessons_view
FROM lessons l WHERE track_id = $1
JOIN tracks t ON ... AND user_id = $2
LEFT JOIN progress p ORDER BY sort_order
ON p.lesson_id = l.id
AND p.user_id = $2
WHERE t.id = $1
ORDER BY l.sort_order
→ 3 таблицы, 2 JOIN'а → 1 таблица, 0 JOIN'ов
→ Индексы конфликтуют → Индекс точно под запрос
→ Формат не совпадает с UI → Формат = то, что нужно фронту
Варианты реализации Read Model
1. Отдельная таблица (самый распространённый)
CREATE TABLE track_lessons_view (
track_id BIGINT NOT NULL,
lesson_id BIGINT NOT NULL,
user_id BIGINT NOT NULL,
lesson_title TEXT NOT NULL,
sort_order INT NOT NULL,
completed BOOLEAN NOT NULL DEFAULT false,
completed_at TIMESTAMPTZ,
duration_min INT NOT NULL DEFAULT 0,
PRIMARY KEY (track_id, lesson_id, user_id)
);
-- Индекс под основной запрос: «все уроки трека для пользователя»
CREATE INDEX idx_track_lessons_view_track_user
ON track_lessons_view(track_id, user_id, sort_order);
2. Materialized View
Materialized view вычисляется один раз - при CREATE и REFRESH. Значения из сессии (например, current_setting('app.user_id')) в неё класть нельзя: попадут данные той сессии, которая делала REFRESH. Поэтому строки строим сразу по всем пользователям:
CREATE MATERIALIZED VIEW track_stats_mv AS
SELECT
t.id AS track_id,
u.id AS user_id,
t.title,
COUNT(l.id) AS total_lessons,
COUNT(p.id) FILTER (WHERE p.completed) AS completed_lessons,
ROUND(COUNT(p.id) FILTER (WHERE p.completed)::numeric /
NULLIF(COUNT(l.id), 0) * 100) AS progress_percent
FROM tracks t
JOIN lessons l ON l.track_id = t.id
CROSS JOIN users u
LEFT JOIN progress p ON p.lesson_id = l.id AND p.user_id = u.id
GROUP BY t.id, u.id, t.title;
-- REFRESH ... CONCURRENTLY требует уникального индекса на materialized view
CREATE UNIQUE INDEX track_stats_mv_track_user ON track_stats_mv (track_id, user_id);
-- Обновляем по расписанию или по событию
REFRESH MATERIALIZED VIEW CONCURRENTLY track_stats_mv;
CROSS JOIN users даёт строку на каждую пару «трек - пользователь». На большой базе это дорого, и тогда лучше отдельная таблица из варианта 1, которую обновляют по событиям.
3. Денормализованный JSON в Redis (для редко меняющихся данных)
// Кэшируем в Redis как готовый JSON
type TrackOverview struct {
TrackID int64 `json:"track_id"`
Title string `json:"title"`
Lessons []LessonSummary `json:"lessons"`
TotalLessons int `json:"total_lessons"`
}
func (r *ReadRepo) CacheTrackOverview(ctx context.Context, overview TrackOverview) error {
data, _ := json.Marshal(overview)
return r.redis.Set(ctx,
fmt.Sprintf("track:%d:overview", overview.TrackID),
data,
30*time.Minute,
).Err()
}
<?php
declare(strict_types=1);
// Кэшируем в Redis как готовый JSON
final readonly class TrackOverview
{
public function __construct(
public int $trackId,
public string $title,
/** @var LessonSummary[] */
public array $lessons,
public int $totalLessons,
) {}
}
final class ReadRepository
{
public function __construct(
private readonly Redis $redis,
) {}
public function cacheTrackOverview(TrackOverview $overview): void
{
$payload = json_encode($overview, JSON_THROW_ON_ERROR);
$this->redis->setex(
"track:{$overview->trackId}:overview",
1800, // 30 минут
$payload,
);
}
}
import json
from dataclasses import asdict, dataclass
import redis # redis-py
# Кэшируем в Redis как готовый JSON
@dataclass(frozen=True, slots=True)
class TrackOverview:
track_id: int
title: str
lessons: list[LessonSummary]
total_lessons: int
class ReadRepo:
def __init__(self, client: redis.Redis) -> None:
self._redis = client
def cache_track_overview(self, overview: TrackOverview) -> None:
data = json.dumps(asdict(overview)) # asdict разворачивает и вложенные dataclass-ы
self._redis.set(
f"track:{overview.track_id}:overview",
data,
ex=30 * 60, # TTL 30 минут
)
ℹ️ Какой вариант выбрать
Отдельная таблица - универсальный выбор, работает для 90% случаев. Materialized view - если данные обновляются редко и допустима задержка. JSON в Redis - для «горячих» данных с высоким RPS (см. паттерны кеширования).
Денормализация: цена и выгода
Read model почти всегда денормализована - данные дублируются ради скорости чтения:
Выгода Цена
────────────────────── ──────────────────────────
Быстрое чтение (0 JOIN'ов) Дублирование данных
Индексы под конкретные запросы Нужен механизм обновления
Формат совпадает с API Eventual consistency
Простые запросы Больше места в БД
Главное правило: пишем в write model, читаем из read model. Если кто-то обновляет read model напрямую - архитектура сломана.
Как обновлять Read Model
Три подхода:
Синхронно (в той же транзакции)
func (h *CompleteLessonHandler) Handle(ctx context.Context, cmd CompleteLesson) error {
return h.db.Transaction(func(tx *gorm.DB) error {
// Write
if err := tx.Model(&Progress{}).
Where("user_id = ? AND lesson_id = ?", cmd.UserID, cmd.LessonID).
Update("completed", true).Error; err != nil {
return err
}
// Read model update (в той же транзакции)
return tx.Model(&TrackLessonsView{}).
Where("user_id = ? AND lesson_id = ?", cmd.UserID, cmd.LessonID).
Update("completed", true).Error
})
}
<?php
declare(strict_types=1);
final class CompleteLessonHandler
{
public function __construct(
private readonly Connection $db,
) {}
public function __invoke(CompleteLesson $cmd): void
{
$this->db->transactional(function (Connection $tx) use ($cmd): void {
// Write
$tx->update(
'progress',
['completed' => true],
['user_id' => $cmd->userId, 'lesson_id' => $cmd->lessonId],
);
// Read model update (в той же транзакции)
$tx->update(
'track_lessons_view',
['completed' => true],
['user_id' => $cmd->userId, 'lesson_id' => $cmd->lessonId],
);
});
}
}
import psycopg
class CompleteLessonHandler:
def __init__(self, conn: psycopg.Connection) -> None:
self._conn = conn
def handle(self, cmd: CompleteLesson) -> None:
# Контекстный менеджер: commit на выходе, rollback при исключении
# (в SQLAlchemy то же самое - with session.begin():)
with self._conn.transaction():
# Write
self._conn.execute(
"UPDATE progress SET completed = true WHERE user_id = %s AND lesson_id = %s",
(cmd.user_id, cmd.lesson_id),
)
# Read model update (в той же транзакции)
self._conn.execute(
"UPDATE track_lessons_view SET completed = true WHERE user_id = %s AND lesson_id = %s",
(cmd.user_id, cmd.lesson_id),
)
Просто, но связывает write и read. Для одной БД это вариант по умолчанию: read model всегда консистентна, и именно так собран проект трека.
Асинхронно через событие (когда синхронного мало)
К нему переходят, когда read model живёт в другом хранилище (Redis, Elasticsearch) или одно событие должны обработать несколько систем. Цена - eventual consistency (см. ниже).
У этого варианта есть ловушка: если Publish вызвать внутри транзакции, а транзакция потом откатится, воркер обновит read model по событию, которого не было. Публикация - строго после commit, а надёжнее - через outbox-таблицу, куда событие пишется в той же транзакции, что и данные.
// Write model публикует событие
func (h *CompleteLessonHandler) Handle(ctx context.Context, cmd CompleteLesson) error {
// ... обновляем progress ...
return h.publisher.Publish(ctx, "lesson.completed", LessonCompletedEvent{
UserID: cmd.UserID,
LessonID: cmd.LessonID,
})
}
// Отдельный воркер обновляет read model
func (w *ReadModelUpdater) HandleLessonCompleted(ctx context.Context, evt LessonCompletedEvent) error {
return w.readRepo.MarkCompleted(ctx, evt.UserID, evt.LessonID)
}
<?php
declare(strict_types=1);
// Write model публикует событие
final class CompleteLessonHandler
{
public function __construct(
private readonly ProgressRepository $progress,
private readonly EventPublisher $publisher,
) {}
public function __invoke(CompleteLesson $cmd): void
{
// ... обновляем progress ...
$this->publisher->publish(
'lesson.completed',
new LessonCompletedEvent(
userId: $cmd->userId,
lessonId: $cmd->lessonId,
),
);
}
}
// Отдельный воркер обновляет read model
final class ReadModelUpdater
{
public function __construct(
private readonly ReadRepository $readRepo,
) {}
public function handleLessonCompleted(LessonCompletedEvent $evt): void
{
$this->readRepo->markCompleted($evt->userId, $evt->lessonId);
}
}
В Symfony Messenger такой обработчик помечается атрибутом #[AsMessageHandler], а транспорт настраивается на async (RabbitMQ / Redis) - это и есть «асинхронный консьюмер».
# Write model публикует событие
class CompleteLessonHandler:
def __init__(self, progress: ProgressRepo, publisher: EventPublisher) -> None:
self._progress = progress
self._publisher = publisher
def handle(self, cmd: CompleteLesson) -> None:
# ... обновляем progress ...
self._publisher.publish("lesson.completed", LessonCompletedEvent(
user_id=cmd.user_id,
lesson_id=cmd.lesson_id,
))
# Отдельный воркер обновляет read model
# (консьюмер очереди: pika для RabbitMQ, Celery-таска или asyncio-воркер)
class ReadModelUpdater:
def __init__(self, read_repo: ReadRepo) -> None:
self._read_repo = read_repo
def handle_lesson_completed(self, evt: LessonCompletedEvent) -> None:
self._read_repo.mark_completed(evt.user_id, evt.lesson_id)
По расписанию (для materialized views)
// Cron-задача каждые 5 минут
func (j *RefreshJob) Run(ctx context.Context) error {
_, err := j.db.ExecContext(ctx,
"REFRESH MATERIALIZED VIEW CONCURRENTLY track_stats_mv")
return err
}
<?php
declare(strict_types=1);
// Symfony Console команда, дёргается cron'ом каждые 5 минут
#[AsCommand(name: 'app:refresh-track-stats')]
final class RefreshTrackStatsCommand extends Command
{
public function __construct(
private readonly Connection $db,
) {
parent::__construct();
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$this->db->executeStatement(
'REFRESH MATERIALIZED VIEW CONCURRENTLY track_stats_mv'
);
return Command::SUCCESS;
}
}
import psycopg
# Cron-задача каждые 5 минут (системный cron, Celery beat или APScheduler)
class RefreshJob:
def __init__(self, dsn: str) -> None:
self._dsn = dsn
def run(self) -> None:
# psycopg по умолчанию (autocommit=False) неявно открывает транзакцию
# на первом execute, а REFRESH ... CONCURRENTLY внутри транзакции
# запрещён. Поэтому своё соединение с autocommit=True: команда
# фиксируется сразу, без висящего «idle in transaction»
with psycopg.connect(self._dsn, autocommit=True) as conn:
conn.execute("REFRESH MATERIALIZED VIEW CONCURRENTLY track_stats_mv")
⚠️ Eventual Consistency
При асинхронном обновлении read model может отставать от write на секунды. Для большинства UI это незаметно. Но если пользователь завершил урок и тут же открывает список - он может не увидеть галочку. Решения: для большинства экранов - оптимистичное обновление на фронте; для критичных экранов - read-your-writes (UI ждёт, пока проекция догонит нужную версию); если read model в той же БД - синхронное обновление в той же транзакции (вариант выше).
Пересборка Read Model
Одно из главных преимуществ - read model можно пересобрать с нуля:
func (r *ReadModelRebuilder) RebuildTrackLessonsView(ctx context.Context) error {
// TRUNCATE + INSERT в одной транзакции: упал INSERT - откат вернёт старые данные
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
// Очищаем
if err := tx.Exec("TRUNCATE track_lessons_view").Error; err != nil {
return err
}
// Заполняем из write-модели. user_id берём из users, а не из progress:
// для непройденных уроков p.* равны NULL
return tx.Exec(`
INSERT INTO track_lessons_view
(track_id, lesson_id, user_id, lesson_title, sort_order,
completed, completed_at, duration_min)
SELECT
l.track_id, l.id, u.id, l.title, l.sort_order,
COALESCE(p.completed, false), p.completed_at, l.duration_min
FROM lessons l
CROSS JOIN users u
LEFT JOIN progress p ON p.lesson_id = l.id AND p.user_id = u.id
`).Error
})
}
<?php
declare(strict_types=1);
final class ReadModelRebuilder
{
public function __construct(
private readonly Connection $db,
) {}
public function rebuildTrackLessonsView(): void
{
// TRUNCATE + INSERT в одной транзакции: упал INSERT - откат вернёт старые данные
$this->db->transactional(function (Connection $tx): void {
// Очищаем
$tx->executeStatement('TRUNCATE track_lessons_view');
// Заполняем из write-модели. user_id берём из users, а не из progress:
// для непройденных уроков p.* равны NULL
$tx->executeStatement(
'INSERT INTO track_lessons_view
(track_id, lesson_id, user_id, lesson_title, sort_order,
completed, completed_at, duration_min)
SELECT
l.track_id, l.id, u.id, l.title, l.sort_order,
COALESCE(p.completed, false), p.completed_at, l.duration_min
FROM lessons l
CROSS JOIN users u
LEFT JOIN progress p ON p.lesson_id = l.id AND p.user_id = u.id'
);
});
}
}
import psycopg
class ReadModelRebuilder:
def __init__(self, conn: psycopg.Connection) -> None:
self._conn = conn
def rebuild_track_lessons_view(self) -> None:
# TRUNCATE + INSERT в одной транзакции - атомарно: упал INSERT -
# откат вернёт старые данные, пустую витрину никто не увидит
# (TRUNCATE держит ACCESS EXCLUSIVE до коммита, читатели подождут).
# Без transaction() psycopg (autocommit=False) так и не сделал бы
# commit: при закрытии соединения всё откатится
with self._conn.transaction():
# Очищаем
self._conn.execute("TRUNCATE track_lessons_view")
# Заполняем из write-модели
self._conn.execute(
"""
INSERT INTO track_lessons_view
(track_id, lesson_id, user_id, lesson_title, sort_order,
completed, completed_at, duration_min)
SELECT
l.track_id, l.id, u.id, l.title, l.sort_order,
COALESCE(p.completed, false), p.completed_at, l.duration_min
FROM lessons l
CROSS JOIN users u
LEFT JOIN progress p ON p.lesson_id = l.id AND p.user_id = u.id
"""
)
Это спасает, когда структура read model изменилась после миграции - просто пересобрал и всё.
Если хочется увидеть всё сразу на одном сценарии, command, read-проекция, схема БД и тест use-case собраны в мини-проекте трека.
Что почитать
- Go - Работа с базами данных - SQL, транзакции и миграции в Go
Мини-задание
- Выбери один UI-список из своего проекта (например, список уроков трека с прогрессом)
- Набросай SQL-схему read model таблицы под этот список
- Реализуй Go-функцию, которая читает из read model одним SELECT (без JOIN)
- Подумай: как бы ты обновлял эту read model - синхронно или через событие?