Merge pull request #17607 from Shadowghost/optimize-db-helper-memory

Optimize query helper memory

tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs

@@ -4,11 +4,6 @@ using System;
 using System.Linq;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Locking;
-using Jellyfin.Database.Providers.Sqlite;
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging.Abstractions;
 using Xunit;
 
 namespace Jellyfin.Server.Implementations.Tests.Item;
@@ -18,22 +13,10 @@ namespace Jellyfin.Server.Implementations.Tests.Item;
 /// (BaseItemRepository.TranslateQuery) and the DatePlayed ordering (OrderMapper) translate
 /// and evaluate correctly on the SQLite provider.
 /// </summary>
-public sealed class AlternateVersionQueryTranslationTests : IDisposable
+public sealed class AlternateVersionQueryTranslationTests : SqliteDbTestFixture
 {
-    private readonly SqliteConnection _connection;
-    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
-
     public AlternateVersionQueryTranslationTests()
     {
-        _connection = new SqliteConnection("Data Source=:memory:");
-        _connection.Open();
-
-        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
-            .UseSqlite(_connection)
-            .Options;
-
-        using var ctx = CreateDbContext();
-        ctx.Database.EnsureCreated();
     }
 
     [Fact]
@@ -220,18 +203,4 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
         ctx.SaveChanges();
         return (user.Id, primary.Id, versionA.Id, versionB.Id);
     }
-
-    private JellyfinDbContext CreateDbContext()
-    {
-        return new JellyfinDbContext(
-            _dbOptions,
-            NullLogger<JellyfinDbContext>.Instance,
-            new SqliteDatabaseProvider(null!, NullLogger<SqliteDatabaseProvider>.Instance),
-            new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
-    }
-
-    public void Dispose()
-    {
-        _connection.Dispose();
-    }
 }

tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryByNameTotalCountTests.cs

@@ -3,17 +3,8 @@ using System.Linq;
 using Emby.Server.Implementations.Data;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Locking;
-using Jellyfin.Database.Providers.Sqlite;
 using Jellyfin.Server.Implementations.Item;
-using MediaBrowser.Controller;
-using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
-using MediaBrowser.Model.Configuration;
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging.Abstractions;
-using Moq;
 using Xunit;
 using BaseItemKind = Jellyfin.Data.Enums.BaseItemKind;
 
@@ -24,46 +15,16 @@ namespace Jellyfin.Server.Implementations.Tests.Item;
 /// <c>GetItemValues</c>. A query without a <c>Limit</c> used to have its total record count
 /// silently disabled, so callers got a populated <c>Items</c> array next to a zero total.
 /// </summary>
-public sealed class BaseItemRepositoryByNameTotalCountTests : IDisposable
+public sealed class BaseItemRepositoryByNameTotalCountTests : SqliteDbTestFixture
 {
-    private readonly SqliteConnection _connection;
-    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
     private readonly BaseItemRepository _repository;
     private readonly ItemTypeLookup _itemTypeLookup;
 
     public BaseItemRepositoryByNameTotalCountTests()
     {
-        _connection = new SqliteConnection("Data Source=:memory:");
-        _connection.Open();
-
-        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
-            .UseSqlite(_connection)
-            .Options;
-
-        using (var ctx = CreateDbContext())
-        {
-            ctx.Database.EnsureCreated();
-        }
-
-        var factory = new Mock<IDbContextFactory<JellyfinDbContext>>();
-        factory.Setup(f => f.CreateDbContext()).Returns(CreateDbContext);
-
         _itemTypeLookup = new ItemTypeLookup();
 
-        var serverConfigurationManager = new Mock<IServerConfigurationManager>();
-        serverConfigurationManager.Setup(c => c.Configuration).Returns(new ServerConfiguration());
-
-        _repository = new BaseItemRepository(
-            factory.Object,
-            new Mock<IServerApplicationHost>().Object,
-            _itemTypeLookup,
-            serverConfigurationManager.Object,
-            NullLogger<BaseItemRepository>.Instance);
-    }
-
-    public void Dispose()
-    {
-        _connection.Dispose();
+        _repository = CreateBaseItemRepository(_itemTypeLookup);
     }
 
     [Fact]
@@ -187,13 +148,4 @@ public sealed class BaseItemRepositoryByNameTotalCountTests : IDisposable
 
         ctx.SaveChanges();
     }
-
-    private JellyfinDbContext CreateDbContext()
-    {
-        return new JellyfinDbContext(
-            _dbOptions,
-            NullLogger<JellyfinDbContext>.Instance,
-            new SqliteDatabaseProvider(null!, NullLogger<SqliteDatabaseProvider>.Instance),
-            new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
-    }
 }

tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryGroupingTests.cs

@@ -3,64 +3,25 @@ using System.Linq;
 using Emby.Server.Implementations.Data;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Locking;
-using Jellyfin.Database.Providers.Sqlite;
 using Jellyfin.Server.Implementations.Item;
-using MediaBrowser.Controller;
-using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
-using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging.Abstractions;
-using Moq;
 using Xunit;
 using BaseItemKind = Jellyfin.Data.Enums.BaseItemKind;
 
 namespace Jellyfin.Server.Implementations.Tests.Item;
 
-public sealed class BaseItemRepositoryGroupingTests : IDisposable
+public sealed class BaseItemRepositoryGroupingTests : SqliteDbTestFixture
 {
-    private readonly SqliteConnection _connection;
-    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
     private readonly BaseItemRepository _repository;
     private readonly string _movieTypeName;
 
     public BaseItemRepositoryGroupingTests()
     {
-        _connection = new SqliteConnection("Data Source=:memory:");
-        _connection.Open();
-
-        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
-            .UseSqlite(_connection)
-            .Options;
-
-        using (var ctx = CreateDbContext())
-        {
-            ctx.Database.EnsureCreated();
-        }
-
-        var factory = new Mock<IDbContextFactory<JellyfinDbContext>>();
-        factory.Setup(f => f.CreateDbContext()).Returns(CreateDbContext);
-
         var itemTypeLookup = new ItemTypeLookup();
         _movieTypeName = itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];
 
-        var serverConfigurationManager = new Mock<IServerConfigurationManager>();
-        serverConfigurationManager.Setup(c => c.Configuration).Returns(new ServerConfiguration());
-
-        _repository = new BaseItemRepository(
-            factory.Object,
-            new Mock<IServerApplicationHost>().Object,
-            itemTypeLookup,
-            serverConfigurationManager.Object,
-            NullLogger<BaseItemRepository>.Instance);
-    }
-
-    public void Dispose()
-    {
-        _connection.Dispose();
+        _repository = CreateBaseItemRepository(itemTypeLookup);
     }
 
     [Fact]
@@ -132,13 +93,4 @@ public sealed class BaseItemRepositoryGroupingTests : IDisposable
             IsVirtualItem = false
         };
     }
