From 2cdc44abe432cf452ac58f33703575346ea60e23 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 23:28:40 +0000 Subject: [PATCH] fix(data): write a sequence's tags in one order on PostgreSQL Each tag upsert locks its row until commit, and tags were written in the order the caller listed them. A PATCH listing them in another order than an upload, a scan or another edit of a sequence sharing two of them could lock the rows in opposite orders, and PostgreSQL aborted one writer with a deadlock that nothing retries. Tags are now written in the order of their keys, and a set the sequence already carries is not written again. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- .../Repositories/SequenceRepository.cs | 15 ++++++- .../Repositories/SequenceEditTests.cs | 45 +++++++++++++++++++ 2 files changed, 58 insertions(+), 2 deletions(-) diff --git a/src/Titano.Data/Repositories/SequenceRepository.cs b/src/Titano.Data/Repositories/SequenceRepository.cs index 7eb69fe2..bf947800 100644 --- a/src/Titano.Data/Repositories/SequenceRepository.cs +++ b/src/Titano.Data/Repositories/SequenceRepository.cs @@ -500,11 +500,22 @@ public sealed class SequenceRepository await session.ScalarAsync($"SELECT id FROM sequences WHERE id = $1{SqlDialect.For(session.Dialect).ForUpdate}", [id], cancellationToken) .ConfigureAwait(false) is not null; - /// Replaces the tag links of a sequence whose row the caller has locked (or just upserted). + /// + /// Replaces the tag links of a sequence whose row the caller has locked (or just upserted); a set the sequence already + /// carries (names compared case-insensitively) is left as it is. On PostgreSQL every tag written is locked until + /// commit, and the tags are written in the order of their keys whatever order the caller listed them in (a PATCH sends + /// them in any order): writers of two sequences that share tags then take those rows in one order, and never wait for + /// each other's (PostgreSQL would abort one with a deadlock, and nothing retries it). + /// private async Task ReplaceTagsAsync(IDbSession session, Guid sequenceId, IEnumerable tags, CancellationToken cancellationToken) { + var wanted = TagRepository.NormalizeSet(tags); + var keys = wanted.Select(TagRepository.Key).ToList(); + var stored = await session.QueryListAsync("SELECT t.name_key FROM sequence_tags st JOIN tags t ON t.id = st.tag_id WHERE st.sequence_id = $1", + [sequenceId], r => r.GetString(0), cancellationToken).ConfigureAwait(false); + if (stored.Count == keys.Count && stored.ToHashSet(StringComparer.Ordinal).SetEquals(keys)) return; await session.ExecuteAsync("DELETE FROM sequence_tags WHERE sequence_id = $1", [sequenceId], cancellationToken).ConfigureAwait(false); - foreach (var tag in TagRepository.NormalizeSet(tags)) + foreach (var tag in wanted.OrderBy(TagRepository.Key, StringComparer.Ordinal)) { DbParam[] args = [Guid.CreateVersion7(), tag, TagRepository.Key(tag)]; Guid tagId; diff --git a/tests/Titano.Data.Tests/Repositories/SequenceEditTests.cs b/tests/Titano.Data.Tests/Repositories/SequenceEditTests.cs index bab97147..c923dd47 100644 --- a/tests/Titano.Data.Tests/Repositories/SequenceEditTests.cs +++ b/tests/Titano.Data.Tests/Repositories/SequenceEditTests.cs @@ -101,6 +101,51 @@ public abstract class SequenceEditTests(TestContext context) : RepositoryTest(co var later = await db.Sequences.EditAsync(sequence.Id, new SequenceEdit { Rating = 3 }, stored.SettingsVersion, Ct); Assert.Equal((sequence.SettingsVersion + 1, sequence.FramesVersion + 1, 3), (later.Sequence!.SettingsVersion, later.Sequence.FramesVersion, later.Sequence.Rating)); } + + [Test] + public async Task WritersOfSequencesSharingTagsListedInOppositeOrdersBothComplete() + { + var db = await OpenTitanoAsync(multiConnection: true); + var archive = TestData.Archive(); + await db.Archives.UpsertAsync(archive, Ct); + var tagged = TestData.Sequence(archive.Id, title: "Tagged"); + var first = TestData.Sequence(archive.Id, title: "First"); + var second = TestData.Sequence(archive.Id, title: "Second"); + await db.Sequences.UpsertAsync(tagged with { Tags = ["Alps", "sunset"] }, Ct); + await db.Sequences.UpsertAsync(first, Ct); + await db.Sequences.UpsertAsync(second, Ct); + var alps = (await db.Tags.ListAsync(Ct)).Single(t => t.Name == "Alps"); + + // A transaction holds the first of the two tags (SQLite: its write lock), so both writers below wait until it ends. + Task forward, backward; + await using (var tx = await db.BeginAsync(Ct)) + { + if (Dialect == Dialect.Postgres) + Assert.Equal(alps.Id, await tx.Session.ScalarAsync("SELECT id FROM tags WHERE id = $1 FOR UPDATE", [alps.Id], Ct)); + else + Assert.True(await tx.Tags.RenameAsync(alps.Id, "Alps", Ct)); + forward = db.Sequences.EditAsync(first.Id, new SequenceEdit { Tags = ["Alps", "sunset"] }, null, Ct); + await Task.WhenAny(forward, Task.Delay(300, Ct)); + // The other writer lists the tags the other way round (a PATCH sends them in any order). + backward = db.Sequences.EditAsync(second.Id, new SequenceEdit { Tags = ["SUNSET", "alps"] }, null, Ct); + await Task.WhenAny(backward, Task.Delay(300, Ct)); + Assert.False(forward.IsCompleted || backward.IsCompleted, "both writers wait for the tag"); + if (Dialect == Dialect.Postgres) + { + // A writer whose tags are already the stored ones takes no tag at all. + var unchanged = db.Sequences.EditAsync(tagged.Id, new SequenceEdit { Tags = ["sunset", "ALPS"], Rating = 2 }, null, Ct); + Assert.Equal(unchanged, await Task.WhenAny(unchanged, Task.Delay(TimeSpan.FromSeconds(20), Ct))); + Assert.Equal(SequenceEditOutcome.Updated, (await unchanged).Outcome); + } + await tx.CommitAsync(Ct); + } + + // Both take the tags in one order: neither is aborted for a deadlock. + Assert.Equal((SequenceEditOutcome.Updated, SequenceEditOutcome.Updated), ((await forward).Outcome, (await backward).Outcome)); + foreach (var sequence in new[] { tagged, first, second }) + Assert.SequenceEqual(["Alps", "sunset"], (await db.Sequences.GetAsync(sequence.Id, Ct))!.Tags); + Assert.Count(2, await db.Tags.ListAsync(Ct)); + } } public sealed class SqliteSequenceEditTests(TestContext context) : SequenceEditTests(context)