Практическая статья упомянула upcasting в одном разделе — но именно эволюция событий отличает учебный ES от того, что прожил в проде три года. События записаны навсегда, а требования, поля и смысл меняются: добавить атрибут, переименовать, разбить одно событие на два, слить два в одно. При этом старые события должны оставаться читаемыми — иначе rebuild проекции, главная страховка ES, однажды перестаёт работать. Эта статья — про цепочку upcaster’ов на конкретном коде, про типы изменений схемы, которые она обязана покрывать, и про то, что стенд смог и не смог сказать о её цене на чтении.
Четвёртая статья серии. Разворачивает контракты событий и schema evolution применительно к event-sourced-хранилищу, где события живут не в топике с retention, а вечно.
В статье
- Цепочка upcaster’ов: домен знает только текущую форму
- Типы изменений схемы
- Слабая схема против строгой: что ловится на записи, а что только на чтении
- Ленивая миграция против энергичной: когда какая
- Честная цена: направление переворачивается между прогонами
- Постусловие: почему одной суммы было мало
- Граница вывода
Цепочка 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, что и в первой статье серии.
Документация и первоисточники
- Канон: Greg Young — Versioning in an Event Sourced System (книга, бесплатно), Confluent — Schema Evolution and Compatibility.
- Смежное на сайте: контракты событий и schema evolution, ES на практике (upcasting), проектирование агрегатов и событий, event store вглубь, проекции: чекпоинт, сверка и пересборка, Kafka: экосистема и Schema Registry.
Обсуждение в Telegram
Присоединиться →