-
-    private JellyfinDbContext CreateDbContext()
-    {
-        return new JellyfinDbContext(
-            _dbOptions,
-            NullLogger<JellyfinDbContext>.Instance,
-            new SqliteDatabaseProvider(null!, NullLogger<SqliteDatabaseProvider>.Instance),
-            new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
-    }
 }

tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryStreamFilterTests.cs

@@ -0,0 +1,553 @@
+using System;
+using System.Linq;
+using Emby.Server.Implementations.Data;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Server.Implementations.Item;
+using MediaBrowser.Controller.Entities;
+using Xunit;
+using LinkedChildType = Jellyfin.Database.Implementations.Entities.LinkedChildType;
+
+namespace Jellyfin.Server.Implementations.Tests.Item;
+
+/// <summary>
+/// Covers the filters resolving "folders with a matching descendant" through
+/// <see cref="DescendantQueryHelper.GetFolderIdsMatching"/>, positive and negated.
+/// </summary>
+public sealed class BaseItemRepositoryStreamFilterTests : SqliteDbTestFixture
+{
+    private const string FolderType = "MediaBrowser.Controller.Entities.Folder";
+    private const string BoxSetType = "MediaBrowser.Controller.Entities.Movies.BoxSet";
+    private const string MovieType = "MediaBrowser.Controller.Entities.Movies.Movie";
+
+    private readonly BaseItemRepository _repository;
+
+    private readonly Guid _library = Guid.NewGuid();
+    private readonly Guid _withSubtitles = Guid.NewGuid();
+    private readonly Guid _withoutSubtitles = Guid.NewGuid();
+    private readonly Guid _collection = Guid.NewGuid();
+    private readonly Guid _linkedSeries = Guid.NewGuid();
+    private readonly Guid _linkedEpisode = Guid.NewGuid();
+
+    // A version group in a library of its own, so it cannot move the assertions above: an SD primary
+    // that carries nothing, and a 4K second file carrying the subtitles, chapter image and audio.
+    private readonly Guid _versionLibrary = Guid.NewGuid();
+    private readonly Guid _versionedMovie = Guid.NewGuid();
+    private readonly Guid _alternateVersion = Guid.NewGuid();
+
+    // A series in the same library, so the folder branch of the resolution filter has a version group
+    // to reach through as well: an SD episode whose second file is 4K.
+    private readonly Guid _versionedSeries = Guid.NewGuid();
+    private readonly Guid _versionedEpisode = Guid.NewGuid();
+    private readonly Guid _episodeAlternate = Guid.NewGuid();
+
+    // An unprobed primary: only its second file carries dimensions, and they are SD.
+    private readonly Guid _unprobedMovie = Guid.NewGuid();
+    private readonly Guid _unprobedAlternate = Guid.NewGuid();
+
+    // A plain SD movie with no second file, as the control the version groups are read against.
+    private readonly Guid _sdMovie = Guid.NewGuid();
+
+    // An unprobed primary whose only second file is HD, so the HD bucket has to place it off nulls.
+    private readonly Guid _hdOnlyByVersion = Guid.NewGuid();
+    private readonly Guid _hdOnlyAlternate = Guid.NewGuid();
+
+    // Three files for one movie: the HD one would place it in the HD bucket on its own, the 4K one has
+    // to win. Only a group holding both can tell the HD bucket's upper guard from its lower one.
+    private readonly Guid _threeWayMovie = Guid.NewGuid();
+    private readonly Guid _threeWayHd = Guid.NewGuid();
+    private readonly Guid _threeWay4K = Guid.NewGuid();
+
+    public BaseItemRepositoryStreamFilterTests()
+    {
+        using (var ctx = CreateDbContext())
+        {
+            Seed(ctx);
+        }
+
+        _repository = CreateBaseItemRepository(new ItemTypeLookup());
+    }
+
+    [Fact]
+    public void HasSubtitles_MatchesTheItemAndItsParentFolder()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasSubtitles = true });
+
+        Assert.Contains(_withSubtitles, ids);
+        // The library is a folder, and it has a descendant with subtitles.
+        Assert.Contains(_library, ids);
+        Assert.DoesNotContain(_withoutSubtitles, ids);
+    }
+
+    [Fact]
+    public void HasSubtitles_Negated_ExcludesTheItemAndItsParentFolder()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasSubtitles = false });
+
+        Assert.Contains(_withoutSubtitles, ids);
+        Assert.DoesNotContain(_withSubtitles, ids);
+        Assert.DoesNotContain(_library, ids);
+    }
+
+    [Fact]
+    public void SubtitleLanguages_MatchesTheRequestedLanguageOnly()
+    {
+        Assert.Contains(_withSubtitles, _repository.GetItemIdsList(new InternalItemsQuery { SubtitleLanguages = ["ger"] }));
+        Assert.DoesNotContain(_withSubtitles, _repository.GetItemIdsList(new InternalItemsQuery { SubtitleLanguages = ["fre"] }));
+    }
+
+    [Fact]
+    public void HasNoSubtitleTrackWithLanguage_ExcludesTheMatchingItemAndFolder()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasNoSubtitleTrackWithLanguage = "ger" });
+
+        Assert.Contains(_withoutSubtitles, ids);
+        Assert.DoesNotContain(_withSubtitles, ids);
+        Assert.DoesNotContain(_library, ids);
+    }
+
+    [Fact]
+    public void HasSubtitles_MatchesACollectionLinkingAFolder()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasSubtitles = true });
+
+        Assert.Contains(_linkedSeries, ids);
+        Assert.Contains(_collection, ids);
+    }
+
+    [Fact]
+    public void HasSubtitles_Negated_ExcludesACollectionLinkingAFolder()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasSubtitles = false });
+
+        Assert.DoesNotContain(_linkedSeries, ids);
+        Assert.DoesNotContain(_collection, ids);
+    }
+
+    [Fact]
+    public void HasChapterImages_MatchesTheItemAndItsParentFolder()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasChapterImages = true });
+
+        Assert.Contains(_withSubtitles, ids);
+        Assert.Contains(_library, ids);
+        Assert.DoesNotContain(_withoutSubtitles, ids);
+    }
+
+    [Fact]
+    public void HasSubtitles_MatchesAnItemWhoseAlternateVersionCarriesThem()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasSubtitles = true });
+
+        Assert.Contains(_versionedMovie, ids);
+        Assert.Contains(_versionLibrary, ids);
+        // The second file is never listed on its own, which is why its tracks have to count for the primary.
+        Assert.DoesNotContain(_alternateVersion, ids);
+    }
+
+    [Fact]
+    public void HasSubtitles_Negated_ExcludesAnItemWhoseAlternateVersionCarriesThem()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasSubtitles = false });
+
+        Assert.DoesNotContain(_versionedMovie, ids);
+        Assert.DoesNotContain(_versionLibrary, ids);
+    }
+
+    [Fact]
+    public void SubtitleLanguages_MatchesTheLanguageOnAnAlternateVersion()
+    {
+        Assert.Contains(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { SubtitleLanguages = ["ger"] }));
+        Assert.DoesNotContain(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { SubtitleLanguages = ["fre"] }));
+    }
+
+    [Fact]
+    public void HasNoSubtitleTrackWithLanguage_ExcludesAnItemWhoseAlternateVersionHasIt()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasNoSubtitleTrackWithLanguage = "ger" });
+
+        Assert.DoesNotContain(_versionedMovie, ids);
+        Assert.DoesNotContain(_versionLibrary, ids);
+    }
+
+    [Fact]
+    public void AudioLanguages_MatchesTheLanguageOnAnAlternateVersion()
+    {
+        Assert.Contains(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { AudioLanguages = ["fre"] }));
+    }
+
+    [Fact]
+    public void HasNoAudioTrackWithLanguage_ExcludesAnItemWhoseAlternateVersionHasIt()
+    {
+        Assert.DoesNotContain(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { HasNoAudioTrackWithLanguage = "fre" }));
+    }
+
+    [Fact]
+    public void HasChapterImages_MatchesAnItemWhoseAlternateVersionCarriesThem()
+    {
+        Assert.Contains(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { HasChapterImages = true }));
+    }
+
+    [Fact]
+    public void Is4K_MatchesAnItemWhoseAlternateVersionIs4K()
+    {
+        // The primary file is SD; the resolution a caller can actually play is the 4K second file's.
+        Assert.Contains(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { Is4K = true }));
+    }
+
+    [Fact]
+    public void MinWidth_MatchesAnItemWhoseAlternateVersionIsWideEnough()
+    {
+        Assert.Contains(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { MinWidth = 3000 }));
+        Assert.DoesNotContain(_withSubtitles, _repository.GetItemIdsList(new InternalItemsQuery { MinWidth = 3000 }));
+    }
+
+    [Fact]
+    public void MaxWidth_ExcludesAnItemWhoseAlternateVersionBreachesTheBound()
+    {
+        // The SD primary is narrow enough on its own, but the 4K second file is what a caller would play.
+        Assert.DoesNotContain(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { MaxWidth = 1920 }));
+        Assert.Contains(_sdMovie, _repository.GetItemIdsList(new InternalItemsQuery { MaxWidth = 1920 }));
+    }
+
+    [Fact]
+    public void MaxHeight_ExcludesAnItemWhoseAlternateVersionBreachesTheBound()
+    {
+        Assert.DoesNotContain(_versionedMovie, _repository.GetItemIdsList(new InternalItemsQuery { MaxHeight = 1080 }));
+        Assert.Contains(_sdMovie, _repository.GetItemIdsList(new InternalItemsQuery { MaxHeight = 1080 }));
+    }
+
+    [Fact]
+    public void IsHD_False_ExcludesAnSdPrimaryWhoseAlternateVersionIsBetter()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { IsHD = false });
+
+        // 720x480 on its own, but the version group tops out at 4K.
+        Assert.DoesNotContain(_versionedMovie, ids);
+        Assert.Contains(_sdMovie, ids);
+    }
+
+    [Fact]
+    public void IsHD_False_MatchesAPrimaryPlacedOnlyByItsAlternateVersion()
+    {
+        // The primary carries no dimensions at all; the SD second file is the group's best.
+        Assert.Contains(_unprobedMovie, _repository.GetItemIdsList(new InternalItemsQuery { IsHD = false }));
+    }
+
+    [Fact]
+    public void IsHD_True_ExcludesAnItemWhoseVersionGroupReaches4K()
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { IsHD = true });
+
+        Assert.DoesNotContain(_versionedMovie, ids);
+        Assert.DoesNotContain(_unprobedMovie, ids);
+        // The 1920-wide second file alone would say HD; the 4K third file is the group's best.
+        Assert.DoesNotContain(_threeWayMovie, ids);
+    }
+
+    [Fact]
+    public void Is4K_MatchesAnItemWhoseVersionGroupHoldsBothHdAnd4K()
+    {
+        Assert.Contains(_threeWayMovie, _repository.GetItemIdsList(new InternalItemsQuery { Is4K = true }));
+    }
+
+    [Fact]
+    public void IsHD_True_MatchesAPrimaryPlacedOnlyByItsAlternateVersion()
+    {
+        // The primary carries no dimensions of its own; the HD second file is the group's best.
+        Assert.Contains(_hdOnlyByVersion, _repository.GetItemIdsList(new InternalItemsQuery { IsHD = true }));
+    }
+
+    [Fact]
+    public void Is4K_MatchesTheSeriesOfAnEpisodeWhoseAlternateVersionIs4K()
+    {
+        // The folder branch buckets a descendant the same way the item branch buckets a top-level item.
+        Assert.Contains(_versionedSeries, _repository.GetItemIdsList(new InternalItemsQuery { Is4K = true }));
+    }
+
+    [Fact]
+    public void IsHD_False_ExcludesTheSeriesOfAnSdEpisodeWithABetterAlternateVersion()
+    {
+        // Before the version group was consulted on descendants too, the SD episode alone matched here
+        // while the same pair at top level did not.
+        Assert.DoesNotContain(_versionedSeries, _repository.GetItemIdsList(new InternalItemsQuery { IsHD = false }));
+    }
+
+    [Theory]
+    [InlineData("und")]
+    [InlineData("UND")]
+    public void HasNoAudioTrackWithLanguage_TreatsUndeterminedCaseInsensitively(string language)
+    {
+        var ids = _repository.GetItemIdsList(new InternalItemsQuery { HasNoAudioTrackWithLanguage = language });
+
+        // The alternate version carries an audio track with no language, which is what "und" stands for,
+        // so the item it is reported against does have one.
+        Assert.DoesNotContain(_unprobedMovie, ids);
+        Assert.Contains(_versionedMovie, ids);
+    }
+
+    private void Seed(JellyfinDbContext context)
+    {
+        context.BaseItems.Add(new BaseItemEntity { Id = _library, Type = FolderType, Name = "Library", IsFolder = true });
+        context.BaseItems.Add(new BaseItemEntity { Id = _withSubtitles, Type = MovieType, Name = "With subtitles" });
+        context.BaseItems.Add(new BaseItemEntity { Id = _withoutSubtitles, Type = MovieType, Name = "Without subtitles" });
+
+        foreach (var itemId in new[] { _withSubtitles, _withoutSubtitles })
+        {
+            context.AncestorIds.Add(new AncestorId
+            {
+                ItemId = itemId,
+                ParentItemId = _library,
+                Item = null!,
+                ParentItem = null!
+            });
+
+            context.MediaStreamInfos.Add(new MediaStreamInfo
+            {
+                ItemId = itemId,
+                StreamIndex = 0,
+                StreamType = MediaStreamTypeEntity.Video,
+                Item = null!
+            });
+        }
+
+        context.MediaStreamInfos.Add(new MediaStreamInfo
+        {
+            ItemId = _withSubtitles,
+            StreamIndex = 1,
+            StreamType = MediaStreamTypeEntity.Subtitle,
+            Language = "ger",
+            Item = null!
+        });
+
+        // A collection linking a folder: the match is two edges away, one link then one closure hop.
+        context.BaseItems.Add(new BaseItemEntity { Id = _collection, Type = BoxSetType, Name = "Collection", IsFolder = true });
+        context.BaseItems.Add(new BaseItemEntity { Id = _linkedSeries, Type = FolderType, Name = "Linked series", IsFolder = true });
+        context.BaseItems.Add(new BaseItemEntity { Id = _linkedEpisode, Type = MovieType, Name = "Linked episode" });
+
+        context.AncestorIds.Add(new AncestorId
+        {
+            ItemId = _linkedEpisode,
+            ParentItemId = _linkedSeries,
+            Item = null!,
+            ParentItem = null!
+        });
+
+        context.LinkedChildren.Add(new LinkedChildEntity
+        {
+            ParentId = _collection,
+            ChildId = _linkedSeries,
+            ChildType = LinkedChildType.Manual,
+            SortOrder = 0
+        });
+
+        context.MediaStreamInfos.Add(new MediaStreamInfo
+        {
+            ItemId = _linkedEpisode,
+            StreamIndex = 0,
+            StreamType = MediaStreamTypeEntity.Subtitle,
+            Language = "ger",
+            Item = null!
+        });
+
+        context.Chapters.Add(new Chapter
+        {
+            ItemId = _withSubtitles,
+            ChapterIndex = 0,
+            StartPositionTicks = 0,
+            ImagePath = "/chapter.jpg",
+            Item = null!
+        });
+
+        SeedVersionGroup(context);
+
+        context.SaveChanges();
+    }
+
+    // An SD primary whose only extras live on a 4K second file, so every filter has to reach through
+    // PrimaryVersionId to answer correctly.
+    private void SeedVersionGroup(JellyfinDbContext context)
+    {
+        context.BaseItems.Add(new BaseItemEntity { Id = _versionLibrary, Type = FolderType, Name = "Version library", IsFolder = true });
+        context.BaseItems.Add(new BaseItemEntity { Id = _versionedMovie, Type = MovieType, Name = "Versioned movie", Width = 720, Height = 480 });
+        context.BaseItems.Add(new BaseItemEntity
+        {
+            Id = _alternateVersion,
+            Type = MovieType,
+            Name = "Versioned movie 4K",
+            PrimaryVersionId = _versionedMovie,
+            Width = 3840,
+            Height = 2160
+        });
+
+        foreach (var itemId in new[] { _versionedMovie, _alternateVersion })
+        {
+            context.AncestorIds.Add(new AncestorId
+            {
+                ItemId = itemId,
+                ParentItemId = _versionLibrary,
+                Item = null!,
+                ParentItem = null!
+            });
+        }
+
+        context.MediaStreamInfos.Add(new MediaStreamInfo
+        {
+            ItemId = _alternateVersion,
+            StreamIndex = 0,
+            StreamType = MediaStreamTypeEntity.Subtitle,
+            Language = "ger",
+            Item = null!
+        });
+
+        context.MediaStreamInfos.Add(new MediaStreamInfo
+        {
+            ItemId = _alternateVersion,
+            StreamIndex = 1,
+            StreamType = MediaStreamTypeEntity.Audio,
+            Language = "fre",
+            Item = null!
+        });
+
+        SeedVersionedSeries(context);
+        SeedUnprobedVersionGroup(context);
+
+        context.Chapters.Add(new Chapter
+        {
+            ItemId = _alternateVersion,
+            ChapterIndex = 0,
+            StartPositionTicks = 0,
+            ImagePath = "/alternate-chapter.jpg",
+            Item = null!
+        });
+    }
+
+    // The same SD primary / 4K second file pair one level down, so the resolution filter has to answer
+    // for the series off its descendants.
+    private void SeedVersionedSeries(JellyfinDbContext context)
+    {
+        context.BaseItems.Add(new BaseItemEntity { Id = _versionedSeries, Type = FolderType, Name = "Versioned series", IsFolder = true });
+        context.BaseItems.Add(new BaseItemEntity { Id = _versionedEpisode, Type = MovieType, Name = "Versioned episode", Width = 720, Height = 480 });
+        context.BaseItems.Add(new BaseItemEntity
+        {
+            Id = _episodeAlternate,
+            Type = MovieType,
+            Name = "Versioned episode 4K",
+            PrimaryVersionId = _versionedEpisode,
+            Width = 3840,
+            Height = 2160
+        });
+
+        context.AncestorIds.Add(new AncestorId
+        {
+            ItemId = _versionedSeries,
+            ParentItemId = _versionLibrary,
+            Item = null!,
+            ParentItem = null!
+        });
+
+        foreach (var itemId in new[] { _versionedEpisode, _episodeAlternate })
+        {
+            context.AncestorIds.Add(new AncestorId
+            {
+                ItemId = itemId,
+                ParentItemId = _versionedSeries,
+                Item = null!,
+                ParentItem = null!
+            });
+        }
+    }
+
+    // A primary that was never probed, so only its second file can place it in a bucket. Its audio track
+    // declares no language, which is what the "und" filters stand in for.
+    private void SeedUnprobedVersionGroup(JellyfinDbContext context)
+    {
+        context.BaseItems.Add(new BaseItemEntity { Id = _sdMovie, Type = MovieType, Name = "SD movie", Width = 720, Height = 480 });
+        context.AncestorIds.Add(new AncestorId
+        {
+            ItemId = _sdMovie,
+            ParentItemId = _versionLibrary,
+            Item = null!,
+            ParentItem = null!
+        });
+
+        context.BaseItems.Add(new BaseItemEntity { Id = _unprobedMovie, Type = MovieType, Name = "Unprobed movie" });
+        context.BaseItems.Add(new BaseItemEntity
+        {
+            Id = _unprobedAlternate,
+            Type = MovieType,
+            Name = "Unprobed movie SD",
+            PrimaryVersionId = _unprobedMovie,
+            Width = 720,
+            Height = 480
+        });
+
+        foreach (var itemId in new[] { _unprobedMovie, _unprobedAlternate })
+        {
+            context.AncestorIds.Add(new AncestorId
+            {
+                ItemId = itemId,
+                ParentItemId = _versionLibrary,
+                Item = null!,
+                ParentItem = null!
+            });
+        }
+
+        context.MediaStreamInfos.Add(new MediaStreamInfo
+        {
+            ItemId = _unprobedAlternate,
+            StreamIndex = 0,
+            StreamType = MediaStreamTypeEntity.Audio,
+            Item = null!
+        });
+
+        SeedMixedVersionGroups(context);
+    }
+
+    // The two groups that separate the HD bucket's lower bound from its upper one: one that only a 4K
+    // third file keeps out of HD, and one that only an HD second file puts into it.
+    private void SeedMixedVersionGroups(JellyfinDbContext context)
+    {
+        context.BaseItems.Add(new BaseItemEntity { Id = _threeWayMovie, Type = MovieType, Name = "Three-way movie", Width = 720, Height = 480 });
+        context.BaseItems.Add(new BaseItemEntity
+        {
+            Id = _threeWayHd,
+            Type = MovieType,
+            Name = "Three-way movie HD",
+            PrimaryVersionId = _threeWayMovie,
+            Width = 1920,
+            Height = 1080
+        });
+        context.BaseItems.Add(new BaseItemEntity
+        {
+            Id = _threeWay4K,
+            Type = MovieType,
+            Name = "Three-way movie 4K",
+            PrimaryVersionId = _threeWayMovie,
+            Width = 3840,
+            Height = 2160
+        });
+
+        context.BaseItems.Add(new BaseItemEntity { Id = _hdOnlyByVersion, Type = MovieType, Name = "HD only by version" });
+        context.BaseItems.Add(new BaseItemEntity
+        {
+            Id = _hdOnlyAlternate,
+            Type = MovieType,
+            Name = "HD only by version, HD file",
+            PrimaryVersionId = _hdOnlyByVersion,
+            Width = 1920,
+            Height = 1080
+        });
+
+        foreach (var itemId in new[] { _threeWayMovie, _threeWayHd, _threeWay4K, _hdOnlyByVersion, _hdOnlyAlternate })
+        {
+            context.AncestorIds.Add(new AncestorId
+            {
+                ItemId = itemId,
+                ParentItemId = _versionLibrary,
+                Item = null!,
+                ParentItem = null!
+            });
+        }
+    }
+}

