feat: разбор и хранение тренировок и состояния разума
- секции `workouts` и `stateOfMind` покрыты разбором: тренировка лежит одной строкой вместе с маршрутом и внутренними рядами, запись — по ключу `род + id`; миграция 00007 заводит обе таблицы и возвращает в очередь `partial`-доставки с этими ключами - сущность заменяется целиком, но условно: приехавшая побеждает, если не теряет содержания сохранённой (множество ключей и длины верхнеуровневых массивов), а при равном содержании выигрывает версия из более поздней доставки ЖУРНАЛА — «побеждает приехавшая» было бы функцией порядка свёртки, и живая витрина расходилась бы с пересборкой молча - отпечаток витрины покрывает тренировки и записи и снимается одним снимком базы; отчёт `reindex` считает «было и стало» по каждой единице хранения
This commit is contained in:
@@ -246,6 +246,72 @@ func (f Fields) Relate(g Fields) Fullness {
|
||||
return FullnessEqual
|
||||
}
|
||||
|
||||
// Covers говорит, несёт ли f всё СОДЕРЖАНИЕ g: каждый содержательный ключ g
|
||||
// есть у f, и ни один верхнеуровневый массив не стал короче.
|
||||
//
|
||||
// Отдельно от Relate, и это не дубль. Relate гасит отношение включения до
|
||||
// FullnessEqual, когда значения общих содержательных ключей разошлись, — верно
|
||||
// для точки (надмножество имён при других значениях означает другое
|
||||
// измерение), но неверно для сущности с собственным `id`: у неё вторая версия
|
||||
// есть тот же объект, пересчитанный источником, и значения между версиями
|
||||
// расходятся ВСЕГДА. Приложи Relate к тренировке — и обеднённая версия
|
||||
// получила бы «равенство» и заместила бы сохранённую вместе с маршрутом
|
||||
// (95% её веса), а тест на фикстуре с неизменёнными значениями остался бы
|
||||
// зелёным.
|
||||
//
|
||||
// Длина верхнеуровневых массивов сравнивается потому, что усечённый маршрут
|
||||
// (три точки вместо 593) ключа не теряет. Досчёт ряды удлиняет, поэтому
|
||||
// укорачивание — законный признак «приехало меньше». Предел правила назван
|
||||
// вслух: сокращение ВНУТРИ элемента ряда (точка маршрута без altitude) не
|
||||
// ловится ничем, кроме сверки с телом в архиве.
|
||||
//
|
||||
// Длины считаются здесь, а не в Analyze: Analyze зовётся на каждый кандидат
|
||||
// слияния точек, и разбор heartbeatSeries на каждой точке стоил бы дороже
|
||||
// самого сравнения.
|
||||
func (f Fields) Covers(g Fields) bool {
|
||||
for k, gv := range g.full {
|
||||
fv, ok := f.full[k]
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
gn, gok := arrayLen(gv)
|
||||
if !gok {
|
||||
continue
|
||||
}
|
||||
fn, fok := arrayLen(fv)
|
||||
if !fok || fn < gn {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// arrayLen возвращает число элементов верхнеуровневого массива. Второй возврат
|
||||
// — является ли значение массивом вообще.
|
||||
//
|
||||
// Элементы проглатываются в выбрасываемый RawMessage: считать нужно только
|
||||
// количество, а материализация маршрута в дерево значений стоила бы того же,
|
||||
// от чего отказался разбор тела.
|
||||
func arrayLen(raw json.RawMessage) (int, bool) {
|
||||
if len(bytes.TrimSpace(raw)) == 0 || bytes.TrimSpace(raw)[0] != '[' {
|
||||
return 0, false
|
||||
}
|
||||
|
||||
dec := json.NewDecoder(bytes.NewReader(raw))
|
||||
if _, err := dec.Token(); err != nil { // открывающая скобка
|
||||
return 0, false
|
||||
}
|
||||
n := 0
|
||||
for dec.More() {
|
||||
var skip json.RawMessage
|
||||
if err := dec.Decode(&skip); err != nil {
|
||||
return 0, false
|
||||
}
|
||||
n++
|
||||
}
|
||||
return n, true
|
||||
}
|
||||
|
||||
// agreeOnShared говорит, совпадают ли значения ключей, содержательных у обеих
|
||||
// точек. Сравнение каноническое: порядок ключей и дребезг последнего разряда
|
||||
// расхождением не считаются.
|
||||
|
||||
+85
-28
@@ -65,26 +65,28 @@ func New(arch *archive.Archive, st *store.Store, maxBody int64, log *slog.Logger
|
||||
const finishTimeout = 10 * time.Second
|
||||
|
||||
// Stats — итог свёртки одной доставки.
|
||||
//
|
||||
// Счётчики слияния ВСТРОЕНЫ, а не переписаны полем в поле: ручное копирование
|
||||
// молча теряет новый счётчик, а по одному из них (удержанная обеднённая версия
|
||||
// сущности) принято решение не объединять поля — забытая строка присваивания
|
||||
// отменила бы наблюдение при зелёных тестах хранилища.
|
||||
type Stats struct {
|
||||
store.MergeStats
|
||||
|
||||
Metrics int
|
||||
Points int
|
||||
Stored int
|
||||
Buckets int
|
||||
Unchanged int
|
||||
Overwrites int
|
||||
Incomparable int
|
||||
SealedHits int
|
||||
UnitsConflicts int
|
||||
SkippedNoTime int
|
||||
SkippedMalformed int
|
||||
SkippedBadEnd int
|
||||
Layer string
|
||||
LayerMismatch bool
|
||||
Collisions []store.Collision
|
||||
IncomparableAt []store.Collision
|
||||
// Счётчики пропуска сущностей: у каждого класса свой, потому что тело в
|
||||
// архиве остаётся, а вернуть сущность может только пересборка.
|
||||
SkippedNoID int
|
||||
SkippedEntityNoTime int
|
||||
SkippedEntityMalformed int
|
||||
Layer string
|
||||
LayerMismatch bool
|
||||
// Uncovered — верхнеуровневые ключи `data`, которых разбор не покрывает.
|
||||
// Это ответ на вопрос «что останется потерянным, если тело удалить»:
|
||||
// для stateOfMind он необратим — в экспорте Apple этой секции нет.
|
||||
// Это ответ на вопрос «что останется потерянным, если тело удалить».
|
||||
Uncovered []string
|
||||
// UncoveredDropped — сколько имён отброшено границей списка.
|
||||
UncoveredDropped int
|
||||
@@ -158,24 +160,21 @@ func (s *Service) Fold(ctx context.Context, deliveryID string) (stats Stats, err
|
||||
stats.SkippedNoTime = parsed.SkippedNoTime
|
||||
stats.SkippedMalformed = parsed.SkippedMalformed
|
||||
stats.SkippedBadEnd = parsed.SkippedBadEnd
|
||||
stats.SkippedNoID = parsed.SkippedNoID
|
||||
stats.SkippedEntityNoTime = parsed.SkippedEntityNoTime
|
||||
stats.SkippedEntityMalformed = parsed.SkippedEntityMalformed
|
||||
stats.Layer = string(parsed.Layer)
|
||||
stats.LayerMismatch = parsed.LayerMismatch
|
||||
|
||||
merge, err := s.store.MergePoints(ctx, toIncoming(parsed.Points), deliveryID)
|
||||
merge, err := s.store.Merge(ctx, toIncoming(parsed), store.DeliveryRef{
|
||||
ID: d.ID,
|
||||
ReceivedAt: d.ReceivedAt,
|
||||
})
|
||||
if err != nil {
|
||||
s.fail(ctx, deliveryID, err, parsed.Uncovered)
|
||||
return stats, err
|
||||
}
|
||||
|
||||
stats.Stored = merge.Stored
|
||||
stats.Buckets = merge.Buckets
|
||||
stats.Unchanged = merge.Unchanged
|
||||
stats.Overwrites = merge.Overwrites
|
||||
stats.Incomparable = merge.Incomparable
|
||||
stats.SealedHits = merge.SealedHits
|
||||
stats.UnitsConflicts = merge.UnitsConflicts
|
||||
stats.Collisions = merge.Collisions
|
||||
stats.IncomparableAt = merge.IncomparableAt
|
||||
stats.MergeStats = merge
|
||||
|
||||
// Источник истины — список; статус производен от него и от факта отказа.
|
||||
// Приоритет назван явно, иначе два будущих читателя (ретеншен и /stats)
|
||||
@@ -212,6 +211,7 @@ func (s *Service) Fold(ctx context.Context, deliveryID string) (stats Stats, err
|
||||
// значения.
|
||||
func (s *Service) logResult(ctx context.Context, deliveryID string, st Stats) {
|
||||
skipped := st.SkippedNoTime + st.SkippedMalformed + st.SkippedBadEnd
|
||||
skippedEntities := st.SkippedNoID + st.SkippedEntityNoTime + st.SkippedEntityMalformed
|
||||
|
||||
attrs := []any{
|
||||
"delivery_id", deliveryID,
|
||||
@@ -228,6 +228,16 @@ func (s *Service) logResult(ctx context.Context, deliveryID string, st Stats) {
|
||||
"skipped_no_time", st.SkippedNoTime,
|
||||
"skipped_malformed", st.SkippedMalformed,
|
||||
"skipped_bad_end", st.SkippedBadEnd,
|
||||
// Сущности с собственным `id`: пришло, легло и удержано. Координаты
|
||||
// (род и идентификатор) разрешены, содержимое — нет: маршрут
|
||||
// тренировки это геотрек до дома, а метки состояния разума —
|
||||
// измерение душевного состояния.
|
||||
"workouts", st.Workouts,
|
||||
"workouts_written", st.WorkoutsWritten,
|
||||
"records", st.Records,
|
||||
"records_written", st.RecordsWritten,
|
||||
"entities_held", st.EntitiesHeld,
|
||||
"skipped_entities", skippedEntities,
|
||||
"layer", st.Layer,
|
||||
"layer_mismatch", st.LayerMismatch,
|
||||
// Структурным []string, а не склейкой: JSON-кодировщик slog экранирует
|
||||
@@ -242,13 +252,26 @@ func (s *Service) logResult(ctx context.Context, deliveryID string, st Stats) {
|
||||
if len(st.IncomparableAt) > 0 {
|
||||
attrs = append(attrs, "incomparable_at", formatCollisions(st.IncomparableAt))
|
||||
}
|
||||
if len(st.HeldAt) > 0 {
|
||||
attrs = append(attrs, "held_at", formatEntityRefs(st.HeldAt))
|
||||
}
|
||||
|
||||
// Доставка, у которой отброшены ВСЕ точки, — это сломавшийся формат, а не
|
||||
// штатная работа. Без этого условия смена формата метки выглядела бы как
|
||||
// здоровый поток: 200, parsed, INFO, points=0.
|
||||
allSkipped := st.Points == 0 && skipped > 0
|
||||
// То же для сущностей: доставка из одних тренировок, у которой не осталось
|
||||
// ни одной, — это сменившийся формат, а не пустая секция.
|
||||
allEntitiesSkipped := st.Workouts == 0 && st.Records == 0 && skippedEntities > 0
|
||||
|
||||
switch {
|
||||
case st.EntitiesHeld > 0:
|
||||
// Приехавшая версия сущности отклонена как теряющая содержание. Плата
|
||||
// за отказ объединять поля: событие обязано быть видно, потому что на
|
||||
// живом потоке оно не наступало ни разу и правило держится на этом.
|
||||
s.log.WarnContext(ctx, "delivery folded, poorer entity version held", attrs...)
|
||||
case allEntitiesSkipped:
|
||||
s.log.WarnContext(ctx, "delivery folded, all entities skipped", attrs...)
|
||||
case st.UncoveredDropped > 0:
|
||||
// Не частичный разбор, а тело, не похожее на HAE: секций у HAE восемь,
|
||||
// а границу выбило больше тридцати двух.
|
||||
@@ -288,6 +311,16 @@ func formatCollisions(cs []store.Collision) string {
|
||||
return strings.Join(parts, " ")
|
||||
}
|
||||
|
||||
// formatEntityRefs превращает координаты сущностей в строку для лога.
|
||||
// Содержимого не несёт: род и идентификатор — координаты, а не измерение.
|
||||
func formatEntityRefs(refs []store.EntityRef) string {
|
||||
parts := make([]string, 0, len(refs))
|
||||
for _, r := range refs {
|
||||
parts = append(parts, r.Kind+"/"+r.ID)
|
||||
}
|
||||
return strings.Join(parts, " ")
|
||||
}
|
||||
|
||||
// keepLayer — значение слоя, означающее «оставить как было».
|
||||
const keepLayer = ""
|
||||
|
||||
@@ -379,10 +412,10 @@ func (s *Service) readBody(rawPath string) ([]byte, error) {
|
||||
return body, nil
|
||||
}
|
||||
|
||||
func toIncoming(points []hae.Point) []store.IncomingPoint {
|
||||
out := make([]store.IncomingPoint, 0, len(points))
|
||||
for _, p := range points {
|
||||
out = append(out, store.IncomingPoint{
|
||||
func toIncoming(parsed hae.Result) store.Incoming {
|
||||
points := make([]store.IncomingPoint, 0, len(parsed.Points))
|
||||
for _, p := range parsed.Points {
|
||||
points = append(points, store.IncomingPoint{
|
||||
Metric: p.Metric,
|
||||
Layer: string(p.Layer),
|
||||
Units: p.Units,
|
||||
@@ -394,5 +427,29 @@ func toIncoming(points []hae.Point) []store.IncomingPoint {
|
||||
},
|
||||
})
|
||||
}
|
||||
return store.Incoming{
|
||||
Points: points,
|
||||
Workouts: toEntities(parsed.Workouts),
|
||||
Records: toEntities(parsed.Records),
|
||||
}
|
||||
}
|
||||
|
||||
func toEntities(in []hae.Entity) []store.IncomingEntity {
|
||||
if len(in) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]store.IncomingEntity, 0, len(in))
|
||||
for _, e := range in {
|
||||
out = append(out, store.IncomingEntity{
|
||||
ID: e.ID,
|
||||
Kind: e.Kind,
|
||||
Name: e.Name,
|
||||
Start: e.Start,
|
||||
End: e.End,
|
||||
OffsetSeconds: e.OffsetSeconds,
|
||||
Duration: e.Duration,
|
||||
Raw: e.Raw,
|
||||
})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
@@ -257,8 +257,8 @@ func TestFoldЧастичныйРазборВиденВУчёте(t *testing.T)
|
||||
if d.ParseStatus != store.ParsePartial {
|
||||
t.Errorf("статус %q, ожидался %q", d.ParseStatus, store.ParsePartial)
|
||||
}
|
||||
if !strings.Contains(d.UncoveredSections, "stateOfMind") {
|
||||
t.Errorf("список в базе %q не содержит stateOfMind", d.UncoveredSections)
|
||||
if !strings.Contains(d.UncoveredSections, "ecg") {
|
||||
t.Errorf("список в базе %q не содержит непокрытой секции", d.UncoveredSections)
|
||||
}
|
||||
// Точки метрик обязаны сохраниться: частичность не отменяет разобранного.
|
||||
if stats.Points == 0 {
|
||||
|
||||
+130
-5
@@ -221,7 +221,7 @@ func TestFoldЧастичныйРазборВЛоге(t *testing.T) {
|
||||
{"date":"2025-06-05 10:07:00 +0300","qty":8},
|
||||
{"date":"2025-06-05 10:08:00 +0300","qty":9},
|
||||
{"date":"2025-06-05 10:09:00 +0300","qty":10}]}],
|
||||
"stateOfMind":[{"valence":"СЕКРЕТНОЕ-НАСТРОЕНИЕ"}]}}`
|
||||
"ecg":[{"classification":"СЕКРЕТНЫЙ-РИТМ"}]}}`
|
||||
|
||||
deliver(t, arch, st, "d1", "Minutes", "a1", []byte(body))
|
||||
if _, err := f.Fold(ctx, "d1"); err != nil {
|
||||
@@ -229,10 +229,10 @@ func TestFoldЧастичныйРазборВЛоге(t *testing.T) {
|
||||
}
|
||||
|
||||
out := buf.String()
|
||||
if !strings.Contains(out, "stateOfMind") {
|
||||
if !strings.Contains(out, "ecg") {
|
||||
t.Error("имени непокрытой секции нет в логе — момент появления новой секции незаметен")
|
||||
}
|
||||
if strings.Contains(out, "СЕКРЕТНОЕ-НАСТРОЕНИЕ") {
|
||||
if strings.Contains(out, "СЕКРЕТНЫЙ-РИТМ") {
|
||||
t.Error("содержимое непокрытой секции утекло в лог")
|
||||
}
|
||||
|
||||
@@ -250,7 +250,132 @@ func TestFoldЧастичныйРазборВЛоге(t *testing.T) {
|
||||
if rec.Level != "INFO" {
|
||||
t.Errorf("уровень %q, ожидался INFO: частичность — не отклонение", rec.Level)
|
||||
}
|
||||
if len(rec.Uncovered) != 1 || rec.Uncovered[0] != "stateOfMind" {
|
||||
t.Errorf("атрибут uncovered = %v, ожидался структурный список из stateOfMind", rec.Uncovered)
|
||||
if len(rec.Uncovered) != 1 || rec.Uncovered[0] != "ecg" {
|
||||
t.Errorf("атрибут uncovered = %v, ожидался структурный список из ecg", rec.Uncovered)
|
||||
}
|
||||
}
|
||||
|
||||
// Содержимое сущности чувствительнее значения точки: маршрут тренировки — это
|
||||
// геотрек до дома, а метки состояния разума — измерение душевного состояния.
|
||||
// Разрешены только координаты: род, идентификатор, интервал.
|
||||
func TestFoldНеПишетСодержимогоСущностейВЛог(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var buf bytes.Buffer
|
||||
log := slog.New(slog.NewJSONHandler(&buf, &slog.HandlerOptions{Level: slog.LevelInfo}))
|
||||
|
||||
dir := t.TempDir()
|
||||
arch, err := archive.New(filepath.Join(dir, "raw"))
|
||||
if err != nil {
|
||||
t.Fatalf("архив: %v", err)
|
||||
}
|
||||
st, err := store.Open(filepath.Join(dir, "healthlog.db"))
|
||||
if err != nil {
|
||||
t.Fatalf("база: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { _ = st.Close() })
|
||||
|
||||
f := fold.New(arch, st, 0, log)
|
||||
ctx := context.Background()
|
||||
|
||||
const full = `{"data":{"workouts":[{"id":"w-открытый","name":"На улице Ходьба",` +
|
||||
`"start":"2025-06-05 10:00:00 +0300","end":"2025-06-05 10:10:00 +0300",` +
|
||||
`"route":[{"latitude":55.987654,"longitude":37.123456},{"latitude":55.987655,"longitude":37.123457}],` +
|
||||
`"totalEnergy":{"qty":404040.4}}],` +
|
||||
`"stateOfMind":[{"id":"e-открытый","start":"2025-06-05T18:00:00Z",` +
|
||||
`"labels":["СЕКРЕТНАЯ-ЭМОЦИЯ"],"valence":0.777777}]}}`
|
||||
|
||||
// Вторая доставка теряет маршрут и меняет значения — та самая ветка, где
|
||||
// пишется WARN об удержанной версии и где велик соблазн приписать «что
|
||||
// именно потерялось».
|
||||
const poorer = `{"data":{"workouts":[{"id":"w-открытый","name":"На улице Ходьба",` +
|
||||
`"start":"2025-06-05 10:00:00 +0300","end":"2025-06-05 10:10:00 +0300",` +
|
||||
`"totalEnergy":{"qty":505050.5}}]}}`
|
||||
|
||||
deliver(t, arch, st, "d1", "Minutes", "auto-1", []byte(full))
|
||||
if _, err := f.Fold(ctx, "d1"); err != nil {
|
||||
t.Fatalf("свёртка первой доставки: %v", err)
|
||||
}
|
||||
deliver(t, arch, st, "d2", "Minutes", "auto-1", []byte(poorer))
|
||||
if _, err := f.Fold(ctx, "d2"); err != nil {
|
||||
t.Fatalf("свёртка второй доставки: %v", err)
|
||||
}
|
||||
|
||||
logged := buf.String()
|
||||
for _, secret := range []string{"55.98", "37.12", "latitude", "СЕКРЕТНАЯ-ЭМОЦИЯ", "404040", "505050", "0.777777"} {
|
||||
if strings.Contains(logged, secret) {
|
||||
t.Errorf("в логе оказалось %q:\n%s", secret, logged)
|
||||
}
|
||||
}
|
||||
// Координаты, наоборот, обязаны быть: без них счётчик удержанных версий не
|
||||
// говорит, какая сущность пострадала.
|
||||
if !strings.Contains(logged, "w-открытый") {
|
||||
t.Error("координат удержанной сущности в логе нет")
|
||||
}
|
||||
if !strings.Contains(logged, "poorer entity version held") {
|
||||
t.Error("удержание обеднённой версии не отмечено записью WARN")
|
||||
}
|
||||
}
|
||||
|
||||
// Счётчики разбора доезжают до лога ручным присваиванием, и забытая строка
|
||||
// молча выключила бы наблюдение — тот самый класс, ради которого счётчики
|
||||
// слияния встроены структурой. Тест закрепляет имена атрибутов.
|
||||
func TestFoldСчётчикиСущностейДоезжаютДоЛога(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var buf bytes.Buffer
|
||||
log := slog.New(slog.NewJSONHandler(&buf, &slog.HandlerOptions{Level: slog.LevelInfo}))
|
||||
|
||||
dir := t.TempDir()
|
||||
arch, err := archive.New(filepath.Join(dir, "raw"))
|
||||
if err != nil {
|
||||
t.Fatalf("архив: %v", err)
|
||||
}
|
||||
st, err := store.Open(filepath.Join(dir, "healthlog.db"))
|
||||
if err != nil {
|
||||
t.Fatalf("база: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { _ = st.Close() })
|
||||
|
||||
f := fold.New(arch, st, 0, log)
|
||||
|
||||
// Одна годная тренировка, одна без `id`, одна с неразбираемой меткой и один
|
||||
// элемент, не являющийся объектом: три класса пропуска плюс успех.
|
||||
const body = `{"data":{"workouts":[
|
||||
{"id":"w1","start":"2025-06-05 10:00:00 +0300","end":"2025-06-05 10:10:00 +0300"},
|
||||
{"start":"2025-06-05 11:00:00 +0300"},
|
||||
{"id":"w3","start":"позавчера"},
|
||||
"строка вместо объекта"]}}`
|
||||
|
||||
deliver(t, arch, st, "d1", "Minutes", "auto-1", []byte(body))
|
||||
if _, err := f.Fold(context.Background(), "d1"); err != nil {
|
||||
t.Fatalf("свёртка: %v", err)
|
||||
}
|
||||
|
||||
var rec struct {
|
||||
Workouts int `json:"workouts"`
|
||||
WorkoutsWritten int `json:"workouts_written"`
|
||||
Records int `json:"records"`
|
||||
RecordsWritten int `json:"records_written"`
|
||||
EntitiesHeld int `json:"entities_held"`
|
||||
SkippedEntities int `json:"skipped_entities"`
|
||||
}
|
||||
line := strings.TrimSpace(buf.String())
|
||||
if i := strings.LastIndex(line, "\n"); i >= 0 {
|
||||
line = line[i+1:]
|
||||
}
|
||||
if err := json.Unmarshal([]byte(line), &rec); err != nil {
|
||||
t.Fatalf("запись лога не разбирается: %v", err)
|
||||
}
|
||||
|
||||
if rec.Workouts != 1 || rec.WorkoutsWritten != 1 {
|
||||
t.Errorf("тренировок %d, записано %d — ожидалось 1 и 1", rec.Workouts, rec.WorkoutsWritten)
|
||||
}
|
||||
if rec.SkippedEntities != 3 {
|
||||
t.Errorf("пропущено сущностей %d, ожидалось 3 — счётчик не доехал до лога", rec.SkippedEntities)
|
||||
}
|
||||
if rec.Records != 0 || rec.RecordsWritten != 0 || rec.EntitiesHeld != 0 {
|
||||
t.Errorf("лишние счётчики: записей %d/%d, удержано %d",
|
||||
rec.Records, rec.RecordsWritten, rec.EntitiesHeld)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
package hae
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
// maxEntityID — предел длины идентификатора сущности.
|
||||
//
|
||||
// `id` приходит из тела, которым отправитель управляет целиком, а уезжает и в
|
||||
// первичный ключ таблицы, и в записи лога. UUID HealthKit — 36 байт, так что
|
||||
// запас велик; правило то же, что уже действует для имён непокрытых секций, и
|
||||
// оно снимает класс, а не случай.
|
||||
const maxEntityID = 128
|
||||
|
||||
// rfc3339Layout — второй формат метки, которым HAE шлёт stateOfMind
|
||||
// (находка 16). Метрики и тренировки идут первым, `timeLayout`.
|
||||
const rfc3339Layout = time.RFC3339
|
||||
|
||||
// entityHead — поля сущности, нужные разбору. Всё остальное остаётся в Raw и
|
||||
// хранится дословно.
|
||||
//
|
||||
// Длительность читается сырым сообщением, а не числом: нечисловое значение —
|
||||
// это пропуск ОДНОГО поля, а не сломанная сущность, и типизированное поле
|
||||
// уводило бы всю тренировку в счётчик «не разобралась как объект».
|
||||
type entityHead struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Date string `json:"date"`
|
||||
Start string `json:"start"`
|
||||
End string `json:"end"`
|
||||
|
||||
Duration json.RawMessage `json:"duration"`
|
||||
}
|
||||
|
||||
// decodeEntities разбирает элементы одной покрытой секции в сущности.
|
||||
//
|
||||
// Пропуск одного элемента не уносит соседей: у каждого класса пропуска свой
|
||||
// счётчик, тело остаётся в архиве, и доставку вернёт пересборка, когда разбор
|
||||
// научится понимать пропущенное.
|
||||
func decodeEntities(raws []json.RawMessage, kind string, res *Result) []Entity {
|
||||
if len(raws) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
out := make([]Entity, 0, len(raws))
|
||||
for _, raw := range raws {
|
||||
var head entityHead
|
||||
if err := json.Unmarshal(raw, &head); err != nil {
|
||||
res.SkippedEntityMalformed++
|
||||
continue
|
||||
}
|
||||
if head.ID == "" || len(head.ID) > maxEntityID {
|
||||
res.SkippedNoID++
|
||||
continue
|
||||
}
|
||||
|
||||
start, ok := parseEntityTime(firstNonEmpty(head.Start, head.Date))
|
||||
if !ok {
|
||||
res.SkippedEntityNoTime++
|
||||
continue
|
||||
}
|
||||
|
||||
// Конец, которого нет или который не читается, равен началу. У точки то
|
||||
// же вырождение запрещено — там оно схлопнуло бы две записи в одну
|
||||
// координату, — а сущность адресуется своим `id`, и схлопывать нечего.
|
||||
// Истина при этом остаётся в Raw дословно.
|
||||
end := start
|
||||
if head.End != "" {
|
||||
if e, ok := parseEntityTime(head.End); ok {
|
||||
end = e
|
||||
}
|
||||
}
|
||||
|
||||
_, offset := start.Zone()
|
||||
e := Entity{
|
||||
ID: head.ID,
|
||||
Kind: kind,
|
||||
Name: head.Name,
|
||||
Start: start.UTC(),
|
||||
End: end.UTC(),
|
||||
OffsetSeconds: offset,
|
||||
Duration: parseDuration(head.Duration),
|
||||
Raw: raw,
|
||||
}
|
||||
out = append(out, e)
|
||||
}
|
||||
if len(out) == 0 {
|
||||
return nil
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// parseEntityTime разбирает метку сущности, принимая оба измеренных формата.
|
||||
//
|
||||
// Оба, а не приписанный секции: формы однозначны и не пересекаются (RFC 3339
|
||||
// несёт `T` и `Z`), а HAE выравнивает секции между собой по ходу своих
|
||||
// обновлений — `stateOfMind` уже шлёт стабильные коды HealthKit там, где старые
|
||||
// секции шлют переводы. Приписанный секции формат ломался бы молча в день
|
||||
// такого выравнивания.
|
||||
//
|
||||
// Метка ТОЧКИ остаётся строгой (parseTime), и асимметрия намеренная: по метке
|
||||
// точки выводится слой, причём по метке в исходной зоне. Терпимость там
|
||||
// означала бы, что метка в UTC тихо портит выравнивание и часовая выгрузка
|
||||
// складывается с минутной; у сущности слоя нет, и терять на строгости нечего.
|
||||
func parseEntityTime(s string) (time.Time, bool) {
|
||||
if s == "" {
|
||||
return time.Time{}, false
|
||||
}
|
||||
if t, err := time.Parse(timeLayout, s); err == nil {
|
||||
return t, true
|
||||
}
|
||||
if t, err := time.Parse(rfc3339Layout, s); err == nil {
|
||||
return t, true
|
||||
}
|
||||
return time.Time{}, false
|
||||
}
|
||||
|
||||
// parseDuration переводит длительность в секунды.
|
||||
//
|
||||
// Отсутствие и нечисловое значение дают nil, а не ноль: ноль — законная
|
||||
// длительность, и потребитель, сложивший столбец, иначе не отличил бы
|
||||
// «источник не прислал» от «измерено ноль». Вычислять длительность из
|
||||
// интервала нельзя: HAE шлёт 91.746 при интервале в 91 секунду.
|
||||
func parseDuration(raw json.RawMessage) *float64 {
|
||||
lit := bytes.TrimSpace(raw)
|
||||
if len(lit) == 0 {
|
||||
return nil
|
||||
}
|
||||
v, err := strconv.ParseFloat(string(lit), 64)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return &v
|
||||
}
|
||||
|
||||
func firstNonEmpty(a, b string) string {
|
||||
if a != "" {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
package hae_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.vakhrushev.me/av/healthlog/internal/hae"
|
||||
)
|
||||
|
||||
func parseFixture(t *testing.T, name string) hae.Result {
|
||||
t.Helper()
|
||||
|
||||
res, err := hae.Parse(load(t, name), hae.Meta{})
|
||||
if err != nil {
|
||||
t.Fatalf("разбор %s: %v", name, err)
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
// Тренировка хранится дословно: маршрут и внутренние ряды остаются теми же
|
||||
// байтами, какими пришли. Раскладывать их по колонкам значило бы решить за
|
||||
// Apple, что в тренировке главное.
|
||||
func TestParseТренировкаСМаршрутом(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
res := parseFixture(t, "workout_route.json")
|
||||
|
||||
var w hae.Entity
|
||||
for _, e := range res.Workouts {
|
||||
if strings.Contains(string(e.Raw), `"route"`) {
|
||||
w = e
|
||||
}
|
||||
}
|
||||
if w.ID == "" {
|
||||
t.Fatal("уличной тренировки с маршрутом в фикстуре не нашлось")
|
||||
}
|
||||
if w.Name == "" {
|
||||
t.Error("имя пусто — по нему идёт выборка заголовков")
|
||||
}
|
||||
if !w.End.After(w.Start) {
|
||||
t.Errorf("интервал %v — %v", w.Start, w.End)
|
||||
}
|
||||
if w.OffsetSeconds != 3*3600 {
|
||||
t.Errorf("офсет %d, ожидался 10800", w.OffsetSeconds)
|
||||
}
|
||||
if w.Duration == nil || *w.Duration <= 0 {
|
||||
t.Errorf("длительность %v — обязана браться из тела", w.Duration)
|
||||
}
|
||||
|
||||
var body map[string]json.RawMessage
|
||||
if err := json.Unmarshal(w.Raw, &body); err != nil {
|
||||
t.Fatalf("содержимое не разбирается: %v", err)
|
||||
}
|
||||
for _, key := range []string{"route", "heartRateData", "activeEnergy", "heartRateRecovery"} {
|
||||
if _, ok := body[key]; !ok {
|
||||
t.Errorf("в содержимом нет %q — внутренние ряды обязаны храниться дословно", key)
|
||||
}
|
||||
}
|
||||
// Точки маршрута проходят исходными байтами: их метка (`timestamp`)
|
||||
// меткой сущности не является и не разбирается.
|
||||
if !strings.Contains(string(body["route"]), "timestamp") {
|
||||
t.Error("точки маршрута потеряли своё поле времени")
|
||||
}
|
||||
}
|
||||
|
||||
// Пульс приезжает дважды — в общем потоке метрик и внутри тренировки. Это
|
||||
// разные таблицы; смешение задвоило бы ряд.
|
||||
func TestParseРядПульсаТренировкиНеСтановитсяМетрикой(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
res := parseFixture(t, "workout_route.json")
|
||||
|
||||
if len(res.Points) != 0 {
|
||||
t.Errorf("точек %d, ожидалось 0: доставка несёт только тренировки", len(res.Points))
|
||||
}
|
||||
if res.Metrics != 0 {
|
||||
t.Errorf("метрик %d, ожидалось 0", res.Metrics)
|
||||
}
|
||||
if len(res.Uncovered) != 0 {
|
||||
t.Errorf("непокрытые %v, ожидался пустой список", res.Uncovered)
|
||||
}
|
||||
}
|
||||
|
||||
// Набор полей тренировки зависит от её типа: у домашней нет маршрута, зато
|
||||
// есть температура и влажность. Фиксированной схемы не существует.
|
||||
func TestParseТренировкаБезМаршрута(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
res := parseFixture(t, "workout_indoor.json")
|
||||
|
||||
if len(res.Workouts) == 0 {
|
||||
t.Fatal("тренировок нет")
|
||||
}
|
||||
var body map[string]json.RawMessage
|
||||
if err := json.Unmarshal(res.Workouts[0].Raw, &body); err != nil {
|
||||
t.Fatalf("содержимое не разбирается: %v", err)
|
||||
}
|
||||
if _, ok := body["route"]; ok {
|
||||
t.Error("у домашней тренировки взялся маршрут")
|
||||
}
|
||||
for _, key := range []string{"temperature", "humidity", "intensity"} {
|
||||
if _, ok := body[key]; !ok {
|
||||
t.Errorf("в содержимом нет %q", key)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// stateOfMind живёт по другим соглашениям: RFC 3339 в UTC, коды HealthKit
|
||||
// вместо переводов, поля source нет вовсе.
|
||||
func TestParseСостояниеРазума(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
res := parseFixture(t, "state_of_mind.json")
|
||||
|
||||
if len(res.Records) == 0 {
|
||||
t.Fatal("записей нет")
|
||||
}
|
||||
for _, r := range res.Records {
|
||||
if r.Kind != "stateOfMind" {
|
||||
t.Errorf("род %q, ожидался stateOfMind — имя секции хранится дословно", r.Kind)
|
||||
}
|
||||
if r.ID == "" {
|
||||
t.Error("идентификатор пуст")
|
||||
}
|
||||
// HAE прислал UTC — офсет ноль. Это значит «источник прислал UTC», а не
|
||||
// «человек был в Гринвиче»: местной зоны у секции в потоке нет вовсе.
|
||||
if r.OffsetSeconds != 0 {
|
||||
t.Errorf("офсет %d, ожидался 0", r.OffsetSeconds)
|
||||
}
|
||||
if r.Start.IsZero() {
|
||||
t.Error("метка не разобралась — RFC 3339 обязан приниматься")
|
||||
}
|
||||
}
|
||||
if len(res.Uncovered) != 0 {
|
||||
t.Errorf("непокрытые %v, ожидался пустой список", res.Uncovered)
|
||||
}
|
||||
}
|
||||
|
||||
// Пропуск одного элемента не уносит соседей, и у каждого класса свой счётчик:
|
||||
// тело остаётся в архиве, а вернуть сущность может только пересборка.
|
||||
func TestParseКраевыеСлучаиСущностей(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
res := parseFixture(t, "handmade_entities.json")
|
||||
|
||||
byID := make(map[string]hae.Entity, len(res.Workouts))
|
||||
for _, w := range res.Workouts {
|
||||
byID[w.ID] = w
|
||||
}
|
||||
|
||||
// Пустой id, отсутствующий id и id длиннее предела — один счётчик на три
|
||||
// случая: исход у них общий.
|
||||
if res.SkippedNoID != 3 {
|
||||
t.Errorf("пропущено по идентификатору %d, ожидалось 3", res.SkippedNoID)
|
||||
}
|
||||
// Метка не разбирается и метки нет вовсе.
|
||||
if res.SkippedEntityNoTime != 2 {
|
||||
t.Errorf("пропущено по метке %d, ожидалось 2", res.SkippedEntityNoTime)
|
||||
}
|
||||
// Элемент, не являющийся объектом.
|
||||
if res.SkippedEntityMalformed != 1 {
|
||||
t.Errorf("пропущено по форме %d, ожидалось 1", res.SkippedEntityMalformed)
|
||||
}
|
||||
|
||||
t.Run("нечитаемый конец не отбрасывает тренировку", func(t *testing.T) {
|
||||
w, ok := byID["00000000-0000-4000-8000-000000000003"]
|
||||
if !ok {
|
||||
t.Fatal("тренировка с нечитаемым концом потерялась целиком")
|
||||
}
|
||||
if !w.End.Equal(w.Start) {
|
||||
t.Errorf("конец %v, ожидался равным началу %v", w.End, w.Start)
|
||||
}
|
||||
if !strings.Contains(string(w.Raw), "никогда") {
|
||||
t.Error("исходное значение конца не сохранилось дословно")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("нечисловая длительность не становится нулём", func(t *testing.T) {
|
||||
w := byID["00000000-0000-4000-8000-000000000004"]
|
||||
if w.Duration != nil {
|
||||
t.Errorf("длительность %v, ожидалось отсутствие", *w.Duration)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("отсутствующая длительность отличима от нуля", func(t *testing.T) {
|
||||
w := byID["00000000-0000-4000-8000-000000000005"]
|
||||
if w.Duration != nil {
|
||||
t.Errorf("длительность %v, ожидалось отсутствие", *w.Duration)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("начало берётся из date, когда start отсутствует", func(t *testing.T) {
|
||||
w, ok := byID["00000000-0000-4000-8000-000000000006"]
|
||||
if !ok {
|
||||
t.Fatal("тренировка с меткой в date потерялась")
|
||||
}
|
||||
if w.Start.IsZero() {
|
||||
t.Error("метка не разобралась")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("незнакомое поле переживает разбор дословно", func(t *testing.T) {
|
||||
w := byID["00000000-0000-4000-8000-000000000009"]
|
||||
for _, lit := range []string{"невиданноеПоле", "1.0", "9007199254740993", "0.123456789012345678"} {
|
||||
if !strings.Contains(string(w.Raw), lit) {
|
||||
t.Errorf("литерал %q потерян при разборе", lit)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("запись со временем в формате метрик тоже разбирается", func(t *testing.T) {
|
||||
var daily *hae.Entity
|
||||
for i, r := range res.Records {
|
||||
if strings.Contains(string(r.Raw), "daily_mood") {
|
||||
daily = &res.Records[i]
|
||||
}
|
||||
}
|
||||
if daily == nil {
|
||||
t.Fatal("запись daily_mood потерялась")
|
||||
}
|
||||
if daily.OffsetSeconds != 3*3600 {
|
||||
t.Errorf("офсет %d, ожидался 10800: формат метрик обязан приниматься", daily.OffsetSeconds)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Отказ разбора — операция «всё или ничего»: ошибка после уже разобранной
|
||||
// секции не имеет права оставить сущности в результате.
|
||||
func TestParseОбрывПослеСекцииТренировокНеОтдаётСущностей(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const body = `{"data":{"workouts":[{"id":"w1","start":"2025-06-05 10:00:00 +0300"}],"metrics":`
|
||||
res, err := hae.Parse([]byte(body), hae.Meta{})
|
||||
if err == nil {
|
||||
t.Fatal("оборванное тело разобралось без ошибки")
|
||||
}
|
||||
if len(res.Workouts) != 0 {
|
||||
t.Errorf("сущностей %d, ожидалось 0", len(res.Workouts))
|
||||
}
|
||||
}
|
||||
|
||||
// Невыводимый слой — тоже «всё или ничего»: доставка целиком уходит в failed,
|
||||
// иначе она получила бы failed при частично записанной витрине.
|
||||
func TestParseНевыводимыйСлойНеОтдаётСущностей(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const body = `{"data":{
|
||||
"metrics":[{"name":"vo2_max","units":"ml/kg*min","data":[{"date":"2025-06-05 10:11:12 +0300","qty":1}]}],
|
||||
"stateOfMind":[{"id":"e1","start":"2025-06-05T18:00:00Z","valence":0.5}]}}`
|
||||
|
||||
res, err := hae.Parse([]byte(body), hae.Meta{Aggregation: "Default"})
|
||||
if err == nil {
|
||||
t.Fatal("доставка без выводимого слоя разобралась без ошибки")
|
||||
}
|
||||
if len(res.Records) != 0 {
|
||||
t.Errorf("записей %d, ожидалось 0", len(res.Records))
|
||||
}
|
||||
if len(res.Points) != 0 {
|
||||
t.Errorf("точек %d, ожидалось 0", len(res.Points))
|
||||
}
|
||||
}
|
||||
|
||||
// Повтор ключа покрытой секции объединяет её, а не отдаёт победу последней.
|
||||
func TestParseПовторСекцииТренировокОбъединяет(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const body = `{"data":{
|
||||
"workouts":[{"id":"w1","start":"2025-06-05 10:00:00 +0300"}],
|
||||
"workouts":[{"id":"w2","start":"2025-06-05 11:00:00 +0300"}]}}`
|
||||
|
||||
res, err := hae.Parse([]byte(body), hae.Meta{})
|
||||
if err != nil {
|
||||
t.Fatalf("разбор: %v", err)
|
||||
}
|
||||
if len(res.Workouts) != 2 {
|
||||
t.Errorf("тренировок %d, ожидалось 2 — секции обязаны объединиться", len(res.Workouts))
|
||||
}
|
||||
}
|
||||
|
||||
// Повтор самого члена `data` накапливает результаты: присваивание теряло бы
|
||||
// секции первого члена молча — их имена уже отмечены и во второй список не
|
||||
// попали бы.
|
||||
func TestParseПовторЧленаDataНакапливает(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const body = `{"data":{"ecg":[{"id":"e"}]},"data":{"workouts":[{"id":"w1","start":"2025-06-05 10:00:00 +0300"}]}}`
|
||||
|
||||
res, err := hae.Parse([]byte(body), hae.Meta{})
|
||||
if err != nil {
|
||||
t.Fatalf("разбор: %v", err)
|
||||
}
|
||||
if len(res.Workouts) != 1 {
|
||||
t.Errorf("тренировок %d, ожидалась 1", len(res.Workouts))
|
||||
}
|
||||
if len(res.Uncovered) != 1 || res.Uncovered[0] != "ecg" {
|
||||
t.Errorf("непокрытые %v, ожидался [ecg] — иначе секция потеряна молча", res.Uncovered)
|
||||
}
|
||||
}
|
||||
|
||||
// Непокрытой секцией с собственными `id` остаются те, чьей формы никто не
|
||||
// видел: разбор вслепую хуже честного «не покрыто».
|
||||
func TestParseНепокрытыеСекцииССобственнымиID(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const body = `{"data":{"ecg":[{"id":"e1","start":"2025-06-05 10:00:00 +0300"}]}}`
|
||||
|
||||
res, err := hae.Parse([]byte(body), hae.Meta{})
|
||||
if err != nil {
|
||||
t.Fatalf("разбор: %v", err)
|
||||
}
|
||||
if len(res.Records) != 0 {
|
||||
t.Errorf("записей %d, ожидалось 0", len(res.Records))
|
||||
}
|
||||
if len(res.Uncovered) != 1 || res.Uncovered[0] != "ecg" {
|
||||
t.Errorf("непокрытые %v", res.Uncovered)
|
||||
}
|
||||
}
|
||||
+165
-43
@@ -95,12 +95,66 @@ type Point struct {
|
||||
local time.Time
|
||||
}
|
||||
|
||||
// Entity — сущность с собственным идентификатором: тренировка или запись
|
||||
// секции вроде stateOfMind. От точки отличается тем, что её адресует сам `id`,
|
||||
// а не координаты, и слоя у неё нет вовсе: подробности выгрузки у этих секций
|
||||
// в интерфейсе HAE не бывает.
|
||||
type Entity struct {
|
||||
// ID — идентификатор из HealthKit. Приходит из тела и ограничен по длине:
|
||||
// уезжает и в первичный ключ, и в записи лога.
|
||||
ID string
|
||||
// Kind — верхнеуровневый ключ секции HAE ДОСЛОВНО (`stateOfMind`, не
|
||||
// `state_of_mind`): инвариант «форма Apple не транслируется» относится и к
|
||||
// именам секций, а переименование после того, как значение легло в базу,
|
||||
// стоило бы миграции данных. У тренировки род один и в ключ не входит.
|
||||
Kind string
|
||||
// Name — имя тренировки как прислал HAE, локализованное («В помещении
|
||||
// Ходьба»). У записей пустое.
|
||||
Name string
|
||||
|
||||
// Start и End — координаты в UTC. Конец, которого нет или который не
|
||||
// читается, равен началу: ключ сущности — `id`, схлопывать нечего, а истина
|
||||
// остаётся в Raw. У точки то же вырождение запрещено — там оно схлопнуло бы
|
||||
// две записи в одну координату.
|
||||
Start time.Time
|
||||
End time.Time
|
||||
|
||||
// OffsetSeconds — смещение зоны НАЧАЛА. Колонка одна, а тренировка через
|
||||
// смену зоны дала бы два разных.
|
||||
OffsetSeconds int
|
||||
|
||||
// Duration — длительность тренировки в секундах, как прислал HAE. Не
|
||||
// вычисляется из интервала: HAE шлёт 91.746 при интервале в 91 секунду.
|
||||
// Отсутствие выражается nil, а не нулём: ноль — законная длительность.
|
||||
Duration *float64
|
||||
|
||||
// Raw — содержимое сущности исходными байтами, как пришло в теле, включая
|
||||
// маршрут и внутренние ряды.
|
||||
Raw json.RawMessage
|
||||
}
|
||||
|
||||
// Result — итог разбора доставки. Частичные исходы живут в счётчиках, а не в
|
||||
// ошибке: пакет, у которого не разобралась одна точка из тысячи, — обычное
|
||||
// дело, и терять из-за неё остальное нельзя.
|
||||
type Result struct {
|
||||
Points []Point
|
||||
|
||||
// Workouts и Records — сущности с собственным идентификатором. Разведены,
|
||||
// потому что у тренировки есть заголовок (имя, интервал, длительность), по
|
||||
// которому идёт выборка, а у записи его нет.
|
||||
Workouts []Entity
|
||||
Records []Entity
|
||||
|
||||
// SkippedNoID — сущности без пригодного идентификатора: пустого, нет вовсе
|
||||
// или длиннее предела. Один счётчик на все три случая: исход у них общий, а
|
||||
// различает их только тело, лежащее в архиве.
|
||||
SkippedNoID int
|
||||
// SkippedEntityNoTime — сущности с идентификатором, но без разбираемой
|
||||
// метки времени.
|
||||
SkippedEntityNoTime int
|
||||
// SkippedEntityMalformed — элементы секции, не разобравшиеся как объект.
|
||||
SkippedEntityMalformed int
|
||||
|
||||
// Uncovered — верхнеуровневые ключи `data`, которых разбор не покрывает,
|
||||
// отсортированные и без повторов. Половина живого потока состоит из таких
|
||||
// доставок целиком (48 из 99: workouts и stateOfMind), и без этого списка
|
||||
@@ -170,13 +224,17 @@ func Parse(body []byte, meta Meta) (res Result, err error) {
|
||||
}
|
||||
}()
|
||||
|
||||
metrics, uncovered, dropped, err := decodeEnvelope(body)
|
||||
env, err := decodeEnvelope(body)
|
||||
if err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
res.Uncovered = uncovered
|
||||
res.UncoveredDropped = dropped
|
||||
res.Uncovered = env.uncovered
|
||||
res.UncoveredDropped = env.dropped
|
||||
|
||||
res.Workouts = decodeEntities(env.workouts, workoutsSection, &res)
|
||||
res.Records = decodeEntities(env.stateOfMind, stateOfMindSection, &res)
|
||||
|
||||
metrics := env.metrics
|
||||
res.Metrics = len(metrics)
|
||||
if len(metrics) == 0 {
|
||||
return res, nil
|
||||
@@ -209,6 +267,12 @@ func Parse(body []byte, meta Meta) (res Result, err error) {
|
||||
// определился слой, обязана остаться записью о том, что в теле есть
|
||||
// невосстановимая секция. Иначе ретеншен увидит failed без списка и
|
||||
// решит, что терять нечего.
|
||||
//
|
||||
// Сущности при этом НЕ отдаются, хотя слоя у них нет и разобрались они
|
||||
// успешно. «Всё или ничего» относится к доставке, а не к точкам: отдай
|
||||
// мы их, доставка получила бы `failed` при частично записанной витрине,
|
||||
// и повторная свёртка перестала бы быть no-op. Цена названа в спеке —
|
||||
// такая доставка доедет пересборкой, а тело ждёт в архиве.
|
||||
return Result{
|
||||
Metrics: res.Metrics,
|
||||
Uncovered: res.Uncovered,
|
||||
@@ -262,16 +326,53 @@ type group struct {
|
||||
// 42 МиБ через map[string]any удерживает 197 МиБ кучи против 54 МиБ у этой
|
||||
// формы. Вместе с самим телом пик доходил бы до ~300 МиБ на доставку — это
|
||||
// OOM ровно на пике потока, когда терять доставки дороже всего.
|
||||
// metricsSection — единственная секция, которую разбор покрывает сегодня.
|
||||
const metricsSection = "metrics"
|
||||
// Секции, которые разбор покрывает. Прочие секции с собственными `id` (`ecg`,
|
||||
// `symptoms`, `cycleTracking`, `medications`, `heartRateNotifications`)
|
||||
// покрытыми намеренно не становятся: живой поток не приносил их ни разу, их
|
||||
// форма никем не наблюдалась, а полнота покрытия HealthKit ради полноты целью
|
||||
// проекта не является.
|
||||
const (
|
||||
metricsSection = "metrics"
|
||||
workoutsSection = "workouts"
|
||||
stateOfMindSection = "stateOfMind"
|
||||
)
|
||||
|
||||
// covered говорит, покрывает ли разбор секцию с таким именем.
|
||||
// decodeCovered разбирает секцию, если разбор её покрывает; второй возврат
|
||||
// говорит, взялся ли он за неё.
|
||||
//
|
||||
// Функция, а не изменяемая карта: разбор и перечисление непокрытых ходят по
|
||||
// одному источнику, поэтому состояние «секция разбирается, но числится
|
||||
// непокрытой» невыразимо.
|
||||
func covered(section string) bool {
|
||||
return section == metricsSection
|
||||
// Один источник и для разбора, и для перечисления непокрытых: перечисляющий
|
||||
// спрашивает ровно того, кто разбирает, поэтому состояние «секция разбирается,
|
||||
// но числится непокрытой» невыразимо по построению. Отдельный предикат
|
||||
// `covered` разошёлся бы с этим switch при первой же новой секции.
|
||||
//
|
||||
// Повтор ключа покрытой секции JSON допускает; секции ОБЪЕДИНЯЮТСЯ, а не
|
||||
// побеждает последняя: терять данные молча нельзя.
|
||||
func decodeCovered(name string, dec *json.Decoder, env *envelope) (bool, error) {
|
||||
switch name {
|
||||
case metricsSection:
|
||||
var part []metricEnvelope
|
||||
if err := dec.Decode(&part); err != nil {
|
||||
return true, err
|
||||
}
|
||||
env.metrics = append(env.metrics, part...)
|
||||
return true, nil
|
||||
case workoutsSection:
|
||||
part, err := decodeSection(dec)
|
||||
if err != nil {
|
||||
return true, err
|
||||
}
|
||||
env.workouts = append(env.workouts, part...)
|
||||
return true, nil
|
||||
case stateOfMindSection:
|
||||
part, err := decodeSection(dec)
|
||||
if err != nil {
|
||||
return true, err
|
||||
}
|
||||
env.stateOfMind = append(env.stateOfMind, part...)
|
||||
return true, nil
|
||||
default:
|
||||
return false, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Границы на список непокрытых ключей. Тело контролирует отправитель целиком:
|
||||
@@ -317,9 +418,11 @@ type pointHead struct {
|
||||
// мгновенно. Разбор `data` в map[string]json.RawMessage дешевле по коду, но
|
||||
// копирует байты ВСЕХ секций и держит их до конца разбора; у проглатывания
|
||||
// копия одна и живёт до следующего члена.
|
||||
func decodeEnvelope(body []byte) (metrics []metricEnvelope, uncovered []string, dropped int, err error) {
|
||||
fail := func(e error) ([]metricEnvelope, []string, int, error) {
|
||||
return nil, nil, 0, fmt.Errorf("%w: %v", ErrMalformed, e) //nolint:errorlint // причина уходит в лог, наружу не раскрывается
|
||||
func decodeEnvelope(body []byte) (envelope, error) {
|
||||
var env envelope
|
||||
|
||||
fail := func(e error) (envelope, error) {
|
||||
return envelope{}, fmt.Errorf("%w: %v", ErrMalformed, e) //nolint:errorlint // причина уходит в лог, наружу не раскрывается
|
||||
}
|
||||
|
||||
dec := json.NewDecoder(bytes.NewReader(body))
|
||||
@@ -335,7 +438,7 @@ func decodeEnvelope(body []byte) (metrics []metricEnvelope, uncovered []string,
|
||||
// раскладывал его в пустую структуру. Границы поведения этой задачей не
|
||||
// двигаются — она добавляет список, а не строгость.
|
||||
if tok == nil {
|
||||
return nil, nil, 0, nil
|
||||
return envelope{}, nil
|
||||
}
|
||||
if d, ok := tok.(json.Delim); !ok || d != '{' {
|
||||
return fail(fmt.Errorf("ожидался объект, встречено %v", tok))
|
||||
@@ -352,8 +455,12 @@ func decodeEnvelope(body []byte) (metrics []metricEnvelope, uncovered []string,
|
||||
}
|
||||
continue
|
||||
}
|
||||
metrics, uncovered, dropped, err = decodeData(dec, seen)
|
||||
if err != nil {
|
||||
// Повтор самого члена `data` JSON допускает, и результаты
|
||||
// НАКАПЛИВАЮТСЯ, а не замещаются: присваивание теряло бы секции первого
|
||||
// члена целиком, причём молча — их имена уже отмечены в `seen` и во
|
||||
// второй список непокрытых не попали бы. Правило то же, что уровнем
|
||||
// ниже для повтора ключа секции.
|
||||
if err := decodeData(dec, seen, &env); err != nil {
|
||||
return fail(err)
|
||||
}
|
||||
}
|
||||
@@ -363,60 +470,75 @@ func decodeEnvelope(body []byte) (metrics []metricEnvelope, uncovered []string,
|
||||
|
||||
// Список канонизируется: порядок ключей в JSON от HAE нестабилен, а
|
||||
// значение уезжает в базу и сравнивается между доставками.
|
||||
sort.Strings(uncovered)
|
||||
return metrics, uncovered, dropped, nil
|
||||
sort.Strings(env.uncovered)
|
||||
return env, nil
|
||||
}
|
||||
|
||||
// decodeData разбирает объект data, собирая metrics и имена непокрытых секций.
|
||||
func decodeData(dec *json.Decoder, seen map[string]struct{}) ([]metricEnvelope, []string, int, error) {
|
||||
// envelope — что разбор вынул из тела: покрытые секции и имена непокрытых.
|
||||
type envelope struct {
|
||||
metrics []metricEnvelope
|
||||
workouts []json.RawMessage
|
||||
stateOfMind []json.RawMessage
|
||||
uncovered []string
|
||||
dropped int
|
||||
}
|
||||
|
||||
// decodeData разбирает объект data, дописывая в конверт покрытые секции и
|
||||
// имена непокрытых.
|
||||
func decodeData(dec *json.Decoder, seen map[string]struct{}, env *envelope) error {
|
||||
tok, err := dec.Token()
|
||||
if err != nil {
|
||||
return nil, nil, 0, err
|
||||
return err
|
||||
}
|
||||
// data не объект — прежнее поведение: ошибка ровно там, где была.
|
||||
if d, ok := tok.(json.Delim); !ok || d != '{' {
|
||||
return nil, nil, 0, fmt.Errorf("data: ожидался объект, встречено %v", tok)
|
||||
return fmt.Errorf("data: ожидался объект, встречено %v", tok)
|
||||
}
|
||||
|
||||
var (
|
||||
metrics []metricEnvelope
|
||||
uncovered []string
|
||||
dropped int
|
||||
)
|
||||
for dec.More() {
|
||||
name, err := memberName(dec)
|
||||
if err != nil {
|
||||
return nil, nil, 0, err
|
||||
return err
|
||||
}
|
||||
|
||||
if covered(name) {
|
||||
// Повтор ключа metrics JSON допускает; секции ОБЪЕДИНЯЮТСЯ, а не
|
||||
// побеждает последняя: терять точки молча нельзя.
|
||||
var part []metricEnvelope
|
||||
if err := dec.Decode(&part); err != nil {
|
||||
return nil, nil, 0, err
|
||||
}
|
||||
metrics = append(metrics, part...)
|
||||
handled, err := decodeCovered(name, dec, env)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if handled {
|
||||
continue
|
||||
}
|
||||
|
||||
if err := swallow(dec); err != nil {
|
||||
return nil, nil, 0, err
|
||||
return err
|
||||
}
|
||||
if _, dup := seen[name]; dup {
|
||||
continue
|
||||
}
|
||||
seen[name] = struct{}{}
|
||||
if len(uncovered) >= maxUncovered {
|
||||
dropped++
|
||||
if len(env.uncovered) >= maxUncovered {
|
||||
env.dropped++
|
||||
continue
|
||||
}
|
||||
uncovered = append(uncovered, clipSection(name))
|
||||
env.uncovered = append(env.uncovered, clipSection(name))
|
||||
}
|
||||
if _, err := dec.Token(); err != nil { // закрывающая скобка data
|
||||
return nil, nil, 0, err
|
||||
return err
|
||||
}
|
||||
return metrics, uncovered, dropped, nil
|
||||
return nil
|
||||
}
|
||||
|
||||
// decodeSection читает секцию сущностей элементами исходных байтов.
|
||||
//
|
||||
// Разбор до `json.RawMessage`, а не до структуры: сущность хранится дословно, и
|
||||
// декодирование в типизированное значение потеряло бы литерал — ровно то, от
|
||||
// чего защищает `Point.Raw`.
|
||||
func decodeSection(dec *json.Decoder) ([]json.RawMessage, error) {
|
||||
var part []json.RawMessage
|
||||
if err := dec.Decode(&part); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return part, nil
|
||||
}
|
||||
|
||||
// memberName читает имя члена объекта. Token() отдаёт имя уже после разбора
|
||||
|
||||
+12
-11
@@ -548,10 +548,11 @@ func FuzzParse(f *testing.F) {
|
||||
})
|
||||
}
|
||||
|
||||
// Половина живого потока состоит из непокрытых секций целиком (48 доставок из
|
||||
// 99: workouts и stateOfMind). Без списка они неотличимы от разобранной
|
||||
// доставки с пустой секцией метрик, и ретеншен, ориентируясь на статус, срезал
|
||||
// бы тела, которые для stateOfMind единственный источник.
|
||||
// Непокрытая секция неотличима от разобранной доставки с пустой секцией
|
||||
// метрик, если её не назвать: ретеншен, ориентируясь на статус, срезал бы
|
||||
// тела, которые для секций без экспорта Apple единственный источник. С тех пор
|
||||
// как workouts и stateOfMind стали покрытыми, роль непокрытой в фикстуре
|
||||
// играют секции, которых поток ещё не приносил.
|
||||
func TestParseПеречисляетНепокрытыеСекции(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
@@ -560,7 +561,7 @@ func TestParseПеречисляетНепокрытыеСекции(t *testing.
|
||||
t.Fatalf("разбор: %v", err)
|
||||
}
|
||||
|
||||
want := []string{"stateOfMind", "workouts"}
|
||||
want := []string{"ecg", "symptoms"}
|
||||
if !slices.Equal(res.Uncovered, want) {
|
||||
t.Errorf("непокрытые %v, ожидались %v", res.Uncovered, want)
|
||||
}
|
||||
@@ -578,11 +579,11 @@ func TestParseНепокрытыеСекцииГраницыИДетермини
|
||||
t.Run("доставка из одной непокрытой секции", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
res, err := hae.Parse([]byte(`{"data":{"stateOfMind":[{"x":1}]}}`), hae.Meta{})
|
||||
res, err := hae.Parse([]byte(`{"data":{"ecg":[{"x":1}]}}`), hae.Meta{})
|
||||
if err != nil {
|
||||
t.Fatalf("разбор: %v", err)
|
||||
}
|
||||
if !slices.Equal(res.Uncovered, []string{"stateOfMind"}) {
|
||||
if !slices.Equal(res.Uncovered, []string{"ecg"}) {
|
||||
t.Errorf("непокрытые %v", res.Uncovered)
|
||||
}
|
||||
if len(res.Points) != 0 {
|
||||
@@ -609,11 +610,11 @@ func TestParseНепокрытыеСекцииГраницыИДетермини
|
||||
t.Parallel()
|
||||
|
||||
bodies := []string{
|
||||
`{"data":{"workouts":[],"stateOfMind":[],"ecg":[]}}`,
|
||||
`{"data":{"ecg":[],"workouts":[],"stateOfMind":[]}}`,
|
||||
`{"data":{"stateOfMind":[],"ecg":[],"workouts":[],"ecg":[]}}`,
|
||||
`{"data":{"symptoms":[],"medications":[],"ecg":[]}}`,
|
||||
`{"data":{"ecg":[],"symptoms":[],"medications":[]}}`,
|
||||
`{"data":{"medications":[],"ecg":[],"symptoms":[],"ecg":[]}}`,
|
||||
}
|
||||
want := []string{"ecg", "stateOfMind", "workouts"}
|
||||
want := []string{"ecg", "medications", "symptoms"}
|
||||
for _, b := range bodies {
|
||||
res, err := hae.Parse([]byte(b), hae.Meta{})
|
||||
if err != nil {
|
||||
|
||||
@@ -116,6 +116,13 @@ func TestParseУдержаниеКучиНепокрытойСекции(t *test
|
||||
t.Logf("непокрытых %v, удержано %d МиБ при теле %d МиБ",
|
||||
res.Uncovered, retained>>20, len(body)>>20)
|
||||
|
||||
// Замер обязан идти по ветке проглатывания. Без этой проверки расширение
|
||||
// множества покрытых секций превращает сторож в зелёную пустышку — что уже
|
||||
// однажды и произошло.
|
||||
if len(res.Uncovered) == 0 {
|
||||
t.Fatal("непокрытых секций нет — замер идёт мимо проглатывания и ничего не сторожит")
|
||||
}
|
||||
|
||||
if retained > limit {
|
||||
t.Errorf("удержано %d МиБ при теле %d МиБ — больше четырёх тел; "+
|
||||
"похоже, секции удерживаются, а не проглатываются",
|
||||
@@ -149,9 +156,13 @@ func bodyWithUncovered(size int) []byte {
|
||||
var b strings.Builder
|
||||
b.WriteString(`{"data":{"metrics":[{"name":"m","units":"count","data":[`)
|
||||
b.WriteString(`{"date":"2025-06-05 10:00:00 +0300","qty":1}`)
|
||||
b.WriteString(`]}],"stateOfMind":[`)
|
||||
// Секция обязана быть ЗАВЕДОМО НЕПОКРЫТОЙ: тело из покрытой секции идёт
|
||||
// мимо проглатывания, и замер вырождается в ноль, оставаясь зелёным.
|
||||
// Так уже случилось однажды: здесь стоял `stateOfMind`, и задача, покрывшая
|
||||
// его разбором, обезоружила сторож молча.
|
||||
b.WriteString(`]}],"ecg":[`)
|
||||
|
||||
const entry = `{"id":"00000000-0000-0000-0000-000000000000","kind":"momentary_emotion","valence":0.5},`
|
||||
const entry = `{"id":"00000000-0000-0000-0000-000000000000","classification":"sinusRhythm"},`
|
||||
for b.Len() < size {
|
||||
b.WriteString(entry)
|
||||
}
|
||||
|
||||
Vendored
+21
@@ -12,6 +12,19 @@
|
||||
переставлены с сохранением формы), даты (сдвинуты на постоянную величину),
|
||||
имена устройств.
|
||||
|
||||
Для сущностей с собственным `id` вычищается дополнительно: сами
|
||||
идентификаторы (псевдо-UUID той же формы), метки RFC 3339 и `route[].timestamp`
|
||||
(сдвигаются, как и прочие даты), а также словарные значения `stateOfMind` —
|
||||
`kind`, `valenceClassification`, `labels`, `associations`. Последнее не
|
||||
перестраховка: это измерение душевного состояния, самое чувствительное, что
|
||||
есть в потоке. Значения подменяются другими кодами из того же словаря HealthKit,
|
||||
поэтому форма (snake_case, строка против массива строк) сохраняется, а смысл —
|
||||
нет. Побочный эффект подмены: в `labels` могут появиться повторы, которых HAE не
|
||||
шлёт; разбору это безразлично.
|
||||
|
||||
Координаты маршрута вычищаются как обычные числа — они не отличаются от прочих
|
||||
измерений и после подмены указывают в никуда.
|
||||
|
||||
| Файл | Что проверяет |
|
||||
|---|---|
|
||||
| `minute.json` | минутная доставка; плотные метрики минутные, одна (`apple_stand_hour`) часовая — классификация **по метрике**, а не по доставке; редкие наследуют минутный слой; суточная сводка сна |
|
||||
@@ -20,7 +33,12 @@
|
||||
| `mixed.json` | одна доставка с минутными, посекундными и часовыми метриками — перенастройка автоматизации |
|
||||
| `heartbeat_series.json` | точка с `heartbeatSeries`: третий формат времени, серия проходит исходными байтами |
|
||||
| `sparse_sleep.json` | доставка **без плотных метрик** (заголовок `Default` не спасает) и поэпизодный сон с задвоенной меткой — интервальная идентичность |
|
||||
| `workout_route.json` | уличная тренировка с маршрутом и внутренними рядами; ряды урезаны `--limit`, форма точки маршрута сохранена |
|
||||
| `workout_indoor.json` | тренировка без маршрута: набор полей зависит от типа (`temperature`, `humidity`, `intensity` вместо `route`, `avgSpeed`, `flightsClimbed`) |
|
||||
| `state_of_mind.json` | `stateOfMind`: RFC 3339 в UTC, коды вместо переводов, поля `source` нет вовсе |
|
||||
| `uncovered_sections.json` | одна доставка со всеми родами секций сразу — покрытыми и непокрытыми. Рукотворная: живой поток шлёт по одной секции за раз |
|
||||
| `handmade_edge.json` | случаи, которых живой поток не даёт (см. ниже) |
|
||||
| `handmade_entities.json` | краевые случаи сущностей: пустой, отсутствующий и слишком длинный `id`; неразбираемая метка и её отсутствие; неразбираемый `end`; нечисловая и отсутствующая длительность; две версии одного `id` в одном теле; элемент, не являющийся объектом |
|
||||
|
||||
`handmade_edge.json` собран руками, скриптом не воспроизводится:
|
||||
|
||||
@@ -43,3 +61,6 @@ python3 tmp/research/fixtures.py --list
|
||||
python3 tmp/research/fixtures.py <файл из data/raw> --metrics a,b --limit 14 \
|
||||
--out internal/hae/testdata/<имя>.json
|
||||
```
|
||||
|
||||
`--limit` режет и внутренние ряды тренировки (маршрут, пульс, энергия): фикстуре
|
||||
нужна форма точки ряда, а не 593 её экземпляра.
|
||||
|
||||
+110
@@ -0,0 +1,110 @@
|
||||
{
|
||||
"_comment": "Рукотворная фикстура: краевые случаи сущностей с собственным id, которых живой поток не даёт. Скриптом tmp/research/fixtures.py не порождается, значения выдуманы целиком.",
|
||||
"data": {
|
||||
"workouts": [
|
||||
{
|
||||
"id": "",
|
||||
"name": "Пустой идентификатор",
|
||||
"start": "2025-06-05 10:00:00 +0300",
|
||||
"end": "2025-06-05 10:10:00 +0300",
|
||||
"duration": 600
|
||||
},
|
||||
{
|
||||
"name": "Идентификатора нет вовсе",
|
||||
"start": "2025-06-05 10:00:00 +0300",
|
||||
"end": "2025-06-05 10:10:00 +0300"
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000001",
|
||||
"name": "Метка не разбирается",
|
||||
"start": "вчера вечером",
|
||||
"end": "2025-06-05 10:10:00 +0300"
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000002",
|
||||
"name": "Метки нет вовсе",
|
||||
"duration": 60
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000003",
|
||||
"name": "Конец не разбирается",
|
||||
"start": "2025-06-05 11:00:00 +0300",
|
||||
"end": "никогда",
|
||||
"duration": 61.5
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000004",
|
||||
"name": "Длительность не число",
|
||||
"start": "2025-06-05 12:00:00 +0300",
|
||||
"end": "2025-06-05 12:01:00 +0300",
|
||||
"duration": "минута"
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000005",
|
||||
"name": "Длительности нет",
|
||||
"start": "2025-06-05 13:00:00 +0300",
|
||||
"end": "2025-06-05 13:01:00 +0300"
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000006",
|
||||
"name": "Начало берётся из date",
|
||||
"date": "2025-06-05 14:00:00 +0300",
|
||||
"duration": 30
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000007",
|
||||
"name": "Две версии в одном теле, первая",
|
||||
"start": "2025-06-05 15:00:00 +0300",
|
||||
"end": "2025-06-05 15:30:00 +0300",
|
||||
"duration": 1800,
|
||||
"totalEnergy": {"qty": 100.5, "units": "kJ"}
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000007",
|
||||
"name": "Две версии в одном теле, вторая",
|
||||
"start": "2025-06-05 15:00:00 +0300",
|
||||
"end": "2025-06-05 15:30:00 +0300",
|
||||
"duration": 1800,
|
||||
"totalEnergy": {"qty": 110.5, "units": "kJ"}
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000008-и-ещё-очень-длинный-хвост-который-заведомо-выходит-за-предел-длины-идентификатора-принятый-разбором-сущностей",
|
||||
"name": "Идентификатор длиннее предела",
|
||||
"start": "2025-06-05 16:00:00 +0300",
|
||||
"end": "2025-06-05 16:01:00 +0300"
|
||||
},
|
||||
"не объект вовсе",
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-000000000009",
|
||||
"name": "Незнакомое поле и дословные литералы",
|
||||
"start": "2025-06-05 17:00:00 +0300",
|
||||
"end": "2025-06-05 17:05:00 +0300",
|
||||
"duration": 300,
|
||||
"невиданноеПоле": {"вложенное": [1.0, 9007199254740993, 0.123456789012345678]},
|
||||
"isIndoor": false
|
||||
}
|
||||
],
|
||||
"stateOfMind": [
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-00000000000a",
|
||||
"kind": "momentary_emotion",
|
||||
"start": "2025-06-05T18:00:00Z",
|
||||
"end": "2025-06-05T18:00:00Z",
|
||||
"valence": 0.5,
|
||||
"valenceClassification": "pleasant",
|
||||
"labels": ["calm"],
|
||||
"associations": ["hobbies"]
|
||||
},
|
||||
{
|
||||
"id": "00000000-0000-4000-8000-00000000000b",
|
||||
"kind": "daily_mood",
|
||||
"start": "2025-06-05 21:00:00 +0300",
|
||||
"end": "2025-06-06 21:00:00 +0300",
|
||||
"valence": -0.25,
|
||||
"valenceClassification": "slightly_unpleasant",
|
||||
"labels": [],
|
||||
"associations": []
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"data": {
|
||||
"stateOfMind": [
|
||||
{
|
||||
"associations": [
|
||||
"fitness"
|
||||
],
|
||||
"valenceClassification": "slightly_unpleasant",
|
||||
"valence": 0.021376147736425923,
|
||||
"end": "2025-06-05T18:03:51Z",
|
||||
"labels": [
|
||||
"peaceful",
|
||||
"peaceful"
|
||||
],
|
||||
"kind": "momentary_emotion",
|
||||
"id": "50244944-3582-4508-7804-525425479700",
|
||||
"start": "2025-06-05T18:03:51Z"
|
||||
},
|
||||
{
|
||||
"kind": "daily_mood",
|
||||
"end": "2025-06-05T18:03:17Z",
|
||||
"id": "87868435-7832-4736-7633-078876535422",
|
||||
"associations": [
|
||||
"hobbies"
|
||||
],
|
||||
"start": "2025-06-05T18:03:17Z",
|
||||
"valence": 0.12057562819279189,
|
||||
"valenceClassification": "slightly_unpleasant",
|
||||
"labels": [
|
||||
"relieved",
|
||||
"relieved"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
+90
-15
@@ -5,16 +5,56 @@
|
||||
"name": "step_count",
|
||||
"units": "count",
|
||||
"data": [
|
||||
{"date": "2025-06-05 09:00:00 +0300", "qty": 41.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:01:00 +0300", "qty": 17.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:02:00 +0300", "qty": 82.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:03:00 +0300", "qty": 5.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:04:00 +0300", "qty": 63.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:05:00 +0300", "qty": 28.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:06:00 +0300", "qty": 94.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:07:00 +0300", "qty": 12.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:08:00 +0300", "qty": 71.0, "source": "Device A"},
|
||||
{"date": "2025-06-05 09:09:00 +0300", "qty": 36.0, "source": "Device A"}
|
||||
{
|
||||
"date": "2025-06-05 09:00:00 +0300",
|
||||
"qty": 41.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:01:00 +0300",
|
||||
"qty": 17.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:02:00 +0300",
|
||||
"qty": 82.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:03:00 +0300",
|
||||
"qty": 5.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:04:00 +0300",
|
||||
"qty": 63.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:05:00 +0300",
|
||||
"qty": 28.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:06:00 +0300",
|
||||
"qty": 94.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:07:00 +0300",
|
||||
"qty": 12.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:08:00 +0300",
|
||||
"qty": 71.0,
|
||||
"source": "Device A"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 09:09:00 +0300",
|
||||
"qty": 36.0,
|
||||
"source": "Device A"
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
@@ -26,11 +66,28 @@
|
||||
"end": "2025-06-05 08:30:00 +0300",
|
||||
"duration": 1800,
|
||||
"heartRateData": [
|
||||
{"date": "2025-06-05 08:00:07 +0300", "Min": 91.0, "Avg": 94.5, "Max": 98.0, "units": "count/min"},
|
||||
{"date": "2025-06-05 08:00:21 +0300", "Min": 93.0, "Avg": 95.5, "Max": 99.0, "units": "count/min"}
|
||||
{
|
||||
"date": "2025-06-05 08:00:07 +0300",
|
||||
"Min": 91.0,
|
||||
"Avg": 94.5,
|
||||
"Max": 98.0,
|
||||
"units": "count/min"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 08:00:21 +0300",
|
||||
"Min": 93.0,
|
||||
"Avg": 95.5,
|
||||
"Max": 99.0,
|
||||
"units": "count/min"
|
||||
}
|
||||
],
|
||||
"route": [
|
||||
{"lat": 10.0, "lon": 20.0, "altitude": 30.0, "timestamp": "2025-06-05 08:00:07 +0300"}
|
||||
{
|
||||
"lat": 10.0,
|
||||
"lon": 20.0,
|
||||
"altitude": 30.0,
|
||||
"timestamp": "2025-06-05 08:00:07 +0300"
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
@@ -41,9 +98,27 @@
|
||||
"end": "2025-06-05T05:12:33Z",
|
||||
"kind": "momentary_emotion",
|
||||
"valence": 0.25,
|
||||
"labels": ["slightly_pleasant"],
|
||||
"labels": [
|
||||
"slightly_pleasant"
|
||||
],
|
||||
"associations": []
|
||||
}
|
||||
],
|
||||
"ecg": [
|
||||
{
|
||||
"id": "00000000-0000-0000-0000-000000000003",
|
||||
"start": "2025-06-05 07:00:00 +0300",
|
||||
"classification": "sinusRhythm"
|
||||
}
|
||||
],
|
||||
"symptoms": [
|
||||
{
|
||||
"id": "00000000-0000-0000-0000-000000000004",
|
||||
"start": "2025-06-05 06:00:00 +0300",
|
||||
"name": "Головная боль",
|
||||
"severity": "mild"
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"_comment": "Рукотворная фикстура: одна доставка со всеми родами секций сразу — покрытыми (metrics, workouts, stateOfMind) и непокрытыми (ecg, symptoms). Живой поток такого не даёт: автоматизация HAE шлёт одну секцию за раз."
|
||||
}
|
||||
|
||||
+176
@@ -0,0 +1,176 @@
|
||||
{
|
||||
"data": {
|
||||
"workouts": [
|
||||
{
|
||||
"id": "19336133-5198-0770-0219-503343909539",
|
||||
"maxHeartRate": {
|
||||
"qty": 199,
|
||||
"units": "count/min"
|
||||
},
|
||||
"temperature": {
|
||||
"units": "degC",
|
||||
"qty": 25.642900109344569
|
||||
},
|
||||
"name": "В помещении Ходьба",
|
||||
"avgHeartRate": {
|
||||
"qty": 47.271142352144859,
|
||||
"units": "count/min"
|
||||
},
|
||||
"isIndoor": true,
|
||||
"duration": 11.104378534563007,
|
||||
"walkingAndRunningDistance": [
|
||||
{
|
||||
"qty": 0.051178653222924688,
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"units": "km",
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"qty": 0.0022744856624713684,
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"units": "km",
|
||||
"source": "Device A "
|
||||
}
|
||||
],
|
||||
"intensity": {
|
||||
"qty": 1.1101433306047975,
|
||||
"units": "kcal/hr·kg"
|
||||
},
|
||||
"start": "2025-06-05 21:07:25 +0300",
|
||||
"end": "2025-06-05 21:08:56 +0300",
|
||||
"activeEnergy": [
|
||||
{
|
||||
"units": "kJ",
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"qty": 49.484435766191329,
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"qty": 1.2893292371894432,
|
||||
"units": "kJ",
|
||||
"source": "Device A "
|
||||
}
|
||||
],
|
||||
"basalEnergy": [
|
||||
{
|
||||
"units": "kJ",
|
||||
"qty": 8.118214886809112,
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"units": "kJ",
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"source": "Device A ",
|
||||
"qty": 8.3170473912094565
|
||||
}
|
||||
],
|
||||
"location": "В помещении",
|
||||
"metadata": {},
|
||||
"distance": {
|
||||
"units": "km",
|
||||
"qty": 0.097916506499049191
|
||||
},
|
||||
"totalEnergy": {
|
||||
"qty": 66.474914481955616,
|
||||
"units": "kJ"
|
||||
},
|
||||
"activeEnergyBurned": {
|
||||
"units": "kJ",
|
||||
"qty": 21.260499065517783
|
||||
},
|
||||
"speed": {
|
||||
"qty": 3.842565481147650,
|
||||
"units": "km/hr"
|
||||
},
|
||||
"heartRateData": [
|
||||
{
|
||||
"Max": 199,
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"Avg": 86.126023892474565,
|
||||
"source": "Device A ",
|
||||
"Min": 68,
|
||||
"units": "count/min"
|
||||
},
|
||||
{
|
||||
"Min": 62,
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"Avg": 42.420241306988357,
|
||||
"Max": 11,
|
||||
"units": "count/min"
|
||||
}
|
||||
],
|
||||
"heartRateRecovery": [
|
||||
{
|
||||
"Avg": 18,
|
||||
"units": "count/min",
|
||||
"Max": 18,
|
||||
"date": "2025-06-05 21:09:01 +0300",
|
||||
"Min": 18,
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"Min": 18,
|
||||
"date": "2025-06-05 21:09:05 +0300",
|
||||
"Avg": 18,
|
||||
"Max": 18,
|
||||
"units": "count/min",
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"Max": 18,
|
||||
"date": "2025-06-05 21:09:07 +0300",
|
||||
"Avg": 18,
|
||||
"source": "Device A ",
|
||||
"Min": 18,
|
||||
"units": "count/min"
|
||||
},
|
||||
{
|
||||
"Max": 64,
|
||||
"Avg": 64,
|
||||
"Min": 64,
|
||||
"source": "Device A |Device B",
|
||||
"date": "2025-06-05 21:10:44 +0300",
|
||||
"units": "count/min"
|
||||
},
|
||||
{
|
||||
"Avg": 84,
|
||||
"Max": 84,
|
||||
"units": "count/min",
|
||||
"Min": 84,
|
||||
"source": "Device A |Device B",
|
||||
"date": "2025-06-05 21:10:49 +0300"
|
||||
},
|
||||
{
|
||||
"source": "Device A |Device B",
|
||||
"Min": 16,
|
||||
"units": "count/min",
|
||||
"Max": 16,
|
||||
"Avg": 16,
|
||||
"date": "2025-06-05 21:10:54 +0300"
|
||||
}
|
||||
],
|
||||
"humidity": {
|
||||
"units": "%",
|
||||
"qty": 49
|
||||
},
|
||||
"heartRate": {
|
||||
"max": {
|
||||
"qty": 199,
|
||||
"units": "count/min"
|
||||
},
|
||||
"avg": {
|
||||
"qty": 47.271142352144859,
|
||||
"units": "count/min"
|
||||
},
|
||||
"min": {
|
||||
"qty": 68,
|
||||
"units": "count/min"
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
+588
@@ -0,0 +1,588 @@
|
||||
{
|
||||
"data": {
|
||||
"workouts": [
|
||||
{
|
||||
"elevationDown": {
|
||||
"qty": 58,
|
||||
"units": "m"
|
||||
},
|
||||
"end": "2025-06-06 10:14:23 +0300",
|
||||
"activeEnergy": [
|
||||
{
|
||||
"qty": 19.843076834478356,
|
||||
"units": "kJ",
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:04:28 +0300"
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:05:28 +0300",
|
||||
"qty": 36.215835452964045,
|
||||
"units": "kJ"
|
||||
},
|
||||
{
|
||||
"qty": 44.740245661570856,
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:06:28 +0300",
|
||||
"units": "kJ"
|
||||
},
|
||||
{
|
||||
"qty": 11.685483741512438,
|
||||
"units": "kJ",
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:11:28 +0300"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-06 10:12:28 +0300",
|
||||
"source": "Device A ",
|
||||
"units": "kJ",
|
||||
"qty": 57.203753970215048
|
||||
},
|
||||
{
|
||||
"date": "2025-06-06 10:13:28 +0300",
|
||||
"units": "kJ",
|
||||
"qty": 92.751506515081775,
|
||||
"source": "Device A "
|
||||
}
|
||||
],
|
||||
"basalEnergy": [
|
||||
{
|
||||
"qty": 1.7719543711823085,
|
||||
"date": "2025-06-06 10:04:28 +0300",
|
||||
"units": "kJ",
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"units": "kJ",
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:05:28 +0300",
|
||||
"qty": 3.5941548161054400
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:06:28 +0300",
|
||||
"units": "kJ",
|
||||
"qty": 8.4754498192994867
|
||||
},
|
||||
{
|
||||
"units": "kJ",
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:11:28 +0300",
|
||||
"qty": 3.5994877058893775
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"units": "kJ",
|
||||
"qty": 1.3821773496019762,
|
||||
"date": "2025-06-06 10:12:28 +0300"
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"qty": 3.5575445948756234,
|
||||
"units": "kJ",
|
||||
"date": "2025-06-06 10:13:28 +0300"
|
||||
}
|
||||
],
|
||||
"maxSpeed": {
|
||||
"qty": 1.7500239301072799,
|
||||
"units": "km"
|
||||
},
|
||||
"heartRate": {
|
||||
"avg": {
|
||||
"qty": 580.51441585109356,
|
||||
"units": "count/min"
|
||||
},
|
||||
"min": {
|
||||
"units": "count/min",
|
||||
"qty": 304
|
||||
},
|
||||
"max": {
|
||||
"units": "count/min",
|
||||
"qty": 149
|
||||
}
|
||||
},
|
||||
"heartRateRecovery": [
|
||||
{
|
||||
"Min": 530,
|
||||
"units": "count/min",
|
||||
"Avg": 530,
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:14:26 +0300",
|
||||
"Max": 530
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"Max": 509,
|
||||
"Min": 509,
|
||||
"units": "count/min",
|
||||
"Avg": 509,
|
||||
"date": "2025-06-06 10:14:29 +0300"
|
||||
},
|
||||
{
|
||||
"Min": 103,
|
||||
"Avg": 103,
|
||||
"Max": 103,
|
||||
"date": "2025-06-06 10:14:37 +0300",
|
||||
"units": "count/min",
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"Avg": 744,
|
||||
"date": "2025-06-06 10:16:12 +0300",
|
||||
"source": "Device A ",
|
||||
"Max": 744,
|
||||
"Min": 744,
|
||||
"units": "count/min"
|
||||
},
|
||||
{
|
||||
"Min": 744,
|
||||
"units": "count/min",
|
||||
"Avg": 744,
|
||||
"source": "Device A ",
|
||||
"Max": 744,
|
||||
"date": "2025-06-06 10:16:17 +0300"
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"Max": 556,
|
||||
"Min": 556,
|
||||
"Avg": 556,
|
||||
"units": "count/min",
|
||||
"date": "2025-06-06 10:16:22 +0300"
|
||||
}
|
||||
],
|
||||
"metadata": {},
|
||||
"heartRateData": [
|
||||
{
|
||||
"Min": 304,
|
||||
"Avg": 378.98897969841650,
|
||||
"date": "2025-06-06 10:04:28 +0300",
|
||||
"units": "count/min",
|
||||
"Max": 147,
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"Avg": 989.39259425621223,
|
||||
"source": "Device A ",
|
||||
"units": "count/min",
|
||||
"Max": 485,
|
||||
"date": "2025-06-06 10:05:28 +0300",
|
||||
"Min": 933
|
||||
},
|
||||
{
|
||||
"Min": 859,
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-06 10:06:28 +0300",
|
||||
"Max": 485,
|
||||
"units": "count/min",
|
||||
"Avg": 763.09312691469744
|
||||
},
|
||||
{
|
||||
"date": "2025-06-06 10:11:28 +0300",
|
||||
"Min": 925,
|
||||
"source": "Device A ",
|
||||
"Avg": 930.87887543899777,
|
||||
"units": "count/min",
|
||||
"Max": 744
|
||||
},
|
||||
{
|
||||
"Max": 136,
|
||||
"Avg": 194.26919436633345,
|
||||
"units": "count/min",
|
||||
"date": "2025-06-06 10:12:28 +0300",
|
||||
"Min": 225,
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"Min": 136,
|
||||
"source": "Device A ",
|
||||
"units": "count/min",
|
||||
"date": "2025-06-06 10:13:28 +0300",
|
||||
"Max": 149,
|
||||
"Avg": 503.16594564319518
|
||||
}
|
||||
],
|
||||
"totalEnergy": {
|
||||
"qty": 492.41220115508732,
|
||||
"units": "kJ"
|
||||
},
|
||||
"isIndoor": false,
|
||||
"avgSpeed": {
|
||||
"qty": 1.3262919151335835,
|
||||
"units": "km"
|
||||
},
|
||||
"id": "88509471-0669-5670-1525-588189120267",
|
||||
"flightsClimbed": {
|
||||
"qty": 3,
|
||||
"units": "count"
|
||||
},
|
||||
"avgHeartRate": {
|
||||
"units": "count/min",
|
||||
"qty": 580.51441585109356
|
||||
},
|
||||
"route": [
|
||||
{
|
||||
"speedAccuracy": 1.1423493491291924,
|
||||
"courseAccuracy": -8,
|
||||
"horizontalAccuracy": 37.394709386127353,
|
||||
"course": -8,
|
||||
"speed": 6.370761754418105,
|
||||
"longitude": 19.710543914850393,
|
||||
"altitude": 11.113585029955223,
|
||||
"timestamp": "2025-06-06 10:04:31 +0300",
|
||||
"latitude": 19.536524809019373,
|
||||
"verticalAccuracy": 1.1014334704737449
|
||||
},
|
||||
{
|
||||
"speedAccuracy": 3.6635325607233020,
|
||||
"timestamp": "2025-06-06 10:04:32 +0300",
|
||||
"longitude": 42.942268598619119,
|
||||
"horizontalAccuracy": 60.170973672383984,
|
||||
"verticalAccuracy": 13.574261948723033,
|
||||
"speed": 0,
|
||||
"courseAccuracy": -8,
|
||||
"altitude": 95.460693244383061,
|
||||
"course": -8,
|
||||
"latitude": 55.963120726050803
|
||||
},
|
||||
{
|
||||
"altitude": 98.38291790977828,
|
||||
"speed": 0.24397521532364589,
|
||||
"course": -8,
|
||||
"speedAccuracy": 0.61821384896158206,
|
||||
"courseAccuracy": -8,
|
||||
"latitude": 89.43783944027558,
|
||||
"verticalAccuracy": 9,
|
||||
"timestamp": "2025-06-06 10:04:33 +0300",
|
||||
"longitude": 38.436129962995469,
|
||||
"horizontalAccuracy": 7.0942497223602135
|
||||
},
|
||||
{
|
||||
"timestamp": "2025-06-06 10:14:21 +0300",
|
||||
"latitude": 13.560422352014850,
|
||||
"verticalAccuracy": 9,
|
||||
"speed": 0.43710174633556862,
|
||||
"course": 138.44753628780219,
|
||||
"speedAccuracy": 0.9626723648822914,
|
||||
"horizontalAccuracy": 4.2411766781980601,
|
||||
"courseAccuracy": 974.54474058674578,
|
||||
"longitude": 16.879590022407365,
|
||||
"altitude": 27.895395296040802
|
||||
},
|
||||
{
|
||||
"courseAccuracy": 77.457067793746674,
|
||||
"altitude": 68.180480909094274,
|
||||
"course": 260.10957552178519,
|
||||
"verticalAccuracy": 9,
|
||||
"horizontalAccuracy": 8.6389325539171599,
|
||||
"speedAccuracy": 0.66244428495829519,
|
||||
"speed": 0.73309170745262559,
|
||||
"latitude": 25.591167408963750,
|
||||
"longitude": 84.179710558888322,
|
||||
"timestamp": "2025-06-06 10:14:22 +0300"
|
||||
},
|
||||
{
|
||||
"verticalAccuracy": 9,
|
||||
"course": 626.70356760825397,
|
||||
"altitude": 35.541136651044451,
|
||||
"latitude": 16.540540353133693,
|
||||
"horizontalAccuracy": 6.5267643473591963,
|
||||
"courseAccuracy": 28.348317314778372,
|
||||
"longitude": 54.812184540297820,
|
||||
"timestamp": "2025-06-06 10:14:23 +0300",
|
||||
"speed": 0.50936788164417521,
|
||||
"speedAccuracy": 0.6056449968288769
|
||||
}
|
||||
],
|
||||
"speed": {
|
||||
"units": "km/hr",
|
||||
"qty": 1.8553272323937848
|
||||
},
|
||||
"distance": {
|
||||
"qty": 0.45535883774475302,
|
||||
"units": "km"
|
||||
},
|
||||
"location": "На улице",
|
||||
"stepCount": [
|
||||
{
|
||||
"date": "2025-06-06 10:04:28 +0300",
|
||||
"units": "count",
|
||||
"qty": 578.41514946060714,
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"qty": 888.32265222984684,
|
||||
"date": "2025-06-06 10:05:28 +0300",
|
||||
"units": "count"
|
||||
},
|
||||
{
|
||||
"units": "count",
|
||||
"date": "2025-06-06 10:06:28 +0300",
|
||||
"qty": 389.76300874239161,
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"qty": 856.17715741799695,
|
||||
"source": "Device A |Device B",
|
||||
"date": "2025-06-06 10:11:28 +0300",
|
||||
"units": "count"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-06 10:12:28 +0300",
|
||||
"source": "Device A |Device B",
|
||||
"units": "count",
|
||||
"qty": 139.21282675041696
|
||||
},
|
||||
{
|
||||
"qty": 35.029304391445824,
|
||||
"date": "2025-06-06 10:13:28 +0300",
|
||||
"units": "count",
|
||||
"source": "Device A |Device B"
|
||||
}
|
||||
],
|
||||
"duration": 914.68731011451610,
|
||||
"name": "На улице Ходьба",
|
||||
"start": "2025-06-06 10:04:28 +0300",
|
||||
"activeEnergyBurned": {
|
||||
"qty": 103.57106764020185,
|
||||
"units": "kJ"
|
||||
},
|
||||
"walkingAndRunningDistance": [
|
||||
{
|
||||
"date": "2025-06-06 10:04:28 +0300",
|
||||
"qty": 0.013796342030844388,
|
||||
"source": "Device A ",
|
||||
"units": "km"
|
||||
},
|
||||
{
|
||||
"qty": 0.074232043027597205,
|
||||
"units": "km",
|
||||
"date": "2025-06-06 10:05:28 +0300",
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"qty": 0.026811024049784521,
|
||||
"units": "km",
|
||||
"date": "2025-06-06 10:06:28 +0300",
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"date": "2025-06-06 10:11:28 +0300",
|
||||
"units": "km",
|
||||
"source": "Device A |Device B",
|
||||
"qty": 0.014294089476468883
|
||||
},
|
||||
{
|
||||
"units": "km",
|
||||
"qty": 0.01426458841320012,
|
||||
"source": "Device A |Device B",
|
||||
"date": "2025-06-06 10:12:28 +0300"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-06 10:13:28 +0300",
|
||||
"source": "Device A |Device B",
|
||||
"qty": 0.050652946782496564,
|
||||
"units": "km"
|
||||
}
|
||||
],
|
||||
"stepCadence": {
|
||||
"units": "count/min",
|
||||
"qty": 494.09651343334029
|
||||
},
|
||||
"maxHeartRate": {
|
||||
"units": "count/min",
|
||||
"qty": 149
|
||||
}
|
||||
},
|
||||
{
|
||||
"distance": {
|
||||
"qty": 0.097916506499049191,
|
||||
"units": "km"
|
||||
},
|
||||
"name": "В помещении Ходьба",
|
||||
"activeEnergyBurned": {
|
||||
"units": "kJ",
|
||||
"qty": 21.260499065517783
|
||||
},
|
||||
"temperature": {
|
||||
"units": "degC",
|
||||
"qty": 25.642900109344569
|
||||
},
|
||||
"stepCount": [
|
||||
{
|
||||
"qty": 36.176779283023652,
|
||||
"units": "count",
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-05 21:07:25 +0300"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"qty": 41.246641544770624,
|
||||
"units": "count",
|
||||
"source": "Device A "
|
||||
}
|
||||
],
|
||||
"stepCadence": {
|
||||
"qty": 67.312908402573276,
|
||||
"units": "count/min"
|
||||
},
|
||||
"isIndoor": true,
|
||||
"basalEnergy": [
|
||||
{
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"units": "kJ",
|
||||
"qty": 8.118214886809112,
|
||||
"source": "Device A "
|
||||
},
|
||||
{
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"units": "kJ",
|
||||
"qty": 4.9653503151527592
|
||||
}
|
||||
],
|
||||
"activeEnergy": [
|
||||
{
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"qty": 49.484435766191329,
|
||||
"source": "Device A ",
|
||||
"units": "kJ"
|
||||
},
|
||||
{
|
||||
"qty": 8.3710606151472032,
|
||||
"units": "kJ",
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-05 21:08:25 +0300"
|
||||
}
|
||||
],
|
||||
"id": "19336133-5198-0770-0219-503343909539",
|
||||
"intensity": {
|
||||
"units": "kcal/hr·kg",
|
||||
"qty": 1.1101433306047975
|
||||
},
|
||||
"heartRateData": [
|
||||
{
|
||||
"units": "count/min",
|
||||
"Min": 68,
|
||||
"source": "Device A ",
|
||||
"Max": 199,
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"Avg": 86.126023892474565
|
||||
},
|
||||
{
|
||||
"units": "count/min",
|
||||
"source": "Device A ",
|
||||
"Max": 11,
|
||||
"Min": 62,
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"Avg": 42.420241306988357
|
||||
}
|
||||
],
|
||||
"end": "2025-06-05 21:08:56 +0300",
|
||||
"location": "В помещении",
|
||||
"speed": {
|
||||
"qty": 3.842565481147650,
|
||||
"units": "km/hr"
|
||||
},
|
||||
"totalEnergy": {
|
||||
"qty": 67.010279114793536,
|
||||
"units": "kJ"
|
||||
},
|
||||
"maxHeartRate": {
|
||||
"units": "count/min",
|
||||
"qty": 199
|
||||
},
|
||||
"avgHeartRate": {
|
||||
"qty": 47.271142352144859,
|
||||
"units": "count/min"
|
||||
},
|
||||
"heartRateRecovery": [
|
||||
{
|
||||
"Min": 18,
|
||||
"Avg": 18,
|
||||
"source": "Device A ",
|
||||
"Max": 18,
|
||||
"units": "count/min",
|
||||
"date": "2025-06-05 21:09:01 +0300"
|
||||
},
|
||||
{
|
||||
"date": "2025-06-05 21:09:05 +0300",
|
||||
"source": "Device A ",
|
||||
"Avg": 18,
|
||||
"units": "count/min",
|
||||
"Min": 18,
|
||||
"Max": 18
|
||||
},
|
||||
{
|
||||
"Min": 18,
|
||||
"source": "Device A ",
|
||||
"units": "count/min",
|
||||
"Max": 18,
|
||||
"date": "2025-06-05 21:09:07 +0300",
|
||||
"Avg": 18
|
||||
},
|
||||
{
|
||||
"Max": 64,
|
||||
"Min": 64,
|
||||
"Avg": 64,
|
||||
"units": "count/min",
|
||||
"source": "Device A |Device B",
|
||||
"date": "2025-06-05 21:10:44 +0300"
|
||||
},
|
||||
{
|
||||
"Min": 84,
|
||||
"units": "count/min",
|
||||
"date": "2025-06-05 21:10:49 +0300",
|
||||
"Max": 84,
|
||||
"Avg": 84,
|
||||
"source": "Device A |Device B"
|
||||
},
|
||||
{
|
||||
"units": "count/min",
|
||||
"source": "Device A |Device B",
|
||||
"Min": 16,
|
||||
"Avg": 16,
|
||||
"Max": 16,
|
||||
"date": "2025-06-05 21:10:54 +0300"
|
||||
}
|
||||
],
|
||||
"heartRate": {
|
||||
"avg": {
|
||||
"units": "count/min",
|
||||
"qty": 47.271142352144859
|
||||
},
|
||||
"max": {
|
||||
"units": "count/min",
|
||||
"qty": 199
|
||||
},
|
||||
"min": {
|
||||
"units": "count/min",
|
||||
"qty": 68
|
||||
}
|
||||
},
|
||||
"humidity": {
|
||||
"units": "%",
|
||||
"qty": 49
|
||||
},
|
||||
"duration": 11.104378534563007,
|
||||
"walkingAndRunningDistance": [
|
||||
{
|
||||
"date": "2025-06-05 21:07:25 +0300",
|
||||
"source": "Device A ",
|
||||
"units": "km",
|
||||
"qty": 0.051178653222924688
|
||||
},
|
||||
{
|
||||
"units": "km",
|
||||
"source": "Device A ",
|
||||
"date": "2025-06-05 21:08:25 +0300",
|
||||
"qty": 0.0022744856624713684
|
||||
}
|
||||
],
|
||||
"metadata": {},
|
||||
"start": "2025-06-05 21:07:25 +0300"
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -83,12 +83,21 @@ func TestReplayЖивогоАрхива(t *testing.T) {
|
||||
t.Fatal("ни одна доставка не свернулась")
|
||||
}
|
||||
|
||||
// Половина живого потока не несёт metrics вовсе (находка 50): такие
|
||||
// доставки обязаны быть отличимы от разобранных целиком, иначе ретеншен
|
||||
// срежет тела, которые для stateOfMind единственный источник.
|
||||
if first.Partial == 0 {
|
||||
t.Error("ни одной частично разобранной доставки — перечисление непокрытых секций не работает")
|
||||
// Половина живого потока не несёт metrics вовсе (находка 50): это
|
||||
// тренировки и состояние разума. С тех пор как обе секции покрыты,
|
||||
// частично разобранных доставок в архиве нет — и вместо них проверяется то,
|
||||
// ради чего покрытие делалось: сущности доехали до витрины.
|
||||
//
|
||||
// Проверяется свойство, а не число: корпус растёт с каждой доставкой, а
|
||||
// прогон живого архива в гейт не входит, так что протухшая константа
|
||||
// покраснела бы молча.
|
||||
if first.Workouts == 0 {
|
||||
t.Error("тренировок в витрине нет — секция workouts не разбирается")
|
||||
}
|
||||
if first.Records == 0 {
|
||||
t.Error("записей в витрине нет — секция stateOfMind не разбирается")
|
||||
}
|
||||
t.Logf("тренировок %d, записей %d", first.Workouts, first.Records)
|
||||
|
||||
// Повторное проигрывание того же журнала даёт то же состояние: свёртка
|
||||
// детерминирована, и пересборка даёт то же, что живой приём.
|
||||
@@ -101,6 +110,10 @@ func TestReplayЖивогоАрхива(t *testing.T) {
|
||||
if second.Buckets != first.Buckets {
|
||||
t.Errorf("повторное проигрывание изменило число объектов: %d → %d", first.Buckets, second.Buckets)
|
||||
}
|
||||
if second.Workouts != first.Workouts || second.Records != first.Records {
|
||||
t.Errorf("повторное проигрывание изменило число сущностей: %d/%d → %d/%d",
|
||||
first.Workouts, first.Records, second.Workouts, second.Records)
|
||||
}
|
||||
if second.Fingerprint != first.Fingerprint {
|
||||
t.Errorf("повторное проигрывание изменило содержимое объектов:\n %s\n %s",
|
||||
first.Fingerprint, second.Fingerprint)
|
||||
|
||||
@@ -75,7 +75,12 @@ type Report struct {
|
||||
// исходов разошлись бы при первой же правке классификации.
|
||||
Outcome
|
||||
|
||||
Buckets int64
|
||||
Buckets int64
|
||||
// Workouts и Records — остальные единицы хранения витрины. Считаются рядом
|
||||
// с объектами потому, что отпечаток отвечает «да/нет» за витрину целиком, а
|
||||
// решение о подмене базы необратимо и требует направления расхождения.
|
||||
Workouts int64
|
||||
Records int64
|
||||
Fingerprint string
|
||||
|
||||
// Canceled — проигрывание прервано отменой, а не дошло до конца.
|
||||
@@ -171,6 +176,14 @@ func Run(ctx context.Context, o Options) (Report, error) {
|
||||
if err != nil {
|
||||
return stopOr(rep, err)
|
||||
}
|
||||
rep.Workouts, err = o.Target.CountWorkouts(ctx)
|
||||
if err != nil {
|
||||
return stopOr(rep, err)
|
||||
}
|
||||
rep.Records, err = o.Target.CountRecords(ctx)
|
||||
if err != nil {
|
||||
return stopOr(rep, err)
|
||||
}
|
||||
rep.Fingerprint, err = o.Target.Fingerprint(ctx)
|
||||
if err != nil {
|
||||
return stopOr(rep, err)
|
||||
@@ -190,7 +203,9 @@ func Run(ctx context.Context, o Options) (Report, error) {
|
||||
"failed_other", rep.FailedOther,
|
||||
"partial", rep.Partial,
|
||||
"incomparable", rep.Incomparable,
|
||||
"buckets", rep.Buckets)
|
||||
"buckets", rep.Buckets,
|
||||
"workouts", rep.Workouts,
|
||||
"records", rep.Records)
|
||||
return rep, nil
|
||||
}
|
||||
|
||||
|
||||
+173
-24
@@ -72,6 +72,21 @@ type MergeStats struct {
|
||||
Collisions []Collision
|
||||
// IncomparableAt — то же для несравнимых наборов.
|
||||
IncomparableAt []Collision
|
||||
|
||||
// Workouts и Records — сколько сущностей пришло с доставкой.
|
||||
Workouts int
|
||||
Records int
|
||||
// WorkoutsWritten и RecordsWritten — сколько из них действительно легло в
|
||||
// витрину. Разница с пришедшими — работа хеша-детектора: тренировка
|
||||
// переприсылается каждой доставкой, пока не доедет маршрут.
|
||||
WorkoutsWritten int
|
||||
RecordsWritten int
|
||||
// EntitiesHeld — приехавшие версии, отклонённые как теряющие содержание
|
||||
// сохранённой (включая несравнимые наборы). Это и есть плата за отказ
|
||||
// объединять поля: событие считается, а не предотвращается молча.
|
||||
EntitiesHeld int
|
||||
// HeldAt — координаты первых таких сущностей, для записи в лог.
|
||||
HeldAt []EntityRef
|
||||
}
|
||||
|
||||
// Collision — координаты объекта, где столкновение разрешилось перезаписью
|
||||
@@ -102,35 +117,58 @@ func clipMetric(metric string) string {
|
||||
return metric[:maxMetricInLog] + "…"
|
||||
}
|
||||
|
||||
// MergePoints раскладывает точки по часовым объектам и сливает их с
|
||||
// сохранёнными.
|
||||
// Merge раскладывает всё, что дала доставка, по витрине: точки — по часовым
|
||||
// объектам, сущности — по своим таблицам.
|
||||
//
|
||||
// Час берётся по НАЧАЛУ точки: интервал пересекает границы часов, и любой
|
||||
// другой выбор сделал бы принадлежность объекту зависящей от длительности.
|
||||
// Вся доставка сворачивается ОДНОЙ транзакцией, а не транзакцией на объект.
|
||||
// Вся доставка сворачивается ОДНОЙ транзакцией, а не транзакцией на объект и
|
||||
// не отдельной транзакцией на сущности.
|
||||
//
|
||||
// Транзакция на объект давала недетерминированное частичное состояние: обход
|
||||
// карты групп рандомизирован, и при отказе посреди доставки набор уже
|
||||
// закоммиченных объектов каждый раз другой (измерено: восемь прогонов одной
|
||||
// доставки — семь разных состояний). Это ломает инвариант «состояние
|
||||
// пересобираемо»: пересборка из архива давала бы не то, что живой приём, а
|
||||
// хеш-детектор после расхождения переписывал бы «неизменившееся».
|
||||
// хеш-детектор после расхождения переписывал бы «неизменившееся». Наблюдение
|
||||
// «секции не смешиваются в одной доставке» собрано за двое суток и основанием
|
||||
// для второй транзакции не является.
|
||||
//
|
||||
// Заодно снимается стоимость: отдельный коммит на объект стоил около 0.7 мс,
|
||||
// то есть 8.5 мс на килобайт тела.
|
||||
func (s *Store) MergePoints(ctx context.Context, in []IncomingPoint, deliveryID string) (MergeStats, error) {
|
||||
groups := groupByHour(in)
|
||||
func (s *Store) Merge(ctx context.Context, in Incoming, from DeliveryRef) (MergeStats, error) {
|
||||
groups := groupByHour(in.Points)
|
||||
keys := sortedKeys(groups)
|
||||
|
||||
// Хеш и каноническая форма сущности считаются ОДИН раз на доставку, до
|
||||
// входа в транзакцию: канонизация материализует значение целиком, а
|
||||
// транзакция повторяется до пяти раз при занятости базы — внутри неё пик
|
||||
// кучи умножился бы на число попыток.
|
||||
workouts, err := prepareEntities(in.Workouts, from)
|
||||
if err != nil {
|
||||
return MergeStats{}, err
|
||||
}
|
||||
records, err := prepareEntities(in.Records, from)
|
||||
if err != nil {
|
||||
return MergeStats{}, err
|
||||
}
|
||||
workouts, workoutsHeld, workoutsHeldAt := dedupeEntities(workouts)
|
||||
records, recordsHeld, recordsHeldAt := dedupeEntities(records)
|
||||
|
||||
var stats MergeStats
|
||||
err := s.inTx(ctx, func(tx *sql.Tx) error {
|
||||
err = s.inTx(ctx, func(tx *sql.Tx) error {
|
||||
// Счётчики обнуляются на каждой попытке: повтор транзакции начинает
|
||||
// слияние заново, и накопленное от прошлой попытки посчиталось бы дважды.
|
||||
stats = MergeStats{}
|
||||
stats = MergeStats{
|
||||
Workouts: len(in.Workouts),
|
||||
Records: len(in.Records),
|
||||
EntitiesHeld: workoutsHeld + recordsHeld,
|
||||
HeldAt: clipRefs(append(append([]EntityRef{}, workoutsHeldAt...), recordsHeldAt...)),
|
||||
}
|
||||
|
||||
for _, key := range keys {
|
||||
group := groups[key]
|
||||
res, err := mergeBucket(ctx, tx, key, group, deliveryID)
|
||||
res, err := mergeBucket(ctx, tx, key, group, from.ID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -158,6 +196,23 @@ func (s *Store) MergePoints(ctx context.Context, in []IncomingPoint, deliveryID
|
||||
stats.IncomparableAt = append(stats.IncomparableAt, coord)
|
||||
}
|
||||
}
|
||||
|
||||
now := Now()
|
||||
written, held, heldAt, err := mergeEntities(ctx, tx, workoutTable, workouts, now)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
stats.WorkoutsWritten = written
|
||||
stats.EntitiesHeld += held
|
||||
stats.HeldAt = clipRefs(append(stats.HeldAt, heldAt...))
|
||||
|
||||
written, held, heldAt, err = mergeEntities(ctx, tx, recordTable, records, now)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
stats.RecordsWritten = written
|
||||
stats.EntitiesHeld += held
|
||||
stats.HeldAt = clipRefs(append(stats.HeldAt, heldAt...))
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
@@ -591,27 +646,44 @@ func encodePayload(points []Point) ([]byte, error) {
|
||||
return nil, fmt.Errorf("сериализация точек: %w", err)
|
||||
}
|
||||
|
||||
return gzipBytes(raw.Bytes())
|
||||
}
|
||||
|
||||
// gzipBytes и gunzipBytes — единственное кодирование содержимого витрины,
|
||||
// общее для часового объекта и для сущности с собственным `id`. Второй кадр
|
||||
// упаковки разошёлся бы с первым при первой же правке — например, забытым
|
||||
// Close, который оставляет усечённый блоб.
|
||||
func gzipBytes(raw []byte) ([]byte, error) {
|
||||
var buf bytes.Buffer
|
||||
gz := gzip.NewWriter(&buf)
|
||||
if _, err := gz.Write(raw.Bytes()); err != nil {
|
||||
return nil, fmt.Errorf("сжатие точек: %w", err)
|
||||
if _, err := gz.Write(raw); err != nil {
|
||||
return nil, fmt.Errorf("сжатие содержимого: %w", err)
|
||||
}
|
||||
// Close дописывает хвост gzip; без него блоб читается лишь частично.
|
||||
if err := gz.Close(); err != nil {
|
||||
return nil, fmt.Errorf("закрытие gzip: %w", err)
|
||||
}
|
||||
return buf.Bytes(), nil
|
||||
}
|
||||
|
||||
func decodePayload(payload []byte) ([]Point, error) {
|
||||
func gunzipBytes(payload []byte) ([]byte, error) {
|
||||
gz, err := gzip.NewReader(bytes.NewReader(payload))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("распаковка точек: %w", err)
|
||||
return nil, fmt.Errorf("распаковка содержимого: %w", err)
|
||||
}
|
||||
defer func() { _ = gz.Close() }()
|
||||
|
||||
raw, err := io.ReadAll(gz)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("чтение точек: %w", err)
|
||||
return nil, fmt.Errorf("чтение содержимого: %w", err)
|
||||
}
|
||||
return raw, nil
|
||||
}
|
||||
|
||||
func decodePayload(payload []byte) ([]Point, error) {
|
||||
raw, err := gunzipBytes(payload)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var sp []storedPoint
|
||||
@@ -700,7 +772,7 @@ func (s *Store) CountBuckets(ctx context.Context) (int64, error) {
|
||||
}
|
||||
|
||||
// Fingerprint возвращает отпечаток содержимого витрины: SHA-256 по координатам
|
||||
// и хешам всех объектов в детерминированном порядке.
|
||||
// и хешам всех её сущностей в детерминированном порядке.
|
||||
//
|
||||
// Нужен проверке сходимости на живом архиве. Число объектов и число точек к
|
||||
// правилу разрешения столкновений нечувствительны: на координате всегда лежит
|
||||
@@ -708,25 +780,58 @@ func (s *Store) CountBuckets(ctx context.Context) (int64, error) {
|
||||
// Значит «объектов столько же» совпадёт и при заведомо сломанном правиле, а
|
||||
// отпечаток — нет.
|
||||
//
|
||||
// Значений точек он не раскрывает: содержимое участвует только своим хешем.
|
||||
// Покрывает ВСЕ единицы хранения — часовые объекты, тренировки и записи.
|
||||
// Отпечаток одних объектов давал бы «состояние сошлось» при разъехавшихся
|
||||
// тренировках, то есть ломался бы молча тем самым изменением, которое добавило
|
||||
// данные.
|
||||
//
|
||||
// Все разделы читаются ОДНИМ снимком базы: отпечаток рабочей витрины снимается
|
||||
// под живым приёмом, и запросы вне общей транзакции дали бы смесь «объекты до»
|
||||
// и «тренировки после» — ложное расхождение у единственного оракула.
|
||||
//
|
||||
// Значений он не раскрывает: содержимое участвует только своим хешем.
|
||||
func (s *Store) Fingerprint(ctx context.Context) (string, error) {
|
||||
tx, err := s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("begin read tx: %w", err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback() }()
|
||||
|
||||
h := sha256.New()
|
||||
if err := fingerprintBuckets(ctx, tx, h); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err := fingerprintEntities(ctx, tx, h); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(h.Sum(nil)), nil
|
||||
}
|
||||
|
||||
// Признак раздела впереди строки: без него строка одного раздела может совпасть
|
||||
// со строкой другого, и два разных состояния витрины дали бы один отпечаток.
|
||||
const (
|
||||
fpBucket = "b"
|
||||
fpWorkout = "w"
|
||||
fpRecord = "r"
|
||||
)
|
||||
|
||||
func fingerprintBuckets(ctx context.Context, tx *sql.Tx, h io.Writer) error {
|
||||
const q = `
|
||||
SELECT metric, layer, hour_utc, content_hash, points, units, sealed FROM bucket
|
||||
ORDER BY metric, layer, hour_utc`
|
||||
|
||||
rows, err := s.db.QueryContext(ctx, q)
|
||||
rows, err := tx.QueryContext(ctx, q)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("select buckets: %w", err)
|
||||
return fmt.Errorf("select buckets: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
h := sha256.New()
|
||||
for rows.Next() {
|
||||
var metric, layer, hour, hash, units string
|
||||
var points int
|
||||
var sealed bool
|
||||
if err := rows.Scan(&metric, &layer, &hour, &hash, &points, &units, &sealed); err != nil {
|
||||
return "", fmt.Errorf("scan bucket: %w", err)
|
||||
return fmt.Errorf("scan bucket: %w", err)
|
||||
}
|
||||
// Поля переменной длины идут с длиной впереди: разделитель, который
|
||||
// может встретиться ВНУТРИ поля, даёт одну строку для разных состояний,
|
||||
@@ -734,13 +839,57 @@ func (s *Store) Fingerprint(ctx context.Context) (string, error) {
|
||||
// здесь значит получить «состояние совпало» при разошедшемся состоянии —
|
||||
// то есть сломать молча ровно тот оракул, ради которого отпечаток и
|
||||
// заведён. Тот же приём в canon.HashAll и по той же причине.
|
||||
fmt.Fprintf(h, "%d:%s|%d:%s|%s|%s|%d|%d:%s|%t\n",
|
||||
len(metric), metric, len(layer), layer, hour, hash, points, len(units), units, sealed)
|
||||
fmt.Fprintf(h, "%s|%d:%s|%d:%s|%s|%s|%d|%d:%s|%t\n",
|
||||
fpBucket, len(metric), metric, len(layer), layer, hour, hash, points,
|
||||
len(units), units, sealed)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return "", fmt.Errorf("select buckets: %w", err)
|
||||
return fmt.Errorf("select buckets: %w", err)
|
||||
}
|
||||
return hex.EncodeToString(h.Sum(nil)), nil
|
||||
return nil
|
||||
}
|
||||
|
||||
func fingerprintEntities(ctx context.Context, tx *sql.Tx, h io.Writer) error {
|
||||
queries := []struct {
|
||||
tag string
|
||||
sql string
|
||||
}{
|
||||
// Род и идентификатор идут ОТДЕЛЬНЫМИ полями, каждое со своей длиной, а
|
||||
// не склейкой `kind || '/' || id`: склейка выполняется до взятия длины,
|
||||
// и пара (`a`, `b/c`) даёт ту же строку, что (`a/b`, `c`). Отпечаток —
|
||||
// единственный оракул сходимости, по нему принимается необратимое
|
||||
// решение о подмене базы; два разных состояния витрины не имеют права
|
||||
// дать один отпечаток. У тренировки род один и в строку не идёт.
|
||||
{fpWorkout, `SELECT '', id, start_utc, content_hash FROM workout ORDER BY id`},
|
||||
{fpRecord, `SELECT kind, id, ts_utc, content_hash FROM record ORDER BY kind, id`},
|
||||
}
|
||||
|
||||
for _, q := range queries {
|
||||
if err := fingerprintRows(ctx, tx, h, q.tag, q.sql); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func fingerprintRows(ctx context.Context, tx *sql.Tx, h io.Writer, tag, query string) error {
|
||||
rows, err := tx.QueryContext(ctx, query)
|
||||
if err != nil {
|
||||
return fmt.Errorf("select entities: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
for rows.Next() {
|
||||
var kind, id, ts, hash string
|
||||
if err := rows.Scan(&kind, &id, &ts, &hash); err != nil {
|
||||
return fmt.Errorf("scan entity: %w", err)
|
||||
}
|
||||
fmt.Fprintf(h, "%s|%d:%s|%d:%s|%s|%s\n", tag, len(kind), kind, len(id), id, ts, hash)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return fmt.Errorf("select entities: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Bucket читает объект по координатам. Нужен тестам и будущему Read API.
|
||||
|
||||
@@ -51,7 +51,7 @@ func point(t *testing.T, metric, layer, start, end, raw string) store.IncomingPo
|
||||
}
|
||||
}
|
||||
|
||||
func TestMergePointsКладётЧасОднимОбъектом(t *testing.T) {
|
||||
func TestMergeКладётЧасОднимОбъектом(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -63,7 +63,7 @@ func TestMergePointsКладётЧасОднимОбъектом(t *testing.T) {
|
||||
point(t, "step_count", "minute", "2025-06-05T11:00:00Z", "2025-06-05T11:00:00Z", `{"qty":3}`),
|
||||
}
|
||||
|
||||
stats, err := st.MergePoints(ctx, in, "delivery-1")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "delivery-1"})
|
||||
if err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
@@ -91,7 +91,7 @@ func TestMergePointsКладётЧасОднимОбъектом(t *testing.T) {
|
||||
|
||||
// Дозапись в существующий час: объект перечитывается, точки сливаются, ранее
|
||||
// сохранённые остаются. Точки из объекта не удаляются никогда.
|
||||
func TestMergePointsДозаписьНеТеряетСохранённое(t *testing.T) {
|
||||
func TestMergeДозаписьНеТеряетСохранённое(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -104,10 +104,10 @@ func TestMergePointsДозаписьНеТеряетСохранённое(t *te
|
||||
point(t, "step_count", "minute", "2025-06-05T10:30:00Z", "2025-06-05T10:30:00Z", `{"qty":2}`),
|
||||
}
|
||||
|
||||
if _, err := st.MergePoints(ctx, first, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: first}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, second, "d2"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: second}, store.DeliveryRef{ID: "d2"}); err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -125,7 +125,7 @@ func TestMergePointsДозаписьНеТеряетСохранённое(t *te
|
||||
|
||||
// Хеш — детектор изменений: повтор того же часа не пишет в базу. Именно это
|
||||
// делает широкие проходы синхронизации дешёвыми.
|
||||
func TestMergePointsПовторНеПишет(t *testing.T) {
|
||||
func TestMergeПовторНеПишет(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -136,7 +136,7 @@ func TestMergePointsПовторНеПишет(t *testing.T) {
|
||||
point(t, "step_count", "minute", "2025-06-05T10:01:00Z", "2025-06-05T10:01:00Z", `{"qty":2,"source":"Device A"}`),
|
||||
}
|
||||
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
before, err := st.Bucket(ctx, "step_count", "minute", ts(t, "2025-06-05T10:00:00Z"))
|
||||
@@ -144,7 +144,7 @@ func TestMergePointsПовторНеПишет(t *testing.T) {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
|
||||
stats, err := st.MergePoints(ctx, in, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("повторное слияние: %v", err)
|
||||
}
|
||||
@@ -172,7 +172,7 @@ func TestMergePointsПовторНеПишет(t *testing.T) {
|
||||
|
||||
// Порядок точек внутри доставки нестабилен (находка 2), и идентичность не
|
||||
// имеет права от него зависеть.
|
||||
func TestMergePointsИдемпотентенКПорядкуТочек(t *testing.T) {
|
||||
func TestMergeИдемпотентенКПорядкуТочек(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -185,7 +185,7 @@ func TestMergePointsИдемпотентенКПорядкуТочек(t *testin
|
||||
}
|
||||
reversed := []store.IncomingPoint{in[2], in[1], in[0]}
|
||||
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
first, err := st.Bucket(ctx, "step_count", "minute", ts(t, "2025-06-05T10:00:00Z"))
|
||||
@@ -193,7 +193,7 @@ func TestMergePointsИдемпотентенКПорядкуТочек(t *testin
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
|
||||
stats, err := st.MergePoints(ctx, reversed, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: reversed}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("слияние в обратном порядке: %v", err)
|
||||
}
|
||||
@@ -213,7 +213,7 @@ func TestMergePointsИдемпотентенКПорядкуТочек(t *testin
|
||||
// Ключ по метке схлопнул бы эти три записи в одну. Живьём такое встречается в
|
||||
// 22 доставках из 94 (находка 47), причём внутри одной доставки — там тай-брейк
|
||||
// по времени приёма неприменим в принципе.
|
||||
func TestMergePointsЗаписиСОднойМеткойНеСхлопываются(t *testing.T) {
|
||||
func TestMergeЗаписиСОднойМеткойНеСхлопываются(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -225,7 +225,7 @@ func TestMergePointsЗаписиСОднойМеткойНеСхлопывают
|
||||
point(t, "sleep_analysis", "minute", "2025-06-05T19:04:00Z", "2025-06-06T04:51:00Z", `{"qty":9.78,"value":"В кровати"}`),
|
||||
}
|
||||
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -239,7 +239,7 @@ func TestMergePointsЗаписиСОднойМеткойНеСхлопывают
|
||||
|
||||
// Повтор той же тройки не задваивает: координата включает интервал, и он
|
||||
// совпадает.
|
||||
stats, err := st.MergePoints(ctx, in, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("повтор: %v", err)
|
||||
}
|
||||
@@ -250,7 +250,7 @@ func TestMergePointsЗаписиСОднойМеткойНеСхлопывают
|
||||
|
||||
// Эпизод, пересекающий границу часа, ложится в объект по НАЧАЛУ: любой другой
|
||||
// выбор сделал бы принадлежность объекту зависящей от длительности.
|
||||
func TestMergePointsЧасПоНачалуИнтервала(t *testing.T) {
|
||||
func TestMergeЧасПоНачалуИнтервала(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -259,7 +259,7 @@ func TestMergePointsЧасПоНачалуИнтервала(t *testing.T) {
|
||||
in := []store.IncomingPoint{
|
||||
point(t, "sleep_analysis", "minute", "2025-06-05T19:04:00Z", "2025-06-06T04:51:00Z", `{"qty":9.78}`),
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -274,7 +274,7 @@ func TestMergePointsЧасПоНачалуИнтервала(t *testing.T) {
|
||||
// Правило разрешения столкновений: выигрывает более полная точка, а не
|
||||
// последняя пришедшая. Иначе бедная доставка стирает у богатой поля, которых
|
||||
// сама не несёт.
|
||||
func TestMergePointsБеднаяТочкаНеСтираетБогатую(t *testing.T) {
|
||||
func TestMergeБеднаяТочкаНеСтираетБогатую(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -285,10 +285,10 @@ func TestMergePointsБеднаяТочкаНеСтираетБогатую(t *te
|
||||
poor := point(t, "heart_rate", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"Avg":60,"Min":55,"Max":70}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{rich}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{rich}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{poor}, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{poor}}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
@@ -311,7 +311,7 @@ func TestMergePointsБеднаяТочкаНеСтираетБогатую(t *te
|
||||
// Полнота — множество ключей, а не их число. Счётчик значащих полей давал
|
||||
// сохранённой точке 5 против 2 и стирал настоящее измерение безвозвратно:
|
||||
// восстановить его можно было бы только из сырого архива, пока он жив.
|
||||
func TestMergePointsПоляБезСодержанияНеСтираютИзмерение(t *testing.T) {
|
||||
func TestMergeПоляБезСодержанияНеСтираютИзмерение(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -322,10 +322,10 @@ func TestMergePointsПоляБезСодержанияНеСтираютИзме
|
||||
measured := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"date":"2026-07-31 12:00:00 +0300","qty":123.4}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{hollow}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{hollow}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{measured}, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{measured}}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
@@ -345,7 +345,7 @@ func TestMergePointsПоляБезСодержанияНеСтираютИзме
|
||||
|
||||
// Поле с нулевым значением содержания не несёт, но и теряться не должно: при
|
||||
// равном множестве содержательных ключей выигрывает точка со всеми ключами.
|
||||
func TestMergePointsРавноеСодержаниеНеТеряетПоля(t *testing.T) {
|
||||
func TestMergeРавноеСодержаниеНеТеряетПоля(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -356,10 +356,10 @@ func TestMergePointsРавноеСодержаниеНеТеряетПоля(t *
|
||||
narrow := point(t, "heart_rate", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"date":"d","qty":12}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{wide}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{wide}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{narrow}, "d2"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{narrow}}, store.DeliveryRef{ID: "d2"}); err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -375,7 +375,7 @@ func TestMergePointsРавноеСодержаниеНеТеряетПоля(t *
|
||||
// Несравнимые наборы полей на живом потоке не встретились ни разу (0 из 2 897
|
||||
// столкновений), поэтому объединение полей не реализовано. Взамен — наблюдение:
|
||||
// счётчик и координаты объекта, по которым событие можно будет разобрать.
|
||||
func TestMergePointsНесравнимыеНаборыСчитаются(t *testing.T) {
|
||||
func TestMergeНесравнимыеНаборыСчитаются(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -386,10 +386,10 @@ func TestMergePointsНесравнимыеНаборыСчитаются(t *test
|
||||
b := point(t, "blood_glucose", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"mealTime":"До еды"}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{a}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{a}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{b}, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{b}}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
@@ -420,7 +420,7 @@ func TestMergePointsНесравнимыеНаборыСчитаются(t *test
|
||||
|
||||
// Список координат упирается в потолок, счётчик — нет: обрезанный список
|
||||
// остаётся зацепкой для разбора, а масштаб события считает счётчик.
|
||||
func TestMergePointsСчётчикРастётПослеПотолкаКоординат(t *testing.T) {
|
||||
func TestMergeСчётчикРастётПослеПотолкаКоординат(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -434,10 +434,10 @@ func TestMergePointsСчётчикРастётПослеПотолкаКоорд
|
||||
second = append(second, point(t, "blood_glucose", "minute", at, at, `{"mealTime":"До еды"}`))
|
||||
}
|
||||
|
||||
if _, err := st.MergePoints(ctx, first, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: first}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, second, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: second}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
@@ -453,7 +453,7 @@ func TestMergePointsСчётчикРастётПослеПотолкаКоорд
|
||||
|
||||
// source нестабилен: то же измерение приезжает то с одним именем устройства,
|
||||
// то с другим. Он не входит в ключ и не считается полнотой.
|
||||
func TestMergePointsСменаИсточникаНеСоздаётВторуюТочку(t *testing.T) {
|
||||
func TestMergeСменаИсточникаНеСоздаётВторуюТочку(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -464,10 +464,10 @@ func TestMergePointsСменаИсточникаНеСоздаётВторуюТ
|
||||
b := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"qty":1,"source":"Apple Watch Ultra 3"}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{a}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{a}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{b}, "d2"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{b}}, store.DeliveryRef{ID: "d2"}); err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -483,7 +483,7 @@ func TestMergePointsСменаИсточникаНеСоздаётВторуюТ
|
||||
// Исход столкновения точек равной полноты обязан зависеть только от значений:
|
||||
// свёртка по журналу должна давать то же состояние, что приём в реальном
|
||||
// времени, а внутри одной доставки время приёма общее.
|
||||
func TestMergePointsРавнаяПолнотаРазрешаетсяДетерминированно(t *testing.T) {
|
||||
func TestMergeРавнаяПолнотаРазрешаетсяДетерминированно(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
@@ -494,7 +494,7 @@ func TestMergePointsРавнаяПолнотаРазрешаетсяДетерм
|
||||
winner := func(order []store.IncomingPoint) string {
|
||||
st := open(t)
|
||||
for _, p := range order {
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{p}, "d"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{p}}, store.DeliveryRef{ID: "d"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -515,7 +515,7 @@ func TestMergePointsРавнаяПолнотаРазрешаетсяДетерм
|
||||
// Содержимое точки хранится исходными байтами: пересборка повторной
|
||||
// сериализацией теряет литерал, и потеря не видна тестам, сравнивающим
|
||||
// разобранное с разобранным.
|
||||
func TestMergePointsХранитТочкуДословно(t *testing.T) {
|
||||
func TestMergeХранитТочкуДословно(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -525,7 +525,7 @@ func TestMergePointsХранитТочкуДословно(t *testing.T) {
|
||||
in := []store.IncomingPoint{
|
||||
point(t, "unknown", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", raw),
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -541,7 +541,7 @@ func TestMergePointsХранитТочкуДословно(t *testing.T) {
|
||||
// Тело доставки доходит до 42 МиБ, приходят они непрерывно и внахлёст.
|
||||
// Конкурентное слияние того же часа не имеет права терять точки: между
|
||||
// чтением и записью может вклиниться другая доставка.
|
||||
func TestMergePointsКонкурентноеСлияниеНеТеряетТочки(t *testing.T) {
|
||||
func TestMergeКонкурентноеСлияниеНеТеряетТочки(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -568,7 +568,7 @@ func TestMergePointsКонкурентноеСлияниеНеТеряетТоч
|
||||
Raw: json.RawMessage(`{"qty":` + itoa(minute) + `}`),
|
||||
},
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{p}, "d"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{p}}, store.DeliveryRef{ID: "d"}); err != nil {
|
||||
errs <- err
|
||||
return
|
||||
}
|
||||
@@ -607,7 +607,7 @@ func itoa(n int) string {
|
||||
// Изменение запечатанного часа — сигнал, а не отказ: данные пишутся всё равно,
|
||||
// но факт обязан дойти до владельца сервиса. Без счётчика допущение «глубже
|
||||
// такого-то порога досчёта не бывает» не получило бы ни одного наблюдения.
|
||||
func TestMergePointsИзменениеЗапечатанногоЧаса(t *testing.T) {
|
||||
func TestMergeИзменениеЗапечатанногоЧаса(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -617,7 +617,7 @@ func TestMergePointsИзменениеЗапечатанногоЧаса(t *test
|
||||
first := []store.IncomingPoint{
|
||||
point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":1}`),
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, first, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: first}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
if err := st.MarkSealed(ctx, "step_count", "minute", hour, true); err != nil {
|
||||
@@ -627,7 +627,7 @@ func TestMergePointsИзменениеЗапечатанногоЧаса(t *test
|
||||
late := []store.IncomingPoint{
|
||||
point(t, "step_count", "minute", "2025-06-05T10:30:00Z", "2025-06-05T10:30:00Z", `{"qty":2}`),
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, late, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: late}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("досчёт запечатанного часа: %v", err)
|
||||
}
|
||||
@@ -649,7 +649,7 @@ func TestMergePointsИзменениеЗапечатанногоЧаса(t *test
|
||||
|
||||
// Отмена посреди слияния не имеет права оставить половину: объект либо
|
||||
// прежний, либо полный.
|
||||
func TestMergePointsОтменаНеОставляетПоловины(t *testing.T) {
|
||||
func TestMergeОтменаНеОставляетПоловины(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -657,19 +657,30 @@ func TestMergePointsОтменаНеОставляетПоловины(t *testin
|
||||
base := []store.IncomingPoint{
|
||||
point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":1}`),
|
||||
}
|
||||
if _, err := st.MergePoints(context.Background(), base, "d1"); err != nil {
|
||||
if _, err := st.Merge(context.Background(), store.Incoming{Points: base}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
|
||||
more := []store.IncomingPoint{
|
||||
point(t, "step_count", "minute", "2025-06-05T10:30:00Z", "2025-06-05T10:30:00Z", `{"qty":2}`),
|
||||
// Сущности идут в ТОЙ ЖЕ транзакции и пишутся ПОСЛЕ объектов, то есть на
|
||||
// той половине, где отмена вероятнее. Вынесение их во вторую транзакцию —
|
||||
// напрашивающаяся правка при жалобе на длину транзакции с маршрутом, и она
|
||||
// прошла бы зелёной, сломав «состояние пересобираемо»: доставка получила бы
|
||||
// failed при записанной тренировке.
|
||||
more := store.Incoming{
|
||||
Points: []store.IncomingPoint{
|
||||
point(t, "step_count", "minute", "2025-06-05T10:30:00Z", "2025-06-05T10:30:00Z", `{"qty":2}`),
|
||||
},
|
||||
Workouts: []store.IncomingEntity{workout(t, "w-отменённая", `{"id":"w-отменённая","qty":1}`)},
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, more, "d2"); err == nil {
|
||||
if _, err := st.Merge(ctx, more, store.DeliveryRef{ID: "d2"}); err == nil {
|
||||
t.Fatal("слияние на отменённом контексте прошло успешно")
|
||||
}
|
||||
if _, err := st.Workout(context.Background(), "w-отменённая"); !errors.Is(err, store.ErrNotFound) {
|
||||
t.Errorf("тренировка отменённой доставки осталась в витрине: %v", err)
|
||||
}
|
||||
|
||||
b, err := st.Bucket(context.Background(), "step_count", "minute", ts(t, "2025-06-05T10:00:00Z"))
|
||||
if err != nil {
|
||||
@@ -704,7 +715,7 @@ func cycleTriple(t *testing.T) []store.IncomingPoint {
|
||||
}
|
||||
}
|
||||
|
||||
func TestMergePointsПовторнаяСвёрткаНеМеняетСостояние(t *testing.T) {
|
||||
func TestMergeПовторнаяСвёрткаНеМеняетСостояние(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -714,7 +725,7 @@ func TestMergePointsПовторнаяСвёрткаНеМеняетСостоя
|
||||
state := func() (string, string) {
|
||||
t.Helper()
|
||||
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
b, err := st.Bucket(ctx, "heart_rate", "raw", ts(t, "2025-06-05T10:00:00Z"))
|
||||
@@ -738,7 +749,7 @@ func TestMergePointsПовторнаяСвёрткаНеМеняетСостоя
|
||||
}
|
||||
}
|
||||
|
||||
func TestMergePointsИсходНеЗависитОтПерестановки(t *testing.T) {
|
||||
func TestMergeИсходНеЗависитОтПерестановки(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
@@ -752,7 +763,7 @@ func TestMergePointsИсходНеЗависитОтПерестановки(t *
|
||||
st := open(t)
|
||||
if split {
|
||||
for _, i := range order {
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{in[i]}, "d"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{in[i]}}, store.DeliveryRef{ID: "d"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -761,7 +772,7 @@ func TestMergePointsИсходНеЗависитОтПерестановки(t *
|
||||
for _, i := range order {
|
||||
batch = append(batch, in[i])
|
||||
}
|
||||
if _, err := st.MergePoints(ctx, batch, "d"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: batch}, store.DeliveryRef{ID: "d"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -785,7 +796,7 @@ func TestMergePointsИсходНеЗависитОтПерестановки(t *
|
||||
// Точка, ни одно значение которой не несёт измерения, не должна вытеснять
|
||||
// настоящее измерение. Раньше вытесняла: множества содержательных ключей
|
||||
// равны, и решал второй разряд — по ключам, а не по содержанию.
|
||||
func TestMergePointsПадингНеВытесняетИзмерение(t *testing.T) {
|
||||
func TestMergeПадингНеВытесняетИзмерение(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
@@ -808,7 +819,7 @@ func TestMergePointsПадингНеВытесняетИзмерение(t *test
|
||||
point(t, "heart_rate", "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", real),
|
||||
point(t, "heart_rate", "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", c.junk),
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, in, "d1")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"})
|
||||
if err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
@@ -824,7 +835,7 @@ func TestMergePointsПадингНеВытесняетИзмерение(t *test
|
||||
// Имя метрики приходит из тела доставки дословно и ничем не ограничено.
|
||||
// Без обрезки одна доставка порождает WARN-строку в десятки мегабайт и
|
||||
// вытесняет из ротации логов всю недавнюю историю.
|
||||
func TestMergePointsИмяМетрикиВКоординатеОбрезано(t *testing.T) {
|
||||
func TestMergeИмяМетрикиВКоординатеОбрезано(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -835,7 +846,7 @@ func TestMergePointsИмяМетрикиВКоординатеОбрезано(t
|
||||
point(t, huge, "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":1}`),
|
||||
point(t, huge, "raw", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":2}`),
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, in, "d1")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"})
|
||||
if err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,586 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"git.vakhrushev.me/av/healthlog/internal/canon"
|
||||
)
|
||||
|
||||
// Роды таблиц сущностей. Тренировка живёт в своей таблице: у неё есть
|
||||
// заголовок, по которому идёт выборка, а у записи его нет.
|
||||
const (
|
||||
workoutTable = "workout"
|
||||
recordTable = "record"
|
||||
)
|
||||
|
||||
// IncomingEntity — сущность с собственным идентификатором, пришедшая на запись.
|
||||
//
|
||||
// Содержимое хранится исходными байтами: сущность, пересобранная повторной
|
||||
// сериализацией, теряет литерал ровно так же, как точка.
|
||||
type IncomingEntity struct {
|
||||
ID string
|
||||
Kind string
|
||||
Name string
|
||||
|
||||
Start time.Time
|
||||
End time.Time
|
||||
// OffsetSeconds — смещение зоны начала.
|
||||
OffsetSeconds int
|
||||
// Duration — длительность тренировки в секундах. nil означает «источник не
|
||||
// прислал» и отличим от нуля: ноль — законная длительность.
|
||||
Duration *float64
|
||||
|
||||
Raw json.RawMessage
|
||||
}
|
||||
|
||||
// Incoming — всё, что дала одна доставка. Единицей записи является доставка, а
|
||||
// не точка и не сущность: частичное состояние ломает инвариант «состояние
|
||||
// пересобираемо».
|
||||
type Incoming struct {
|
||||
Points []IncomingPoint
|
||||
Workouts []IncomingEntity
|
||||
Records []IncomingEntity
|
||||
}
|
||||
|
||||
// DeliveryRef — место доставки в журнале. Пара, а не идентификатор: по ней
|
||||
// разрешается тай-брейк между версиями сущности равной полноты, а порядок
|
||||
// журнала задан парой `(received_at, id)`.
|
||||
type DeliveryRef struct {
|
||||
ID string
|
||||
ReceivedAt time.Time
|
||||
}
|
||||
|
||||
func (d DeliveryRef) before(other DeliveryRef) bool {
|
||||
if !d.ReceivedAt.Equal(other.ReceivedAt) {
|
||||
return d.ReceivedAt.Before(other.ReceivedAt)
|
||||
}
|
||||
return d.ID < other.ID
|
||||
}
|
||||
|
||||
// EntityRef — координаты сущности для записи в лог. Содержимого не несёт:
|
||||
// маршрут тренировки — это геотрек до дома, а метки состояния разума —
|
||||
// измерение душевного состояния.
|
||||
type EntityRef struct {
|
||||
Kind string
|
||||
ID string
|
||||
}
|
||||
|
||||
// maxEntityRefsReported — сколько координат сущностей попадает в лог.
|
||||
const maxEntityRefsReported = 5
|
||||
|
||||
// prepareEntities считает хеш каждой сущности.
|
||||
//
|
||||
// Вынесено из транзакции намеренно: хеширование материализует значение целиком
|
||||
// (маршрут — до мегабайта), а транзакция повторяется до пяти раз при занятости
|
||||
// базы.
|
||||
func prepareEntities(in []IncomingEntity, from DeliveryRef) ([]entityVersion, error) {
|
||||
if len(in) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
out := make([]entityVersion, 0, len(in))
|
||||
for _, e := range in {
|
||||
v, err := newEntityVersion(e, from)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, v)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// clipRefs держит список координат в потолке: он зацепка для разбора, а не
|
||||
// отчёт; масштаб события считает счётчик.
|
||||
func clipRefs(refs []EntityRef) []EntityRef {
|
||||
if len(refs) <= maxEntityRefsReported {
|
||||
return refs
|
||||
}
|
||||
return refs[:maxEntityRefsReported]
|
||||
}
|
||||
|
||||
// entityVersion — версия сущности вместе с тем, что нужно знать при выборе
|
||||
// победителя.
|
||||
//
|
||||
// Разбор и канонизация ОТЛОЖЕНЫ: они нужны только когда хеш разошёлся с
|
||||
// сохранённым, то есть на одной доставке из сорока четырёх. Считать их сразу
|
||||
// значило бы разворачивать маршрут (95% веса тренировки, до мегабайта) в дерево
|
||||
// значений на каждой копии — ровно та форма, от которой разбор тела отказался
|
||||
// замером (197 МиБ кучи против 54 МиБ на теле 42 МиБ). Хеш при этом считается
|
||||
// сразу и один раз на доставку: он и есть быстрый путь.
|
||||
type entityVersion struct {
|
||||
raw json.RawMessage
|
||||
hash string
|
||||
from DeliveryRef
|
||||
|
||||
// key и fields заполняются лениво, методом analyze().
|
||||
key []byte
|
||||
fields canon.Fields
|
||||
parsed bool
|
||||
|
||||
// head — заголовок, который пишется колонками. У сохранённой версии он не
|
||||
// нужен: она либо побеждает и остаётся как есть, либо замещается целиком.
|
||||
head IncomingEntity
|
||||
}
|
||||
|
||||
func newEntityVersion(e IncomingEntity, from DeliveryRef) (entityVersion, error) {
|
||||
h, err := canon.Hash(e.Raw)
|
||||
if err != nil {
|
||||
return entityVersion{}, fmt.Errorf("хеш сущности: %w", err)
|
||||
}
|
||||
return entityVersion{raw: e.Raw, hash: h, from: from, head: e}, nil
|
||||
}
|
||||
|
||||
// analyze разбирает версию, если этого ещё не делали.
|
||||
func (v *entityVersion) analyze() {
|
||||
if v.parsed {
|
||||
return
|
||||
}
|
||||
v.key = canon.SortKey(v.raw)
|
||||
v.fields = canon.Analyze(v.raw)
|
||||
v.parsed = true
|
||||
}
|
||||
|
||||
// pickEntity выбирает между сохранённой и приехавшей версией.
|
||||
//
|
||||
// Второй возврат — потеряла ли бы витрина содержание, приняв приехавшую. Это и
|
||||
// есть плата за отказ объединять поля: событие не предотвращается молча, а
|
||||
// считается и уходит в WARN.
|
||||
//
|
||||
// 1. приехавшая несёт всё содержание сохранённой и сверх того → приехавшая
|
||||
// 2. сохранённая несёт всё содержание приехавшей и сверх того → сохранённая
|
||||
// 3. содержание равно → версия из более поздней доставки ЖУРНАЛА
|
||||
// 4. наборы несравнимы → сохранённая
|
||||
//
|
||||
// Пункт 3 — не «побеждает приехавшая». Приехавшая есть функция порядка
|
||||
// СВЁРТКИ, а он порядку журнала не равен: воркер сворачивает в порядке журнала
|
||||
// только среди видимых ему доставок. Доставка с более ранней меткой, свёрнутая
|
||||
// позже, вернула бы витрину к недосчитанной версии, и пересборка разошлась бы
|
||||
// с живым приёмом молча — в содержимом тренировки, где это не видно ничем,
|
||||
// кроме отпечатка.
|
||||
//
|
||||
// Равные позиции означают две версии одного ключа внутри ОДНОЙ доставки; там
|
||||
// решает минимум канонической формы, потому что порядок элементов в
|
||||
// JSON-массиве нестабилен.
|
||||
func pickEntity(stored, incoming *entityVersion) (takeIncoming, lost bool) {
|
||||
switch v := compareEntities(stored, incoming); v {
|
||||
case entityIncomingRicher:
|
||||
return true, false
|
||||
case entityStoredRicher:
|
||||
return false, true
|
||||
case entityIncomparable:
|
||||
// Несравнимы: у каждой версии есть содержание, которого нет у другой.
|
||||
// Объединение полей отвергнуто там же и по той же причине, что для
|
||||
// точек, — на живом потоке событие не наступало ни разу, — а из двух
|
||||
// версий остаётся сохранённая: правило называется «не теряет
|
||||
// содержания», и приехавшая его теряет. Исход при этом остаётся
|
||||
// функцией журнала: доставки проигрываются в его порядке.
|
||||
return false, true
|
||||
default:
|
||||
return laterInJournal(stored, incoming), false
|
||||
}
|
||||
}
|
||||
|
||||
// pickWithinDelivery выбирает между двумя версиями одного ключа ВНУТРИ одной
|
||||
// доставки. Второй возврат — различается ли их содержание вообще.
|
||||
//
|
||||
// Отдельно от pickEntity, и не ради симметрии: «сохранённой» версии здесь нет,
|
||||
// есть только порядок элементов в JSON-массиве, а он нестабилен. Правило
|
||||
// «остаётся первая встреченная» сделало бы исход функцией порядка на проводе,
|
||||
// поэтому при равном и при несравнимом содержании решает тотальный порядок
|
||||
// канонических форм.
|
||||
func pickWithinDelivery(a, b *entityVersion) (takeB, differs bool) {
|
||||
switch v := compareEntities(a, b); v {
|
||||
case entityIncomingRicher:
|
||||
return true, true
|
||||
case entityStoredRicher:
|
||||
return false, true
|
||||
case entityIncomparable:
|
||||
return laterInJournal(a, b), true
|
||||
default:
|
||||
return laterInJournal(a, b), false
|
||||
}
|
||||
}
|
||||
|
||||
// entityVerdict — как соотносится СОДЕРЖАНИЕ двух версий одной сущности.
|
||||
// Нумерация с единицы: нулевое значение не должно выглядеть как «равны».
|
||||
type entityVerdict int
|
||||
|
||||
const (
|
||||
// entityEqualContent — множества содержательных ключей совпадают, длины
|
||||
// верхнеуровневых массивов тоже. Значения при этом могут расходиться: их
|
||||
// сравнение здесь неприменимо (см. canon.Fields.Covers).
|
||||
entityEqualContent entityVerdict = iota + 1
|
||||
entityIncomingRicher
|
||||
entityStoredRicher
|
||||
entityIncomparable
|
||||
)
|
||||
|
||||
func compareEntities(stored, incoming *entityVersion) entityVerdict {
|
||||
stored.analyze()
|
||||
incoming.analyze()
|
||||
|
||||
storedCovers := stored.fields.Covers(incoming.fields)
|
||||
incomingCovers := incoming.fields.Covers(stored.fields)
|
||||
|
||||
switch {
|
||||
case incomingCovers && storedCovers:
|
||||
return entityEqualContent
|
||||
case incomingCovers:
|
||||
return entityIncomingRicher
|
||||
case storedCovers:
|
||||
return entityStoredRicher
|
||||
default:
|
||||
return entityIncomparable
|
||||
}
|
||||
}
|
||||
|
||||
// laterInJournal говорит, стоит ли приехавшая версия позже сохранённой в
|
||||
// журнале. Позиции равны у двух версий одного ключа внутри одной доставки;
|
||||
// там решает минимум канонической формы — порядок тотальный и от порядка
|
||||
// элементов в массиве не зависит.
|
||||
func laterInJournal(stored, incoming *entityVersion) bool {
|
||||
if stored.from.before(incoming.from) {
|
||||
return true
|
||||
}
|
||||
if incoming.from.before(stored.from) {
|
||||
return false
|
||||
}
|
||||
return bytes.Compare(incoming.key, stored.key) < 0
|
||||
}
|
||||
|
||||
// dedupeEntities сворачивает версии одного ключа ВНУТРИ доставки тем же
|
||||
// правилом — до сравнения с сохранённой.
|
||||
//
|
||||
// Без этого исход зависел бы от того, как написан цикл: карта по ключу дала бы
|
||||
// победу последнему элементу массива мимо правила полноты, а порядок элементов
|
||||
// в JSON-массиве нестабилен.
|
||||
//
|
||||
// Счётчик здесь считает СИММЕТРИЧНО — «в одном теле приехали две версии одного
|
||||
// ключа с разным содержанием», — а не «приехавшая обеднена». Внутри доставки
|
||||
// «сохранённой» версии не существует, есть только порядок элементов массива, и
|
||||
// счётчик, зависящий от него, наблюдал бы событие через раз.
|
||||
func dedupeEntities(versions []entityVersion) ([]entityVersion, int, []EntityRef) {
|
||||
type slot struct {
|
||||
v entityVersion
|
||||
pos int
|
||||
}
|
||||
|
||||
byKey := make(map[EntityRef]slot, len(versions))
|
||||
order := make([]EntityRef, 0, len(versions))
|
||||
held := 0
|
||||
var heldAt []EntityRef
|
||||
|
||||
for _, v := range versions {
|
||||
ref := EntityRef{Kind: v.head.Kind, ID: v.head.ID}
|
||||
prev, seen := byKey[ref]
|
||||
if !seen {
|
||||
byKey[ref] = slot{v: v, pos: len(order)}
|
||||
order = append(order, ref)
|
||||
continue
|
||||
}
|
||||
takeB, differs := pickWithinDelivery(&prev.v, &v)
|
||||
if differs {
|
||||
held++
|
||||
if len(heldAt) < maxEntityRefsReported {
|
||||
heldAt = append(heldAt, ref)
|
||||
}
|
||||
}
|
||||
winner := prev.v
|
||||
if takeB {
|
||||
winner = v
|
||||
}
|
||||
byKey[ref] = slot{v: winner, pos: prev.pos}
|
||||
}
|
||||
|
||||
out := make([]entityVersion, 0, len(order))
|
||||
for _, ref := range order {
|
||||
out = append(out, byKey[ref].v)
|
||||
}
|
||||
return out, held, heldAt
|
||||
}
|
||||
|
||||
// mergeEntities сливает сущности одной секции с сохранёнными.
|
||||
func mergeEntities(ctx context.Context, tx *sql.Tx, table string, versions []entityVersion, now time.Time) (written, held int, heldAt []EntityRef, err error) {
|
||||
for _, v := range versions {
|
||||
stored, found, err := readEntityHead(ctx, tx, table, v.head.Kind, v.head.ID)
|
||||
if err != nil {
|
||||
return 0, 0, nil, err
|
||||
}
|
||||
|
||||
if !found {
|
||||
if err := writeEntity(ctx, tx, table, v, now); err != nil {
|
||||
return 0, 0, nil, err
|
||||
}
|
||||
written++
|
||||
continue
|
||||
}
|
||||
|
||||
// Хеш — детектор изменений: совпал, значит писать нечего, и содержимое
|
||||
// сохранённой сущности читать не приходится вовсе. Тренировка
|
||||
// переприсылается каждой доставкой, пока не доедет маршрут, — на живом
|
||||
// архиве 44 копии дают три различных содержимых.
|
||||
if stored.hash == v.hash {
|
||||
continue
|
||||
}
|
||||
|
||||
storedRaw, err := readEntityPayload(ctx, tx, table, v.head.Kind, v.head.ID)
|
||||
if err != nil {
|
||||
return 0, 0, nil, err
|
||||
}
|
||||
prev := entityVersion{raw: storedRaw, hash: stored.hash, from: stored.from}
|
||||
|
||||
takeIncoming, lost := pickEntity(&prev, &v)
|
||||
if lost {
|
||||
held++
|
||||
if len(heldAt) < maxEntityRefsReported {
|
||||
heldAt = append(heldAt, EntityRef{Kind: v.head.Kind, ID: v.head.ID})
|
||||
}
|
||||
}
|
||||
if !takeIncoming {
|
||||
continue
|
||||
}
|
||||
if err := writeEntity(ctx, tx, table, v, now); err != nil {
|
||||
return 0, 0, nil, err
|
||||
}
|
||||
written++
|
||||
}
|
||||
return written, held, heldAt, nil
|
||||
}
|
||||
|
||||
type storedEntityHead struct {
|
||||
hash string
|
||||
from DeliveryRef
|
||||
}
|
||||
|
||||
func readEntityHead(ctx context.Context, tx *sql.Tx, table, kind, id string) (storedEntityHead, bool, error) {
|
||||
q := `SELECT content_hash, delivery_id, delivery_received_at FROM ` + table + entityWhere(table)
|
||||
|
||||
var (
|
||||
head storedEntityHead
|
||||
receivedAt string
|
||||
)
|
||||
row := queryEntity(ctx, tx, q, table, kind, id)
|
||||
err := row.Scan(&head.hash, &head.from.ID, &receivedAt)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return storedEntityHead{}, false, nil
|
||||
}
|
||||
if err != nil {
|
||||
return storedEntityHead{}, false, fmt.Errorf("select %s: %w", table, err)
|
||||
}
|
||||
// Пустую метку не терпим: колонка NOT NULL без умолчания, и пустота здесь
|
||||
// означала бы дефект писателя. Молчаливый нулевой момент сделал бы
|
||||
// сохранённую версию «самой ранней в журнале», и её затирала бы любая
|
||||
// приехавшая — то есть дефект проявился бы потерей данных, а не отказом.
|
||||
head.from.ReceivedAt, err = ParseTime(receivedAt)
|
||||
if err != nil {
|
||||
return storedEntityHead{}, false, err
|
||||
}
|
||||
return head, true, nil
|
||||
}
|
||||
|
||||
func readEntityPayload(ctx context.Context, tx *sql.Tx, table, kind, id string) (json.RawMessage, error) {
|
||||
q := `SELECT payload FROM ` + table + entityWhere(table)
|
||||
|
||||
var payload []byte
|
||||
if err := queryEntity(ctx, tx, q, table, kind, id).Scan(&payload); err != nil {
|
||||
return nil, fmt.Errorf("select %s payload: %w", table, err)
|
||||
}
|
||||
raw, err := gunzipBytes(payload)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return raw, nil
|
||||
}
|
||||
|
||||
// entityWhere и queryEntity держат разницу между таблицами в одном месте:
|
||||
// у тренировки ключ — `id`, у записи — пара `kind + id`.
|
||||
func entityWhere(table string) string {
|
||||
if table == recordTable {
|
||||
return ` WHERE kind = ? AND id = ?`
|
||||
}
|
||||
return ` WHERE id = ?`
|
||||
}
|
||||
|
||||
func queryEntity(ctx context.Context, tx *sql.Tx, q, table, kind, id string) *sql.Row {
|
||||
if table == recordTable {
|
||||
return tx.QueryRowContext(ctx, q, kind, id)
|
||||
}
|
||||
return tx.QueryRowContext(ctx, q, id)
|
||||
}
|
||||
|
||||
func writeEntity(ctx context.Context, tx *sql.Tx, table string, v entityVersion, now time.Time) error {
|
||||
payload, err := gzipBytes(v.raw)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
stamp := FormatTime(now)
|
||||
received := FormatTime(v.from.ReceivedAt)
|
||||
|
||||
if table == recordTable {
|
||||
const q = `
|
||||
INSERT INTO record (kind, id, ts_utc, tz_offset, payload, content_hash,
|
||||
delivery_id, delivery_received_at, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT (kind, id) DO UPDATE SET
|
||||
ts_utc = excluded.ts_utc,
|
||||
tz_offset = excluded.tz_offset,
|
||||
payload = excluded.payload,
|
||||
content_hash = excluded.content_hash,
|
||||
delivery_id = excluded.delivery_id,
|
||||
delivery_received_at = excluded.delivery_received_at,
|
||||
updated_at = excluded.updated_at`
|
||||
|
||||
if _, err := tx.ExecContext(ctx, q,
|
||||
v.head.Kind, v.head.ID, FormatTime(v.head.Start), v.head.OffsetSeconds,
|
||||
payload, v.hash, v.from.ID, received, stamp, stamp); err != nil {
|
||||
return fmt.Errorf("upsert record: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
const q = `
|
||||
INSERT INTO workout (id, name, start_utc, end_utc, tz_offset, duration_sec,
|
||||
payload, content_hash, delivery_id, delivery_received_at,
|
||||
created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT (id) DO UPDATE SET
|
||||
name = excluded.name,
|
||||
start_utc = excluded.start_utc,
|
||||
end_utc = excluded.end_utc,
|
||||
tz_offset = excluded.tz_offset,
|
||||
duration_sec = excluded.duration_sec,
|
||||
payload = excluded.payload,
|
||||
content_hash = excluded.content_hash,
|
||||
delivery_id = excluded.delivery_id,
|
||||
delivery_received_at = excluded.delivery_received_at,
|
||||
updated_at = excluded.updated_at`
|
||||
|
||||
var duration any
|
||||
if v.head.Duration != nil {
|
||||
duration = *v.head.Duration
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, q,
|
||||
v.head.ID, v.head.Name, FormatTime(v.head.Start), FormatTime(v.head.End),
|
||||
v.head.OffsetSeconds, duration, payload, v.hash, v.from.ID, received,
|
||||
stamp, stamp); err != nil {
|
||||
return fmt.Errorf("upsert workout: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Workout — тренировка, прочитанная из витрины. Нужна тестам и будущему
|
||||
// Read API: содержимое отдаётся целиком, заголовок — из колонок.
|
||||
type Workout struct {
|
||||
ID string
|
||||
Name string
|
||||
Start time.Time
|
||||
End time.Time
|
||||
OffsetSeconds int
|
||||
Duration *float64
|
||||
Raw json.RawMessage
|
||||
Delivery string
|
||||
}
|
||||
|
||||
// Workout читает тренировку по идентификатору.
|
||||
func (s *Store) Workout(ctx context.Context, id string) (Workout, error) {
|
||||
const q = `
|
||||
SELECT id, name, start_utc, end_utc, tz_offset, duration_sec, payload, delivery_id
|
||||
FROM workout WHERE id = ?`
|
||||
|
||||
var (
|
||||
w Workout
|
||||
start, end string
|
||||
duration sql.NullFloat64
|
||||
payload []byte
|
||||
deliveryFrom string
|
||||
)
|
||||
err := s.db.QueryRowxContext(ctx, q, id).
|
||||
Scan(&w.ID, &w.Name, &start, &end, &w.OffsetSeconds, &duration, &payload, &deliveryFrom)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return Workout{}, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return Workout{}, fmt.Errorf("select workout: %w", err)
|
||||
}
|
||||
|
||||
if w.Start, err = ParseTime(start); err != nil {
|
||||
return Workout{}, err
|
||||
}
|
||||
if w.End, err = ParseTime(end); err != nil {
|
||||
return Workout{}, err
|
||||
}
|
||||
if duration.Valid {
|
||||
v := duration.Float64
|
||||
w.Duration = &v
|
||||
}
|
||||
if w.Raw, err = gunzipBytes(payload); err != nil {
|
||||
return Workout{}, err
|
||||
}
|
||||
w.Delivery = deliveryFrom
|
||||
return w, nil
|
||||
}
|
||||
|
||||
// Record — запись секции с собственным идентификатором.
|
||||
type Record struct {
|
||||
Kind string
|
||||
ID string
|
||||
TS time.Time
|
||||
OffsetSeconds int
|
||||
Raw json.RawMessage
|
||||
Delivery string
|
||||
}
|
||||
|
||||
// Record читает запись по роду и идентификатору.
|
||||
func (s *Store) Record(ctx context.Context, kind, id string) (Record, error) {
|
||||
const q = `
|
||||
SELECT kind, id, ts_utc, tz_offset, payload, delivery_id
|
||||
FROM record WHERE kind = ? AND id = ?`
|
||||
|
||||
var (
|
||||
r Record
|
||||
ts string
|
||||
payload []byte
|
||||
deliveryFrom string
|
||||
)
|
||||
err := s.db.QueryRowxContext(ctx, q, kind, id).
|
||||
Scan(&r.Kind, &r.ID, &ts, &r.OffsetSeconds, &payload, &deliveryFrom)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return Record{}, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return Record{}, fmt.Errorf("select record: %w", err)
|
||||
}
|
||||
|
||||
if r.TS, err = ParseTime(ts); err != nil {
|
||||
return Record{}, err
|
||||
}
|
||||
if r.Raw, err = gunzipBytes(payload); err != nil {
|
||||
return Record{}, err
|
||||
}
|
||||
r.Delivery = deliveryFrom
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// CountWorkouts и CountRecords нужны отчёту пересборки: отпечаток отвечает
|
||||
// «да/нет», а по «да/нет» нельзя судить о направлении расхождения.
|
||||
func (s *Store) CountWorkouts(ctx context.Context) (int64, error) {
|
||||
var n int64
|
||||
if err := s.db.GetContext(ctx, &n, `SELECT count(*) FROM workout`); err != nil {
|
||||
return 0, fmt.Errorf("count workouts: %w", err)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// CountRecords возвращает число записей секций с собственным `id`.
|
||||
func (s *Store) CountRecords(ctx context.Context) (int64, error) {
|
||||
var n int64
|
||||
if err := s.db.GetContext(ctx, &n, `SELECT count(*) FROM record`); err != nil {
|
||||
return 0, fmt.Errorf("count records: %w", err)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
@@ -0,0 +1,460 @@
|
||||
package store_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"git.vakhrushev.me/av/healthlog/internal/store"
|
||||
)
|
||||
|
||||
// workout собирает тренировку с заданным содержимым. Заголовок в этих тестах
|
||||
// вторичен: правило замены смотрит на содержание, а не на колонки.
|
||||
func workout(t *testing.T, id, raw string) store.IncomingEntity {
|
||||
t.Helper()
|
||||
|
||||
return store.IncomingEntity{
|
||||
ID: id,
|
||||
Kind: "workouts",
|
||||
Name: "На улице Ходьба",
|
||||
Start: ts(t, "2025-06-05T07:00:00Z"),
|
||||
End: ts(t, "2025-06-05T07:10:00Z"),
|
||||
OffsetSeconds: 3 * 3600,
|
||||
Raw: json.RawMessage(raw),
|
||||
}
|
||||
}
|
||||
|
||||
func from(t *testing.T, id, receivedAt string) store.DeliveryRef {
|
||||
t.Helper()
|
||||
|
||||
return store.DeliveryRef{ID: id, ReceivedAt: ts(t, receivedAt)}
|
||||
}
|
||||
|
||||
func mergeWorkouts(t *testing.T, st *store.Store, d store.DeliveryRef, ws ...store.IncomingEntity) store.MergeStats {
|
||||
t.Helper()
|
||||
|
||||
stats, err := st.Merge(context.Background(), store.Incoming{Workouts: ws}, d)
|
||||
if err != nil {
|
||||
t.Fatalf("слияние сущностей: %v", err)
|
||||
}
|
||||
return stats
|
||||
}
|
||||
|
||||
const (
|
||||
// Содержимое подобрано так, чтобы отличаться от прежнего ЗНАЧЕНИЯМИ общих
|
||||
// полей: именно так тренировка и меняется между версиями (досчёт энергии),
|
||||
// и именно на этом ломается правило полноты, написанное для точек.
|
||||
woWithRoute = `{"id":"w1","name":"На улице Ходьба","route":[{"lat":1},{"lat":2},{"lat":3}],
|
||||
"activeEnergy":[{"qty":10}],"totalEnergy":{"qty":20,"units":"kJ"}}`
|
||||
woNoRouteNewValues = `{"id":"w1","name":"На улице Ходьба",
|
||||
"activeEnergy":[{"qty":11}],"totalEnergy":{"qty":21,"units":"kJ"}}`
|
||||
woShortRoute = `{"id":"w1","name":"На улице Ходьба","route":[{"lat":1}],
|
||||
"activeEnergy":[{"qty":11}],"totalEnergy":{"qty":21,"units":"kJ"}}`
|
||||
woRicher = `{"id":"w1","name":"На улице Ходьба","route":[{"lat":1},{"lat":2},{"lat":3}],
|
||||
"activeEnergy":[{"qty":11}],"totalEnergy":{"qty":21,"units":"kJ"},"stepCount":{"qty":900}}`
|
||||
woSameShapeNewValues = `{"id":"w1","name":"На улице Ходьба","route":[{"lat":1},{"lat":2},{"lat":3}],
|
||||
"activeEnergy":[{"qty":11}],"totalEnergy":{"qty":21,"units":"kJ"}}`
|
||||
woIncomparable = `{"id":"w1","name":"На улице Ходьба",
|
||||
"activeEnergy":[{"qty":11}],"totalEnergy":{"qty":21,"units":"kJ"},"flightsClimbed":{"qty":3}}`
|
||||
)
|
||||
|
||||
func storedRaw(t *testing.T, st *store.Store, id string) string {
|
||||
t.Helper()
|
||||
|
||||
w, err := st.Workout(context.Background(), id)
|
||||
if err != nil {
|
||||
t.Fatalf("чтение тренировки: %v", err)
|
||||
}
|
||||
return string(w.Raw)
|
||||
}
|
||||
|
||||
// Единственная причина повторной присылки тренировки — доезжающий маршрут.
|
||||
func TestMergeДоехавшийМаршрутЗамещаетТренировку(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
mergeWorkouts(t, st, from(t, "d1", "2025-06-05T08:00:00Z"), workout(t, "w1", woNoRouteNewValues))
|
||||
stats := mergeWorkouts(t, st, from(t, "d2", "2025-06-05T08:05:00Z"), workout(t, "w1", woWithRoute))
|
||||
|
||||
if stats.WorkoutsWritten != 1 {
|
||||
t.Errorf("записано %d, ожидалась 1: версия с маршрутом полнее", stats.WorkoutsWritten)
|
||||
}
|
||||
if stats.EntitiesHeld != 0 {
|
||||
t.Errorf("удержано %d, ожидалось 0", stats.EntitiesHeld)
|
||||
}
|
||||
if got := storedRaw(t, st, "w1"); got != woWithRoute {
|
||||
t.Error("в витрине не версия с маршрутом")
|
||||
}
|
||||
}
|
||||
|
||||
// Тренировка досчитывается задним числом ровно так же, как минутное ведро:
|
||||
// набор полей тот же, значения новые. Тай-брейк по канонической форме
|
||||
// заморозил бы её на произвольной версии навсегда.
|
||||
func TestMergeДосчётПриТомЖеНабореПолейПобеждает(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
mergeWorkouts(t, st, from(t, "d1", "2025-06-05T08:00:00Z"), workout(t, "w1", woWithRoute))
|
||||
stats := mergeWorkouts(t, st, from(t, "d2", "2025-06-05T08:05:00Z"), workout(t, "w1", woSameShapeNewValues))
|
||||
|
||||
if stats.WorkoutsWritten != 1 {
|
||||
t.Errorf("записано %d, ожидалась 1", stats.WorkoutsWritten)
|
||||
}
|
||||
if got := storedRaw(t, st, "w1"); got != woSameShapeNewValues {
|
||||
t.Error("досчитанная версия не легла в витрину")
|
||||
}
|
||||
}
|
||||
|
||||
// Исход обязан быть функцией ЖУРНАЛА, а не порядка свёртки: воркер сворачивает
|
||||
// в порядке журнала только среди видимых ему доставок, и доставка с более
|
||||
// ранней меткой может свернуться позже.
|
||||
func TestMergeВерсияИзБолееРаннейДоставкиНеОткатываетВитрину(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
early := from(t, "d1", "2025-06-05T08:00:00Z")
|
||||
late := from(t, "d2", "2025-06-05T08:05:00Z")
|
||||
|
||||
прямой := open(t)
|
||||
mergeWorkouts(t, прямой, early, workout(t, "w1", woWithRoute))
|
||||
mergeWorkouts(t, прямой, late, workout(t, "w1", woSameShapeNewValues))
|
||||
|
||||
обратный := open(t)
|
||||
mergeWorkouts(t, обратный, late, workout(t, "w1", woSameShapeNewValues))
|
||||
mergeWorkouts(t, обратный, early, workout(t, "w1", woWithRoute))
|
||||
|
||||
a, b := storedRaw(t, прямой, "w1"), storedRaw(t, обратный, "w1")
|
||||
if a != b {
|
||||
t.Error("исход зависит от порядка свёртки — живая витрина разойдётся с пересборкой")
|
||||
}
|
||||
if a != woSameShapeNewValues {
|
||||
t.Error("победила версия не из более поздней доставки журнала")
|
||||
}
|
||||
}
|
||||
|
||||
// Маршрут — 95% содержимого тренировки, а восстановление требует пересборки
|
||||
// всего журнала. Событие делается наблюдаемым, а не необратимым.
|
||||
func TestMergeОбеднённаяВерсияНеЗатираетСохранённую(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
mergeWorkouts(t, st, from(t, "d1", "2025-06-05T08:00:00Z"), workout(t, "w1", woWithRoute))
|
||||
stats := mergeWorkouts(t, st, from(t, "d2", "2025-06-05T08:05:00Z"), workout(t, "w1", woNoRouteNewValues))
|
||||
|
||||
if stats.WorkoutsWritten != 0 {
|
||||
t.Errorf("записано %d, ожидалось 0: приехавшая теряет маршрут", stats.WorkoutsWritten)
|
||||
}
|
||||
if stats.EntitiesHeld != 1 {
|
||||
t.Errorf("удержано %d, ожидалась 1 — событие обязано быть видно", stats.EntitiesHeld)
|
||||
}
|
||||
if len(stats.HeldAt) != 1 || stats.HeldAt[0].ID != "w1" {
|
||||
t.Errorf("координаты удержанной версии %v", stats.HeldAt)
|
||||
}
|
||||
if got := storedRaw(t, st, "w1"); got != woWithRoute {
|
||||
t.Error("маршрут пропал из витрины")
|
||||
}
|
||||
}
|
||||
|
||||
// Усечённый маршрут ключа не теряет — множеств ключей мало.
|
||||
func TestMergeУсечённыйМаршрутНеЗатираетСохранённый(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
mergeWorkouts(t, st, from(t, "d1", "2025-06-05T08:00:00Z"), workout(t, "w1", woWithRoute))
|
||||
stats := mergeWorkouts(t, st, from(t, "d2", "2025-06-05T08:05:00Z"), workout(t, "w1", woShortRoute))
|
||||
|
||||
if stats.EntitiesHeld != 1 {
|
||||
t.Errorf("удержано %d, ожидалась 1", stats.EntitiesHeld)
|
||||
}
|
||||
if got := storedRaw(t, st, "w1"); got != woWithRoute {
|
||||
t.Error("полный маршрут вытеснен усечённым")
|
||||
}
|
||||
}
|
||||
|
||||
// Несравнимые наборы: у каждой версии есть содержание, которого нет у другой.
|
||||
// Поля не объединяются, вместо этого — счётчик.
|
||||
func TestMergeНесравнимыеНаборыНеОбъединяются(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
mergeWorkouts(t, st, from(t, "d1", "2025-06-05T08:00:00Z"), workout(t, "w1", woWithRoute))
|
||||
stats := mergeWorkouts(t, st, from(t, "d2", "2025-06-05T08:05:00Z"), workout(t, "w1", woIncomparable))
|
||||
|
||||
if stats.EntitiesHeld != 1 {
|
||||
t.Errorf("удержано %d, ожидалась 1", stats.EntitiesHeld)
|
||||
}
|
||||
if got := storedRaw(t, st, "w1"); got != woWithRoute {
|
||||
t.Error("несравнимая версия заместила сохранённую")
|
||||
}
|
||||
}
|
||||
|
||||
// Хеш — детектор изменений: тренировка переприсылается каждой доставкой, пока
|
||||
// не доедет маршрут, и 41 копия из 44 записи вызывать не должна.
|
||||
func TestMergeПовторТойЖеТренировкиНеПишет(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
mergeWorkouts(t, st, from(t, "d1", "2025-06-05T08:00:00Z"), workout(t, "w1", woWithRoute))
|
||||
|
||||
// Тот же смысл, другой порядок ключей и дребезг литерала: каноническая
|
||||
// форма обязана совпасть.
|
||||
same := `{"name":"На улице Ходьба","id":"w1","totalEnergy":{"units":"kJ","qty":20.0},
|
||||
"activeEnergy":[{"qty":10}],"route":[{"lat":1},{"lat":2},{"lat":3}]}`
|
||||
stats := mergeWorkouts(t, st, from(t, "d2", "2025-06-05T08:05:00Z"), workout(t, "w1", same))
|
||||
|
||||
if stats.WorkoutsWritten != 0 {
|
||||
t.Errorf("записано %d, ожидалось 0: содержимое то же", stats.WorkoutsWritten)
|
||||
}
|
||||
}
|
||||
|
||||
// Три версии в разных порядках подачи: пункты правила, не зависящие от порядка
|
||||
// свёртки, обязаны давать одно состояние. Конвенция требует перестановки трёх,
|
||||
// а не пары: попарная свёртка уже давала нетранзитивную победу на точках.
|
||||
func TestMergeПерестановкаТрёхВерсийДаётОдноСостояние(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
type step struct {
|
||||
d store.DeliveryRef
|
||||
raw string
|
||||
}
|
||||
steps := []step{
|
||||
{from(t, "d1", "2025-06-05T08:00:00Z"), woNoRouteNewValues},
|
||||
{from(t, "d2", "2025-06-05T08:05:00Z"), woWithRoute},
|
||||
{from(t, "d3", "2025-06-05T08:10:00Z"), woRicher},
|
||||
}
|
||||
orders := [][]int{{0, 1, 2}, {2, 1, 0}, {1, 0, 2}, {1, 2, 0}, {2, 0, 1}, {0, 2, 1}}
|
||||
|
||||
var want string
|
||||
for i, order := range orders {
|
||||
st := open(t)
|
||||
for _, idx := range order {
|
||||
mergeWorkouts(t, st, steps[idx].d, workout(t, "w1", steps[idx].raw))
|
||||
}
|
||||
got := storedRaw(t, st, "w1")
|
||||
if i == 0 {
|
||||
want = got
|
||||
if want != woRicher {
|
||||
t.Fatalf("победила не самая полная версия")
|
||||
}
|
||||
continue
|
||||
}
|
||||
if got != want {
|
||||
t.Errorf("порядок %v дал другое состояние", order)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Порядок элементов в JSON-массиве нестабилен, поэтому две версии одного ключа
|
||||
// внутри одной доставки не имеют права разрешаться «последним в массиве».
|
||||
func TestMergeДвеВерсииВОдномТелеНеЗависятОтПорядка(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
d := from(t, "d1", "2025-06-05T08:00:00Z")
|
||||
|
||||
прямой := open(t)
|
||||
mergeWorkouts(t, прямой, d, workout(t, "w1", woWithRoute), workout(t, "w1", woSameShapeNewValues))
|
||||
|
||||
обратный := open(t)
|
||||
mergeWorkouts(t, обратный, d, workout(t, "w1", woSameShapeNewValues), workout(t, "w1", woWithRoute))
|
||||
|
||||
if storedRaw(t, прямой, "w1") != storedRaw(t, обратный, "w1") {
|
||||
t.Error("исход зависит от порядка элементов в массиве секции")
|
||||
}
|
||||
}
|
||||
|
||||
// Записи разных родов с одним идентификатором — разные записи: ключ пара, а не
|
||||
// один id.
|
||||
func TestMergeЗаписиРазныхРодовСОднимIDНеСталкиваются(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
mind := store.IncomingEntity{
|
||||
ID: "e1", Kind: "stateOfMind",
|
||||
Start: ts(t, "2025-06-05T18:00:00Z"),
|
||||
End: ts(t, "2025-06-05T18:00:00Z"),
|
||||
Raw: json.RawMessage(`{"id":"e1","kind":"momentary_emotion","valence":0.5}`),
|
||||
}
|
||||
ecg := store.IncomingEntity{
|
||||
ID: "e1", Kind: "ecg",
|
||||
Start: ts(t, "2025-06-05T19:00:00Z"),
|
||||
End: ts(t, "2025-06-05T19:00:00Z"),
|
||||
Raw: json.RawMessage(`{"id":"e1","classification":"sinusRhythm"}`),
|
||||
}
|
||||
if _, err := st.Merge(ctx, store.Incoming{Records: []store.IncomingEntity{mind, ecg}},
|
||||
from(t, "d1", "2025-06-05T20:00:00Z")); err != nil {
|
||||
t.Fatalf("слияние записей: %v", err)
|
||||
}
|
||||
|
||||
for _, kind := range []string{"stateOfMind", "ecg"} {
|
||||
if _, err := st.Record(ctx, kind, "e1"); err != nil {
|
||||
t.Errorf("запись рода %q не найдена: %v", kind, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Отпечаток — единственный оракул сходимости. Витрины, совпадающие по часовым
|
||||
// объектам, но разошедшиеся в тренировке, обязаны давать разные отпечатки.
|
||||
func TestFingerprintРазличаетТренировки(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
build := func(raw string) string {
|
||||
st := open(t)
|
||||
in := store.Incoming{
|
||||
Points: []store.IncomingPoint{point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":1}`)},
|
||||
Workouts: []store.IncomingEntity{workout(t, "w1", raw)},
|
||||
}
|
||||
if _, err := st.Merge(ctx, in, from(t, "d1", "2025-06-05T08:00:00Z")); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
fp, err := st.Fingerprint(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("отпечаток: %v", err)
|
||||
}
|
||||
return fp
|
||||
}
|
||||
|
||||
full, changed := build(woWithRoute), build(woSameShapeNewValues)
|
||||
if full == changed {
|
||||
t.Error("отпечатки совпали при разошедшемся содержимом тренировки")
|
||||
}
|
||||
if again := build(woWithRoute); again != full {
|
||||
t.Error("отпечаток не воспроизводится на одном содержимом")
|
||||
}
|
||||
}
|
||||
|
||||
// Длительность: ноль — законное измерение, а «не прислали» обязано быть
|
||||
// отличимо от него.
|
||||
func TestWorkoutДлительностьОтличаетНольОтОтсутствия(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
zero := 0.0
|
||||
withZero := workout(t, "w-zero", `{"id":"w-zero","qty":1}`)
|
||||
withZero.Duration = &zero
|
||||
withNone := workout(t, "w-none", `{"id":"w-none","qty":1}`)
|
||||
|
||||
if _, err := st.Merge(ctx, store.Incoming{Workouts: []store.IncomingEntity{withZero, withNone}},
|
||||
from(t, "d1", "2025-06-05T08:00:00Z")); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
|
||||
w, err := st.Workout(ctx, "w-zero")
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
if w.Duration == nil || *w.Duration != 0 {
|
||||
t.Errorf("нулевая длительность потерялась: %v", w.Duration)
|
||||
}
|
||||
w, err = st.Workout(ctx, "w-none")
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
if w.Duration != nil {
|
||||
t.Errorf("отсутствие длительности стало значением %v", *w.Duration)
|
||||
}
|
||||
}
|
||||
|
||||
// Содержимое сущности хранится дословно: побайтовый круг «запись → чтение».
|
||||
func TestWorkoutСодержимоеХранитсяДословно(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
// Литералы, которые теряет любая пересборка через разобранные значения:
|
||||
// `1.0`, целое больше 2^53, дробь длиннее двенадцати значащих цифр, а также
|
||||
// символы, которые json.Marshal экранирует по умолчанию.
|
||||
const raw = `{"id":"w9","route":[{"lat":1.0,"big":9007199254740993,"p":0.123456789012345678}],
|
||||
"note":"a<b&c>d","isIndoor":false}`
|
||||
|
||||
if _, err := st.Merge(context.Background(),
|
||||
store.Incoming{Workouts: []store.IncomingEntity{workout(t, "w9", raw)}},
|
||||
from(t, "d1", "2025-06-05T08:00:00Z")); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
if got := storedRaw(t, st, "w9"); got != raw {
|
||||
t.Errorf("содержимое изменилось при хранении:\nбыло %s\nстало %s", raw, got)
|
||||
}
|
||||
}
|
||||
|
||||
// Провенанс нужен не отчётности: по нему разрешается тай-брейк, и без него
|
||||
// запись WARN об удержанной версии не связать с телом в архиве.
|
||||
func TestWorkoutНесётПровенанс(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
mergeWorkouts(t, st, from(t, "d7", "2025-06-05T08:00:00Z"), workout(t, "w1", woWithRoute))
|
||||
|
||||
w, err := st.Workout(context.Background(), "w1")
|
||||
if err != nil {
|
||||
t.Fatalf("чтение: %v", err)
|
||||
}
|
||||
if w.Delivery != "d7" {
|
||||
t.Errorf("провенанс %q, ожидался d7", w.Delivery)
|
||||
}
|
||||
if w.Start.IsZero() || w.End.Before(w.Start) {
|
||||
t.Errorf("интервал заголовка неверен: %v — %v", w.Start, w.End)
|
||||
}
|
||||
if w.OffsetSeconds != 3*3600 {
|
||||
t.Errorf("офсет %d, ожидался 10800", w.OffsetSeconds)
|
||||
}
|
||||
}
|
||||
|
||||
// Внутри одной доставки «сохранённой» версии не существует — есть только
|
||||
// порядок элементов в JSON-массиве, а он нестабилен. Ни исход, ни счётчик не
|
||||
// имеют права от него зависеть.
|
||||
func TestMergeНесравнимыеВерсииВОдномТелеНеЗависятОтПорядка(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
d := from(t, "d1", "2025-06-05T08:00:00Z")
|
||||
const withRoute = `{"id":"w1","route":[{"lat":1}],"stepCount":{"qty":9}}`
|
||||
const withFlights = `{"id":"w1","route":[{"lat":1}],"flightsClimbed":{"qty":3}}`
|
||||
|
||||
прямой := open(t)
|
||||
a := mergeWorkouts(t, прямой, d, workout(t, "w1", withRoute), workout(t, "w1", withFlights))
|
||||
|
||||
обратный := open(t)
|
||||
b := mergeWorkouts(t, обратный, d, workout(t, "w1", withFlights), workout(t, "w1", withRoute))
|
||||
|
||||
if storedRaw(t, прямой, "w1") != storedRaw(t, обратный, "w1") {
|
||||
t.Error("исход зависит от порядка элементов в массиве секции")
|
||||
}
|
||||
if a.EntitiesHeld != b.EntitiesHeld {
|
||||
t.Errorf("счётчик зависит от порядка: %d против %d", a.EntitiesHeld, b.EntitiesHeld)
|
||||
}
|
||||
if a.EntitiesHeld == 0 {
|
||||
t.Error("две версии с разным содержанием в одном теле остались незамеченными")
|
||||
}
|
||||
}
|
||||
|
||||
// Отпечаток обязан различать состояния, а не только содержимое: составной ключ
|
||||
// записи, склеенный до взятия длины, даёт (`a`, `b/c`) = (`a/b`, `c`).
|
||||
func TestFingerprintРазличаетСоставнойКлючЗаписи(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := context.Background()
|
||||
build := func(kind, id string) string {
|
||||
st := open(t)
|
||||
rec := store.IncomingEntity{
|
||||
ID: id, Kind: kind,
|
||||
Start: ts(t, "2025-06-05T18:00:00Z"),
|
||||
End: ts(t, "2025-06-05T18:00:00Z"),
|
||||
Raw: json.RawMessage(`{"id":"x","valence":0.5}`),
|
||||
}
|
||||
if _, err := st.Merge(ctx, store.Incoming{Records: []store.IncomingEntity{rec}},
|
||||
from(t, "d1", "2025-06-05T08:00:00Z")); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
fp, err := st.Fingerprint(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("отпечаток: %v", err)
|
||||
}
|
||||
return fp
|
||||
}
|
||||
|
||||
if build("a", "b/c") == build("a/b", "c") {
|
||||
t.Error("два разных состояния витрины дали один отпечаток: составной ключ склеен до взятия длины")
|
||||
}
|
||||
}
|
||||
@@ -88,3 +88,77 @@ func TestMigrationПрежниеParsedСтановятсяPending(t *testing.T)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Миграция 00007 исполняет правило «покрыли секцию — пересверните»: список
|
||||
// непокрытых ключей это снимок покрытия на момент свёртки, и доставки,
|
||||
// свёрнутые до того, как workouts и stateOfMind стали покрытыми, остались бы
|
||||
// `partial` со старым списком навсегда — а ретеншен вечно щадил бы их тела.
|
||||
//
|
||||
// Перевод ТОЧЕЧНЫЙ: доставка, у которой непокрыта только `ecg`, пересворачивать
|
||||
// нечего, и трогать её значило бы гонять весь архив на каждую новую секцию.
|
||||
func TestMigrationПокрытыеСекцииВозвращаютсяВОчередь(t *testing.T) {
|
||||
db, err := sqlx.Connect("sqlite", dsn(filepath.Join(t.TempDir(), "healthlog.db")))
|
||||
if err != nil {
|
||||
t.Fatalf("открытие базы: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Close() })
|
||||
|
||||
sub, err := fs.Sub(migrationsFS, "migrations")
|
||||
if err != nil {
|
||||
t.Fatalf("миграции: %v", err)
|
||||
}
|
||||
p, err := goose.NewProvider(goose.DialectSQLite3, db.DB, sub)
|
||||
if err != nil {
|
||||
t.Fatalf("провайдер: %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
if _, err := p.UpTo(ctx, 6); err != nil {
|
||||
t.Fatalf("миграция до 6: %v", err)
|
||||
}
|
||||
|
||||
const insert = `
|
||||
INSERT INTO delivery (id, received_at, automation_name, automation_id,
|
||||
aggregation, period, session_id, bytes, sha256, raw_path,
|
||||
parse_status, points, uncovered_sections)
|
||||
VALUES (?, '2025-06-05T10:00:00Z', '', '', '', '', '', 0, '-', '-', ?, 0, ?)`
|
||||
cases := []struct {
|
||||
id string
|
||||
status string
|
||||
uncovered string
|
||||
want string
|
||||
}{
|
||||
{"d-workouts", ParsePartial, `["workouts"]`, ParsePending},
|
||||
{"d-mind", ParsePartial, `["stateOfMind"]`, ParsePending},
|
||||
{"d-both", ParsePartial, `["stateOfMind","workouts"]`, ParsePending},
|
||||
{"d-mixed", ParsePartial, `["ecg","workouts"]`, ParsePending},
|
||||
// Ничего из ставшего покрытым: трогать нечего.
|
||||
{"d-ecg", ParsePartial, `["ecg"]`, ParsePartial},
|
||||
// Подстрока имени секции — не имя секции: отбор идёт по элементу
|
||||
// массива, иначе чужое тело управляло бы тем, что мы пересворачиваем.
|
||||
{"d-lookalike", ParsePartial, `["myworkoutsx"]`, ParsePartial},
|
||||
// Статус `failed` возвращает только пересборка, а `parsed` этой
|
||||
// миграцией не трогается: у него пустой список непокрытых.
|
||||
{"d-failed", ParseFailed, `["workouts"]`, ParseFailed},
|
||||
{"d-parsed", ParseDone, `[]`, ParseDone},
|
||||
}
|
||||
for _, c := range cases {
|
||||
if _, err := db.ExecContext(ctx, insert, c.id, c.status, c.uncovered); err != nil {
|
||||
t.Fatalf("вставка %s: %v", c.id, err)
|
||||
}
|
||||
}
|
||||
|
||||
if _, err := p.UpTo(ctx, 7); err != nil {
|
||||
t.Fatalf("миграция до 7: %v", err)
|
||||
}
|
||||
|
||||
for _, c := range cases {
|
||||
var got string
|
||||
if err := db.GetContext(ctx, &got, `SELECT parse_status FROM delivery WHERE id = ?`, c.id); err != nil {
|
||||
t.Fatalf("чтение %s: %v", c.id, err)
|
||||
}
|
||||
if got != c.want {
|
||||
t.Errorf("%s: статус %q, ожидался %q (непокрытые %s)", c.id, got, c.want, c.uncovered)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
-- +goose Up
|
||||
-- Вторая единица хранения витрины: сущность с собственным идентификатором.
|
||||
-- Часовой объект ей не подходит — у неё есть естественный ключ, она редка (за
|
||||
-- двое суток потока две тренировки и две записи состояния разума при 44 и 52
|
||||
-- доставленных копиях), и группировать её по часам незачем.
|
||||
--
|
||||
-- Таблицы две, а не одна с колонкой рода: у тренировки есть заголовок, по
|
||||
-- которому идёт выборка (имя, интервал, длительность), а у записи его нет.
|
||||
-- Общая таблица либо теряла бы заголовок, либо держала колонки, пустые у пяти
|
||||
-- родов из шести.
|
||||
CREATE TABLE workout (
|
||||
-- Идентификатор из HealthKit. Приходит из тела и ограничен по длине
|
||||
-- разбором: уезжает и в ключ, и в записи лога.
|
||||
id TEXT PRIMARY KEY,
|
||||
|
||||
-- Имя как прислал HAE, локализованное («В помещении Ходьба» — машинная
|
||||
-- калька с Indoor Walk). Хранится дословно; стабильный код HealthKit
|
||||
-- припишет задача словаря категориальных значений.
|
||||
name TEXT NOT NULL DEFAULT '',
|
||||
|
||||
-- Интервал в UTC, RFC 3339. Конец, которого нет или который не читается,
|
||||
-- равен началу: ключ — id, схлопывать координаты нечем, а истина остаётся
|
||||
-- в payload.
|
||||
start_utc TEXT NOT NULL,
|
||||
end_utc TEXT NOT NULL,
|
||||
-- Смещение зоны НАЧАЛА: колонка одна, а тренировка через смену зоны дала
|
||||
-- бы два разных.
|
||||
tz_offset INTEGER NOT NULL DEFAULT 0,
|
||||
|
||||
-- Длительность в секундах, как прислал HAE. NULL означает «источник не
|
||||
-- прислал»: ноль — законная длительность, и потребитель, сложивший
|
||||
-- столбец, иначе не отличил бы одно от другого. Не вычисляется из
|
||||
-- интервала — HAE шлёт 91.746 при интервале в 91 секунду.
|
||||
duration_sec REAL,
|
||||
|
||||
-- Тренировка целиком исходными байтами, сжатая gzip: заголовок, маршрут,
|
||||
-- внутренние ряды и сводки. Маршрут — 95% веса (190 КБ из 199,6 у
|
||||
-- десятиминутной прогулки), а такой JSON жмётся примерно в 25 раз.
|
||||
-- Внутрь средствами SQL не заглянуть — та же плата, что у bucket.payload.
|
||||
payload BLOB NOT NULL,
|
||||
-- Хеш канонической формы содержимого: детектор изменений, а не ключ.
|
||||
-- Тренировка переприсылается каждой доставкой, пока не доедет маршрут: 44
|
||||
-- копии на живом архиве дают три различных содержимых.
|
||||
content_hash TEXT NOT NULL,
|
||||
|
||||
-- Провенанс: доставка, ЧЬЯ ВЕРСИЯ лежит сейчас, и её метка приёма. Не
|
||||
-- отчётность: по паре (received_at, id) разрешается тай-брейк между
|
||||
-- версиями равной полноты. «Побеждает приехавшая» было бы функцией порядка
|
||||
-- свёртки, а он порядку журнала не равен — доставка с более ранней меткой,
|
||||
-- свёрнутая позже, вернула бы витрину к недосчитанной версии, и пересборка
|
||||
-- разошлась бы с живым приёмом молча.
|
||||
-- Без DEFAULT намеренно: единственный писатель заполняет обе колонки
|
||||
-- всегда, а умолчание превратило бы его дефект из отказа вставки в тихо
|
||||
-- неверный исход — строка с пустой меткой оказалась бы «самой ранней в
|
||||
-- журнале», и её затирала бы любая приехавшая версия.
|
||||
delivery_id TEXT NOT NULL,
|
||||
delivery_received_at TEXT NOT NULL,
|
||||
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
|
||||
-- Основной запрос трекера — «заголовки тренировок за период».
|
||||
CREATE INDEX workout_start_utc ON workout (start_utc);
|
||||
|
||||
CREATE TABLE record (
|
||||
-- Род — верхнеуровневый ключ секции HAE ДОСЛОВНО (`stateOfMind`, не
|
||||
-- `state_of_mind`): инвариант «форма Apple не транслируется» относится и к
|
||||
-- именам секций.
|
||||
kind TEXT NOT NULL,
|
||||
id TEXT NOT NULL,
|
||||
|
||||
-- Метка события в UTC и смещение исходной зоны. У stateOfMind HAE шлёт
|
||||
-- RFC 3339 в UTC, поэтому смещение там всегда 0 — это значит «источник
|
||||
-- прислал UTC», а не «человек был в Гринвиче»: местной зоны у секции в
|
||||
-- потоке нет вовсе.
|
||||
ts_utc TEXT NOT NULL,
|
||||
tz_offset INTEGER NOT NULL DEFAULT 0,
|
||||
|
||||
payload BLOB NOT NULL,
|
||||
content_hash TEXT NOT NULL,
|
||||
|
||||
delivery_id TEXT NOT NULL,
|
||||
delivery_received_at TEXT NOT NULL,
|
||||
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL,
|
||||
|
||||
-- Ключ — ПАРА, а не один id. Собственный id наблюдался живьём только у
|
||||
-- stateOfMind, где он UUID HealthKit; форма идентификатора остальных пяти
|
||||
-- секций не наблюдалась никем, и короткий несквозной id в двух разных
|
||||
-- секциях затёр бы одну запись другой молча. Пара стоит ноль: запросы к
|
||||
-- записям всегда идут с родом.
|
||||
PRIMARY KEY (kind, id)
|
||||
);
|
||||
|
||||
-- «Записи такого-то рода за период» — единственная форма запроса к таблице.
|
||||
CREATE INDEX record_kind_ts ON record (kind, ts_utc);
|
||||
|
||||
-- Покрыли секцию — пересверните. Список непокрытых ключей это снимок покрытия
|
||||
-- на момент свёртки: доставки, свёрнутые до того, как workouts и stateOfMind
|
||||
-- стали покрытыми, остались бы partial со старым списком, и ретеншен вечно
|
||||
-- щадил бы тела, которые больше ничего не хранят сверх витрины.
|
||||
--
|
||||
-- Отбор по ЭЛЕМЕНТУ массива, а не по подстроке тела: имя секции приходит из
|
||||
-- чужого тела, и LIKE '%workouts%' поймал бы ключ, лишь содержащий эту
|
||||
-- подстроку. Перевод точечный, а не «все partial»: доставка с непокрытой ecg
|
||||
-- пересворачивать нечего.
|
||||
UPDATE delivery
|
||||
SET parse_status = 'pending'
|
||||
WHERE parse_status = 'partial'
|
||||
AND EXISTS (
|
||||
SELECT 1 FROM json_each(delivery.uncovered_sections)
|
||||
WHERE json_each.value IN ('workouts', 'stateOfMind')
|
||||
);
|
||||
|
||||
-- +goose Down
|
||||
-- Строки, переведённые в pending, Down обратно не возвращает: какими они были,
|
||||
-- восстановить неоткуда, а pending консервативен — ретеншен его не трогает.
|
||||
DROP INDEX record_kind_ts;
|
||||
DROP TABLE record;
|
||||
DROP INDEX workout_start_utc;
|
||||
DROP TABLE workout;
|
||||
@@ -17,7 +17,7 @@ import (
|
||||
// каждом глубоком проходе, и настоящий отказ правила слияния становился
|
||||
// неотличим от нормы — при том что счётчик перезаписей объявлен единственным
|
||||
// наблюдением за этим правилом.
|
||||
func TestMergePointsДребезгНеСчитаетсяСтолкновением(t *testing.T) {
|
||||
func TestMergeДребезгНеСчитаетсяСтолкновением(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
cases := map[string][2]string{
|
||||
@@ -41,10 +41,10 @@ func TestMergePointsДребезгНеСчитаетсяСтолкновение
|
||||
first := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", pair[0])
|
||||
second := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", pair[1])
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{first}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{first}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{second}, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{second}}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
@@ -63,7 +63,7 @@ func TestMergePointsДребезгНеСчитаетсяСтолкновение
|
||||
// Настоящее столкновение обязано оставить след с координатами объекта: одно
|
||||
// число `overwrites` не говорит, какая метрика и какой час пострадали, и
|
||||
// расследовать перезапись по нему нечем.
|
||||
func TestMergePointsСтолкновениеОставляетКоординаты(t *testing.T) {
|
||||
func TestMergeСтолкновениеОставляетКоординаты(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -74,10 +74,10 @@ func TestMergePointsСтолкновениеОставляетКоординат
|
||||
poor := point(t, "heart_rate", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z",
|
||||
`{"Avg":61}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{rich}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{rich}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{poor}, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{poor}}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
@@ -98,7 +98,7 @@ func TestMergePointsСтолкновениеОставляетКоординат
|
||||
// экранирует `&`, `<` и `>` внутри содержимого — порчи значений это не даёт, но
|
||||
// обещание перестаёт быть правдой, а сравнение байтов при следующей доставке
|
||||
// той же точки начинает промахиваться навсегда.
|
||||
func TestMergePointsХранитУгловыеСкобкиИАмперсанд(t *testing.T) {
|
||||
func TestMergeХранитУгловыеСкобкиИАмперсанд(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -107,7 +107,7 @@ func TestMergePointsХранитУгловыеСкобкиИАмперсанд(t
|
||||
raw := `{"qty":1,"source":"Anton & Co <iPhone> \"x\""}`
|
||||
in := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", raw)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{in}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{in}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
|
||||
@@ -129,7 +129,7 @@ func TestMergePointsХранитУгловыеСкобкиИАмперсанд(t
|
||||
// Смена единиц не имеет права молча переподписать уже сохранённые точки:
|
||||
// внутри точки единиц нет, и у ранних точек не остаётся ничего, по чему их
|
||||
// единицы восстановимы. Правило «первое непустое побеждает» плюс счётчик.
|
||||
func TestMergePointsСменаЕдиницНеПерезаписываетМолча(t *testing.T) {
|
||||
func TestMergeСменаЕдиницНеПерезаписываетМолча(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -148,10 +148,10 @@ func TestMergePointsСменаЕдиницНеПерезаписываетМол
|
||||
mi.End = mi.Start
|
||||
mi.Raw = []byte(`{"qty":2}`)
|
||||
|
||||
if _, err := st.MergePoints(ctx, []store.IncomingPoint{km}, "d1"); err != nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{km}}, store.DeliveryRef{ID: "d1"}); err != nil {
|
||||
t.Fatalf("первое слияние: %v", err)
|
||||
}
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{mi}, "d2")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{mi}}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("второе слияние: %v", err)
|
||||
}
|
||||
@@ -173,14 +173,14 @@ func TestMergePointsСменаЕдиницНеПерезаписываетМол
|
||||
// доставки схлопываются, и счётчик присланных систематически завышал бы
|
||||
// содержимое витрины — расхождение «прислали 1000, лежит 700» было бы невидимо
|
||||
// ровно тогда, когда точки начнут теряться по-настоящему.
|
||||
func TestMergePointsСчитаетСохранённые(t *testing.T) {
|
||||
func TestMergeСчитаетСохранённые(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
ctx := context.Background()
|
||||
|
||||
p := point(t, "step_count", "minute", "2025-06-05T10:00:00Z", "2025-06-05T10:00:00Z", `{"qty":1}`)
|
||||
stats, err := st.MergePoints(ctx, []store.IncomingPoint{p, p, p}, "d1")
|
||||
stats, err := st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{p, p, p}}, store.DeliveryRef{ID: "d1"})
|
||||
if err != nil {
|
||||
t.Fatalf("слияние: %v", err)
|
||||
}
|
||||
@@ -188,7 +188,7 @@ func TestMergePointsСчитаетСохранённые(t *testing.T) {
|
||||
t.Errorf("сохранено %d точек, ожидалась 1 (три точных повтора)", stats.Stored)
|
||||
}
|
||||
|
||||
stats, err = st.MergePoints(ctx, []store.IncomingPoint{p}, "d2")
|
||||
stats, err = st.Merge(ctx, store.Incoming{Points: []store.IncomingPoint{p}}, store.DeliveryRef{ID: "d2"})
|
||||
if err != nil {
|
||||
t.Fatalf("повтор: %v", err)
|
||||
}
|
||||
@@ -201,7 +201,7 @@ func TestMergePointsСчитаетСохранённые(t *testing.T) {
|
||||
// оставляет частичного состояния — а значит и не зависит от порядка обхода.
|
||||
// Раньше транзакция была на объект, и восемь прогонов одной доставки давали
|
||||
// семь разных наборов записанных объектов.
|
||||
func TestMergePointsОтказНеОставляетЧастиОбъектов(t *testing.T) {
|
||||
func TestMergeОтказНеОставляетЧастиОбъектов(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
st := open(t)
|
||||
@@ -218,7 +218,7 @@ func TestMergePointsОтказНеОставляетЧастиОбъектов(t
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
|
||||
if _, err := st.MergePoints(ctx, in, "d1"); err == nil {
|
||||
if _, err := st.Merge(ctx, store.Incoming{Points: in}, store.DeliveryRef{ID: "d1"}); err == nil {
|
||||
t.Fatal("слияние на отменённом контексте прошло успешно")
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user