From 63db9c8a345dead09fd7b6ae95e05b040a952253 Mon Sep 17 00:00:00 2001 From: cesnimda Date: Wed, 18 Nov 2026 18:53:20 +0100 Subject: [PATCH] fix(checklist): recover only system-key duplicate races --- .../AnalyticsStatsPersistenceTests.cs | 129 +++++++ .../ApplicationChecklistPersistenceTests.cs | 124 ++++++ .../ApplicationChecklistConcurrencyTests.cs | 134 +++++++ .../Services/ApplicationChecklistService.cs | 13 +- docs/performance/NATIVE_MARIADB_20261118.md | 35 ++ docs/performance/PERF-06_ANALYTICS_STATS.md | 6 +- .../evidence/NuGet.Config.gz | Bin 0 -> 68 bytes .../evidence/SOURCE_RECEIPTS.json | 365 ++++++++++++++++++ .../evidence/baseline.exit.txt.gz | Bin 0 -> 23 bytes .../evidence/baseline.trx.gz | Bin 0 -> 2773 bytes .../evidence/baseline.txt.gz | Bin 0 -> 1506 bytes .../evidence/candidate.exit.txt.gz | Bin 0 -> 23 bytes .../evidence/candidate.trx.gz | Bin 0 -> 3081 bytes .../evidence/candidate.txt.gz | Bin 0 -> 682 bytes .../checklist-baseline-corrected.exit.txt.gz | Bin 0 -> 23 bytes .../checklist-baseline-corrected.trx.gz | Bin 0 -> 2396 bytes .../checklist-baseline-corrected.txt.gz | Bin 0 -> 1656 bytes .../evidence/checklist-baseline.exit.txt.gz | Bin 0 -> 23 bytes .../evidence/checklist-baseline.trx.gz | Bin 0 -> 2374 bytes .../evidence/checklist-baseline.txt.gz | Bin 0 -> 1645 bytes .../evidence/cleanup.exit.txt.gz | Bin 0 -> 23 bytes .../evidence/cleanup.py.gz | Bin 0 -> 1173 bytes .../evidence/cleanup.txt.gz | Bin 0 -> 133 bytes .../evidence/full.exit.txt.gz | Bin 0 -> 23 bytes .../evidence/full.trx.gz | Bin 0 -> 25831 bytes .../evidence/full.txt.gz | Bin 0 -> 452 bytes .../evidence/remaining-schemas.txt.gz | Bin 0 -> 22 bytes .../evidence/resources.compose.yml.gz | Bin 0 -> 72 bytes .../evidence/restore.txt.gz | Bin 0 -> 512 bytes .../evidence/serial.runsettings.gz | Bin 0 -> 103 bytes .../evidence/server.txt.gz | Bin 0 -> 1452 bytes .../evidence/start.txt.gz | Bin 0 -> 402 bytes .../evidence/state.json.gz | Bin 0 -> 212 bytes .../evidence/target.json.gz | Bin 0 -> 303 bytes .../evidence/unit-baseline.exit.json.gz | Bin 0 -> 335 bytes .../evidence/unit-baseline.stderr.txt.gz | Bin 0 -> 173 bytes .../evidence/unit-baseline.stdout.txt.gz | Bin 0 -> 903 bytes .../evidence/unit-checklist-all.exit.json.gz | Bin 0 -> 325 bytes .../evidence/unit-checklist-all.stdout.txt.gz | Bin 0 -> 1062 bytes .../evidence/unit-checklist-all.trx.gz | Bin 0 -> 3811 bytes .../evidence/unit-final.exit.json.gz | Bin 0 -> 332 bytes .../evidence/unit-final.stdout.txt.gz | Bin 0 -> 617 bytes .../unit-qualified-related.exit.json.gz | Bin 0 -> 338 bytes .../unit-qualified-related.stdout.txt.gz | Bin 0 -> 625 bytes 44 files changed, 804 insertions(+), 2 deletions(-) create mode 100644 JobTrackerApi.MariaDb.Tests/AnalyticsStatsPersistenceTests.cs create mode 100644 JobTrackerApi.MariaDb.Tests/ApplicationChecklistPersistenceTests.cs create mode 100644 JobTrackerApi.Tests/ApplicationChecklistConcurrencyTests.cs create mode 100644 docs/performance/NATIVE_MARIADB_20261118.md create mode 100644 docs/performance/native-mariadb-20261118/evidence/NuGet.Config.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/SOURCE_RECEIPTS.json create mode 100644 docs/performance/native-mariadb-20261118/evidence/baseline.exit.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/baseline.trx.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/baseline.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/candidate.exit.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/candidate.trx.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/candidate.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/checklist-baseline-corrected.exit.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/checklist-baseline-corrected.trx.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/checklist-baseline-corrected.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/checklist-baseline.exit.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/checklist-baseline.trx.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/checklist-baseline.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/cleanup.exit.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/cleanup.py.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/cleanup.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/full.exit.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/full.trx.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/full.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/remaining-schemas.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/resources.compose.yml.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/restore.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/serial.runsettings.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/server.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/start.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/state.json.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/target.json.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-baseline.exit.json.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-baseline.stderr.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-baseline.stdout.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-checklist-all.exit.json.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-checklist-all.stdout.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-checklist-all.trx.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-final.exit.json.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-final.stdout.txt.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-qualified-related.exit.json.gz create mode 100644 docs/performance/native-mariadb-20261118/evidence/unit-qualified-related.stdout.txt.gz diff --git a/JobTrackerApi.MariaDb.Tests/AnalyticsStatsPersistenceTests.cs b/JobTrackerApi.MariaDb.Tests/AnalyticsStatsPersistenceTests.cs new file mode 100644 index 00000000..351e392b --- /dev/null +++ b/JobTrackerApi.MariaDb.Tests/AnalyticsStatsPersistenceTests.cs @@ -0,0 +1,129 @@ +using System.Data.Common; +using System.Text.Json; +using JobTrackerApi.Models; +using JobTrackerApi.Services; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using Xunit; +using Xunit.Abstractions; + +namespace JobTrackerApi.MariaDb.Tests; + +public sealed class AnalyticsStatsPersistenceTests(ITestOutputHelper output) +{ + private const string Owner = "rd21-owner"; + + [Theory] + [InlineData(0)] + [InlineData(250)] + [InlineData(2500)] + public async Task Stats_keep_owned_results_with_bounded_native_roundtrips(int size) + { + await using var database = await MariaDbDatabase.CreateAsync(); + var recorder = new Reads(); + await using var db = database.Context(interceptor: recorder); + var company = new Company { Name = "Synthetic analytics", OwnerUserId = Owner }; + db.Companies.Add(company); + await db.SaveChangesAsync(); + var date = DateTime.Now.AddDays(-10); + db.JobApplications.AddRange(Enumerable.Range(0, size).Select(_ => Job(company.Id, Owner, "Applied", date))); + db.JobApplications.Add(Job(company.Id, "foreign-owner", "Private", date)); + db.JobApplications.Add(Job(company.Id, null, "Unowned", date)); + await db.SaveChangesAsync(); + db.ChangeTracker.Clear(); + recorder.Sql.Clear(); + + var stats = await new AnalyticsService(db).GetStatsAsync(default); + Assert.Equal(size, stats.Total); + Assert.Equal(size, stats.Active); + Assert.Equal(0, stats.Deleted); + Assert.Equal(size, stats.AppliedLast30Days); + Assert.Equal(size == 0 ? 0 : 10, stats.AverageDaysSinceApplied); + Assert.Equal(size == 0 ? 0 : 1, stats.ByStatus.Count); + if (size > 0) Assert.Equal(size, stats.ByStatus["Applied"]); + Assert.Empty(db.ChangeTracker.Entries()); + Assert.All(recorder.Sql, sql => + { + Assert.DoesNotContain("Description", sql); + Assert.DoesNotContain("CoverLetterText", sql); + }); + output.WriteLine(JsonSerializer.Serialize(new { database.ActualVersion, OwnedRows = size, + Commands = recorder.Sql.Count, Sql = recorder.Sql })); + Assert.Equal(size == 0 ? 2 : 3, recorder.Sql.Count); + } + + [Fact] + public async Task Stats_preserve_native_nullable_dates_deletion_ownership_and_mutation() + { + await using var database = await MariaDbDatabase.CreateAsync(); + await using var db = database.Context(); + var company = new Company { Name = "Synthetic semantics", OwnerUserId = Owner }; + db.Add(company); + await db.SaveChangesAsync(); + var now = DateTime.Now; + db.JobApplications.AddRange( + Job(company.Id, Owner, "Applied", now.AddDays(-29)), + Job(company.Id, Owner, "Interview", now.AddDays(-31)), + Job(company.Id, Owner, "", null), + Job(company.Id, Owner, " ", now.AddDays(2)), + Job(company.Id, Owner, "Unknown", null), + Job(company.Id, Owner, "Deleted", now, deleted: true), + Job(company.Id, "foreign-owner", "Private", now), + Job(company.Id, null, "Unowned", now)); + await db.SaveChangesAsync(); + var service = new AnalyticsService(db); + var stats = await service.GetStatsAsync(default); + Assert.Equal(6, stats.Total); + Assert.Equal(5, stats.Active); + Assert.Equal(1, stats.Deleted); + Assert.Equal(2, stats.AppliedLast30Days); + Assert.Equal(20, stats.AverageDaysSinceApplied); + Assert.Equal(3, stats.ByStatus["Unknown"]); + Assert.Equal(1, stats.ByStatus["Applied"]); + Assert.Equal(1, stats.ByStatus["Interview"]); + await using var other = database.Context("foreign-owner"); + Assert.Equal(1, (await new AnalyticsService(other).GetStatsAsync(default)).Total); + await using var anonymous = database.Context(null!); + var denied = await new AnalyticsService(anonymous).GetStatsAsync(default); + Assert.Equal(0, denied.Total); + Assert.Empty(denied.ByStatus); + db.JobApplications.Add(Job(company.Id, Owner, "Saved", null)); + await db.SaveChangesAsync(); + Assert.Equal(7, (await service.GetStatsAsync(default)).Total); + output.WriteLine(database.ActualVersion); + } + + [Fact] + public async Task Cancellation_at_native_command_boundary_prevents_later_stats_reads() + { + await using var database = await MariaDbDatabase.CreateAsync(); + using var cancellation = new CancellationTokenSource(); + var recorder = new Reads { BeforeRead = cancellation.Cancel }; + await using var db = database.Context(interceptor: recorder); + await Assert.ThrowsAnyAsync(() => + new AnalyticsService(db).GetStatsAsync(cancellation.Token)); + Assert.Single(recorder.Sql); + output.WriteLine(database.ActualVersion); + } + + private static JobApplication Job(int companyId, string? owner, string status, DateTime? date, bool deleted = false) => new() + { + CompanyId = companyId, OwnerUserId = owner, JobTitle = "Synthetic analyst", Status = status, + DateApplied = date, IsDeleted = deleted, Description = "Synthetic wide data must not be selected", + CoverLetterText = "Synthetic private letter must not be selected", + }; + + private sealed class Reads : DbCommandInterceptor + { + public List Sql { get; } = []; + public Action? BeforeRead { get; init; } + + public override ValueTask> ReaderExecutingAsync(DbCommand command, + CommandEventData eventData, InterceptionResult result, CancellationToken cancellationToken = default) + { + Sql.Add(command.CommandText); + BeforeRead?.Invoke(); + return base.ReaderExecutingAsync(command, eventData, result, cancellationToken); + } + } +} diff --git a/JobTrackerApi.MariaDb.Tests/ApplicationChecklistPersistenceTests.cs b/JobTrackerApi.MariaDb.Tests/ApplicationChecklistPersistenceTests.cs new file mode 100644 index 00000000..956acd1d --- /dev/null +++ b/JobTrackerApi.MariaDb.Tests/ApplicationChecklistPersistenceTests.cs @@ -0,0 +1,124 @@ +using JobTrackerApi.Models; +using JobTrackerApi.Services; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using MySqlConnector; +using Xunit; +using Xunit.Abstractions; + +namespace JobTrackerApi.MariaDb.Tests; + +public sealed class ApplicationChecklistPersistenceTests(ITestOutputHelper output) +{ + private const string Owner = "rd21-owner"; + + [Theory] + [InlineData("system-key")] + [InlineData("foreign-key")] + [InlineData("unrelated-unique")] + public async Task Seed_recovers_only_its_actual_unique_constraint(string scenario) + { + await using var database = await MariaDbDatabase.CreateAsync(); + int jobId; + const string spoof = "IX_ApplicationChecklistItems_JobApplicationId_SystemKey"; + await using (var seed = database.Context()) + { + seed.Users.Add(new ApplicationUser { Id = Owner, UserName = spoof, NormalizedUserName = spoof }); + var job = new JobApplication { OwnerUserId = Owner, Company = new Company { OwnerUserId = Owner, Name = "Synthetic checklist" }, Status = "Interview", Version = 7 }; + seed.JobApplications.Add(job); + await seed.SaveChangesAsync(); + jobId = job.Id; + seed.ApplicationChecklistItems.AddRange( + new ApplicationChecklistItem { OwnerUserId = Owner, JobApplicationId = jobId, SystemKey = "prepare-cv", AutoSignal = ChecklistSignalKeys.Cv, + IsSystemGenerated = true, Title = "Prepare CV", Category = ChecklistCategories.Preparation, Status = ChecklistStatuses.Dismissed }, + new ApplicationChecklistItem { OwnerUserId = Owner, JobApplicationId = jobId, Title = "Manual decision", Category = ChecklistCategories.Custom, + Status = ChecklistStatuses.Done, SortOrder = 90 }); + await seed.SaveChangesAsync(); + } + var race = new Race(); + await using var winner = database.Context(interceptor: new Gate(race, winner: true)); + var losingGate = new Gate(race, winner: false, saveOtherFirst: scenario == "unrelated-unique"); + await using var loser = database.Context(interceptor: losingGate); + if (scenario == "foreign-key") + loser.ApplicationChecklistItems.Add(new ApplicationChecklistItem { OwnerUserId = Owner, JobApplicationId = int.MaxValue, + Title = "Invalid parent must fail", Status = ChecklistStatuses.Done }); + if (scenario == "unrelated-unique") + loser.Users.Add(new ApplicationUser { Id = "other-user", UserName = spoof, NormalizedUserName = spoof }); + using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)); + var winningRead = new ApplicationChecklistService(winner).GetAsync(Owner, jobId, timeout.Token); + var losingRead = new ApplicationChecklistService(loser).GetAsync(Owner, jobId, timeout.Token); + Assert.NotNull(await winningRead); + var observed = await Record.ExceptionAsync(async () => await losingRead); + var saveError = Assert.IsType(losingGate.Failure); + var native = Assert.IsType(saveError.InnerException); + output.WriteLine($"Server={database.ActualVersion}; scenario={scenario}; native={native.Number}; message={native.Message}; service={observed?.GetType().Name ?? "none"}"); + if (scenario == "system-key") + { + Assert.Equal(1062, native.Number); + Assert.Null(observed); + var first = (await winningRead)!; + var second = (await losingRead)!; + Assert.Equal(first.Items.Select(item => item.Id).Order(), second.Items.Select(item => item.Id).Order()); + Assert.Equal(ChecklistStatuses.Dismissed, second.Items.Single(item => item.SystemKey == "prepare-cv").Status); + Assert.Equal(ChecklistStatuses.Done, second.Items.Single(item => item.SystemKey == null).Status); + } + else + { + if (scenario == "unrelated-unique") + { + Assert.EndsWith("for key 'UserNameIndex'", native.Message); + Assert.Contains(spoof, native.Message, StringComparison.Ordinal); + } + Assert.IsType(observed); + Assert.Equal(scenario == "foreign-key" ? 1452 : 1062, native.Number); + Assert.True(loser.ChangeTracker.Entries().Any(entry => entry.State == EntityState.Added)); + } + await using var verify = database.Context(); + Assert.Equal(15, await verify.ApplicationChecklistItems.CountAsync()); + Assert.Equal(7, (await verify.JobApplications.SingleAsync()).Version); + Assert.Equal(1, await verify.Users.CountAsync()); + } + + private sealed class Race + { + private int _arrivals; + public TaskCompletionSource BothReady { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously); + public TaskCompletionSource Committed { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously); + public void Arrive() { if (Interlocked.Increment(ref _arrivals) == 2) BothReady.TrySetResult(); } + } + + private sealed class Gate(Race race, bool winner, bool saveOtherFirst = false) : SaveChangesInterceptor + { + private bool _used; + public Exception? Failure { get; private set; } + public override async ValueTask> SavingChangesAsync(DbContextEventData data, InterceptionResult result, CancellationToken ct = default) + { + if (_used) return result; + _used = true; + race.Arrive(); + await race.BothReady.Task.WaitAsync(ct); + if (!winner) await race.Committed.Task.WaitAsync(ct); + if (saveOtherFirst) + { + // Force the unrelated tracked write first; normal batch ordering hits checklist duplicates first. + var context = data.Context!; + var seeds = context.ChangeTracker.Entries() + .Where(entry => entry.State == EntityState.Added).ToList(); + foreach (var seed in seeds) seed.State = EntityState.Detached; + try { await context.SaveChangesAsync(ct); } + finally { foreach (var seed in seeds) context.Add(seed.Entity); } + } + return result; + } + public override ValueTask SavedChangesAsync(SaveChangesCompletedEventData data, int result, CancellationToken ct = default) + { + if (winner) race.Committed.TrySetResult(); + return ValueTask.FromResult(result); + } + public override Task SaveChangesFailedAsync(DbContextErrorEventData data, CancellationToken ct = default) + { + Failure = data.Exception; + return Task.CompletedTask; + } + } +} diff --git a/JobTrackerApi.Tests/ApplicationChecklistConcurrencyTests.cs b/JobTrackerApi.Tests/ApplicationChecklistConcurrencyTests.cs new file mode 100644 index 00000000..c4e35cb5 --- /dev/null +++ b/JobTrackerApi.Tests/ApplicationChecklistConcurrencyTests.cs @@ -0,0 +1,134 @@ +using JobTrackerApi.Data; +using JobTrackerApi.Models; +using JobTrackerApi.Services; +using Microsoft.Data.Sqlite; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using Moq; +using Xunit; +using Xunit.Abstractions; + +namespace JobTrackerApi.Tests; + +public sealed class ApplicationChecklistConcurrencyTests(ITestOutputHelper output) +{ + [Fact] + public async Task Native_duplicate_seed_race_recovers_both_reads_without_losing_user_decisions() + { + await using var database = await Database.Create(); + var race = new SeedRace(); + await using var winner = database.Context(new SeedGate(race, winner: true)); + var loserGate = new SeedGate(race, winner: false); + await using var loser = database.Context(loserGate); + using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(20)); + var results = await Task.WhenAll( + new ApplicationChecklistService(winner).GetAsync(Database.Owner, database.JobId, timeout.Token), + new ApplicationChecklistService(loser).GetAsync(Database.Owner, database.JobId, timeout.Token)); + Assert.All(results, result => Assert.NotNull(result)); + Assert.Equal(results[0]!.Items.Select(x => x.Id).Order(), results[1]!.Items.Select(x => x.Id).Order()); + Assert.All(results, result => + { + Assert.Equal(14, result!.Items.Count(x => x.SystemKey != null)); + Assert.Equal(ChecklistStatuses.Dismissed, result.Items.Single(x => x.SystemKey == "prepare-cv").Status); + Assert.Equal("Manual decision", result.Items.Single(x => x.SystemKey == null).Title); + Assert.Equal(ChecklistStatuses.Done, result.Items.Single(x => x.SystemKey == null).Status); + }); + var duplicate = Assert.IsType(Assert.IsType(loserGate.Failure).InnerException); + Assert.Equal(2067, duplicate.SqliteExtendedErrorCode); + await using var verify = database.Context(); + Assert.Equal(15, await verify.ApplicationChecklistItems.CountAsync()); + Assert.Equal(7, (await verify.JobApplications.SingleAsync()).Version); + Assert.DoesNotContain(loser.ChangeTracker.Entries(), entry => entry.State == EntityState.Added); + output.WriteLine("Native SQLite duplicate2067 observed and recovered; both calls returned the same15 persisted IDs, user decisions and job revision7 preserved."); + } + + [Fact] + public async Task Concurrent_seed_recovery_does_not_swallow_an_unrelated_native_foreign_key_failure() + { + await using var database = await Database.Create(); + var race = new SeedRace(); + await using var winner = database.Context(new SeedGate(race, winner: true)); + var loserGate = new SeedGate(race, winner: false); + await using var loser = database.Context(loserGate); + var invalidCustom = new ApplicationChecklistItem { OwnerUserId = Database.Owner, JobApplicationId = int.MaxValue, Title = "Invalid parent must fail", Status = ChecklistStatuses.Done }; + loser.ApplicationChecklistItems.Add(invalidCustom); + using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(20)); + var winningRead = new ApplicationChecklistService(winner).GetAsync(Database.Owner, database.JobId, timeout.Token); + var losingRead = new ApplicationChecklistService(loser).GetAsync(Database.Owner, database.JobId, timeout.Token); + Assert.NotNull(await winningRead); + var observed = await Record.ExceptionAsync(async () => await losingRead); + output.WriteLine($"Native save error={((loserGate.Failure as DbUpdateException)?.InnerException as SqliteException)?.SqliteExtendedErrorCode}; service exception={observed?.GetType().Name ?? "none"}."); + var error = Assert.IsType(observed); + var native = Assert.IsType(error.InnerException); + Assert.Equal(787, native.SqliteExtendedErrorCode); + Assert.Equal(EntityState.Added, loser.Entry(invalidCustom).State); + await using var verify = database.Context(); + Assert.Equal(15, await verify.ApplicationChecklistItems.CountAsync()); + Assert.False(await verify.ApplicationChecklistItems.AnyAsync(x => x.Title == invalidCustom.Title)); + output.WriteLine("Native SQLite foreign-key787 propagated despite another request having persisted all missing default keys."); + } + + private sealed class SeedRace + { + private int _arrivals; + public TaskCompletionSource BothReady { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously); + public TaskCompletionSource WinnerCommitted { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously); + public void Arrive() { if (Interlocked.Increment(ref _arrivals) == 2) BothReady.TrySetResult(); } + } + + private sealed class SeedGate(SeedRace race, bool winner) : SaveChangesInterceptor + { + private bool _used; + public Exception? Failure { get; private set; } + public override async ValueTask> SavingChangesAsync(DbContextEventData eventData, InterceptionResult result, CancellationToken cancellationToken = default) + { + if (_used) return result; + _used = true; + race.Arrive(); + await race.BothReady.Task.WaitAsync(cancellationToken); + if (!winner) await race.WinnerCommitted.Task.WaitAsync(cancellationToken); + return result; + } + public override ValueTask SavedChangesAsync(SaveChangesCompletedEventData eventData, int result, CancellationToken cancellationToken = default) + { + if (winner) race.WinnerCommitted.TrySetResult(); + return ValueTask.FromResult(result); + } + public override Task SaveChangesFailedAsync(DbContextErrorEventData eventData, CancellationToken cancellationToken = default) + { + Failure = eventData.Exception; + return Task.CompletedTask; + } + } + + private sealed class Database(string file) : IAsyncDisposable + { + public const string Owner = "owner"; + public int JobId { get; private set; } + public JobTrackerContext Context(SaveChangesInterceptor? interceptor = null) + { + var options = new DbContextOptionsBuilder().UseSqlite($"Data Source={file};Pooling=False"); + if (interceptor != null) options.AddInterceptors(interceptor); + var user = new Mock(); + user.SetupGet(x => x.UserId).Returns(Owner); + return new JobTrackerContext(options.Options, user.Object); + } + public static async Task Create() + { + var database = new Database(Path.Combine(Path.GetTempPath(), $"checklist-race-{Guid.NewGuid():N}.db")); + await using var db = database.Context(); + await db.Database.EnsureCreatedAsync(); + db.Users.Add(new ApplicationUser { Id = Owner }); + var job = new JobApplication { OwnerUserId = Owner, Company = new Company { OwnerUserId = Owner, Name = "Synthetic" }, Status = "Interview", Version = 7 }; + db.JobApplications.Add(job); + await db.SaveChangesAsync(); + database.JobId = job.Id; + db.ApplicationChecklistItems.AddRange( + new ApplicationChecklistItem { OwnerUserId = Owner, JobApplicationId = job.Id, SystemKey = "prepare-cv", AutoSignal = ChecklistSignalKeys.Cv, IsSystemGenerated = true, Title = "Prepare CV", Category = ChecklistCategories.Preparation, Status = ChecklistStatuses.Dismissed }, + new ApplicationChecklistItem { OwnerUserId = Owner, JobApplicationId = job.Id, Title = "Manual decision", Category = ChecklistCategories.Custom, Status = ChecklistStatuses.Done, SortOrder = 90 }); + await db.SaveChangesAsync(); + return database; + } + public ValueTask DisposeAsync() { File.Delete(file); return ValueTask.CompletedTask; } + } +} diff --git a/JobTrackerApi/Services/ApplicationChecklistService.cs b/JobTrackerApi/Services/ApplicationChecklistService.cs index aa8cb5a1..6390e54c 100644 --- a/JobTrackerApi/Services/ApplicationChecklistService.cs +++ b/JobTrackerApi/Services/ApplicationChecklistService.cs @@ -388,7 +388,7 @@ public sealed class ApplicationChecklistService : IApplicationChecklistService await _db.SaveChangesAsync(ct); return items; } - catch (DbUpdateException) + catch (DbUpdateException ex) when (IsDuplicateSystemKey(ex)) { foreach (var item in seeded) _db.Entry(item).State = EntityState.Detached; @@ -401,6 +401,17 @@ public sealed class ApplicationChecklistService : IApplicationChecklistService } } + private static bool IsDuplicateSystemKey(DbUpdateException exception) => exception.InnerException switch + { + Microsoft.Data.Sqlite.SqliteException sqlite => sqlite.SqliteErrorCode == 19 + && sqlite.SqliteExtendedErrorCode == 2067 + && sqlite.Message.EndsWith("UNIQUE constraint failed: ApplicationChecklistItems.JobApplicationId, ApplicationChecklistItems.SystemKey'.", StringComparison.Ordinal), + MySqlConnector.MySqlException mysql => mysql.Number == 1062 + && (mysql.Message.EndsWith("for key 'IX_ApplicationChecklistItems_JobApplicationId_SystemKey'", StringComparison.Ordinal) + || mysql.Message.EndsWith("for key 'ApplicationChecklistItems.IX_ApplicationChecklistItems_JobApplicationId_SystemKey'", StringComparison.Ordinal)), + _ => false, + }; + private async Task SyncAutoCompletionAsync(List items, ChecklistSignals signals, CancellationToken ct) { var changed = false; diff --git a/docs/performance/NATIVE_MARIADB_20261118.md b/docs/performance/NATIVE_MARIADB_20261118.md new file mode 100644 index 00000000..3cef3957 --- /dev/null +++ b/docs/performance/NATIVE_MARIADB_20261118.md @@ -0,0 +1,35 @@ +# Native MariaDB qualification: statistics and checklist recovery + +18November2026. Isolated codex/perf-mariadb-qualification started at1db5f488; analytics41134d8f was cherry-picked asbe984f1b, then the recovered checklist correction was tested alongside it. No startup-script, existing app container, persistent development data, production service or model was changed. + +## Actual provider evidence + +Docker Desktop's local Linux engine became available after the user started the local app. The existing disposable MariaDB lane was used with its cached pinned12.2.2 manifest, a generated jobtracker-it project, fresh loopback port, tmpfs database,1CPU/768MiB limit and existing generated jt_it schema guard. Exact observed version: **12.2.2-MariaDB-ubu2404**. The fixture initialises the actual startup schema, uses independent TCP contexts and drops only each successfully-created schema. Locked restore used the existing NuGet cache with package sources cleared; no package versions changed or network restore was needed. + +| Execution | Result | Meaning | +| --- | --- | --- | +| Original statistics, five new cases |3 expected budget failures /2 passes | Owned results/cancellation remained correct; measured5 commands for250/2500 active rows and4 empty | +| Original checklist, corrected native ordering |1 pass /2 failures | Genuine duplicate recovery succeeds; unrelated FK1452 and username-unique1062 errors were swallowed | +| Optimised statistics and narrowed checklist |8/8 passed,0skips | New actual-provider cases pass; statistics uses3 active/2 empty commands | +| Complete MariaDB persistence project |**98/98 passed,0skips**,169seconds | Includes those8; never add98+8 | +| Ordinary affected checklist project subset |**17/17 passed**,0skips | Includes two new SQLite concurrency cases and15 existing service cases; earlier2-case runs overlap17 | + +This supersedes the prior NOT RUN boundary for these specific local MariaDB operations. It does not establish hosted CI, production equivalence, query plans/rows examined, load/p95/throughput, connection-pool tuning, restore/rollback, TLS, physical PDF fidelity or human/device/provider/model acceptance. Statistics' date projection still grows with applied active rows; only the measured roundtrips are reduced. No new cache, schema, migration, controller/DTO or overview change was introduced. + +## Checklist defect and minimal correction + +The original seed method recovered any DbUpdateException once another request had persisted all missing system keys. Native SQLite reproduced FK787 being swallowed; real MariaDB reproduced FK1452 and an unrelated username-unique1062 being swallowed. The catch now handles only the actual checklist system-key unique constraint. Unknown/foreign-key/concurrency failures propagate through existing error handling. MySQL matching uses the terminal key identity, so a duplicate value containing the checklist index's name cannot impersonate that index. SQLite requires its exact unique column-list suffix and native19/2067 codes. Existing missing-key revalidation and detach-only-this-call's-seeds behaviour remain. + +Positive races retain the same15 persisted IDs,14 system items, dismissed/manual user decisions and job revision7. Other pending writes remain tracked after failure. This is bounded recovery correctness, not an unrestricted retry or proof that every network-uncertain write is idempotent. + +The first native unrelated-unique proposal hit the genuine checklist constraint before the intended username error. Its corrected test interceptor temporarily detaches only new checklist seeds, flushes the unrelated tracked user first and restores those seeds; real EF/MySqlConnector still produces the error. The final synthetic duplicate value was shortened so MariaDB's diagnostic truncation retains the entire index-name text. Original and corrected negative runs are retained; these verifier changes are not application fixes. Red test-file snapshots were not frozen at execution; original production Git baseline and native failure outputs are retained, rather than claiming complete immutable red test sources. + +The historical reminders log contains two distinct observations: expected duplicate-key diagnostics and a separate OperationCanceledException stack in GetReminders. Deterministic duplicate races can return both successful service results despite EF logging. No request correlation proves the cause or harmlessness of the historical cancelled HTTP request, and this package does not claim to fix it. + +## Isolation and evidence + +After the98-case run, zero jt_it schemas remained. Cleanup verified generated project/service labels, pinned image and tmpfs at /var/lib/mysql with **no persistent mounts**, retained server logs, then removed only the owned mariadb-test service with Compose rm--stop--force. No down/-v was used. Docker reports this tmpfs in HostConfig.Tmpfs rather than Mounts; an initial stricter inspection failed safely before cleanup, then was corrected from the actual fields. The user's three local app containers remained healthy. + +Exact source/native gzip/TRX, target identity, cleanup and counts: [receipts](native-mariadb-20261118/evidence/SOURCE_RECEIPTS.json). All data/accounts are synthetic; application credentials and browser traces are excluded. The ordinary test source and API classifier were copied byte-for-byte from the recovered worktree; current source hashes bind both test projects. Adding the ordinary test file after the MariaDB run changes neither the API nor the separate MariaDB assembly, so unchanged native evidence is reused. Source/API/tests have no pending product changes beyond those listed. + +AST-only update passed19,974nodes/49,552edges with existing PDF/SQL/symbol-free input warnings; no model processing. Rollback restores the small predicate/count deltas and removes their tests; no data migration or rollback is required. Formal roadmap/security/release gates remain open. diff --git a/docs/performance/PERF-06_ANALYTICS_STATS.md b/docs/performance/PERF-06_ANALYTICS_STATS.md index de5fc167..e1b8d09b 100644 --- a/docs/performance/PERF-06_ANALYTICS_STATS.md +++ b/docs/performance/PERF-06_ANALYTICS_STATS.md @@ -1,4 +1,4 @@ -# PERF-06 · Analytics stats aggregate queries +# PERF-06 · Analytics stats aggregate queries Application baseline `1db5f488f6138e4f0f33749452b7d9f47658f4b0`, isolated `codex/analytics-query-batch`. Roadmap source `271d37d1`, `docs/direct-roadmap/LATEST_CHECKPOINT.md` and PERF-06 in `ROADMAP_TODO.md`, required a measured baseline before combining queries. The only application edit is inside `AnalyticsService.GetStatsAsync`; controller, DTO, overview, schema, configuration, Career completeness and caching are unchanged. @@ -37,3 +37,7 @@ Nine of those dedicated cases execute SQLite. The legacy **null Status** case us **Actual MariaDB execution/server acceptance, EXPLAIN/rows examined, native cancellation and provider-specific status collation remain NOT RUN.** Pomelo SQL generation alone does not establish those properties. Before MariaDB qualification, execute the actual service against a disposable pinned MariaDB fixture with the same ownership/deletion/date/status cases and measure its command/plan behavior. SQLite results do not qualify the standard MariaDB deployment or infer throughput gains. The change adds no cross-query transaction snapshot; status/date queries remain separate, as before. No full backend suite, frontend regression, browser, hosted CI, production workload, provider/model, deployment or orchestrator work was performed. Parent review/integration and real-provider qualification remain separate decisions. No main merge or push was performed by this worker. + +## Subsequent actual-provider qualification + +The historical boundaries above describe this original package. The later [native MariaDB qualification](NATIVE_MARIADB_20261118.md) records 98 passing local persistence tests, including the real-provider statistics cases and measured command counts. Hosted/production, query plans and workload performance remain separate. diff --git a/docs/performance/native-mariadb-20261118/evidence/NuGet.Config.gz b/docs/performance/native-mariadb-20261118/evidence/NuGet.Config.gz new file mode 100644 index 0000000000000000000000000000000000000000..faa25a3997a011f607b341895c0cdac4d1958fa0 GIT binary patch literal 68 zcmb2|=3oE;Ca%q%=gxbd_R-h%(m8qN{N~M?9zN&%eEfOO0Y&_Dw*jR+eRYB^Y~Os* UefmZBt0!3*>>?kedja(V08Zf=CIA2c literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/SOURCE_RECEIPTS.json b/docs/performance/native-mariadb-20261118/evidence/SOURCE_RECEIPTS.json new file mode 100644 index 00000000..c6e9306c --- /dev/null +++ b/docs/performance/native-mariadb-20261118/evidence/SOURCE_RECEIPTS.json @@ -0,0 +1,365 @@ +{ + "baseline": "1db5f488f6138e4f0f33749452b7d9f47658f4b0", + "candidateHead": "be984f1b", + "candidateDelta": "Reviewed ApplicationChecklistService narrow classifier; source hashes below", + "native": [ + { + "file": "state.json.gz", + "rawBytes": 263, + "rawSha256": "14a8a012e7af5f731540d6c539187a1b9590536e43fceb97170154a010dae5b6", + "gzipSha256": "081326aef36aec9879e4b51c063ec87151f287a0417e35224fe54b8372604edf" + }, + { + "file": "target.json.gz", + "rawBytes": 480, + "rawSha256": "3094a11fbbbad68ca01ca9668438564a29b4142752abeafb0b5afcb755ecb177", + "gzipSha256": "eca5d54bd9672274af0fad1e0005a08722dbfa941fb06a20a771ef42b7484f5c" + }, + { + "file": "start.txt.gz", + "rawBytes": 1698, + "rawSha256": "ed8b02e69cda13fa442dac34fc5bf1d046b481cfd77a436c2b001099871667a6", + "gzipSha256": "2bed921ad2d3cc917a6b8360a1cbeea2779e235aa9f25f17dd1219b93710150f" + }, + { + "file": "restore.txt.gz", + "rawBytes": 1708, + "rawSha256": "e2e1cd7fe736511fa682d7f6f1d458fa00be57e44bbd3fb12a4e5e9996f93a84", + "gzipSha256": "e47176aab7f430b34dfe9af83cd3fe03b6c43c0639b23f68b27becaa10335225" + }, + { + "file": "baseline.txt.gz", + "rawBytes": 18572, + "rawSha256": "0c7ba5b475c16b561c955c3dad149a4ebf15ff6796c31438d963420fa70f93a7", + "gzipSha256": "ddbdfe2febf5c72ff53e7fd60fe0650f4eb340d35a1520e1d382e5bd690b64ed" + }, + { + "file": "baseline.trx.gz", + "rawBytes": 26073, + "rawSha256": "76ba28b8d14eac934492ef5d1b9e66ec828015c2e1cea60251fb5db833583121", + "gzipSha256": "06a80722382e3de1c6d1b65fd72eaf1003fbe59116f73edd812e66e5f1112fae" + }, + { + "file": "baseline.exit.txt.gz", + "rawBytes": 3, + "rawSha256": "f1b2f662800122bed0ff255693df89c4487fbdcf453d3524a42d4ec20c3d9c04", + "gzipSha256": "baf0683e1103b94b68d94e8a12d7e144b4e0571e9948de7fb0d85103b045460e" + }, + { + "file": "checklist-baseline.txt.gz", + "rawBytes": 11890, + "rawSha256": "6f18ee0c89d2671fe77885cf9e6fea6eb217b0b881659aa88661e760d52478c7", + "gzipSha256": "eb4e72dc1dcc4f0b825a223fdbb04030494fd8bdc1018598b56990ed9d18b9b8" + }, + { + "file": "checklist-baseline.trx.gz", + "rawBytes": 15303, + "rawSha256": "80a736c8c7f10dd008512a84b85d2ef70fe7781f694e7c4070d278b195b44db3", + "gzipSha256": "949cc22dc48cfde8cb0db7c6c1c660419550f43286c27a985d1a4f1bc3819d5b" + }, + { + "file": "checklist-baseline.exit.txt.gz", + "rawBytes": 3, + "rawSha256": "f1b2f662800122bed0ff255693df89c4487fbdcf453d3524a42d4ec20c3d9c04", + "gzipSha256": "baf0683e1103b94b68d94e8a12d7e144b4e0571e9948de7fb0d85103b045460e" + }, + { + "file": "checklist-baseline-corrected.txt.gz", + "rawBytes": 11916, + "rawSha256": "0b0ecfa6ea70e76a87991e40c3390513d0040388af1ed880956bf322fcce52a7", + "gzipSha256": "ee4585a14dc3db7ec102a612d5206fda90814d02a47ade651912142a64586347" + }, + { + "file": "checklist-baseline-corrected.trx.gz", + "rawBytes": 15307, + "rawSha256": "00948a9f9bbf5ecc0f013e1ef99613248fc57949532d529eab6cd6760fb1b586", + "gzipSha256": "9a8a4f35f256ad58ec336bc33e036f259e005adf0c9b14797fc2ae0acffb2184" + }, + { + "file": "checklist-baseline-corrected.exit.txt.gz", + "rawBytes": 3, + "rawSha256": "f1b2f662800122bed0ff255693df89c4487fbdcf453d3524a42d4ec20c3d9c04", + "gzipSha256": "baf0683e1103b94b68d94e8a12d7e144b4e0571e9948de7fb0d85103b045460e" + }, + { + "file": "candidate.txt.gz", + "rawBytes": 2868, + "rawSha256": "9fb27fcbb311262987c7358323cc95049a4243d4eb6063c06742218f2cbba51f", + "gzipSha256": "af3b11c6ac1d10339a9ee88e124509a34f3cfa2b455867be4753525d4dd74f56" + }, + { + "file": "candidate.trx.gz", + "rawBytes": 19793, + "rawSha256": "765b4c7d01de8d1b2110e7e598d6d3fdb849333bb5135a9a92038110b7639043", + "gzipSha256": "2ffd80b6496310b4ea3260a852008590d92c756ced5d63c4c2d6ef6215464fe5" + }, + { + "file": "candidate.exit.txt.gz", + "rawBytes": 3, + "rawSha256": "13bf7b3039c63bf5a50491fa3cfd8eb4e699d1ba1436315aef9cbe5711530354", + "gzipSha256": "7f636460b48b02e48ffda30b26e6cf24cebee6b983bfd77e79a2f7205a71497f" + }, + { + "file": "full.txt.gz", + "rawBytes": 1204, + "rawSha256": "cdd7e671c5f3f1d448537268abc8ba21179cf8a0ff285ee876a4da8938266665", + "gzipSha256": "5cb8bc51c0dc2114843da48065dc0655a6822465fd127505f8af3910dd94fc86" + }, + { + "file": "full.trx.gz", + "rawBytes": 167700, + "rawSha256": "f132ccbdf646187418f5e98fd2f501ba88ade812e5f12feba485026c0203873d", + "gzipSha256": "1fb3eed294d94ce4d4a173bd7b241ea375134742e655e026fa089dfcffcc6f09" + }, + { + "file": "full.exit.txt.gz", + "rawBytes": 3, + "rawSha256": "13bf7b3039c63bf5a50491fa3cfd8eb4e699d1ba1436315aef9cbe5711530354", + "gzipSha256": "7f636460b48b02e48ffda30b26e6cf24cebee6b983bfd77e79a2f7205a71497f" + }, + { + "file": "server.txt.gz", + "rawBytes": 6252, + "rawSha256": "49263816a13229f4fad67c3408abd580651a1036bc5fd8baed18a9ed806de695", + "gzipSha256": "b4f5d10e4b0bfb7fbdf2f33b02abb02a8ea6ac2e4e8c7e94bcd68a7659703aca" + }, + { + "file": "remaining-schemas.txt.gz", + "rawBytes": 2, + "rawSha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "gzipSha256": "8afc61325213625995e1de8b0d2df70f01b1d5304993484a41cc9df249f00fad" + }, + { + "file": "cleanup.txt.gz", + "rawBytes": 408, + "rawSha256": "6f14edd5ae32f306d6d9fe6e0462430dcc52a7f097a718dc2e233b6d2316a0c7", + "gzipSha256": "6c384ac059786a9bdeb8f4310aac50f6c1053e40ed981c4f56adb41028fe73ec" + }, + { + "file": "cleanup.exit.txt.gz", + "rawBytes": 3, + "rawSha256": "13bf7b3039c63bf5a50491fa3cfd8eb4e699d1ba1436315aef9cbe5711530354", + "gzipSha256": "7f636460b48b02e48ffda30b26e6cf24cebee6b983bfd77e79a2f7205a71497f" + }, + { + "file": "cleanup.py.gz", + "rawBytes": 2509, + "rawSha256": "942ef2644c4d8078f5db05ee2e4227a75e8922433b77dd0f1a791e34cf6b537b", + "gzipSha256": "22ca184e044bf336caebbc3fe0a28d703dcaf0f02080b3693bf9af160ec85f1e" + }, + { + "file": "serial.runsettings.gz", + "rawBytes": 147, + "rawSha256": "5a1dc26f49fa2a9874e30aa868ca5de5973449bd5325d23ae1e3e84fcd560fc5", + "gzipSha256": "cf64d8cbc38b1cf9677671e4e1ea6e9d944e3cea6965235b1df73f37536e8006" + }, + { + "file": "resources.compose.yml.gz", + "rawBytes": 58, + "rawSha256": "102bff56fc8f487656fecb2aa308f4b79972dbca2c259d7ee931546a206d3b03", + "gzipSha256": "e10009fa468b5f677d955e1151b125efbf746380428ab4aecd9aba14d841d781" + }, + { + "file": "NuGet.Config.gz", + "rawBytes": 74, + "rawSha256": "9508cae5f76364f56e80eb97cb16493977243cf38e5cca6284e3d74f83b20a2c", + "gzipSha256": "05db889e8047b1623c559f092197f603f433f4d73b1774ff936736ba488fe087" + }, + { + "file": "unit-baseline.stdout.txt.gz", + "rawBytes": 4856, + "rawSha256": "0bbb5b8c9b03be13f83127bc850d86efe3a1d32864611b37d22e79767ec56eec", + "gzipSha256": "f6999c1104c316f34f69fb96a2f8122e453ff154d89a4015e6e9a4240f041206" + }, + { + "file": "unit-baseline.stderr.txt.gz", + "rawBytes": 193, + "rawSha256": "142203fabbdb3da84197036c836b727f68b527336a2f5b5dd7ac6d4baeab9e21", + "gzipSha256": "2aa698372ab8697ad475e4a6824a8b226cc486cd31a6f3fd5959f45547a64b8e" + }, + { + "file": "unit-baseline.exit.json.gz", + "rawBytes": 478, + "rawSha256": "908fe0dc4832b47d8f80f791afae55e892ae64e6ee1c8da70ebfe95ee46b6955", + "gzipSha256": "eccb1d15d394dcbc636c0930476d2e5a217309bde7a0deb082066df56fb1c458" + }, + { + "file": "unit-final.stdout.txt.gz", + "rawBytes": 1634, + "rawSha256": "d74c1aa6cb7d281ecae4aa24fb2eb4fbcf9bfb7f7529552cdf29755a4f871580", + "gzipSha256": "e5c6468347a57a83c4ecdb6a85687f294214ddf226b34b14e7aea9aa9ef460c0" + }, + { + "file": "unit-final.exit.json.gz", + "rawBytes": 473, + "rawSha256": "d0e384c114af6e1454f9ce7bd596509c635774e9a32d6dbb07c0ee9387650da8", + "gzipSha256": "f71572b28404d28cf64457bdc55adbf0cb76b5d854683ffb119418a3b1e6d593" + }, + { + "file": "unit-qualified-related.stdout.txt.gz", + "rawBytes": 1658, + "rawSha256": "76025529ace3e58eea933eada5957a694af8aa1ef487b3e26dbbb91b2fc21d08", + "gzipSha256": "613acb0ab3cd2d02a9fa93a646374c8b24fc1fcc456765101bd0b79229e0c074" + }, + { + "file": "unit-qualified-related.exit.json.gz", + "rawBytes": 497, + "rawSha256": "f9fb6160fd85e2bb0c4151931742847a235df35361865f6bc3b62fe148f78fc7", + "gzipSha256": "5ec423cd4f69b05058ed1c9f9122dfd87d13f1a8c43305e4c96e4746fc0b9220" + }, + { + "file": "unit-checklist-all.stdout.txt.gz", + "rawBytes": 3368, + "rawSha256": "527f0a8189d6c04d32b8afad1f182034397e101d9729259a36af87376c7ebecb", + "gzipSha256": "579fab8fa01132747591fcdc15007e29484f755785b9a54641fb25cd8a633b95" + }, + { + "file": "unit-checklist-all.exit.json.gz", + "rawBytes": 472, + "rawSha256": "80f0fea9a71d254f6fbf3582f4029447e2399710a93cdc70692f22ce528d713c", + "gzipSha256": "23b9b1bca5c2aa2e9ac1ce26abb33f3844883a9d6b2c7c69106f27e4aa459a72" + }, + { + "file": "unit-checklist-all.trx.gz", + "rawBytes": 27089, + "rawSha256": "6ff38bc16958b118cdea606df44f1c69114b79d7f4ff4069c9ef9cfa8b80c99b", + "gzipSha256": "f9e28cc034f78897835ae493485adbcd8d7f95feeb83d4bd5f13eeb9a71dee83" + } + ], + "sources": { + "JobTrackerApi/Services/AnalyticsService.cs": "0859ad9202bbaf4de810f8b1bc9946cbed061f69105c02993f079715f59aa2b1", + "JobTrackerApi/Services/ApplicationChecklistService.cs": "0c807ab96cbb4a638d3f5ba62b2608cdfb599751df2de4e3d58b6d599b69b5e8", + "JobTrackerApi.MariaDb.Tests/AnalyticsStatsPersistenceTests.cs": "7b95ba1a69456aaf61aa6fd7825e7f0374756d6997066275b8e48f77910b9e68", + "JobTrackerApi.MariaDb.Tests/ApplicationChecklistPersistenceTests.cs": "4e455291fdc786ed368891cd20c0aec3fac20fe32b84201fbebdbd784ab19bf0", + "JobTrackerApi.MariaDb.Tests/MariaDbDatabase.cs": "1375d97093f686f77d511ef6d81ad2d62ecf329aa6e7bf53036cd6e199035e40", + "JobTrackerApi.MariaDb.Tests/JobTrackerApi.MariaDb.Tests.csproj": "2df22a5b79fae14566b437081932218254eb811c8dc1b2af3d51692d8e0d6825", + "JobTrackerApi.MariaDb.Tests/packages.lock.json": "0389a52bfdf31aac07feac5c2ad2ce6771d9b450c899caf9c53ef7ecace0db49", + "JobTrackerApi/JobTrackerApi.csproj": "50164c5dceafc805cc73018bfcd444428736029f6fdad220e4ff07cf38e116c4", + "JobTrackerApi/packages.lock.json": "f63bbf68503fd46effda290a29551ebacac84d0faf8c367fe28caa11ec404abf", + "JobTrackerApi.Tests/ApplicationChecklistConcurrencyTests.cs": "b8c520e15d7886b501d39367acaa4e08529b0605a8f470242eec09c8ae23f84c", + "JobTrackerApi.Tests/JobTrackerApi.Tests.csproj": "6564ff0044af2ce8c55d557b180c57e16e238395424778878b56eb9e3e082c0d", + "JobTrackerApi.Tests/packages.lock.json": "548f67d1ef3b5a9acfe5fc6124891583b6073ac4b6ca515241330e097152bc4a" + }, + "trx": { + "baseline.trx": { + "total": "5", + "executed": "5", + "passed": "2", + "failed": "3", + "error": "0", + "timeout": "0", + "aborted": "0", + "inconclusive": "0", + "passedButRunAborted": "0", + "notRunnable": "0", + "notExecuted": "0", + "disconnected": "0", + "warning": "0", + "completed": "0", + "inProgress": "0", + "pending": "0" + }, + "checklist-baseline.trx": { + "total": "3", + "executed": "3", + "passed": "1", + "failed": "2", + "error": "0", + "timeout": "0", + "aborted": "0", + "inconclusive": "0", + "passedButRunAborted": "0", + "notRunnable": "0", + "notExecuted": "0", + "disconnected": "0", + "warning": "0", + "completed": "0", + "inProgress": "0", + "pending": "0" + }, + "checklist-baseline-corrected.trx": { + "total": "3", + "executed": "3", + "passed": "1", + "failed": "2", + "error": "0", + "timeout": "0", + "aborted": "0", + "inconclusive": "0", + "passedButRunAborted": "0", + "notRunnable": "0", + "notExecuted": "0", + "disconnected": "0", + "warning": "0", + "completed": "0", + "inProgress": "0", + "pending": "0" + }, + "candidate.trx": { + "total": "8", + "executed": "8", + "passed": "8", + "failed": "0", + "error": "0", + "timeout": "0", + "aborted": "0", + "inconclusive": "0", + "passedButRunAborted": "0", + "notRunnable": "0", + "notExecuted": "0", + "disconnected": "0", + "warning": "0", + "completed": "0", + "inProgress": "0", + "pending": "0" + }, + "full.trx": { + "total": "98", + "executed": "98", + "passed": "98", + "failed": "0", + "error": "0", + "timeout": "0", + "aborted": "0", + "inconclusive": "0", + "passedButRunAborted": "0", + "notRunnable": "0", + "notExecuted": "0", + "disconnected": "0", + "warning": "0", + "completed": "0", + "inProgress": "0", + "pending": "0" + }, + "unit-checklist-all.trx": { + "total": "17", + "executed": "17", + "passed": "17", + "failed": "0", + "error": "0", + "timeout": "0", + "aborted": "0", + "inconclusive": "0", + "passedButRunAborted": "0", + "notRunnable": "0", + "notExecuted": "0", + "disconnected": "0", + "warning": "0", + "completed": "0", + "inProgress": "0", + "pending": "0" + } + }, + "isolation": { + "name": "jobtracker-it-fc0e8c29a256416d8b911f07f80fef8d-mariadb-test-1", + "id": "e4e7603940fdd67f7e24787867036f8436b1fc7320c1c36f6e1d5fdf67a0aac6", + "project": "jobtracker-it-fc0e8c29a256416d8b911f07f80fef8d", + "service": "mariadb-test", + "image": "mariadb:12.2.2@sha256:42a27baaba3e8f3f0159d16381d5a7156661aa91dcc65f663cabb6a6f9503c00", + "tmpfsDatabase": true, + "persistentMounts": [], + "memoryBytes": 805306368, + "cpuNano": 1000000000, + "port": 56408 + } +} diff --git a/docs/performance/native-mariadb-20261118/evidence/baseline.exit.txt.gz b/docs/performance/native-mariadb-20261118/evidence/baseline.exit.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..92386c0562e12f031d40ebeb551000144681260a GIT binary patch literal 23 bcmb2|=3oE;CNASAPnj5=9h}_H4CDd;Iu-?q literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/baseline.trx.gz b/docs/performance/native-mariadb-20261118/evidence/baseline.trx.gz new file mode 100644 index 0000000000000000000000000000000000000000..7fcd2e78402141bf39fb102c8671c09350f91775 GIT binary patch literal 2773 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 b=Z=RqMOEr=v<#YJ)5re@fMj@D*<}C#R*7n1 literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/baseline.txt.gz b/docs/performance/native-mariadb-20261118/evidence/baseline.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..399754b00771388e28518cfc8ef90677fc8b099a GIT binary patch literal 1506 zcmV<81s(byiwFP!000023hi8fPvb@qoxdyfJGfC*g&r}Gz*S9kRVjp)>Ml^oQB?;* zkeDM}NYdDWyH@Q-Z~Nx0?bsm+*Fq_9Bg@9#8SnghyE{8U{_9UqJo!O-ax4uQ$dNSV zjRd$`mA33{B2O%d{-s*q>Hzv zTe6S#HhFf?+QE4QeN@XXu918xzAVn{!H4_~j*sOdne8=SUZgs&gU1I~0BP!@$K%mi zR^EoUr}v(XMAGVkcZl9S*q|OY58sA|Jt^Y84qrB8jeZRHc3aI(;`tWB(4mj6%H<)pJ@N{YOJNip8?Yyhh z?KCnW_3wfnFGe)AYH^+gqkQk*H@6SO-d zctGl>wDSTS4IujkeDD?8Kf_r7%B!+~=!CIf7Kr;U4n_Y0N5&|w3lpPU$YE;M>N-N_ zlT4ha9e>>Uk*sxksD^8dU4ZeZ-gt*dbUEKn(pF9N{Oobyd@~yZRibkc z&k>G#z}aAj^LUTi)*z=z+$QtIxLq4Wu8xo&b2GK-T0{Q>+PlfI?(7<2Sn+Yr*`k}{ zb}|x48=Q|i@qBTgNAg{a;tJ={gVZ}CuX(UvbqM1XyPApBD%%6D3O?RRR@EYVO*}lL z6)JO&)L}fIw;0nCzOQ{MD*ACAkYKVB&nnvH`mV;ZS5iHk7d2{L8o|7tdK_Id_8(K6 zbry)=yE3EdVy+QsbFF{udDzWjrTo=&1yh`rGe|NN8Hx-=hNAx$MI|2Uy)LsCw{r?J z>tK|wgSv+rFeB1kk;e9dRt>oZCtixuouKPGzqYCrwNYhlahKQUbv!o+(^dC3b`i}E?pxerZr-@XAkThPqI(~vTr;&fPWyY9{yQon%InzK*u+s{2Ez8j=_ zsZEZDthUdtk-o-UZa}O?xqc3rNfu&H-(TMrAFy}lGMd#PvGI>I+(dutab?Qo*IBB? z?(Sk&{12k{Z|q)=YX_r<1y}4&o+^mI$Oj!(^>kHVOzoS5pZC=ySrdn2IGLY-!AaOz zi!+aCB8CjD_iLs}y!9R9@)CKFhZX6p&|G%~e;>+k2-A0gYVpmhkCT2uu-a_iJ4;rXwQ7h}L#(D|C^8foimWpG z;3~6Lm$kaARZFZcYn2JB%UT`H>atdswb}1})nzOE-)^hRdRCLY)-(6D9$TJTk6pHU ztkpoQl4d9}6d8)F9{T~;W2e_*m#r3SwOFf=SS{A75mt*ev_9%u?0AK2Czr))HNw?- zst+jZ^wV!soG_bnT4l5DQk?ZA-|BGRrARVHpLyWh)F;_$*C)*HN@F#!YNldR;V9f@ zpWzj1nbcj_-R4Ldr@JxSNWX-UrLB;*PArb>t@1k=%gkh*W;g$;NcJlw?yDbv16@%! I4U9+t0K57A%m4rY literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/candidate.exit.txt.gz b/docs/performance/native-mariadb-20261118/evidence/candidate.exit.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..8ce2703e763195e26135c42867f9c1a89cd9bcd1 GIT binary patch literal 23 acmb2|=3oE;CNAR#Pnj4lt`6*D266#669pFl literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/candidate.trx.gz b/docs/performance/native-mariadb-20261118/evidence/candidate.trx.gz new file mode 100644 index 0000000000000000000000000000000000000000..9525b525765d8c04b9f6a97cd2d1a4452d3cd043 GIT binary patch literal 3081 zcmV+k4EFOMiwFP!000023hi8NbK5o&{@$7U4;bA{V_yRaAi)AMPjJU$_NHS+Zl@Vx`#+Dr z`#7DT_d3m@B;IM!HfbRp%S1)->z!7ShuCj@_wAp)dOXruepJLLQadfJSs;BWv9MeZ zGbITY+;y;{eBm(`O2SwR#bT;=T6;+xC+YWl{o!E$S#K9v#BwpEnEHtNU5j@e-a=^+ zzsPh7(mIQysS?N4X)OfW#o12lB+qBvPG=g)G|7@MZ_8xb$>fQiimdZ8$_gfLXSt$RA)%0TIA(bE_4{pb!gk%C6>*yWu@ zmWwpMOp>*2>Vlv>mkgsg%1$nd+N4XZHno_?sXrI()T+a!40WD^E?I3+r9)9n@>b;v zNi1$Dj-_%HW`s)2rNyxJ11oT}Z3S9XR)E2JdNxT;r#jA!#TR==Ns`Y!HJ*EFyijrs ze=R;Xo~qUAEbCPrI?@?vmCfgR5l4B6nes5wAGIuu_4h$(zjtW^TFb3in;P3yez<;uWXJrSS*xM`yO={NM%CWVHiLN2Idq`Q7i)Af{0WKJS`aa{52u9 zJZf+VX%i4y12rxHyun0|72q-(D?QOAl#>rJ3~&<7#siWohm4hbTX(k}4dmA)K1sJdI}A zRu=t3cM;Uj?HeK0^C8ZdeGO8bHt{VFYG(ta&SjlDiPT1ZZ-CT)wsvI>MCxTl23y_M z<=AaKY#kam9wi^LRu|m!5U4|0AYs>j*c!f@w7S2vhW&&7-U#g-z8H+Q{<4jBhv>K< z#3iF77n5r9Vg2*o?y!HH9>+$Vzx~)Bpuyn?ZB;UFNcDfa`foq$nXIN&wY!Z*MxL6p z`-9%nG;lFsuJz5cJLs(t?Lo5Loy{iET)5Q0?(d-Q$G{M>+$Q6z6s=A@CBSLd$sVE@_v2w4E=D@<#$SCO5^(K4L(AYtVfTy|5dRTkU&q9&^lybSm& z@qU>pSK8%j3w{F5dtj%n#)euw_osPbe^@$T@Z#WLd%N}PzrF+w2yDypyijAIfqJr# zF`zKi!%)_waD2s_&|1&{pNEc?+QYyF1cv3jg>4B%OnKVjp+%V+@H;^RZb$-{$EfG? zYe<0Gb{yY!32Q(C=Cb@wl7L2D|6(NI90jm86ktOEHWc8GMghJ|HM4~$WGFP&w)A0{ z8ZaEVZV0K_r`%T#k$h=U>v}{H9fnvlUqUM6rli60*5+Ecf|J1WyvEgR;kUgLE#FQc zQ-501bXmt_V(y@ilX!AEj-aB6GKY?fIC@u@+lO(Mry`2;txW0|W=Xo}>vu(xKgv#F zv?+e8Ppkc#6*eu`J&uy&z4=7Ic`$&JlZ;}8jor`FaJwRcSA{Ycc z*#GI-0xTr4 zb?A7$BF-YtEQ@hsa~E@<9hio`jeYnRhk>9$KwVdm;I7;}x)E`-+njRd689S7Xtyoy zFpqc*h~r%LZW6~vj{lN(k2bfDHr#Q;9XGd+Hn)%N#O))?mQX|-g{ftpdkN)X5lR~q zUrI{2wEU1Qh=6tob3$rkEnOEA%dxRkG=METl+5;tqx793+(lfLLalHmdn?)veABbY zHME~%BJw=XQV!D;3k7VAXd$p-9>9b- z)ZyF>cfuX@Z6|2Hlc-7V*ZM zrFh#Dah&8xD1{(iiZUROK=LG-D3m52y0BA^QbyAP3n(<}V6^q>O%9kD+o2OkP69@K z&XnzQK^S)eUk4$q;6wLS`_;-geq}h+U^qJ3-5-q5tEWFT4*5@0z$^6h@TkB4!vOu% z{~5IVfH5q`|V5X(J$MyE{EKS}3y0c?ZEv>*uGo%uk9luF}H{xxMCy5jj z925Yk*m9 zR7dAcbrohxQwb$zkgrXata5f$!IHGw>3oD5kau2Yb*C^8XR8C_N=OM}HiKjjYuW5` z?+4A>if;+gg%=iqcGu#kYIwSL5!9%mY*hp`>s{MK(C;ULek;m(@8YTv(O(r;&DIo~ zxM~(x4KRBaT{na7|FbTAZqxX^i=akr`KuzR*&6_x2wHn(`dpaa3!--~nO>u(zblzu zqX*5Kc-k<%&+MbQcVX42d1+NxHS3ewgw^kb=>4Y8%I;lgHF`|BDzutC5#5B=A7c%* zj#tF*UHmk91%Kr|h(>SwZ{lZ-jBgzvT@g&xrynjpeky&|kAXMpv*%IsL#H?VlEW=O z6>+l%ubtIeHhYWzmY)e&o0iSq-@fGw;%n2g+3RJue1C0iS~h!a;Fj+ttWC>iP1m>V z>Ry|c%{szv*>bivEt_@E+_F9AHd&#vMW~f)Ulcio*Dl_=gz!u=a-MB?6!d-pt=W&vpy?&J^Jdh!7cY!n7(H& z4)`{x*+o|nk=5ha_VPGdbK`Q@!rn+D@t=+ZgYqcd;D XsiADXjn=72-M9Y(bZ{MyQB42b%!Ni-ov4<;H?XfNVnyX>|L z3#`jhseiosy>EtPtGEa2MPeolGw=8N-kZ1IzZo&|PL^^dBgrL@P-YV0)RRmS@LKX3 z`y1)XScXzSQl+jTGnN6)OPS&vg0ljp$5SG=RD1Ik-9K0q9q_e}BbQ>@4G=m7Ar^1igwhm3_(gow6rXISY^_Ri#nxy{H?*#RxC{4Ih^h<#_t zGRuaX%5!N-N1n+MkTddyz89>>HSQa^;H{9Ss6q$3O7-E@fW8FXAWN;6L2N6Ya!@UE zTjSP%Wy5+H_}s>6h>C$XgBmDGYubq5G4U}PM&V>a=%?(Cu*}+mezDj08Tkb?)xy@2 zLqe;gnhnHKU}d0prH!>g3@%sed+$Ciz)2&$ldm4#HgimgYI_e>n)%0r@5w*Ya~+s@ z6h86w*3Y~;Ylkxr>#=_LtgNfZZjNrLh8?c2Feak^5&jzp>-4em0a%VWt8z%V$=;O9 za&l`PuYjNPdBnP00{LBSZtuw&%$!rmb}-X*S1%hm!OiLFZ^)^b6DK#}i_)6TUajA{ zM6n5KRzbmiAKWz5r51aBx)-d3!6{}WRm(AJ8S$OYSta)+m{975mRGEE=xgbC8D$G* zx$yqZX-B87d-rd>?e0I+o3^Y$%>HpvExe3I)gp3%=Y;(BOu(Cv7QsRR3!Ad816F87 z+@5fbwunvO(U}mR?K);m#^+x(bE+E>^^U1BGVQzcEO>B4AGSoG1+;dd_jcu4>Ek3aW*JDS>AmUJjW)#=%lBEMIQ=Lln`u|bsE`RvP@nh zX;O_ix@Wm|BN;|Xl%HOw)Yc5!a9q=BM7y==FqMgr5^Tw9M7aoA5z9{L3T}p>r<)FD zf$w8#dOl{MOR*d1t{V`K`i@_r0Lq495vR+!NTfo1b#;`cvhmcc@ziW(rULVpZK>%tJG6?$N$5rEN-i(N)+EPUqK)Fw>m zVFyXLTS+^P!7VBXW?c8NE*Qg{Iv)II5zF%&h(TIOAC~z1EA@{v7MzJ}u!yu5EQ{FC z*OV=}Hdrj;C@8~V|5OBLag@tfD)@5=Q7pk^nX||^u)UfNgQn9-s3Qfx;RBr-CB>ZMslU_u(0_%9W0AXSVJn%T6$$bmckWtJ$ zhhy&9RuF`N&8go(X(3?(Ab!B2Snx{0^QiKV8@O3Igk8ApyyYYZ#eG4uel7A_Ir@iJ`$iT>1SeF8sov zI(>{9FZI{l^B7V}8PzA$G9DwS5;=P(`uhwrK_bREN;6a}IFkY~6r4seM_Kx*2N$&# z1X|E47ElNPKBJVe9M^U?7L?GGmVgW+fwUH8JWm%eylQ3Nygy9zz z)K3OED3IDXSK+v`i&TIWndqT6EG`6!py(BG{PW+>hmU_6oi89}1n(gU!fCkk;^K8M zN@OIL2N`77r!+g;2j^%*|8?oP(Rm;iY9hOpnn9VzJ+MNl-s?7|T(WN>p@OI~BA&n{ zljtw6DifJOalHuJT@)o~)SFHqX~5d)t1NvFXyj9v4n*)2;$VSz8syXWssEmxNgSsE zi?Lro&`uX33-MeT&3*g<9vFqS!P6TiHf=SrAn(OdB9QG?_-^rPhnHh*@!I0`?eW4G zqfr8{vQROK;0#Gs)=-$GbF|3B$0#jwq>NK)5lE{teo_6_N_qG5TE5r4^g7<_UZ#C* z$e<;d;kr~{VFRh7mSbZN_#L(w6^h!KmdRFRP*^&(LSkYO*f!P;%ftaEKno2s45;bq z78ehS3>Hbrd<4gp?Clw$p}`^on7sD|MrdlLZQHI+S}?*!)_#zTuvJLhBO|=(qZKXG z?KN6BEUI`BfUL}x=n-!Q@JGc~@c7@YIogW;KZ*ImO1xQ>0|x|lLM#EiiU-40EY`h-);*LrNWqjOz^Ar{mPFcTib zh7C8Ho?tffbl-8D2Suy$C1{)9t;Gg}idw|5oG%b6TO-7A%vLS7M%MUhLiLKlyZgRd zY;A(!9tqXTJ8h{H!763MCk$zgxsa-jwnmR`#jIwN^6}5a@=HXjO`h#_*E`!~Lw+b! zBfsp8T}{QhNBP++wc6o^iP2A&T3rBD$NcY}b6hV|V}FtZcWIz2jo}E>>27u^t1Z z)k@W+kWd44Ox8;dbeKxj5MfAtR~4B%;IpQ95Xb0w%DCXDenzF0c+@18?O@k3!B2+4 z;1hQ+rQjq%Y}@DT@_bh2*GGRQ#T@F#^0Tdh#*+QCNFeQVBvZ-ae#dN_Ab5GPC>Oq9 zN~b(Up*|WQqM9S%A%Gv2-k`hu%=|Pf?}N`#0?8S~MXr{aYM@f|v`__PuqK$KWl3Rv zESl@lg#mEQqZ~9PWiz}S_{6fLJOrj!-Gx}Jo(a|UT?VV!>WL!Zjo=0HS60!@8v6Hh zRW&pyYN+l<=$fv-MXTXAlk)XEsLCYzXlSlx{9=2MIMiZ6q+)*|TQQ0}{wUI{;wS~H4yT9tYy$8{0{;`2{tSyjRAh$q%1(3Ji z!D*wmdh55W(%U1e-}}hwCO^5FL+*!OtZVva^x~4at?0%29c}2vy8M=2d_@iVF@XF5 ziuo4EEszfx$a|v~>uSG1FD_f~e{%kD!(<83XxRcdD1TK~HY8fK60RHqxOxQOs7TaN zoP5={sYf=RFS+PJ{358zS#6rEZwGNb53Oakj1e$zpg#B>U4a^t(wjn1?}vj z-wy`k=WkUb@O=F=MGe(A!cHApwsg<*+GDrMhwq8q)%L)_27N2@02 z8l*VoT&Li1hJHtN*;B{AgZ2T&c0qlBQ6fbft>@_V(OyUU5#B$6O6WW2?QpEj*i#-x z-M*3ow0B6egVrv7b;u)9dbo$`jdIo8L=GFV;H+s6jX5JZHMOEKn}!WUO9S#~VaAS? zQBw*-)4=#H(b0%k?V^2e?A+_@4>3|WM4XH!#5yu^8nT4A`e-kxSzK3;!K~G_*c)!E z<4GjFR-dhQXSv2MwK_XSSF-XCFCLSBZ=6A3-)iBIyLYnBo5bzq_`}J%e!Q=oWRb*= zMy;9%mtEMVMl%gRg@(oZxM~x++@-JbL18@mjM|Sqx2&TG{h2v)w97s;pV;PNh*rbr zEQ2<$7I~LhuGIHC|at>(chP9>X>ytL*Dm^=2lXDqsxK?J(Q|Uv>14kZQ zLvwTJjqXe6c>^sS(%0xmcpUc$&*CbcWyLijLC(6!va;eD`O3Ld27bTgtQVlz1>WC78>?vljH@(NfC2`+1DxS-*)}}uV2v#D3?gMPE@sE8PUcyEaA~!(D8SyA~inqk?tBg&PjHt+Z&k}g8vbvI%t;ihGi!1el z0HZsfb^9bTj;ib@7C)N$yJR$6kE?%?EZWMV$LiH{K9 zEPzKF?;?Mbzb00(f}dDt9&3{K7W)?PwusghaC7myFWxG44+R)A!<>2x`J~j)c9_?0 z;z^^gtlmPlhjXpj9W#F9UHy{deq`3P1$jz%{|ORl$Wl_jS>4?|KF18a1TH21Z$jb{ z)~N3o9dK@$BjK~f`8P2B9jlWi>TC_%H!ryjS0o@F55 zxzyusKQ&~Abs_P*`BJWI^Tfh4+L>P zCH8mhZZJKK8x|2M%vVg&?sDkWeCrzx##|!eD%M>(tNw=j!x_o73#t5Po;9Xz&J*0| z&9k=(nL5P6X#X7hcjIrV(tQi;+hAsy=%qledE&rG_W1A8(%-q6{O~U*RsBGWE&u?V CiF3OE literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/checklist-baseline.exit.txt.gz b/docs/performance/native-mariadb-20261118/evidence/checklist-baseline.exit.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..92386c0562e12f031d40ebeb551000144681260a GIT binary patch literal 23 bcmb2|=3oE;CNASAPnj5=9h}_H4CDd;Iu-?q literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/checklist-baseline.trx.gz b/docs/performance/native-mariadb-20261118/evidence/checklist-baseline.trx.gz new file mode 100644 index 0000000000000000000000000000000000000000..b35b9fe6c101d3d043654f0dae2dc8f5c0ad0cc8 GIT binary patch literal 2374 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 literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/checklist-baseline.txt.gz b/docs/performance/native-mariadb-20261118/evidence/checklist-baseline.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..57981c245086cdc2af57a8ee5155907bbe02034d GIT binary patch literal 1645 zcmV-z29o(7iwFP!000023hi3!Pvb@q-_Mo$KWtA`Av)|3-UOu*g`}c)2b2J6b)a0x z0|LRx*$$6>=%3#9H@{s!0wF-5?LjTejP)rp zwyOH7gE>cik7rpG)q$$25Rd|O444D8jrX29#d`xY0Y+B&)=?Ln5Ai$)9<7>yYY^g; zv`&HJ4D*iaa;A=72jc^*?E?A$tAvX-M$a+pW4w;>BmDmiD1q-_w!^hTv8Oz&x?7S1 zjCTmLgV8STI`|PTJv>9TtXwrc7K01=U0h$QuU>&ZT=gNwvkn*+P%Us2@!iMOy@78{ zolv$j&Is%_F$VTu3os2l6HG3poKy?Y@02R2S(St4w7Mj1j}|$`|0}h}f1#Rz6$*F? z)H$9PfYab1B2BdcqDZ+NVZH{tYJ z{bseBr;J@{H9taEBKgNx?~{LTo$y5k8EuN$eH-4Pq@$VYHvpg2@ji8plsj79jF zc%Q(%#klbg4gdX?R4)Lr3xEFrZLDDYJ5pa`=H0WITXLw$+#b2gbH60k&X2VHn;}md zcVbR__HD}gcU`~#>sOQkO0gPPrIFpEf zoHK@aL(qmsM5#i*@7gHxCGYS5Zg0;s<|gN^M3)*`Y4JR5vU@RQ!QpfE2Htmpvmc-H zBh3#;S@_sbo$fo#0G_qKsn@QozlO1|h8Ck_l1cC)`WMaujtJc{@kBa6Rt+MZ9RsiypZv1lm*q0V~f>@Yc}ovKrRSsads*dqFJ$@(Az3 zzuZkov4neuJ(@PKF9Lqa_7>`ZJOVZs_e1?{!|tH~Yo=IJZ=s%)9@-A;+D*J^%vIDo z@b-ADHM?U*ue@(wYTQq(nzq1C8UKF-M;g48)vs1}_pi^f0xttgnZKLhxC|NfJ*xxK z78(hjEz)1d`uFTkmZ`HUsOY|_=uTh^-?uYc_7BI66%fFO<+}&A2 zBz}6$E-QU@p6j+Ec80Kx?#yL9kH_k-kaa(@?nid&%eo(#Uu9Kl=2w|tWqy_URo4CZ zg1R5~o#aRLL8P7>-3M7`w+R&*4G?RZrN`MrK2&C`W7nc zf=r+m_~jqyA8c^%RzV}ME8daf#Di<_9qK{O^5!eKimefgFKAb~@fS;N8>0e#kCoWo zu{*)cG;ZlzxG-NZMLWx-<*#BrrK{&}xDT8gHFYsn=ghE|v`w7Bt=R%+tDxVZRd3Eu rbAC7eW-2{5%ei${kckciVu=9axMS>>#$H` literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/cleanup.exit.txt.gz b/docs/performance/native-mariadb-20261118/evidence/cleanup.exit.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..8ce2703e763195e26135c42867f9c1a89cd9bcd1 GIT binary patch literal 23 acmb2|=3oE;CNAR#Pnj4lt`6*D266#669pFl literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/cleanup.py.gz b/docs/performance/native-mariadb-20261118/evidence/cleanup.py.gz new file mode 100644 index 0000000000000000000000000000000000000000..10ceddb2266b3dc4c80561fa38f8c3a9ce57c1c1 GIT binary patch literal 1173 zcmV;G1Zw*qiwFP!000023Y}J4Z=*OAe&<(Mvk!(X&~8Us?aqjYOq;5enzq|88m+Ps za=;{R!DeieHanXCzUN>_lV0|ghs1$%{myqj5Ot%pC3i;2kSG(9hS^mm79r6*B&J<7 zTIJjrPb+0fGTe@D;MdQxQdB(4f>?8-sx|k6xM7-0Yi7rDPqqKS!!wpy4)$0|Tq#x< z--if?w7U`GWr}XB$Si-fK9{*Fgj^=HwPo~6WWoI{)_m_&bFzF~N*Nr*}NJbRKwxLQ^PaM%@vtXcXm2Vru+TaC2`} z6IDXCk96)yR%7wcLmkklW?Haf5m|0*^b_@jG!5JnN}~N1;8?fPcgYTBv^RoG7UQxcOpcz3M;slgTVu(JtvQ&HhHE2?1>%$1nR=G#CC7~^L~ebY zdxBpf5k=yHUKALxM?QHz2yCiDHQ5I=^vK?)gDrUj-jH-~oifW7%!bB2O&VC4R$=r(ugrsU~8KHye3>T9^wd`s%8HYay z&>p?BnXnoC_--D)rX{;l;y~6ATS&kva(PT_LHY)`7dU9Y18-25VF`9G!jBe>AK=z5 z=n>snhdwHCc|JmCYhbHb;!|M3p-WEkiZj_Z)O!$iMf#@!a2$lh)uI|MefqGV0f9)6 zi?jMehxA+HtklxDNzFr7V&dHJAJ;nBah#^7*PqipXt-Pptz?aR+b^mzaep-=lhN(P z==4*Tj;CpMbA6j)aDSh}fd?X3Gg)AOp{!mPI|lR%-LZp)FSeXUC73zSXwcK5-`99k zS6i-?=&gro8r5oOYb(KM8T9$^p$tKHC=LH~-IZhDG1nbnBsp5`iOYOyg4@I{%u&(Q52l9V8v4O!uIs8%BJ@R&1fzY@@;H3f>iORs=l!@(Y#WM#a z_7Si;1uzJ{9{`u(A=IZPB?Dv&>NOg$_36!MI{iQzAtf)!l7l4-w{Vh6%6>6`-l7z| n2+5yZD}pc&%L1=xpfp51pntFSxIk(RNdoUL>9H3S%?SViLN72> literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/cleanup.txt.gz b/docs/performance/native-mariadb-20261118/evidence/cleanup.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..3857b6bf78c1a196dc01835beb5e9f219fda6e7a GIT binary patch literal 133 zcmV;00DAu)iwFP!000023a!t<4Z<)CK+$`r@B)^S3QBtBz#S%V5(fp;xN97eXZ}Q>)*l~ULUNd(2NA~3}c~69$m;nF)wYWW4 literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/full.exit.txt.gz b/docs/performance/native-mariadb-20261118/evidence/full.exit.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..8ce2703e763195e26135c42867f9c1a89cd9bcd1 GIT binary patch literal 23 acmb2|=3oE;CNAR#Pnj4lt`6*D266#669pFl literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/full.trx.gz b/docs/performance/native-mariadb-20261118/evidence/full.trx.gz new file mode 100644 index 0000000000000000000000000000000000000000..d00846ba70f84fe87e297a92518dc02d9477e880 GIT binary patch literal 25831 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 C_u-@f literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/full.txt.gz b/docs/performance/native-mariadb-20261118/evidence/full.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..3a752d6a0f4187b2ca4c87cb0776df3bba48483f GIT binary patch literal 452 zcmV;#0XzO5iwFP!000023e{6hPr^VDePdeW0=x}BYQ^LA$5_T#;a5i)o`{U#oUDG9rVJM9MgW_EW5bY97oDtpn_*{WknxXoL_$C2@Y|@?3jOH>=L8%P}#&WE&A}`mM?-R_I;qO~K)fR?K*y#~54UNX2WNrPRXd z^c`~~Ep6wdq301ST^XVP literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/restore.txt.gz b/docs/performance/native-mariadb-20261118/evidence/restore.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..016b6c513646201388058550a4a86bec41deb6e8 GIT binary patch literal 512 zcmV+b0{{IViwFP!000023f+`XZ__{!#pjH~cUVrPhq#~~5WQ7O0D(ZLq;Sb)>o~28 zlbEdAz?TPp^K1u#5URN#p_T2~nc4T|-}>9v`*zPhSYegrwzefwum&kuW^Zg_Q>3TJ zkL-cD@956Uz2Di`UV-o)+>IqGL0;L(4l}c3du&hSdl&RJ+6_33BK-p14f|jVbk5Kq zN2^)Ra>c$uPVA0Y(LVBImRpZHP5A$%=T63ZF7S{$BDi8jGeD4W>j zy4Yo%x+>?2$hm_(R}WsGzxZt=m$F~Uo^`XeAJLJto~1{0&Phi<*z*bMdfS;ATR)rb zTPW6Bo)T+>r;@JaT6TFPMeGxDt2{lbp_R))E(cEkzh542V2zc9-@m0g>dz(m8qM0S zvE-V4%XFW56Xl~mFNw|hKGA_%*woZ-Eu zhu7+aSG|%Y@*SbSQJ3fV)yido)_d&#f{6Zt{U^MldgZg5|8!So_EP9m#hAn37^h&B zWcPZ9GuE_DyDZaRpUad}U*TX6RrSEXF5_=^+)Z$9hyQtP|6IReHTn+bAEn`}1^@tZ CbPp2% literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/serial.runsettings.gz b/docs/performance/native-mariadb-20261118/evidence/serial.runsettings.gz new file mode 100644 index 0000000000000000000000000000000000000000..4165b1210fae11155bda1bd1b5b6e39858e10dd3 GIT binary patch literal 103 zcmb2|=3oE;Ca%q#T4%ZabTv<&@z&qAc_qi$(>fbBb9(4_ojK`w_T(BbUQb=U!gK6J zle~>Sf9`sFNvOChIQPrP6&pVKu4(XWPZ3$FwoK%<yX literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/server.txt.gz b/docs/performance/native-mariadb-20261118/evidence/server.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..699ae5280a37900be62fb6402a47b312fa0298e2 GIT binary patch literal 1452 zcmV;d1ylMTiwFP!000023hh^2Q`BIi^y^`}mi({OHZug<|^gFXaDap=bf-6y^u z`#yYnBMtowp9aFHc`lhSpJP}*fKC+44NRnh*F-ULdJIFVW>i5C2cd_5Pcl3HcQG!) zuHOZ1h%z+wcEZhTek4kKzh+0zb!VbG$)%D--syBQnn^YHaz(W+6a^s-Tq|bCnA3fj z6e2N93c{J0Lm|kFFm7Lgk;_QyLa5sI@S2%q%EYC`NNLIvf;)ji<8E8oTz}!MZ6SY9 zCJ*b@JQK_?%*$81laye>h^8=Moa!nlSQG@m{tPaHbezV(&iyr2;7112BViQ0LjLX*>7I9qhU{_O$p$iDtVQXrNe9zlS6vZl*gNyKE{N>y}k4bW6 zi_O`XFjg43+gE;BWE?&O9oWDz+0g`1&gXo|><})GW>2VAv zGIJtNcIaP04-5L~#Rx7&fEu{OoPBxeR~P@n~F3CP+bB)RD$hI?Bk+vmoqe`bb@xV&^d4>`R%<`UE9!m6k)Ll5Vuib&bsPhSsNlw`{Om>aA7Y@jOONxx%9-_OPW(l@ShlT9_0^>fu($ z`TY=NZdm37WNIk^^v21B*9>9hq?QX;OG(Ad(;{<;xYaIp^`1?8XGT;9yJg8K)SBC! zsu}q4x1cGmg*0FGEbIzlF9>cSRG>z8Q7`b0HnYBKRlBvEyQ_!O*BE|V3gmCiaEFWB ztwVgeK^?pO@UA)@)~~WY@^{v$nz-fhLpr18YzwsX-ImQOOO{GOJxuaamr8L%@3m9E z!T+P151LheYcn4`f|-vVX6B<`X1>PEM-MRb(SKm(qsKJ!(IcDrsF|5Z6>K(n8#5pM zNHZV(bTc14qM47Hn)!dzu9k?_J6HIFiIUmY4k3ELT_Jk#T_L*HpK#o3oj-~0X@HAn z?0h+t`h}-Pz}Y#vbl-D-t^I{7Zyg-?y_WY7$T;2(?Lk+h=qKG??8ffD!2AQkgjZW^ G7ytl9rqfga literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/start.txt.gz b/docs/performance/native-mariadb-20261118/evidence/start.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..ef8734b3b3662f1e6216a28119a6747b61c2fb1a GIT binary patch literal 402 zcmV;D0d4*tiwFP!000023eA&EPr^VDhTpS^|DgvD8iZKl2iB7z7`d1z2M@+W=?5Sb zNU26H{&e-(DLp`p-b^#;?#?^2Gw;k!zdmCv6ltnNxjY4Yp1NRj6$&+BFD)-%L$DmQ z@^4}wrgNRjXN|#!pgxk~cfs0WPr2bvF%dHE*Jc}7x^cEGZtj;U&?JhKtXw!p4 z@0KSvMpMoUEwPt*U$J`Tn}IIyNH+JEL|Tv|!RqRmlQ%Q#f!Qif6~n*es;-j78y;PIc{jcDE$=c% wxz_h@O01@OvK$zfeCMC9GtWAA^U;{py_dH(moxM+e`Cq=8wv)rE20Jf0Ol9MF#rGn literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/state.json.gz b/docs/performance/native-mariadb-20261118/evidence/state.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..6786df4c3fce8855cd13d2e0f5c012d1613a786b GIT binary patch literal 212 zcmV;_04x6=iwFP!000023O$ZNZo)7SMfZ_%hbn7QdF*&%XVt5W#~vCe7&%5ls(P|6 zdZb=~0D_s#*XY0h=l}QbyKUaq=}sl@64!28^)826i1(@VbM1vya;!aRivwVE!2^gI z#VJYRVz+rl7N>e&io7Pxk(SSy=twyKB8{L3czEqG^=p+al z0wRwq>=@?*`}}{mwLfwE8vJFqzp^*gk>3Aid)3^R|ByZw?7nTNF^&b{1SQZd@fP zqMEjEpG)B~?Gnc?_VatrSE8w^lrza}@Sdz@*;@b~vK2W;K1&Tn2QlkI3MWWz21$ev zyZAuG)+>DgzpQP#Wi({}V5ttZr+wEUba%c2f(mCUAsh+MRpc-E&SC`L-Pa9b`_d@1 zI}7GXRq(T{YqVNLOK$ZE`hYe>mZ}@?!RhuquBSmN%bq6s)BKUjwMFPS76p$+>mcQa zzqOiNAcXl5d_lp+cEMYy6!vwjv%wgIu^u!lZaesXCgp|`Rf3ey?315@luI4$k&y^h zJusvh+EcMthsfi!LQympjgwpgi3GigJ4U;9K^R%ky$B}UU^LDrLDeSEtXOewn`HpL@B$)Z@GWVRDz=neiQ;`AC_Zt7u$GCDMF~`AkXYBZnv=3X18y=;>JM z^b;!N4pWW3$6EIdm{98Y2;ifbytQWO&<=e${=G@D5jqNX|B<^gy>GEibw{lKCEvYJ zR%UgU;V0Nq!^GISGhr#H=SnLd~;|(lf@6kNV(^=L*aO;@Ws36*`!6PbCTPQv_FF zE+>*!1@|7UCco>|XH6lf1ZcIA>cd*C8~As7lVV@+f_z}nW@oJZqTB0R1GJ(osaj&^6aLnRYHvsTXy4+C3R93Q!S-X8Z?QeZiB=88|m%(?7C3*h9m(C=2 zj_}#lO6s1HIS=q(Y)NuqbY5DEI$zgDA9&zcCd%3tv%sP(uqd-wW$v=E@l#rH;j*Rl zQ&aj(8Apj_B^|p=P?G`~99*}--R!EU!#Z)OD7^ZVu=VUOH(D3iXu>6zs~{PN1(FenXv_HS0_mbeT4^ zz2r)nWyW<@YKw~6ATnL^jz%BKTb<2tolR;YG@5@BfM*8)4*(tjd^~_r6v04?p#QEK zo<2YU6Km#BSX@X`Itajp+=KPLkpGmvDE$MbZ!LM?IDMhD#-5*^oxTQArG=yna4Qk# z+Gu1yi+3rtbkj=Oe<;vF-u{a~KY4TD`eiqUc@S!%ai|~OqjSXMB>Vh4l}uyG_ zHx|sDYT#qhwrI7AmR$J?dWUv!A_P)h53=YFvs?9Ah$(0P3N*Pu2(vx- zih_;DIgj2b9O~FyhcO6aJ!rOh?CI;Nlq&|R1}X1(I8FsA7dqNKGZC70WJoi$rE05o zk=tp7qUtOfDSs>l03&!`AYg9|I1RtEY&d!0c5twA XFDBz6A5ShP=NIpv7yfGm*Z}|lqpXyP literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/unit-checklist-all.stdout.txt.gz b/docs/performance/native-mariadb-20261118/evidence/unit-checklist-all.stdout.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..c9d9f6c6a0199f47a94c3b01742237d4ba2c8083 GIT binary patch literal 1062 zcmV+>1lju^iwFP!000023e8qsYa=%leGlY6=rK#zgD3Vnv7rSw*@c#}EOELob`Y|3 z$5tXsgQT(Jf4@gF<77=;N;_#O1e1~O$GKlem$6^n^4<&iM1ERo*87QloGfP1d9k9! z7w;ZP#;};msJFC;v?-Z#GAth5@=-j+o^eu`-m=n0E##WylhGme0+H&$C@qexFP7Ra z?#Pe`w6GM%S^rodQ^uU1G4@3jKYOnynmU> zTC72t{$;+htZ@GSgp6HepFiH;I8W2EeE*ev(9Zt2g~q${v#+xn_O>}?`Bjz=vz%Q# zkA}ECKbuA2qqZv+lNdddtRe*8v$A&0c0$K2%g)cHEV?KRa|O#A;X)em^BY6wG`Sb4kh8J*CjP!e?xbibPu_N=AYEL+w z8frL(zzgp-932M~LTO9k;65POaVM`+E~^k-n_?*}UlROM?atD3oR!+|D8@-G+qLT@uKf(!4a4x! zZeBY(91dbjdvSQS~f(N^FEW%F+HI>T_( zJO>t3czInUn`YEI_(|gvIydbv7Vpwl(+&YpnLIgb_S{u5MA4L7#5zFzB8i(7b&c&e z65b~BK2gvH?Nv*Kgaea`tfqlQHl+^rc`9Q=%nig7#2q@<_l}%b_3Mg`$6A52mK=Ay zzUjchH(=HDc3HV^2TP=#imR%TrJ4+R+M4R5q`ihOL0(O%`A)|*>cWi+3Ey#g(vZIm zs+WV<;%T7lLH*QFX4r{D0;mYDtS6I5hTA5XL_r`s{zQ9T2yH5lPPrWBP0sG{dK;|2 zpRis{-gM9G(H0|uXY0F5pgjJ{qJK_{VZD>xVcVTmQetL{%3zzjuXn(-{)Gva$&^cW gNN0P{is%i{53oB?`~$@a$S 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 literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/unit-final.exit.json.gz b/docs/performance/native-mariadb-20261118/evidence/unit-final.exit.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..f65074d9182aa79b7553cbc52b91366904c44f1c GIT binary patch literal 332 zcmV-S0ki%eiwFP!000023T;urPQx$^{gtU_(vHD|wrPiHVh4l}uyLXs(!?v?+_*~8 zX%&KR$8F()xWw^`{rsNukr=Kj?QAk1y(a5<_7cE{Y|YNG&r-|LLCl7b!Woi_Q4%4< zF5Ypm^V%H2uWC$pf`;rLEH$C_eCRrq>CR^$(4nVN%CYiN#r`MXBSrAtebW%NPmLzr zBiILB!Ply;35|}(Zv77CNEo6>HI4V+OxuqeXo$;lpo#vxxaV?%1Rck6k4{r6=-)!a zE-=C31is*av0cgvDosP3h-@eZWzmBXxorpE&hvaLi7p|}AH}3Rg*;!Gh$lfJRQ1TR z5$M3hK_8=xGn!PvIF}&E<1120W8(6Ed{tLdc zP&ofTDT5xnxtd=(kJGX|y+-voBu#nSP~ z@xp`iM*#S$gLLGWY)y_O>p1s({3{pL1m4aa^=t0Fm&ANCm&`VrueH@-*_`?tF3qzD zfqHu^26XdAOHp6lFN8LgM|c>FQ&`vP?l4q_J|))_)yccgY=RrD$OLAEw!*Ye7X7XsswU5O z^re_pQep^2WoQ!S&HU7(6DDw0w+{B*YuB#;y(X;#HoO=OU`EZbif;b}W8dq_Vg>*J D$%ZN~ literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/unit-qualified-related.exit.json.gz b/docs/performance/native-mariadb-20261118/evidence/unit-qualified-related.exit.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..c30aa154adfc334c8fb457059f7e327a0a8be27f GIT binary patch literal 338 zcmV-Y0j>TYiwFP!000023T;urPQx$^{gtU_(n1+*Y}#R(*a0B~Y@7&(H1SF{H!ev! ztwQkaxGP+MOB}!0&+j?!iKePj&Loq;bF!FZPXT<$7UUfHEHxAz#H_B7ESrngisEkegJd;4MJxu_zT zlq-HWX>x%OrhD)O1smHLucK1f*RkLRV-UuA&@8>};OmK$D^64iQr@#+ehN~~b+mg% zB2@LjkY;F0#a8VikJAc8(O5K6>K{KMK&MS<5U{s~eR206(a8&sgo9=K2KetzIW>(x ku4V-+-vma_M(H@u^YM9pIl3AR#}~toFQlf4Wbpw200p6(QUCw| literal 0 HcmV?d00001 diff --git a/docs/performance/native-mariadb-20261118/evidence/unit-qualified-related.stdout.txt.gz b/docs/performance/native-mariadb-20261118/evidence/unit-qualified-related.stdout.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..5f9c19ba3fdbf80333d4fcd2a8a13137c9f94c2e GIT binary patch literal 625 zcmV-%0*?J3iwFP!000023e8l@Zrd;ryc_U8>@h(jLUNsl4YYupCWjt^Aa-+!0)i%2 zF=LukNy>KqzAMRYYg9#hXo>X$-L4=<#K^?X>^E5KvW40#r$A;KG!zCLxUn< zZZVEndf32}G5sFEttvivw+ZN{v6{awDK^7E!wz5B#q_XaPqky#KjHgZE1R~KW&Ia? zWub8Xe_{ql?B;5A={!!#^5h~!!503UUbjuexuaaXdsu@|Esv8cxI=h#tNWA|PX@)uazNf841({+_}dqzu9 z+kd$a$)&Th@*b^xX`60DoiVPewikJwB3`G6du*5oK6i0JC!qr0=(uoIlig4gnIhiNO3zB}^0gWJm4i z3X6VQFI$uIJNkl5D=9IAqB680vu3aAl?r1R)Rw~D)%Lt=&@0k#PFWkKFeQ_$BLBYv LQLS9tdIkUh=2j_D literal 0 HcmV?d00001