Версионирование и upcasting: цена цепочки, которую не удалось поймать в поле

События неизменяемы, а код вокруг них живёт годами. Разбираем цепочку upcaster'ов v1→v2→v3 на конкретном `Upcast` (каждый шаг знает только про соседние версии, домен — только про текущую форму); типы изменений схемы — добавление поля, переименование, разбиение, слияние — и почему правка события на месте запрещена, а альтернатива ей copy-transform; когда по канону выбирать ленивую миграцию (upcasting на чтении), а когда энергичную (разовый реплей стрима) — по цене за чтение, судьбе старых снапшотов, обратимости и риску остановки записи. Центральный разбор — честная цена: полевой замер на чтении целого стрима дал направление, которое переворачивается между прогонами, а изолированный микробенчмарк на одних и тех же байтах показал, что аллокации цепочка добавляет детерминированно, а время — нет. И постусловие: почему проверки одной суммы для upcasting оказалось мало

Практическая статья упомянула upcasting в одном разделе — но именно эволюция событий отличает учебный ES от того, что прожил в проде три года. События записаны навсегда, а требования, поля и смысл меняются: добавить атрибут, переименовать, разбить одно событие на два, слить два в одно. При этом старые события должны оставаться читаемыми — иначе rebuild проекции, главная страховка ES, однажды перестаёт работать. Эта статья — про цепочку upcaster’ов на конкретном коде, про типы изменений схемы, которые она обязана покрывать, и про то, что стенд смог и не смог сказать о её цене на чтении.

Четвёртая статья серии. Разворачивает контракты событий и schema evolution применительно к event-sourced-хранилищу, где события живут не в топике с retention, а вечно.

Слева вертикальный конвейер из трёх машин с экранами «v1», «v2», «v3», соединённых стрелками снизу вверх с подписями «добавили единицу измерения» и «переименовали поле»; сверху выезжает лист «форма, которую знает код». По центру аптекарские весы, чаши которых качаются и не приходят в равновесие, на гирях «замер на чтении»; под ними подпись «направление гуляет между прогонами: 0.80 · 0.98 · 0.95 против 1.08 · 1.04 · 1.03». Справа блок «а вот это устойчиво» с двумя шкалами: «цепочка v1→v3: 29 аллокаций · 1176 байт» и «без цепочки: 26 аллокаций · 1072 байт». Внизу во всю ширину терракотовая лента: «цепочка не бесплатна — установлено; сколько стоит на реальном чтении — этим замером не установлено»

В статье

Цепочка upcaster’ов: домен знает только текущую форму

Событие OxygenAdded в стенде прошло два изменения формы: сначала не хранило единицу измерения вовсе (подразумевались литры), затем поле переименовали из liters в amount и добавили явный unit. Три версии схемы, помеченные schema_ver в каждой строке events. Код чтения не разбирает их веткой на каждое место использования — вся логика подъёма старых форм до текущей сосредоточена в одной функции:

// EventV3 — текущая форма события. Код домена знает ТОЛЬКО её.
// Это и есть смысл upcasting: старые формы живут в сторе вечно, но наружу
// из слоя чтения выходит одна.
type EventV3 struct {
	Type   string  `json:"type"`
	Amount float64 `json:"amount"`
	Unit   string  `json:"unit"`
}

// currentSchemaVer — версия формы, которую знает код домена (EventV3).
const currentSchemaVer = 3

// upcastStep — один шаг цепочки: поднимает событие с версии v на v+1.
type upcastStep func(map[string]any)

// upcastSteps — цепочка, индексированная ИСХОДНОЙ версией шага: ключ v
// означает «шаг v -> v+1». Добавить v3->v4 — это запись `3: func(...)`
// здесь плюс currentSchemaVer = 4; существующие шаги не трогаются.
var upcastSteps = map[int]upcastStep{
	// v1 -> v2: единица измерения не хранилась, подразумевались литры.
	1: func(m map[string]any) {
		m["unit"] = "liters"
	},
	// v2 -> v3: liters переименовано в amount.
	2: func(m map[string]any) {
		if v, ok := m["liters"]; ok {
			m["amount"] = v
			delete(m, "liters")
		}
	},
}