tests/Jellyfin.Server.Implementations.Tests/Item/DescendantQueryHelperTests.cs

@@ -0,0 +1,526 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.MatchCriteria;
+using Microsoft.EntityFrameworkCore;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Item;
+
+/// <summary>
+/// Verifies the descendant traversals against the SQLite provider: the sets they resolve, and that
+/// they stay sub-selects instead of inlining every descendant id into the statement.
+/// </summary>
+public sealed class DescendantQueryHelperTests : SqliteDbTestFixture
+{
+    private const string FolderType = "MediaBrowser.Controller.Entities.Folder";
+    private const string BoxSetType = "MediaBrowser.Controller.Entities.Movies.BoxSet";
+    private const string MovieType = "MediaBrowser.Controller.Entities.Movies.Movie";
+
+    private readonly Dictionary<Guid, int> _linkCounters = new();
+
+    public DescendantQueryHelperTests()
+    {
+    }
+
+    [Fact]
+    public void GetAllDescendantIds_Hierarchy_ReturnsEveryLevelWithoutTheParent()
+    {
+        var library = Guid.NewGuid();
+        var series = Guid.NewGuid();
+        var season = Guid.NewGuid();
+        var episode = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddFolder(ctx, library);
+            AddFolder(ctx, series);
+            AddFolder(ctx, season);
+            AddItem(ctx, episode, MovieType);
+
+            // AncestorIds is a closure: production writes one row per ancestor, not just the parent.
+            AddAncestors(ctx, series, library);
+            AddAncestors(ctx, season, series, library);
+            AddAncestors(ctx, episode, season, series, library);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var descendants = DescendantQueryHelper.GetAllDescendantIds(ctx, library).ToHashSet();
+
+            Assert.Equal(new[] { series, season, episode }.Order(), descendants.Order());
+            Assert.DoesNotContain(library, descendants);
+        }
+    }
+
+    [Fact]
+    public void GetAllDescendantIds_LinkedFolder_IncludesItsOwnDescendants()
+    {
+        var boxSet = Guid.NewGuid();
+        var series = Guid.NewGuid();
+        var episode = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddItem(ctx, boxSet, BoxSetType, isFolder: true);
+            AddFolder(ctx, series);
+            AddItem(ctx, episode, MovieType);
+
+            AddAncestors(ctx, episode, series);
+            AddLink(ctx, boxSet, series);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var descendants = DescendantQueryHelper.GetAllDescendantIds(ctx, boxSet).ToHashSet();
+
+            Assert.Contains(series, descendants);
+            Assert.Contains(episode, descendants);
+        }
+    }
+
+    // Timeout so that a missing termination guard fails the test instead of hanging the run.
+    [Fact(Timeout = 30000)]
+    public void GetAllDescendantIds_NestedLinks_AreFollowedAndCyclesTerminate()
+    {
+        var outer = Guid.NewGuid();
+        var inner = Guid.NewGuid();
+        var movie = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddItem(ctx, outer, BoxSetType, isFolder: true);
+            AddItem(ctx, inner, BoxSetType, isFolder: true);
+            AddItem(ctx, movie, MovieType);
+
+            AddLink(ctx, outer, inner);
+            AddLink(ctx, inner, movie);
+            // The traversal must not spin on this cycle.
+            AddLink(ctx, inner, outer);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var descendants = DescendantQueryHelper.GetAllDescendantIds(ctx, outer).ToHashSet();
+
+            Assert.Contains(inner, descendants);
+            Assert.Contains(movie, descendants);
+            Assert.DoesNotContain(outer, descendants);
+        }
+    }
+
+    [Fact]
+    public void GetAllDescendantIds_LinksOfNonFolders_AreNotFollowed()
+    {
+        var library = Guid.NewGuid();
+        var movie = Guid.NewGuid();
+        var alternateVersion = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddFolder(ctx, library);
+            AddItem(ctx, movie, MovieType);
+            AddItem(ctx, alternateVersion, MovieType);
+
+            AddAncestors(ctx, movie, library);
+            // An alternate version hangs off the movie by link, and the movie is not a folder.
+            AddLink(ctx, movie, alternateVersion);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var descendants = DescendantQueryHelper.GetAllDescendantIds(ctx, library).ToHashSet();
+
+            Assert.Contains(movie, descendants);
+            Assert.DoesNotContain(alternateVersion, descendants);
+        }
+    }
+
+    [Fact]
+    public void GetAllDescendantIds_ClosureSeamAboveTheCollectionFolder_IsCrossed()
+    {
+        var userRoot = Guid.NewGuid();
+        var collectionFolder = Guid.NewGuid();
+        var series = Guid.NewGuid();
+        var episode = Guid.NewGuid();
+        var boxSet = Guid.NewGuid();
+        var linkedMovie = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddFolder(ctx, userRoot);
+            AddFolder(ctx, collectionFolder);
+            AddFolder(ctx, series);
+            AddItem(ctx, episode, MovieType);
+            AddItem(ctx, boxSet, BoxSetType, isFolder: true);
+            AddItem(ctx, linkedMovie, MovieType);
+
+            // An item carries its own chain plus its collection folder, but not the user root above
+            // it, so one hop from the user root stops at the collection folder.
+            AddAncestors(ctx, collectionFolder, userRoot);
+            AddAncestors(ctx, series, collectionFolder);
+            AddAncestors(ctx, episode, series, collectionFolder);
+            AddAncestors(ctx, boxSet, collectionFolder);
+            // The box set is only reachable across the seam, and its links have to be followed too.
+            AddLink(ctx, boxSet, linkedMovie);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var descendants = DescendantQueryHelper.GetAllDescendantIds(ctx, userRoot).ToHashSet();
+
+            Assert.Equal(
+                new[] { collectionFolder, series, episode, boxSet, linkedMovie }.Order(),
+                descendants.Order());
+        }
+    }
+
+    [Fact]
+    public void GetOwnedDescendantIds_ClosureSeamAboveTheCollectionFolder_IsCrossed()
+    {
+        var userRoot = Guid.NewGuid();
+        var collectionFolder = Guid.NewGuid();
+        var series = Guid.NewGuid();
+        var episode = Guid.NewGuid();
+        var boxSet = Guid.NewGuid();
+        var linkedMovie = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddFolder(ctx, userRoot);
+            AddFolder(ctx, collectionFolder);
+            AddFolder(ctx, series);
+            AddItem(ctx, episode, MovieType);
+            AddItem(ctx, boxSet, BoxSetType, isFolder: true);
+            AddItem(ctx, linkedMovie, MovieType);
+
+            AddAncestors(ctx, collectionFolder, userRoot);
+            AddAncestors(ctx, series, collectionFolder);
+            AddAncestors(ctx, episode, series, collectionFolder);
+            AddAncestors(ctx, boxSet, collectionFolder);
+            AddLink(ctx, boxSet, linkedMovie);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            // Owned only: the linked movie stays out, or deleting a library would delete it.
+            var expected = new[] { collectionFolder, series, episode, boxSet }.Order();
+
+            Assert.Equal(expected, DescendantQueryHelper.GetOwnedDescendantIds(ctx, userRoot).ToHashSet().Order());
+            Assert.Equal(expected, DescendantQueryHelper.GetOwnedDescendantIdsBatch(ctx, [userRoot]).Order());
+        }
+    }
+
+    [Fact]
+    public void GetFolderIdsMatching_LinkAboveAClosure_ReturnsTheLinkingFolder()
+    {
+        var collections = Guid.NewGuid();
+        var boxSet = Guid.NewGuid();
+        var library = Guid.NewGuid();
+        var series = Guid.NewGuid();
+        var episode = Guid.NewGuid();
+        var otherLibrary = Guid.NewGuid();
+        var otherBoxSet = Guid.NewGuid();
+        var silentMovie = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddFolder(ctx, collections);
+            AddItem(ctx, boxSet, BoxSetType, isFolder: true);
+            AddFolder(ctx, library);
+            AddFolder(ctx, series);
+            AddItem(ctx, episode, MovieType);
+
+            AddAncestors(ctx, boxSet, collections);
+            AddAncestors(ctx, series, library);
+            AddAncestors(ctx, episode, series, library);
+            // The link lands on the series, not on the episode that carries the subtitles.
+            AddLink(ctx, boxSet, series);
+            AddStream(ctx, episode, MediaStreamTypeEntity.Subtitle);
+
+            AddFolder(ctx, otherLibrary);
+            AddItem(ctx, otherBoxSet, BoxSetType, isFolder: true);
+            AddItem(ctx, silentMovie, MovieType);
+            AddAncestors(ctx, otherBoxSet, collections);
+            AddAncestors(ctx, silentMovie, otherLibrary);
+            AddLink(ctx, otherBoxSet, silentMovie);
+            // A stream of another type: the criteria, not the mere presence of a stream, decides.
+            AddStream(ctx, silentMovie, MediaStreamTypeEntity.Video);
+
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var folders = DescendantQueryHelper.GetFolderIdsMatching(ctx, new HasSubtitles()).ToHashSet();
+
+            Assert.Equal(new[] { library, series, boxSet, collections }.Order(), folders.Order());
+        }
+    }
+
+    [Fact(Timeout = 30000)]
+    public void GetFolderIdsMatching_NestedLinks_AreFollowedAndCyclesTerminate()
+    {
+        var outer = Guid.NewGuid();
+        var inner = Guid.NewGuid();
+        var movie = Guid.NewGuid();
+        var silentSet = Guid.NewGuid();
+        var silentMovie = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddItem(ctx, outer, BoxSetType, isFolder: true);
+            AddItem(ctx, inner, BoxSetType, isFolder: true);
+            AddItem(ctx, movie, MovieType);
+
+            AddLink(ctx, outer, inner);
+            AddLink(ctx, inner, movie);
+            // Resolving the link parents must not spin on this cycle.
+            AddLink(ctx, inner, outer);
+            AddStream(ctx, movie, MediaStreamTypeEntity.Subtitle);
+
+            AddItem(ctx, silentSet, BoxSetType, isFolder: true);
+            AddItem(ctx, silentMovie, MovieType);
+            AddLink(ctx, silentSet, silentMovie);
+            AddStream(ctx, silentMovie, MediaStreamTypeEntity.Video);
+
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var folders = DescendantQueryHelper.GetFolderIdsMatching(ctx, new HasSubtitles()).ToHashSet();
+
+            Assert.Equal(new[] { inner, outer }.Order(), folders.Order());
+        }
+    }
+
+    [Fact]
+    public void GetFolderIdsMatching_ClosureSeamAboveTheCollectionFolder_IsCrossed()
+    {
+        var userRoot = Guid.NewGuid();
+        var collectionFolder = Guid.NewGuid();
+        var series = Guid.NewGuid();
+        var episode = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddFolder(ctx, userRoot);
+            AddFolder(ctx, collectionFolder);
+            AddFolder(ctx, series);
+            AddItem(ctx, episode, MovieType);
+
+            // The closure is not transitive at this seam: no item records the user root.
+            AddAncestors(ctx, episode, series, collectionFolder);
+            AddAncestors(ctx, series, collectionFolder);
+            AddAncestors(ctx, collectionFolder, userRoot);
+            AddStream(ctx, episode, MediaStreamTypeEntity.Subtitle);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var folders = DescendantQueryHelper.GetFolderIdsMatching(ctx, new HasSubtitles()).ToHashSet();
+
+            Assert.Equal(new[] { series, collectionFolder, userRoot }.Order(), folders.Order());
+        }
+    }
+
+    [Fact]
+    public void GetFolderIdsMatching_LinkedFolder_MatchesOnLanguageOnly()
+    {
+        var boxSet = Guid.NewGuid();
+        var series = Guid.NewGuid();
+        var episode = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddItem(ctx, boxSet, BoxSetType, isFolder: true);
+            AddFolder(ctx, series);
+            AddItem(ctx, episode, MovieType);
+
+            AddAncestors(ctx, episode, series);
+            AddLink(ctx, boxSet, series);
+            AddStream(ctx, episode, MediaStreamTypeEntity.Subtitle, "ger");
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var german = new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, ["ger"]);
+            var french = new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, ["fre"]);
+
+            Assert.Equal(new[] { series, boxSet }.Order(), DescendantQueryHelper.GetFolderIdsMatching(ctx, german).ToHashSet().Order());
+            Assert.Empty(DescendantQueryHelper.GetFolderIdsMatching(ctx, french).ToArray());
+        }
+    }
+
+    [Fact]
+    public void GetFolderIdsMatching_AlternateVersionLinks_AreNotWalked()
+    {
+        var collections = Guid.NewGuid();
+        var boxSet = Guid.NewGuid();
+        var library = Guid.NewGuid();
+        var movie = Guid.NewGuid();
+        var alternateVersion = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddFolder(ctx, collections);
+            AddItem(ctx, boxSet, BoxSetType, isFolder: true);
+            AddFolder(ctx, library);
+            AddItem(ctx, movie, MovieType);
+            AddItem(ctx, alternateVersion, MovieType);
+
+            AddAncestors(ctx, boxSet, collections);
+            AddAncestors(ctx, movie, library);
+            AddAncestors(ctx, alternateVersion, library);
+            // Only the second file carries the subtitles, and it hangs off the movie by an alternate
+            // version link. The movie is not a folder, so that link is not a parent-child edge.
+            AddLink(ctx, movie, alternateVersion, LinkedChildType.LocalAlternateVersion);
+            AddLink(ctx, boxSet, movie);
+            AddStream(ctx, alternateVersion, MediaStreamTypeEntity.Subtitle);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var folders = DescendantQueryHelper.GetFolderIdsMatching(ctx, new HasSubtitles()).ToHashSet();
+
+            // The library still matches: the alternate version carries its own closure. The box set does
+            // not, matching the descendant side, which does not follow a non-folder's links either.
+            Assert.Equal([library], folders);
+        }
+    }
+
+    [Fact]
+    public void GetOwnedDescendantIds_IgnoresLinkedChildren()
+    {
+        var boxSet = Guid.NewGuid();
+        var owned = Guid.NewGuid();
+        var linked = Guid.NewGuid();
+
+        using (var ctx = CreateDbContext())
+        {
+            AddItem(ctx, boxSet, BoxSetType, isFolder: true);
+            AddItem(ctx, owned, MovieType);
+            AddItem(ctx, linked, MovieType);
+
+            AddAncestors(ctx, owned, boxSet);
+            AddLink(ctx, boxSet, linked);
+            ctx.SaveChanges();
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            Assert.Equal([owned], DescendantQueryHelper.GetOwnedDescendantIds(ctx, boxSet).ToArray());
+            Assert.Equal([owned], DescendantQueryHelper.GetOwnedDescendantIdsBatch(ctx, [boxSet]).ToArray());
+        }
+    }
+
+    [Fact]
+    public void GetAllDescendantIds_StatementSizeDoesNotGrowWithTheLibrary()
+    {
+        var small = SeedLibrary(10);
+        var large = SeedLibrary(500);
+
+        using var ctx = CreateDbContext();
+
+        var smallSql = CountingQuery(ctx, small).ToQueryString();
+        var largeSql = CountingQuery(ctx, large).ToQueryString();
+
+        // Reading the ids into memory and handing them back as AsQueryable() makes EF inline one
+        // literal per descendant, which is what allocated megabytes per call.
+        Assert.Equal(smallSql.Length, largeSql.Length);
+        Assert.Contains("AncestorIds", smallSql, StringComparison.Ordinal);
+        Assert.Equal(10, CountingQuery(ctx, small).Count());
+        Assert.Equal(500, CountingQuery(ctx, large).Count());
+    }
+
+    private static IQueryable<BaseItemEntity> CountingQuery(JellyfinDbContext context, Guid libraryId)
+    {
+        var descendantIds = DescendantQueryHelper.GetAllDescendantIds(context, libraryId);
+
+        return context.BaseItems
+            .AsNoTracking()
+            .Where(b => descendantIds.Contains(b.Id))
+            .Where(DescendantQueryHelper.IsCountableLeaf);
+    }
+
+    private Guid SeedLibrary(int childCount)
+    {
+        var library = Guid.NewGuid();
+
+        using var ctx = CreateDbContext();
+        AddFolder(ctx, library);
+        for (var i = 0; i < childCount; i++)
+        {
+            var child = Guid.NewGuid();
+            AddItem(ctx, child, MovieType);
+            AddAncestors(ctx, child, library);
+        }
+
+        ctx.SaveChanges();
+
+        return library;
+    }
+
+    private static void AddFolder(JellyfinDbContext context, Guid id)
+        => AddItem(context, id, FolderType, isFolder: true);
+
+    private static void AddItem(JellyfinDbContext context, Guid id, string type, bool isFolder = false)
+        => context.BaseItems.Add(new BaseItemEntity
+        {
+            Id = id,
+            Type = type,
+            Name = type + " " + id,
+            IsFolder = isFolder
+        });
+
+    private static void AddStream(JellyfinDbContext context, Guid itemId, MediaStreamTypeEntity type, string? language = null)
+        => context.MediaStreamInfos.Add(new MediaStreamInfo
+        {
+            ItemId = itemId,
+            StreamIndex = 0,
+            StreamType = type,
+            Language = language,
+            Item = null!
+        });
+
+    private static void AddAncestors(JellyfinDbContext context, Guid itemId, params Guid[] ancestorIds)
+    {
+        foreach (var ancestorId in ancestorIds)
+        {
+            context.AncestorIds.Add(new AncestorId
+            {
+                ItemId = itemId,
+                ParentItemId = ancestorId,
+                Item = null!,
+                ParentItem = null!
+            });
+        }
+    }
+
+    // LinkedChildren is keyed on (ParentId, SortOrder), so every link of a parent needs its own slot.
+    private void AddLink(JellyfinDbContext context, Guid parentId, Guid childId, LinkedChildType childType = LinkedChildType.Manual)
+    {
+        _linkCounters.TryGetValue(parentId, out var sortOrder);
+        _linkCounters[parentId] = sortOrder + 1;
+
+        context.LinkedChildren.Add(new LinkedChildEntity
+        {
+            ParentId = parentId,
+            ChildId = childId,
+            ChildType = childType,
+            SortOrder = sortOrder
+        });
+    }
+}

