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

Три подхода:

Три способа обновлять 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 собраны в мини-проекте трека.

Что почитать

Мини-задание

  • Выбери один UI-список из своего проекта (например, список уроков трека с прогрессом)
  • Набросай SQL-схему read model таблицы под этот список
  • Реализуй Go-функцию, которая читает из read model одним SELECT (без JOIN)
  • Подумай: как бы ты обновлял эту read model - синхронно или через событие?

Зарегистрируйтесь бесплатно, чтобы пройти квиз, вести прогресс.