func Upcast(raw []byte, schemaVer int) (EventV3, error) {
	if schemaVer < 1 {
		return EventV3{}, fmt.Errorf("недопустимая версия схемы %d: версии нумеруются с 1", schemaVer)
	}
	if schemaVer > currentSchemaVer {
		return EventV3{}, fmt.Errorf("схема версии %d новее кода (код знает до %d)", schemaVer, currentSchemaVer)
	}

	var m map[string]any
	if err := json.Unmarshal(raw, &m); err != nil {
		return EventV3{}, err
	}

	for v := schemaVer; v < currentSchemaVer; v++ {
		step, ok := upcastSteps[v]
		if !ok {
			return EventV3{}, fmt.Errorf("в цепочке нет шага v%d->v%d", v, v+1)
		}
		step(m)
	}

	out, err := json.Marshal(m)
	if err != nil {
		return EventV3{}, err
	}
	var e EventV3
	return e, json.Unmarshal(out, &e)
}

Цикл по версиям — буквальная реализация цепочки: событие schema_ver=1 проходит оба шага, schema_ver=2 — только второй, schema_ver=3 — ни одного. Шаг v1→v2 ничего не знает о том, что случится на v2→v3, и наоборот. Это и есть причина, по которой домен обязан знать только текущую форму (EventV3), а не весь зоопарк исторических: цепочка — единственное место, где живёт знание о прошлых версиях, и оно растёт линейно с числом изменений схемы, а не квадратично с числом потребителей события.

Ловушка — цепочка, которая только выглядит расширяемой. Соблазнительно написать её как switch с fallthrough: ветка case schemaVer <= 1 подставляет unit и проваливается в case schemaVer == 2. Выглядит как цепочка и работает как цепочка — но добавление шага v3→v4 потребует дописать fallthrough в конец уже работающей ветки v2→v3, то есть отредактировать существующий шаг ради нового. «Новый шаг не трогает старые» в такой форме — утверждение про намерение, а не про код. С картой шагов это утверждение проверяемо — и проверяется тестом TestUpcastChainIsComplete, который падает, если currentSchemaVer подняли, а шаг добавить забыли.

Вторая ловушка — границы диапазона версий. Условие schemaVer <= 1 принимает 0 и отрицательные значения как v1: строка с отсутствующим или битым schema_ver молча трактуется как самая старая форма и проходит всю цепочку. Отсутствие данных — не то же самое, что древняя версия, и различать их обязан читатель, а не догадываться. Поэтому обе границы проверяются явно: schemaVer < 1 — отказ, schemaVer > currentSchemaVer — тоже отказ, с разными сообщениями. Вторая ветка возвращает явную ошибку вместо тихого прохода с нулевыми полями — к этому решению статья вернётся в разделе про постусловие.

Типы изменений схемы

Не все изменения одинаково дёшевы для upcaster’а. Добавление поля — самый дешёвый случай: m["unit"] = "liters" подставляет значение, которого раньше не существовало вовсе, опираясь на знание домена (в v1 подразумевались литры, это знание нигде не хранилось явно, кроме как в коде и в головах). Переименование — liters в amount — на одну операцию дороже: нужно скопировать значение под новым ключом и удалить старый, иначе EventV3 не соберётся из map[string]any через json.Marshal/json.Unmarshal обратно в структуру с полем Amount, а не Liters. Оба случая укладываются в один шаг цепочки без обращения к чему-либо, кроме самого события.