tests/Jellyfin.Server.Implementations.Tests/Item/ItemPersistenceOwnedRowTests.cs

@@ -3,49 +3,27 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using Jellyfin.Database.Implementations;
-using Jellyfin.Database.Implementations.Locking;
-using Jellyfin.Database.Providers.Sqlite;
 using Jellyfin.Server.Implementations.Item;
-using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
 
 namespace Jellyfin.Server.Implementations.Tests.Item;
 
-public sealed class ItemPersistenceOwnedRowTests : IDisposable
+public sealed class ItemPersistenceOwnedRowTests : SqliteDbTestFixture
 {
-    private readonly SqliteConnection _connection;
-    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
     private readonly ItemPersistenceService _service;
-    private readonly IApplicationPaths _applicationPaths;
     private readonly ILibraryManager? _previousLibraryManager;
     private readonly IServerConfigurationManager? _previousConfigurationManager;
 
     public ItemPersistenceOwnedRowTests()
     {
-        _applicationPaths = new Mock<IApplicationPaths>().Object;
-
-        _connection = new SqliteConnection("Data Source=:memory:");
-        _connection.Open();
-
-        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
-            .UseSqlite(_connection)
-            .Options;
-
-        using (var ctx = CreateDbContext())
-        {
-            ctx.Database.EnsureCreated();
-        }
-
         // BaseItem resolves these through process-wide statics; restored in Dispose.
         _previousLibraryManager = BaseItem.LibraryManager;
         _previousConfigurationManager = BaseItem.ConfigurationManager;
@@ -59,20 +37,17 @@ public sealed class ItemPersistenceOwnedRowTests : IDisposable
         configurationManager.Setup(c => c.Configuration).Returns(new ServerConfiguration());
         BaseItem.ConfigurationManager = configurationManager.Object;
 
-        var factory = new Mock<IDbContextFactory<JellyfinDbContext>>();
-        factory.Setup(f => f.CreateDbContext()).Returns(CreateDbContext);
-
         _service = new ItemPersistenceService(
-            factory.Object,
+            CreateDbContextFactory(),
             new Mock<IServerApplicationHost>().Object,
             NullLogger<ItemPersistenceService>.Instance);
     }
 
-    public void Dispose()
+    protected override void Dispose(bool disposing)
     {
         BaseItem.LibraryManager = _previousLibraryManager!;
         BaseItem.ConfigurationManager = _previousConfigurationManager!;
-        _connection.Dispose();
+        base.Dispose(disposing);
     }
 
     [Fact]
@@ -140,10 +115,4 @@ public sealed class ItemPersistenceOwnedRowTests : IDisposable
         book.SetImage(new ItemImageInfo { Path = "/img/primary.jpg", Type = ImageType.Primary }, 0);
         return book;
     }
