* feat(catalog): deterministic cross-server content_id Replace per-server Sonyflake content_id with a structured natural key derived from provider IDs (movie:tmdb:…, series:tvdb:…, episode:…, local:… fallback), so two servers holding the same title share one anchor for artwork, watch history, progress, favorites and ratings. - internal/contentid: derivation core, SeriesIDFromContentID transform, frozen precedence, SchemeVersion=1, embedded-series-anchor invariant. - internal/metadata/service.go: deterministic id at every mint site. - internal/catalog/history_source.go: resolve show via string transform for anchored episode ids; skip the episodes_pkey probe. - migrations/sql/20260612130000: collision-safe value remap across the 65-column reference graph + COLLATE "C", FK/trigger handling, audit map, working down. Benchmarked against an exact-cardinality copy of cprod-postgres (1.93M episodes, 775k history rows): 2.57x faster history page, 1.7x throughput at 100 concurrent users, 2.7x cheaper per content_id probe. * feat(catalog): re-ID untagged items to deterministic content_id at first match Untagged libraries get a path-derived local: content_id at scan time and only learn their provider IDs later, when the match worker confirms a result. Previously that id was never folded back in, so untagged-then-matched items kept a per-server local: placeholder forever and never converged across servers (re-ID was deferred to a migration rerun). mergeAndPersist now promotes a local: skeleton to its deterministic provider-anchored id at the moment of first confirmed match, via a single new gate (canonicalizeLocalContentID): - target id already taken -> merge onto it (existing rebind machinery) - target id free -> rename in place The rename is a single SQL function (silo_rename_content_id); FK children follow via ON UPDATE CASCADE added to the content_id family, so a fresh skeleton moves a handful of rows rather than the full-table remap the bulk migration does. The guard is one IsLocal prefix check, so tagged content and all refreshes pay nothing, and the move is self-healing under retry. Verified: gofmt/vet/build clean; migrate-validate passes; migration applies on the real schema (up/down/up), FKs gain ON UPDATE CASCADE while keeping ON DELETE; functional test confirms series PK move + series_id cascade + provider-id sweep, and movie rename. Follow-ups (noted in docs): recomposeSeriesChildIDs for a series that accumulated episodes before matching; a lockstep test for the soft-ref list. * fix(catalog): harden content_id parsing and merge per review Address review feedback on the deterministic content_id work: - history_source.go: gate the anchored-episode display-id transform on the full five-part episode shape (split_part parts 2-5 non-empty), not just the 'episode:' prefix, so a malformed id can't transform to 'series:broken:' and vanish at the media_items join. Shared anchoredEpisodePredicate drives both the null-poisoned join key and the series-recovery expression. - contentid.go: unexport the provider-precedence slices so no package can mutate the frozen SchemeVersion ordering at runtime. - contentid.go: add parseAnchored to validate the exact per-kind arity and numeric season/episode suffixes; SeriesIDFromContentID and IsProviderAnchored now fail closed on truncated/malformed ids (e.g. "episode:tvdb:296762"). - canonicalize.go: distinguish catalog.ErrItemNotFound from transient lookup errors (a real error no longer masquerades as "target free"), and allow a matched local source to be consolidated onto the canonical row instead of orphaning a duplicate. * refactor(contentid): URL-safe "-" separator in content_id Use "-" instead of ":" to join content_id components (movie-tmdb-228064, episode-tvdb-296762-1-5, local-<hex>). "-" is an RFC 3986 unreserved character, so a content_id is URL-safe verbatim: encodeURIComponent is a no-op and the id is its own tidy path segment (/item/series-tvdb-296762) with no %3A escaping. The stored value equals the URL value, so there is no encode/decode boundary and an operator can grep the id straight out of a URL or log. Every component is [a-z0-9]+ (or "tt"+digits), so "-" is unambiguous. Pre-release format finalization: this branch is unmerged, so no deployed data carries ":" ids — the migration mints the "-" form fresh and no re-migration is needed. Still SchemeVersion 1. - contentid.go: single `sep` constant drives construction and parsing so the two can never drift; all constructors/parsers and doc examples updated. - history_source.go: split_part transform and the anchored-episode predicate use '-'; kept in lockstep with the package via a code comment. - 20260612130000_deterministic_content_id.sql: derivation and season/episode composition emit '-'; LIKE filters match 'series-%'. - docs/architecture/deterministic-content-id.md: format spec + rationale for the separator choice; this is the design doc the change is derived from. Client-side: the web frontend treats content_id as an opaque string (no splitting/regex), so no client changes are required; existing encodeURIComponent call sites simply stop emitting %3A. * docs(contentid): show why hash/bigint rejected in probe-cost table Add Cross-server deterministic / Zero-join show transform / Human-readable columns to the index-probe-cost comparison so the trade-off is legible at a glance: the 128-bit hash and bigint surrogate are faster but each give up a load-bearing property, and the structured key is the only all-checkmark row. * docs(contentid): order probe-cost table to end on the structured key * docs(contentid): label fenced blocks and drop stray EOF tags Per CodeRabbit review: add 'text' language to three fenced code blocks (MD040) and remove accidental </content></invoke> artifacts at EOF. * fix(catalog): remap array-valued content_id soft references in deterministic id migration The value-remap migration (20260612130000) enumerates the reference graph by FK plus a scalar name+type sweep (text/varchar/bpchar). That misses trending_discover_snapshots.content_ids: it is text[] (excluded by the type filter), named content_ids not content_id (excluded by the name list), and cannot carry an FK — so the bulk remap left those arrays holding stale Sonyflake ids that resolve to nothing until the snapshot regenerates. A counterexample to the migration's "self-protecting, cannot orphan" invariant. Remap the array element-wise in both directions (Up old->new, Down new->old), preserving order and leaving collision/unmatched elements untouched; a WHERE EXISTS guard skips empty/unaffected arrays so array_agg never collapses the NOT NULL column to NULL. Mirror the gap in silo_rename_content_id (20260614120000) with array_replace for the single-value runtime rename so the two stay in lockstep. Verified on PG18: mixed/collision/empty arrays remap correctly and round-trip clean; runtime array_replace preserves order. Surfaced reviewing #155. The jellycompat restart-decode regression and the atomicity-wording nit are posted as review comments, not addressed here. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(jellycompat): pack content_id into compat UUID reversibly so item ids survive restarts Addresses the restart-decode regression raised in review of #155. With content_id now a structured string instead of a numeric Sonyflake, EncodeStringID sent every item/season id down the one-way SHA1 path, making decode depend on an in-memory reverse map. That map is cold after a process restart (the codec is a process-lifetime singleton), so a client presenting a previously-issued item UUID — resume-from-home, deep link, detail page, image, userdata — got "unknown compat id" until the item was re-listed. Make the encoding reversible instead of stateful: - internal/contentid: add Pack/Unpack, a bit-packed, fixed-budget (<=15 byte) binary form of a structured or local content_id. digitCount preserves provider-id leading zeros (e.g. imdb tt0944947); structured forms are self-delimiting; the local form fills the budget exactly. Provider ids that overflow uint64 return ok=false. - Shrink ForLocal to a 112-bit (sha256(path)[:14]) hash so a local id packs losslessly into the 15-byte UUID payload. 112 bits is far beyond any single server's local-item count. No other code assumed the old width. - internal/jellycompat: EncodeStringID packs item/season content_ids into the UUID (byte 0 = kind, bytes 1..15 = packed, non-zero tag distinguishes it from the numeric encoding); DecodeStringID unpacks first and re-packs to confirm, so an opaque id whose bytes merely parse is rejected and falls through to the map. Numeric ids and arbitrary names (genres, studios) are unchanged. Net: item/season ids decode by pure computation — stable across restarts and across instances — with no lookup table. Only the rare unpackable content_id and non-content names still use the in-memory map. TDD: round-trip property tests in contentid (all kinds, leading zeros, reject cases) and a cross-instance decode test in jellycompat that fails on the old hash+map path. Full contentid + jellycompat suites green; production code golangci-clean. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(migrate): make the migration run timeout configurable (SILO_MIGRATE_TIMEOUT) The boot-path migration runner hardcoded a 5-minute context timeout. The deterministic-content-id value-remap (20260612130000) does a full-table COLLATE rewrite + 65-column remap that needs ~20 min on a real dataset (615k items / 2M episodes), so it was cancelled at 5 min. Worse, Postgres keeps the orphaned backend running (holding AccessExclusive locks) until it notices the dead client at a statement boundary, while the goose session advisory lock releases on disconnect — so each 5-min boot retry piled a new attempt behind the previous one's locks. The migration never applied; the server boot-looped. Make the timeout configurable via SILO_MIGRATE_TIMEOUT (a Go duration like "60m"); 0 or negative disables the deadline for a one-off heavy migration. Default stays 5m. All three entry points (migrate-status, --migrate-only, boot) honor it. Required for the deterministic-content-id migration to apply on any real-sized database, not just dev — the 5m cap made the PR undeployable at scale. Follow-up (not here): on cancellation the runner should actively terminate its backend so a future timeout cannot orphan a lock-holding statement. TDD: MigrationTimeout parsing (default/override/zero/invalid) + MigrationContext deadline behavior. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * fix(contentid): require exact length for local ids in Unpack Tighten the tagLocal branch of Unpack from `len(body) < localHashLen` to an equality check. The local form fills the compat-UUID payload exactly (no padding), so a body of any other length is non-canonical; matching it exactly keeps Unpack a strict fail-closed inverse of Pack for the fixed-length branch, which decodes client-supplied UUIDs. Not applied to the structured branch (a review suggestion proposed the same change there): structured ids are self-delimiting and the compat layer pads them with trailing zeros to fill the 15-byte UUID payload, so ignoring trailing bytes is intentional and documented. Rejecting them would make every structured id fail to decode — the jellycompat cross-instance test guards against that. Not a live bug today (the only caller passes u[1:] from a 16-byte UUID, so body is always exactly localHashLen, and idcodec re-packs to verify), but it is the correct contract and zero-risk. Adds a regression test. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Quick <31828688+Quick104@users.noreply.github.com> Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
135 lines
5.6 KiB
PL/PgSQL
135 lines
5.6 KiB
PL/PgSQL
-- Online re-ID support for content_id (see
|
|
-- docs/architecture/deterministic-content-id.md, "Re-ID on match").
|
|
--
|
|
-- The deterministic-content-id migration (20260612130000) does a one-shot,
|
|
-- whole-table value remap under AccessExclusive locks. This migration instead
|
|
-- makes a *single* content_id value cheap to move at runtime, so an untagged
|
|
-- item that only learns its provider IDs at match time can be promoted from its
|
|
-- local: placeholder to its deterministic id in place:
|
|
--
|
|
-- (a) add ON UPDATE CASCADE to every FK in the content_id family, so updating
|
|
-- a parent PK (media_items / seasons / episodes) propagates to all FK
|
|
-- children automatically (the existing ON DELETE behaviour is preserved);
|
|
-- and
|
|
-- (b) provide silo_rename_content_id(from, to), which moves the PK rows plus
|
|
-- the unconstrained soft references (FK children follow via the cascade
|
|
-- from (a)). The soft-reference name predicate mirrors 20260612130000 so
|
|
-- the two stay in lockstep.
|
|
--
|
|
-- ON UPDATE CASCADE only fires when a content_id is updated (essentially never
|
|
-- outside this promotion), so there is no steady-state cost. The caller
|
|
-- (canonicalizeLocalContentID) guarantees the target id is free before calling
|
|
-- the function; a lost race surfaces as a unique violation and is retried.
|
|
|
|
-- +goose Up
|
|
|
|
-- (a) Rebuild every content_id-family FK with ON UPDATE CASCADE. pg_get_constraintdef
|
|
-- carries the existing ON DELETE clause through, so it is preserved.
|
|
-- +goose StatementBegin
|
|
DO $$
|
|
DECLARE
|
|
r RECORD;
|
|
BEGIN
|
|
FOR r IN
|
|
SELECT con.conname,
|
|
con.conrelid::regclass AS rel,
|
|
pg_get_constraintdef(con.oid) AS condef
|
|
FROM pg_constraint con
|
|
WHERE con.contype = 'f'
|
|
AND con.confrelid IN ('media_items'::regclass, 'seasons'::regclass, 'episodes'::regclass)
|
|
AND position('ON UPDATE' IN pg_get_constraintdef(con.oid)) = 0
|
|
LOOP
|
|
EXECUTE format('ALTER TABLE %s DROP CONSTRAINT %I', r.rel, r.conname);
|
|
EXECUTE format('ALTER TABLE %s ADD CONSTRAINT %I %s ON UPDATE CASCADE',
|
|
r.rel, r.conname, r.condef);
|
|
END LOOP;
|
|
END $$;
|
|
-- +goose StatementEnd
|
|
|
|
-- (b) Move one content_id value across the whole reference graph. FK children
|
|
-- follow via the cascade above; this updates the three PK columns and the
|
|
-- unconstrained soft references (same name predicate as 20260612130000).
|
|
-- The whole body runs as one statement, so the move is atomic.
|
|
-- +goose StatementBegin
|
|
CREATE OR REPLACE FUNCTION silo_rename_content_id(p_from text, p_to text)
|
|
RETURNS void
|
|
LANGUAGE plpgsql
|
|
AS $$
|
|
DECLARE
|
|
c RECORD;
|
|
BEGIN
|
|
IF p_from IS NULL OR p_to IS NULL OR p_from = p_to THEN
|
|
RETURN;
|
|
END IF;
|
|
|
|
FOR c IN
|
|
SELECT cl.oid::regclass AS rel, a.attname AS col
|
|
FROM pg_class cl
|
|
JOIN pg_namespace n ON n.oid = cl.relnamespace
|
|
JOIN pg_attribute a ON a.attrelid = cl.oid AND a.attnum > 0 AND NOT a.attisdropped
|
|
JOIN pg_type t ON t.oid = a.atttypid
|
|
WHERE cl.relkind IN ('r', 'p')
|
|
AND n.nspname = 'public'
|
|
AND t.typname IN ('text', 'varchar', 'bpchar')
|
|
AND a.attname IN (
|
|
'media_item_id', 'series_id', 'season_id', 'episode_id', 'content_id',
|
|
'season_content_id', 'episode_content_id', 'library_item_id', 'cover_item',
|
|
'item_id', 'similar_item_id', 'source_item_id'
|
|
)
|
|
AND cl.relname NOT LIKE 'content_id_migration%'
|
|
-- Skip real FK children of the family; ON UPDATE CASCADE moves those.
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM pg_constraint con
|
|
JOIN unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON TRUE
|
|
WHERE con.contype = 'f'
|
|
AND con.conrelid = cl.oid
|
|
AND con.confrelid IN ('media_items'::regclass, 'seasons'::regclass, 'episodes'::regclass)
|
|
AND k.attnum = a.attnum
|
|
)
|
|
LOOP
|
|
EXECUTE format('UPDATE %s SET %I = $2 WHERE %I = $1', c.rel, c.col, c.col)
|
|
USING p_from, p_to;
|
|
END LOOP;
|
|
|
|
-- Array-valued soft references are not covered by the scalar loop above
|
|
-- (text[] is not in the type filter and cannot carry an FK), matching the
|
|
-- gap closed in 20260612130000 Step 6b. Negligible at runtime — a freshly
|
|
-- matched local item is essentially never already in a trending snapshot —
|
|
-- but kept in lockstep so a rename never leaves a stale array element.
|
|
IF to_regclass('public.trending_discover_snapshots') IS NOT NULL THEN
|
|
UPDATE trending_discover_snapshots
|
|
SET content_ids = array_replace(content_ids, p_from, p_to)
|
|
WHERE p_from = ANY(content_ids);
|
|
END IF;
|
|
END;
|
|
$$;
|
|
-- +goose StatementEnd
|
|
|
|
-- +goose Down
|
|
|
|
DROP FUNCTION IF EXISTS silo_rename_content_id(text, text);
|
|
|
|
-- Revert the content_id-family FKs to their prior (no ON UPDATE) form.
|
|
-- +goose StatementBegin
|
|
DO $$
|
|
DECLARE
|
|
r RECORD;
|
|
BEGIN
|
|
FOR r IN
|
|
SELECT con.conname,
|
|
con.conrelid::regclass AS rel,
|
|
pg_get_constraintdef(con.oid) AS condef
|
|
FROM pg_constraint con
|
|
WHERE con.contype = 'f'
|
|
AND con.confrelid IN ('media_items'::regclass, 'seasons'::regclass, 'episodes'::regclass)
|
|
AND position('ON UPDATE CASCADE' IN pg_get_constraintdef(con.oid)) > 0
|
|
LOOP
|
|
EXECUTE format('ALTER TABLE %s DROP CONSTRAINT %I', r.rel, r.conname);
|
|
EXECUTE format('ALTER TABLE %s ADD CONSTRAINT %I %s',
|
|
r.rel, r.conname,
|
|
replace(r.condef, ' ON UPDATE CASCADE', ''));
|
|
END LOOP;
|
|
END $$;
|
|
-- +goose StatementEnd
|