Разбиение одного типа события на два и слияние двух в один в этой цепочке не встречаются — OxygenAdded во всех трёх версиях остаётся одним типом с меняющейся формой полезной нагрузки, — но принцип тот же: разбиение требует, чтобы upcaster знал, как распределить старое поле между двумя новыми событиями (или синтезировать недостающее из контекста, если контекста в самом событии нет), а слияние — наоборот, скопить несколько событий, прежде чем выпустить одно. Оба случая дороже переименования именно потому, что нарушают предположение «один вход — один выход», на котором построен Upcast: сигнатура func(raw []byte, schemaVer int) (EventV3, error) рассчитана на отображение 1:1, а не на буферизацию нескольких событий или ветвление одного в несколько.

Правка события на месте (UPDATE events SET data = ...) запрещена не из осторожности, а потому что ломает то, ради чего вообще заводился Event Sourcing: неизменяемость истории — это не свойство, которое можно частично нарушить ради удобства миграции, а инвариант, на котором держится сама модель. Если разрешить UPDATE, аудит и rebuild проекции перестают быть детерминированными относительно одной и той же истории — на разных ревизиях базы одна и та же последовательность append могла бы дать разное состояние events. Алгоритм, к которому прибегают, когда upcasting на чтении не тянет (например, схема изменилась настолько, что дешевле пересчитать раз и не платить цепочкой на каждом чтении) — copy-transform: старый стрим реплеится целиком в новый стрим с применением преобразования, оригинал остаётся нетронутым как исторический артефакт или архивируется отдельно. Это осознанная миграция, а не патч на месте: она порождает новые append-события, а не переписывает старые. Из того же append-only следует и вопрос комплаенса: право на забвение нельзя реализовать физическим удалением события — стратегии обхода (crypto-shredding, вынос PII из событий) разобраны в практической статье, раздел Append-only и право на забвение.

Слабая схема против строгой: что ловится на записи, а что только на чтении

Стенд этот вопрос не мерил — ни бенчмарка, ни прогона здесь нет, только разбор по документации Confluent (Schema Registry) в дополнение к цепочке Upcast выше. У events в этом стенде схема слабая: data JSONB принимает любой валидный JSON, Postgres не проверяет ни набор полей, ни их типы при INSERT — совместимость между schema_ver=1 и schema_ver=3 целиком на совести кода, который это событие когда-нибудь читает (Upcast, разобранный выше). Ошибка в форме события — опечатка в имени поля, число в поле, которое ожидалось строкой — здесь ничем не поймается на записи: INSERT пройдёт беспрепятственно, а Upcast либо подставит нулевое значение для отсутствующего поля, либо упадёт с ошибкой типа уже при чтении, когда откатывать поздно.

У систем со строгой схемой и реестром — например, Avro поверх Confluent Schema Registry — часть этих ошибок ловится раньше, на записи. Обязанности здесь разделены: соответствие конкретного сообщения схеме проверяет сериализатор продюсера (или отдельный валидатор), который сериализует его по зарегистрированной Avro-схеме, а сам реестр, по документации Confluent, проверяет совместимость новой схемы со старыми согласно выбранному режиму (BACKWARD, FORWARD, FULL и их транзитивные варианты) до того, как она будет принята.

Важно очертить, что именно ловится, — иначе легко приписать реестру больше, чем он умеет. Сериализатор ловит несоответствие сообщения зарегистрированной схеме (поле не того типа, отсутствует обязательное поле, лишнее поле — в зависимости от настроек), реестр — структурную несовместимость новой схемы со старыми по выбранному правилу. Чего он не ловит — семантики: если новая схема сама по себе совместима, опечатка в имени нового поля (ammount вместо amount) пройдёт регистрацию спокойно, потому что для реестра это просто «добавлено новое поле с default», а не «опечатка». Разница с JSONB-вариантом этого стенда поэтому в классе ошибок, а не в их наличии: связка сериализатора и реестра закрывает структурный класс на записи, семантический в обоих подходах остаётся на человеке.