-
-    private JellyfinDbContext CreateDbContext() => new(
-        _dbOptions,
-        NullLogger<JellyfinDbContext>.Instance,
-        new SqliteDatabaseProvider(_applicationPaths, NullLogger<SqliteDatabaseProvider>.Instance),
-        new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
 }

tests/Jellyfin.Server.Implementations.Tests/Item/PeopleRepositoryUpdatePeopleTests.cs

@@ -4,42 +4,27 @@ using Emby.Server.Implementations.Data;
 using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Locking;
-using Jellyfin.Database.Providers.Sqlite;
 using Jellyfin.Server.Implementations.Item;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Persistence;
-using Microsoft.Data.Sqlite;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
 using BaseItemKind = Jellyfin.Data.Enums.BaseItemKind;
 
 namespace Jellyfin.Server.Implementations.Tests.Item;
 
-public sealed class PeopleRepositoryUpdatePeopleTests : IDisposable
+public sealed class PeopleRepositoryUpdatePeopleTests : SqliteDbTestFixture
 {
     private static readonly Guid _itemId = Guid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa");
 
-    private readonly SqliteConnection _connection;
-    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
     private readonly PeopleRepository _repository;
 
     public PeopleRepositoryUpdatePeopleTests()
     {
-        _connection = new SqliteConnection("Data Source=:memory:");
-        _connection.Open();
-
-        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
-            .UseSqlite(_connection)
-            .Options;
-
         var itemTypeLookup = new ItemTypeLookup();
 
         using (var ctx = CreateDbContext())
         {
-            ctx.Database.EnsureCreated();
             ctx.BaseItems.Add(new BaseItemEntity
             {
                 Id = _itemId,
@@ -53,20 +38,12 @@ public sealed class PeopleRepositoryUpdatePeopleTests : IDisposable
             ctx.SaveChanges();
         }
 
-        var factory = new Mock<IDbContextFactory<JellyfinDbContext>>();
-        factory.Setup(f => f.CreateDbContext()).Returns(CreateDbContext);
-
         _repository = new PeopleRepository(
-            factory.Object,
+            CreateDbContextFactory(),
             itemTypeLookup,
             new Mock<IItemQueryHelpers>().Object);
     }
 
-    public void Dispose()
-    {
-        _connection.Dispose();
-    }
-
     [Fact]
     public void UpdatePeople_SamePersonAndTypeWithDifferentRoles_KeepsEveryCredit()
     {
@@ -174,13 +151,4 @@ public sealed class PeopleRepositoryUpdatePeopleTests : IDisposable
             Role = role
         };
     }
-
-    private JellyfinDbContext CreateDbContext()
-    {
-        return new JellyfinDbContext(
-            _dbOptions,
-            NullLogger<JellyfinDbContext>.Instance,
-            new SqliteDatabaseProvider(null!, NullLogger<SqliteDatabaseProvider>.Instance),
-            new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
-    }
 }

tests/Jellyfin.Server.Implementations.Tests/Item/SqliteDbTestFixture.cs

@@ -0,0 +1,85 @@
+using System;
+using Emby.Server.Implementations.Data;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Locking;
+using Jellyfin.Database.Providers.Sqlite;
+using Jellyfin.Server.Implementations.Item;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Model.Configuration;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+
+namespace Jellyfin.Server.Implementations.Tests.Item;
+
+/// <summary>
+/// Base fixture for the item tests that run against the SQLite provider: one in-memory database per
+/// test class, plus the wiring the repositories under test need. The connection owns the database, so
+/// it stays open for the lifetime of the fixture. Derived classes seed in their own constructor.
+/// </summary>
+public abstract class SqliteDbTestFixture : IDisposable
+{
+    private readonly SqliteConnection _connection;
+    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
+
+    protected SqliteDbTestFixture()
+    {
+        ApplicationPaths = new Mock<IApplicationPaths>().Object;
+
+        _connection = new SqliteConnection("Data Source=:memory:");
+        _connection.Open();
+
+        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
+            .UseSqlite(_connection)
+            .Options;
+
+        using var context = CreateDbContext();
+        context.Database.EnsureCreated();
+    }
+
+    protected IApplicationPaths ApplicationPaths { get; }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected JellyfinDbContext CreateDbContext() => new(
+        _dbOptions,
+        NullLogger<JellyfinDbContext>.Instance,
+        new SqliteDatabaseProvider(ApplicationPaths, NullLogger<SqliteDatabaseProvider>.Instance),
+        new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
+
+    protected IDbContextFactory<JellyfinDbContext> CreateDbContextFactory()
+    {
+        var factory = new Mock<IDbContextFactory<JellyfinDbContext>>();
+        factory.Setup(f => f.CreateDbContext()).Returns(CreateDbContext);
+
+        return factory.Object;
+    }
+
+    protected BaseItemRepository CreateBaseItemRepository(ItemTypeLookup itemTypeLookup)
+    {
+        var serverConfigurationManager = new Mock<IServerConfigurationManager>();
+        serverConfigurationManager.Setup(c => c.Configuration).Returns(new ServerConfiguration());
+
+        return new BaseItemRepository(
+            CreateDbContextFactory(),
+            new Mock<IServerApplicationHost>().Object,
+            itemTypeLookup,
+            serverConfigurationManager.Object,
+            NullLogger<BaseItemRepository>.Instance);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _connection.Dispose();
+        }
+    }
+}