Плата за эту раннюю проверку не бесплатна: строгая схема требует явной эволюции по правилам совместимости (новое поле — только с default-значением для BACKWARD; удалить поле при FORWARD можно, только если старый читатель восстановит его отсутствие — например, у поля в его схеме есть default; и так далее, по той же документации Confluent), тогда как Upcast в этом стенде может подстроиться под любую форму JSON постфактум, включая формы, которые никто заранее не предусмотрел как «схему». Общее для обоих подходов — то, что уже показано кодом Upcast выше: неважно, ловится несовместимость на записи или на чтении, история остаётся неизменяемой, и любое расхождение форматов рано или поздно должно быть явно преобразовано, а не просто проигнорировано.

Ленивая миграция против энергичной: когда какая

Раздел ниже не про стенд — он его не мерил, и в фикстурах этого сравнения нет. Это разбор по канону (Greg Young, «Versioning in an Event Sourced System»), про то, когда выбирать upcasting на чтении (ленивая миграция — то, что показано выше кодом Upcast), а когда copy-transform (энергичная — разовая перезапись стрима).

Цена за каждое чтение против разовой цены переписывания. Ленивая миграция ничего не платит заранее: событие лежит в старой форме сколь угодно долго, цепочка Upcast срабатывает при каждом чтении. Это откладывает решение (не нужно останавливать систему ради миграции), но означает, что цена, установленная в разделе выше (детерминированные аллокации на вызов), платится на каждом чтении каждого старого события, вечно, если история не мигрируется. Энергичная миграция платит один раз — реплей стрима целиком в новый — и дальше читает уже единообразную форму без цепочки вовсе. Компромисс количественно этой статьёй не оценён (сколько именно чтений нужно, чтобы разовая цена переписывания окупилась) — это оценка, которую надо делать под конкретную нагрузку, а не число из канона.

Что происходит со старыми снапшотами. Снапшот хранит состояние агрегата, свёрнутое текущей на момент создания логикой fold. Если fold не менялся, а менялась только форма отдельных событий, ленивая миграция снапшот не трогает: Upcast работает на уровне события до Apply, а снапшот собран уже после свёртки. Энергичная миграция, переписывающая историю в новый стрим, обесценивает старые снапшоты автоматически — они привязаны к stream_id, которого после реплея в новый стрим для старых версий больше нет (или который стал историческим архивом) — снапшоты нужно пересобирать с нуля на новом стриме.

Обратимость. Ленивая миграция обратима дешевле энергичной, но не бесплатно. Старые события физически не тронуты, и в этом всё преимущество. Но просто «убрать шаг из цепочки» нельзя: в реализации выше цикл идёт от версии события до currentSchemaVer, и выпавший шаг даст не тихий проход, а явную ошибку «в цепочке нет шага v1→v2». Убирать шаг можно только вместе с понижением currentSchemaVer, то есть откатывая читателя к прежней форме целиком. А если к этому моменту write-путь успел записать хоть одно событие новой версии, откаченный читатель упрётся в них на верхней границе: «схема версии 3 новее кода». Дешёвый откат возможен ровно до тех пор, пока новая версия не появилась в сторе — то есть это свойство не самой ленивой миграции, а отдельно оговорённого порядка выкатки: сначала читатель, знающий обе формы, потом писатель новой. Энергичная миграция необратима в более сильном смысле: новый стрим — это новые события, отменить copy-transform значит писать ещё один переписывающий проход.

Цепочка, отросшая до нескольких шагов. Greg Young называет рост цепочки upcaster’ов триггером для энергичной миграции — но без точной цифры: конкретное «пять-шесть шагов» в его тексте не названо, это иллюстративная прикидка масштаба, а не цитата из источника. Смысл аргумента не в числе шагов: цепочка, которая раньше стоила «подстановка ключа плюс переименование поля» (как в этом стенде — 2 шага), с ростом числа версий схемы превращается в код, который сам становится источником ошибок — каждый новый шаг обязан оставаться совместимым со всеми предыдущими, тестовая матрица растёт с числом версий, а не с числом изменений. Граница здесь не количественная, а операционная — когда поддержка цепочки как отдельного модуля кода становится заметной статьёй трудозатрат сама по себе, вне зависимости от того, сколько именно шагов накопилось.

Риск остановки записи на время переписывания. У ленивой миграции такого риска нет вообще — она ничего не блокирует, потому что ничего не переписывает. У энергичной он есть по конструкции: пока copy-transform реплеит старый стрим в новый, запись новых событий в тот же логический поток агрегата либо должна быть приостановлена, либо canonical-стрим на время миграции временно раздваивается (что усложняет уже сам протокол записи, а не только миграцию). Greg Young разбирает это как одну из причин, почему copy-transform — операция, а не рефакторинг: она требует эксплуатационного окна или дополнительной координации, которых ленивая миграция не требует в принципе.

Практический вывод из канона, а не из замера: пока цепочка короткая и цена детерминированных аллокаций на чтение не стала заметной статьёй нагрузки (см. раздел ниже — этот стенд её не измерил на реальном чтении однозначно), ленивая миграция — вариант по умолчанию, именно потому что она не требует остановки записи. Обратима она дёшево лишь при оговорённом порядке выкатки: сначала читатель, знающий обе формы, потом писатель новой, — и только пока в сторе не появились события новой версии. Copy-transform становится оправданным решением, когда цепочка отросла настолько, что сама стала эксплуатационной проблемой, или когда снапшоты и логика чтения должны стать canonical на новой форме без вечного хвоста условной логики.

Честная цена: направление переворачивается между прогонами

Стенд наполняет стрим tank 200000 событиями OxygenAdded (значение 1 на событие) — либо целиком в форме v3 (schema_ver=3, {"type":"OxygenAdded","amount":1,"unit":"liters"}), либо целиком в форме v1 (schema_ver=1, {"type":"OxygenAdded","liters":1}). Оба варианта читаются одним и тем же кодом (runVersioningRead → Upcast), различается только форма хранения. Чтение разбито на два раздельно засекаемых интервала: fetch_ms (сетевой круговорот к Postgres — строки выгружаются в память до начала замера) и upcast_ms (цикл Upcast над уже выгруженными строками, без единого обращения к сети). Порядок вариантов чередуется по 3 раундам, состояние сбрасывается перед каждым прогоном.

Прогон 2026-08-13, зафиксированный в фикстурах как финальный:

раунд v3 fetch, мс v3 upcast, мс v1 fetch, мс v1 upcast, мс v1/v3 upcast
1 304.289225 696.862200 178.653194 555.176470 0.80
2 233.634903 565.842590 203.121391 553.776426 0.98
3 242.926587 649.373808 232.583273 615.300317 0.95

Здесь upcast_ms v1 (более старая форма, проходящая полную цепочку из двух шагов) ниже upcast_ms v3 во всех трёх раундах — направление противоположно ожиданию «цепочка дороже». Устойчивым его назвать нельзя: полный список снятых прогонов на той же машине — 0.94/1.07/0.91, затем 0.90/0.93/1.13, затем 1.08/1.02/0.87, затем 1.08/1.04/1.03, затем 0.82/0.86/0.95, затем 0.97/0.90/0.96, затем 0.88/0.93/1.16 (в том прогоне направление перевернулось прямо внутри одного прогона, между раундами) и вот этот. Направление гуляет вокруг единицы и пересекает её в обе стороны. Формулировка результата поэтому осторожная: устойчивое удорожание цепочки upcaster’ов на сценарии «fetch плюс upcast целого стрима из Postgres» не обнаружено — не «эффекта нет», а «на этом сценарии эффект тонет в шуме и в конкурирующем эффекте».

Конкурирующий эффект — длина payload. У v1 два поля (type, liters), у v3 — три (type, amount, unit); более короткая форма экономит на json.Unmarshal внутри Upcast, и эта экономия конкурирует с ценой двух шагов цепочки за то же самое событие. Полевой замер путает эти две причины в одно число: он видит суммарный эффект «короче payload минус дороже цепочка», а не каждое слагаемое по отдельности, и знак суммы зависит от того, какое слагаемое в конкретном прогоне перевесило.

Чтобы разделить причины, go/upcast_test.go держит BenchmarkUpcastV1Chain и BenchmarkUpcastV3NoOp — оба вызывают Upcast на одних и тех же сырых байтах ({"type":"OxygenAdded","liters":42}), различается только передаваемый schemaVer: 1 запускает полную цепочку из двух шагов, 3 — ни одной итерации цикла. Разница здесь объясняется только работой цепочки, а не разной длиной JSON — байты одни и те же. Прогон go test -run '^$' -bench 'BenchmarkUpcast' -benchmem -count=5 ., 2026-08-13:

повтор V1Chain нс/оп V1Chain B/оп V1Chain allocs/оп V3NoOp нс/оп V3NoOp B/оп V3NoOp allocs/оп
1 2974 1176 29 2485 1072 26
2 3488 1176 29 2490 1072 26
3 2911 1176 29 2375 1072 26
4 2929 1176 29 2340 1072 26
5 2924 1176 29 2498 1072 26

Аллокации детерминированы: V1Chain — ровно 29 allocs/оп и 1176 B/оп во всех 5 повторах, V3NoOp — ровно 26 allocs/оп и 1072 B/оп, без исключений ни в одном из сделанных прогонов. Цепочка добавляет ровно 3 аллокации и 104 байта на каждый вызов — величина одна и та же в каждом повторе, шум планировщика на неё не влияет.

По времени в этом прогоне диапазоны не пересекаются: минимум V1Chain (2911 нс/оп) больше максимума V3NoOp (2498 нс/оп). Но именно этот вывод и неустойчив: в одном из зафиксированных прогонов диапазоны пересекались (минимум V1Chain 3019 против максимума V3NoOp 3358 — выброс в пятом повторе при обычных для него 2458–2666), в остальных — нет. Пять снятых прогонов: четырежды разделение есть, один раз нет. Величина слишком близка к шуму планировщика на единичных вызовах, чтобы объявлять её установленной. Аллокации при этом не менялись ни разу.

Вывод, который нельзя размыть до «upcasting дорог» или «upcasting дёшев»: цепочка не бесплатна — это установлено (3 аллокации и 104 байта на вызов, детерминированно, независимо от прогона); сколько именно она стоит на реальном чтении — этим замером не установлено (направление на полевом сценарии переворачивается между прогонами, а на изолированном микробенчмарке время то разделяется, то нет — устойчивы только аллокации). Не показано вовсе: сколько стоит upcasting в чужой системе. Величина зависит от длины цепочки (здесь — 2 шага), от сложности преобразований (здесь — подстановка ключа и переименование поля в map[string]any, а не парсинг вложенных структур или обращение к внешним справочникам) и от того, насколько старая форма события короче новой. У события, где старая форма не короче новой — например, устаревшее поле заменяется двумя новыми той же суммарной длины, — конкурирующий эффект размера payload исчезает, и цена цепочки, вероятно, стала бы видна и на полевом замере, но это не проверялось.

Постусловие: почему одной суммы было мало

Скрипт стенда после каждого раунда сверяет свёртку событий v3 со свёрткой v1 — они обязаны совпасть, иначе upcasting меняет смысл события, а не просто его форму. Проверяются две величины, не одна: sum_amount (сумма Amount по стриму) и bad_unit_events (число событий, чей Unit после Upcast не равен "liters", — сверка по значению, а не по факту «поле непустое»: пустая строка и любая другая непустая строка одинаково не прошли бы проверку). Все 3 раунда обоих вариантов совпали по обеим величинам:

раунд v3 events v3 sum_amount v3 bad_unit v1 events v1 sum_amount v1 bad_unit совпало
1 200000 200000 0 200000 200000 0 да
2 200000 200000 0 200000 200000 0 да
3 200000 200000 0 200000 200000 0 да

Почему одной sum_amount мало. Сумма ловит потерю или обнуление значения при переименовании liters → amount (сумма изменится, если значение потерялось), но не ловит порчу поля unit: если бы шаг v1→v2 подставлял вместо "liters" произвольную строку или оставлял поле пустым, sum_amount совпал бы (Amount от unit никак не зависит), скрипт отрапортовал бы успех, а утверждение «upcasting не меняет смысл события» оказалось бы шире того, что реально проверено — «не меняет одно числовое поле». Поэтому runVersioningRead считает ещё и BadUnitEvents, а скрипт проверяет его отдельно (обе проверки обязаны пройти, а не хотя бы одна). Пути Upcast, которые прогон не задевает, закрыты юнит-тестами: TestUpcastV2PreservesExistingUnit (вход уже schema_ver=2 с unit="gallons" — подтверждает, что шаг v1→v2 не перетирает существующее значение), TestUpcastRejectsFutureSchema (вход schemaVer=4 — явная ошибка вместо тихого прохода с нулевыми полями), TestUpcastRejectsInvalidSchemaVer (0 и отрицательные версии) и TestUpcastChainIsComplete (в цепочке есть шаг для каждой версии). Мысль, которую стоит унести за пределы этого стенда: постусловие на «правильную сумму» проверяет ровно то поле, которое суммируется, и ничего сверх него — если событие несёт несколько атрибутов, каждый из них требует своей сверки, иначе утверждение о корректности мигрированных данных шире, чем то, что реально измерено.

Отдельная оговорка про сам стенд, чтобы не выдать его за то, чем он не является: командный путь записи (AppendEvents в go/store.go) пишет schema_ver жёстко захардкоженным в 1 при каждом вызове, независимо от формы Event, которую сериализует, — версионирующего писателя, который решал бы, в какой схеме класть новое событие, в стенде нет вообще. Форма v3 в таблице events в этом разделе появляется не через обычный путь записи (Decide → AppendEvents, как в предыдущих статьях серии), а через прямой SQL INSERT скрипта 04-versioning.sh — это разовый засев для замера, а не демонстрация миграции write-пути на новую схему. Пример показывает цену чтения старой формы через цепочку upcaster’ов; как в этом стенде выглядела бы миграция самого write-пути на новую схему — такого кода здесь нет.

Граница вывода

Показано двумя разными способами. Изолированный микробенчмарк с зафиксированной длиной входа: цепочка upcaster’ов сама по себе не бесплатна — она детерминированно добавляет 3 аллокации и 104 байта на вызов независимо от прогона, время выполнения при этом иногда устойчиво выше у полной цепочки, иногда диапазоны пересекаются — по времени вывод не устойчив, по аллокациям устойчив. Полевой замер чтения целого стрима из Postgres: итоговая цена на чтении зависит не только от цепочки, но и от конкурирующего эффекта размера payload, и эти два эффекта могут как складываться, так и гасить друг друга — устойчивого направления не установлено ни в одном из восьми сделанных прогонов скрипта — а в одном из них оно перевернулось даже между раундами одного прогона.

Не показано: сколько именно стоит upcasting в чужой системе. Величина зависит от длины цепочки, сложности преобразований и от того, насколько старая форма события короче новой — у события без экономии на длине payload конкурирующий эффект исчезает, и цена цепочки, вероятно, стала бы видна и на полевом замере, но это не проверялось. Абсолютные upcast_ms и нс/оп между раундами и между запусками скрипта не сравниваются — сравнимо только отношение внутри одного раунда/прогона. И отдельно: schema_ver=3 в таблице events этого раздела — засев скрипта прямым INSERT, а не продукт write-пути стенда; выводы про цену цепочки на чтении не переносятся на вопрос «как мигрировать запись».

Демо и версии

  • Demo: digital-cookbook/architecture/event-sourcing-deep — стенд scripts/04-versioning.sh, цепочка Upcast (go/upcast.go), полевой замер fetch/upcast на 200000 событиях, изолированные бенчмарки go/upcast_test.go, постусловие по сумме и единице измерения. Go.
  • Версия на прогоне: Postgres 18.4 — та же схема events, что и в первой статье серии.

Документация и первоисточники

Обсуждение в Telegram

Присоединиться →