Added a sentinel when UI limit is hit + a message when nothing found, fixes #358

approot/messages.xml

@@ -14,6 +14,8 @@
 <message id="Lms.discard">Discard</message>
 <message id="Lms.edit">Edit</message>
 <message id="Lms.field-must-be-in-upper-case">This field must be in upper case</message>
+<message id="Lms.infinite-scrolling-container.limit-reached">Display limit reached — refine your search to see more results</message>
+<message id="Lms.infinite-scrolling-container.no-results">No results found</message>
 <message id="Lms.loading">Loading...</message>
 <message id="Lms.login">Login</message>
 <message id="Lms.logout"><i class="fa fa-fw fa-sign-out" aria-hidden="true"></i> Logout</message>

approot/messages_es.xml

@@ -14,6 +14,8 @@
 <message id="Lms.discard">Descartar</message>
 <message id="Lms.edit">Editar</message>
 <message id="Lms.field-must-be-in-upper-case">Este campo debe estar en mayúsculas</message>
+<message id="Lms.infinite-scrolling-container.limit-reached">Límite de visualización alcanzado — refine su búsqueda para ver más resultados</message>
+<message id="Lms.infinite-scrolling-container.no-results">No se han encontrado resultados</message>
 <message id="Lms.loading">Cargando...</message>
 <message id="Lms.login">Usuario</message>
 <message id="Lms.logout"><i class="fa fa-fw fa-sign-out" aria-hidden="true"></i> Salir</message>

approot/messages_fr.xml

@@ -14,6 +14,8 @@
 <message id="Lms.discard">Annuler</message>
 <message id="Lms.edit">Editer</message>
 <message id="Lms.field-must-be-in-upper-case">Ce champ doit être en majuscule</message>
+<message id="Lms.infinite-scrolling-container.limit-reached">Limite d'affichage atteinte — affinez votre recherche pour voir plus de résultats</message>
+<message id="Lms.infinite-scrolling-container.no-results">Aucun résultat</message>
 <message id="Lms.loading">Chargement...</message>
 <message id="Lms.login">Login</message>
 <message id="Lms.logout"><i class="fa fa-fw fa-sign-out" aria-hidden="true"></i> Quitter</message>

approot/messages_it.xml

@@ -14,6 +14,8 @@
 <message id="Lms.discard">Annulla</message>
 <message id="Lms.edit">Modifica</message>
 <message id="Lms.field-must-be-in-upper-case">Questo campo deve essere in maiuscolo</message>
+<message id="Lms.infinite-scrolling-container.limit-reached">Limite di visualizzazione raggiunto — affina la ricerca per vedere più risultati</message>
+<message id="Lms.infinite-scrolling-container.no-results">Nessun risultato trovato</message>
 <message id="Lms.loading">Caricamento...</message>
 <message id="Lms.login">Login</message>
 <message id="Lms.logout"><i class="fa fa-fw fa-sign-out" aria-hidden="true"></i> Logout</message>

approot/messages_pl.xml

@@ -14,6 +14,8 @@
 <message id="Lms.discard">Odrzuć</message>
 <message id="Lms.edit">Zmień</message>
 <message id="Lms.field-must-be-in-upper-case">Wartość musi się zaczynać wielką literą</message>
+<message id="Lms.infinite-scrolling-container.limit-reached">Osiągnięto limit wyświetlania — doprecyzuj wyszukiwanie, aby zobaczyć więcej wyników</message>
+<message id="Lms.infinite-scrolling-container.no-results">Brak wyników</message>
 <message id="Lms.loading">Wczytywanie...</message>
 <message id="Lms.login">Login</message>
 <message id="Lms.logout"><i class="fa fa-fw fa-sign-out" aria-hidden="true"></i> Wyloguj</message>

approot/messages_zh.xml

@@ -14,6 +14,8 @@
 <message id="Lms.discard">撤销</message>
 <message id="Lms.edit">编辑</message>
 <message id="Lms.field-must-be-in-upper-case">此字段必须为大写</message>
+<message id="Lms.infinite-scrolling-container.limit-reached">已达到显示上限 — 请精简搜索条件以查看更多结果</message>
+<message id="Lms.infinite-scrolling-container.no-results">未找到结果</message>
 <message id="Lms.loading">加载中...</message>
 <message id="Lms.login">登陆</message>
 <message id="Lms.logout"><i class="fa fa-fw fa-sign-out" aria-hidden="true"></i> 注销</message>

approot/misc.xml

@@ -9,6 +9,7 @@
 	</div>
 </message>
 
+
 <message id="Lms.infinite-scrolling-container.template">
 	${elements}
 	${loading-indicator}

src/libs/database/impl/Utils.hpp

@@ -128,29 +128,10 @@ namespace lms::db::utils
     }
 
     template<typename ResultType, typename Query>
-    RangeResults<ResultType> execRangeQuery(Query& query, const std::optional<Range> range)
+    std::vector<ResultType> execRangeQuery(Query& query, const std::optional<Range> range)
     {
-        RangeResults<ResultType> res;
-
-        if (range)
-        {
-            res.range.offset = range->offset;
-            applyRange(query, Range{ range->offset, range->size + 1 });
-
-            res.results.reserve(range->size);
-        }
-
-        // TODO optim useless last copy
-        res.results = utils::fetchQueryResults<ResultType>(query);
-        if (range && (res.results.size() == range->size + 1))
-        {
-            res.moreResults = true;
-            res.results.pop_back();
-        }
-
-        res.range.size = res.results.size();
-
-        return res;
+        applyRange(query, range);
+        return utils::fetchQueryResults<ResultType>(query);
     }
 
     template<typename Query, typename UnaryFunc>
@@ -162,35 +143,6 @@ namespace lms::db::utils
         forEachQueryResult(query, std::forward<UnaryFunc>(func));
     }
 
-    template<typename Query, typename UnaryFunc>
-    void forEachQueryRangeResult(Query& query, std::optional<Range> range, bool& moreResults, UnaryFunc&& func)
-    {
-        using ResultType = typename QueryResultType<Query>::type;
-
-        if (range)
-            applyRange(query, Range{ range->offset, range->size + 1 });
-
-        moreResults = false;
-
-        std::size_t count{};
-        ScopedQueryProfiler queryProfiler{ query };
-        const auto collection{ query.resultList() };
-        auto it{ fetchFirstResult(collection) };
-        while (it != collection.end())
-        {
-            if (range && (count++ == static_cast<std::size_t>(range->size)))
-            {
-                moreResults = true;
-                break;
-            }
-
-            queryProfiler.suspend();
-            func(*it);
-            queryProfiler.resume();
-            fetchNextResult<ResultType>(it);
-        }
-    }
-
     template<typename... Args>
     void executeCommand(Wt::Dbo::Session& session, std::string_view command, const Args&... args)
     {

src/libs/database/impl/objects/Artist.cpp

@@ -135,14 +135,13 @@ namespace lms::db
 
             if (params.starringUser.isValid())
             {
-                assert(params.feedbackBackend);
                 query.join("starred_artist s_a ON s_a.artist_id = a.id")
+                    .join("user u ON u.id = s_a.user_id")
                     .where("s_a.user_id = ?")
                     .bind(params.starringUser)
-                    .where("s_a.backend = ?")
-                    .bind(*params.feedbackBackend)
                     .where("s_a.sync_state <> ?")
-                    .bind(SyncState::PendingRemove);
+                    .bind(SyncState::PendingRemove)
+                    .where("s_a.backend = u.feedback_backend");
             }
 
             if (params.filters.clusters.size() == 1)
@@ -323,7 +322,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Artist>>("SELECT a FROM artist a").where("a.id = ?").bind(id));
     }
 
-    RangeResults<ArtistId> Artist::findIds(Session& session, const FindParameters& params)
+    std::vector<ArtistId> Artist::findIds(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
 
@@ -331,7 +330,7 @@ namespace lms::db
         return utils::execRangeQuery<ArtistId>(query, params.range);
     }
 
-    RangeResults<Artist::pointer> Artist::find(Session& session, const FindParameters& params)
+    std::vector<Artist::pointer> Artist::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
 
@@ -357,7 +356,7 @@ namespace lms::db
         return IdRange<ArtistId>{ .first = std::get<0>(res), .last = std::get<1>(res) };
     }
 
-    RangeResults<ArtistId> Artist::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<ArtistId> Artist::findOrphanIds(Session& session, std::optional<Range> range)
     {
         // TODO extend with release artists
         session.checkReadTransaction();
@@ -388,7 +387,7 @@ AND NOT EXISTS (
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT 1 FROM artist").where("id = ?").bind(id)) == 1;
     }
 
-    RangeResults<Artist::pointer> Artist::findWithMBIDNameVariants(Session& session, ArtistId& lastRetrievedArtist, std::optional<Range> range)
+    std::vector<Artist::pointer> Artist::findWithMBIDNameVariants(Session& session, ArtistId& lastRetrievedArtist, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -407,8 +406,8 @@ AND NOT EXISTS (
 
         auto results{ utils::execRangeQuery<Artist::pointer>(query, range) };
 
-        if (!results.results.empty())
-            lastRetrievedArtist = results.results.back()->getId();
+        if (!results.empty())
+            lastRetrievedArtist = results.back()->getId();
 
         return results;
     }

src/libs/database/impl/objects/Cluster.cpp

@@ -130,7 +130,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM cluster"));
     }
 
-    RangeResults<ClusterId> Cluster::findIds(Session& session, const FindParameters& params)
+    std::vector<ClusterId> Cluster::findIds(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<ClusterId>(session, params) };
@@ -138,7 +138,7 @@ namespace lms::db
         return utils::execRangeQuery<ClusterId>(query, params.range);
     }
 
-    RangeResults<Cluster::pointer> Cluster::find(Session& session, const FindParameters& params)
+    std::vector<Cluster::pointer> Cluster::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<Wt::Dbo::ptr<Cluster>>(session, params) };
@@ -154,7 +154,7 @@ namespace lms::db
         return utils::forEachQueryResult(query, _func);
     }
 
-    RangeResults<ClusterId> Cluster::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<ClusterId> Cluster::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
         auto query{ session.getDboSession()->query<ClusterId>("SELECT DISTINCT c.id FROM cluster c WHERE NOT EXISTS(SELECT 1 FROM track_cluster t_c WHERE t_c.cluster_id = c.id)") };
@@ -188,7 +188,7 @@ namespace lms::db
         _tracks.insert(getDboPtr(track));
     }
 
-    RangeResults<TrackId> Cluster::getTracks(std::optional<Range> range) const
+    std::vector<TrackId> Cluster::getTracks(std::optional<Range> range) const
     {
         assert(session());
 
@@ -217,7 +217,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM cluster_type"));
     }
 
-    RangeResults<ClusterTypeId> ClusterType::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<ClusterTypeId> ClusterType::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -229,7 +229,7 @@ namespace lms::db
         return utils::execRangeQuery<ClusterTypeId>(query, range);
     }
 
-    RangeResults<ClusterTypeId> ClusterType::findUsed(Session& session, std::optional<Range> range)
+    std::vector<ClusterTypeId> ClusterType::findUsed(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -263,7 +263,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->find<ClusterType>().where("id = ?").bind(id));
     }
 
-    RangeResults<ClusterTypeId> ClusterType::findIds(Session& session, std::optional<Range> range)
+    std::vector<ClusterTypeId> ClusterType::findIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/Directory.cpp

@@ -173,7 +173,7 @@ namespace lms::db
         });
     }
 
-    RangeResults<Directory::pointer> Directory::find(Session& session, const FindParameters& params)
+    std::vector<Directory::pointer> Directory::find(Session& session, const FindParameters& params)
     {
         auto query{ createQuery(session, params) };
         return utils::execRangeQuery<Directory::pointer>(query, params.range);
@@ -187,7 +187,7 @@ namespace lms::db
         });
     }
 
-    RangeResults<DirectoryId> Directory::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<DirectoryId> Directory::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -208,7 +208,7 @@ namespace lms::db
         return utils::execRangeQuery<DirectoryId>(query, range);
     }
 
-    RangeResults<DirectoryId> Directory::findMismatchedLibrary(Session& session, std::optional<Range> range, const std::filesystem::path& rootPath, MediaLibraryId expectedLibraryId)
+    std::vector<DirectoryId> Directory::findMismatchedLibrary(Session& session, std::optional<Range> range, const std::filesystem::path& rootPath, MediaLibraryId expectedLibraryId)
     {
         session.checkReadTransaction();
 
@@ -219,7 +219,7 @@ namespace lms::db
         return utils::execRangeQuery<DirectoryId>(query, range);
     }
 
-    RangeResults<Directory::pointer> Directory::findRootDirectories(Session& session, std::optional<Range> range)
+    std::vector<Directory::pointer> Directory::findRootDirectories(Session& session, std::optional<Range> range)
     {
         auto query{ session.getDboSession()->query<Wt::Dbo::ptr<Directory>>("SELECT d from directory d").where("d.parent_directory_id IS NULL") };
         return utils::execRangeQuery<Directory::pointer>(query, range);

src/libs/database/impl/objects/Genre.cpp

@@ -128,14 +128,14 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM genre"));
     }
 
-    RangeResults<GenreId> Genre::findIds(Session& session, const FindParameters& params)
+    std::vector<GenreId> Genre::findIds(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<GenreId>(session, params) };
         return utils::execRangeQuery<GenreId>(query, params.range);
     }
 
-    RangeResults<Genre::pointer> Genre::find(Session& session, const FindParameters& params)
+    std::vector<Genre::pointer> Genre::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<Wt::Dbo::ptr<Genre>>(session, params) };
@@ -165,7 +165,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->find<Genre>().where("name = ?").bind(name));
     }
 
-    RangeResults<GenreId> Genre::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<GenreId> Genre::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
         auto query{ session.getDboSession()->query<GenreId>("SELECT g.id FROM genre g WHERE NOT EXISTS (SELECT 1 FROM track_genre t_g WHERE t_g.genre_id = g.id)") };

src/libs/database/impl/objects/Grouping.cpp

@@ -128,14 +128,14 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM grouping"));
     }
 
-    RangeResults<GroupingId> Grouping::findIds(Session& session, const FindParameters& params)
+    std::vector<GroupingId> Grouping::findIds(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<GroupingId>(session, params) };
         return utils::execRangeQuery<GroupingId>(query, params.range);
     }
 
-    RangeResults<Grouping::pointer> Grouping::find(Session& session, const FindParameters& params)
+    std::vector<Grouping::pointer> Grouping::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<Wt::Dbo::ptr<Grouping>>(session, params) };
@@ -165,7 +165,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->find<Grouping>().where("name = ?").bind(name));
     }
 
-    RangeResults<GroupingId> Grouping::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<GroupingId> Grouping::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
         auto query{ session.getDboSession()->query<GroupingId>("SELECT g.id FROM grouping g WHERE NOT EXISTS (SELECT 1 FROM track_grouping t_gr WHERE t_gr.grouping_id = g.id)") };

src/libs/database/impl/objects/Image.cpp

@@ -105,7 +105,7 @@ namespace lms::db
         });
     }
 
-    RangeResults<Image::pointer> Image::find(Session& session, const FindParameters& params)
+    std::vector<Image::pointer> Image::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/Language.cpp

@@ -128,14 +128,14 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM language"));
     }
 
-    RangeResults<LanguageId> Language::findIds(Session& session, const FindParameters& params)
+    std::vector<LanguageId> Language::findIds(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<LanguageId>(session, params) };
         return utils::execRangeQuery<LanguageId>(query, params.range);
     }
 
-    RangeResults<Language::pointer> Language::find(Session& session, const FindParameters& params)
+    std::vector<Language::pointer> Language::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<Wt::Dbo::ptr<Language>>(session, params) };
@@ -165,7 +165,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->find<Language>().where("name = ?").bind(name));
     }
 
-    RangeResults<LanguageId> Language::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<LanguageId> Language::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
         auto query{ session.getDboSession()->query<LanguageId>("SELECT l.id FROM language l WHERE NOT EXISTS (SELECT 1 FROM track_language t_l WHERE t_l.language_id = l.id)") };

src/libs/database/impl/objects/Listen.cpp

@@ -23,10 +23,12 @@
 #include <Wt/Dbo/WtSqlTraits.h>
 
 #include "database/Session.hpp"
+#include "database/objects/Artist.hpp"
 #include "database/objects/Genre.hpp"
 #include "database/objects/Grouping.hpp"
 #include "database/objects/Language.hpp"
 #include "database/objects/Mood.hpp"
+#include "database/objects/Release.hpp"
 #include "database/objects/Track.hpp"
 #include "database/objects/User.hpp"
 
@@ -46,10 +48,12 @@ namespace lms::db
             auto query{ session.getDboSession()->query<ArtistId>("SELECT a.id from artist a").join("track_artist_link t_a_l ON t_a_l.artist_id = a.id").join("listen l ON l.track_id = t_a_l.track_id") };
 
             if (params.user.isValid())
-                query.where("l.user_id = ?").bind(params.user);
-
-            if (params.backend)
-                query.where("l.backend = ?").bind(*params.backend);
+            {
+                query.join("user u ON u.id = l.user_id")
+                    .where("l.user_id = ?")
+                    .bind(params.user)
+                    .where("l.backend = u.scrobbling_backend");
+            }
 
             assert(!params.artist.isValid()); // poor check
 
@@ -161,10 +165,12 @@ namespace lms::db
             auto query{ session.getDboSession()->query<ReleaseId>("SELECT r.id from release r").join("track t ON t.release_id = r.id").join("listen l ON l.track_id = t.id") };
 
             if (params.user.isValid())
-                query.where("l.user_id = ?").bind(params.user);
-
-            if (params.backend)
-                query.where("l.backend = ?").bind(*params.backend);
+            {
+                query.join("user u ON u.id = l.user_id")
+                    .where("l.user_id = ?")
+                    .bind(params.user)
+                    .where("l.backend = u.scrobbling_backend");
+            }
 
             if (params.artist.isValid())
             {
@@ -244,10 +250,12 @@ namespace lms::db
             auto query{ session.getDboSession()->query<TrackId>("SELECT t.id from track t").join("listen l ON l.track_id = t.id") };
 
             if (params.user.isValid())
-                query.where("l.user_id = ?").bind(params.user);
-
-            if (params.backend)
-                query.where("l.backend = ?").bind(*params.backend);
+            {
+                query.join("user u ON u.id = l.user_id")
+                    .where("l.user_id = ?")
+                    .bind(params.user)
+                    .where("l.backend = u.scrobbling_backend");
+            }
 
             if (params.artist.isValid())
             {
@@ -348,7 +356,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Listen>>("SELECT l from listen l").where("l.id = ?").bind(id));
     }
 
-    RangeResults<ListenId> Listen::find(Session& session, const FindParameters& parameters)
+    std::vector<ListenId> Listen::find(Session& session, const FindParameters& parameters)
     {
         session.checkReadTransaction();
 
@@ -373,39 +381,88 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->find<Listen>().where("user_id = ?").bind(userId).where("track_id = ?").bind(trackId).where("backend = ?").bind(backend).where("date_time = ?").bind(Wt::WDateTime::fromTime_t(dateTime.toTime_t())));
     }
 
-    RangeResults<ArtistId> Listen::getTopArtists(Session& session, const ArtistStatsFindParameters& params)
+    std::vector<ArtistId> Listen::getTopArtists(Session& session, const ArtistStatsFindParameters& params)
     {
         session.checkReadTransaction();
-        auto query{ createArtistsQuery(session, params) };
-
-        auto collection{ query
-                             .orderBy("COUNT(a.id) DESC")
-                             .groupBy("a.id") };
-
+        auto query{ createArtistsQuery(session, params).orderBy("COUNT(a.id) DESC").groupBy("a.id") };
         return utils::execRangeQuery<ArtistId>(query, params.range);
     }
 
-    RangeResults<ReleaseId> Listen::getTopReleases(Session& session, const StatsFindParameters& params)
+    std::vector<ReleaseId> Listen::getTopReleases(Session& session, const StatsFindParameters& params)
+    {
+        session.checkReadTransaction();
+        auto query{ createReleasesQuery(session, params).orderBy("COUNT(r.id) DESC").groupBy("r.id") };
+        return utils::execRangeQuery<ReleaseId>(query, params.range);
+    }
+
+    std::vector<TrackId> Listen::getTopTracks(Session& session, const StatsFindParameters& params)
+    {
+        session.checkReadTransaction();
+        auto query{ createTracksQuery(session, params).orderBy("COUNT(t.id) DESC").groupBy("t.id") };
+        return utils::execRangeQuery<TrackId>(query, params.range);
+    }
+
+    std::vector<ArtistId> Listen::getRecentArtists(Session& session, const ArtistStatsFindParameters& params)
+    {
+        session.checkReadTransaction();
+        auto query{ createArtistsQuery(session, params).groupBy("a.id").having("l.date_time = MAX(l.date_time)").orderBy("l.date_time DESC") };
+        return utils::execRangeQuery<ArtistId>(query, params.range);
+    }
+
+    std::vector<ReleaseId> Listen::getRecentReleases(Session& session, const StatsFindParameters& params)
+    {
+        session.checkReadTransaction();
+        auto query{ createReleasesQuery(session, params).groupBy("r.id").having("l.date_time = MAX(l.date_time)").orderBy("l.date_time DESC") };
+        return utils::execRangeQuery<ReleaseId>(query, params.range);
+    }
+
+    std::vector<TrackId> Listen::getRecentTracks(Session& session, const StatsFindParameters& params)
+    {
+        session.checkReadTransaction();
+        auto query{ createTracksQuery(session, params).groupBy("t.id").having("l.date_time = MAX(l.date_time)").orderBy("l.date_time DESC") };
+        return utils::execRangeQuery<TrackId>(query, params.range);
+    }
+
+    void Listen::getTopArtists(Session& session, const ArtistStatsFindParameters& params, const std::function<void(const ObjectPtr<Artist>&)>& func)
+    {
+        session.checkReadTransaction();
+        auto query{ createArtistsQuery(session, params)
+                        .orderBy("COUNT(a.id) DESC")
+                        .groupBy("a.id") };
+
+        utils::forEachQueryRangeResult(query, params.range, [&](const ArtistId& id) {
+            if (const auto artist{ Artist::find(session, id) })
+                func(artist);
+        });
+    }
+
+    void Listen::getTopReleases(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Release>&)>& func)
     {
         session.checkReadTransaction();
         auto query{ createReleasesQuery(session, params)
                         .orderBy("COUNT(r.id) DESC")
                         .groupBy("r.id") };
 
-        return utils::execRangeQuery<ReleaseId>(query, params.range);
+        utils::forEachQueryRangeResult(query, params.range, [&](const ReleaseId& id) {
+            if (const auto release{ Release::find(session, id) })
+                func(release);
+        });
     }
 
-    RangeResults<TrackId> Listen::getTopTracks(Session& session, const StatsFindParameters& params)
+    void Listen::getTopTracks(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Track>&)>& func)
     {
         session.checkReadTransaction();
         auto query{ createTracksQuery(session, params)
                         .orderBy("COUNT(t.id) DESC")
                         .groupBy("t.id") };
 
-        return utils::execRangeQuery<TrackId>(query, params.range);
+        utils::forEachQueryRangeResult(query, params.range, [&](const TrackId& id) {
+            if (const auto track{ Track::find(session, id) })
+                func(track);
+        });
     }
 
-    RangeResults<ArtistId> Listen::getRecentArtists(Session& session, const ArtistStatsFindParameters& params)
+    void Listen::getRecentArtists(Session& session, const ArtistStatsFindParameters& params, const std::function<void(const ObjectPtr<Artist>&)>& func)
     {
         session.checkReadTransaction();
         auto query{ createArtistsQuery(session, params)
@@ -413,10 +470,13 @@ namespace lms::db
                         .having("l.date_time = MAX(l.date_time)")
                         .orderBy("l.date_time DESC") };
 
-        return utils::execRangeQuery<ArtistId>(query, params.range);
+        utils::forEachQueryRangeResult(query, params.range, [&](const ArtistId& id) {
+            if (const auto artist{ Artist::find(session, id) })
+                func(artist);
+        });
     }
 
-    RangeResults<ReleaseId> Listen::getRecentReleases(Session& session, const StatsFindParameters& params)
+    void Listen::getRecentReleases(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Release>&)>& func)
     {
         session.checkReadTransaction();
         auto query{ createReleasesQuery(session, params)
@@ -424,10 +484,13 @@ namespace lms::db
                         .having("l.date_time = MAX(l.date_time)")
                         .orderBy("l.date_time DESC") };
 
-        return utils::execRangeQuery<ReleaseId>(query, params.range);
+        utils::forEachQueryRangeResult(query, params.range, [&](const ReleaseId& id) {
+            if (const auto release{ Release::find(session, id) })
+                func(release);
+        });
     }
 
-    RangeResults<TrackId> Listen::getRecentTracks(Session& session, const StatsFindParameters& params)
+    void Listen::getRecentTracks(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Track>&)>& func)
     {
         session.checkReadTransaction();
         auto query{ createTracksQuery(session, params)
@@ -435,7 +498,10 @@ namespace lms::db
                         .having("l.date_time = MAX(l.date_time)")
                         .orderBy("l.date_time DESC") };
 
-        return utils::execRangeQuery<TrackId>(query, params.range);
+        utils::forEachQueryRangeResult(query, params.range, [&](const TrackId& id) {
+            if (const auto track{ Track::find(session, id) })
+                func(track);
+        });
     }
 
     std::size_t Listen::getCount(Session& session, UserId userId, TrackId trackId)

src/libs/database/impl/objects/Medium.cpp

@@ -110,7 +110,7 @@ namespace lms::db
         return IdRange<MediumId>{ .first = std::get<0>(res), .last = std::get<1>(res) };
     }
 
-    RangeResults<MediumId> Medium::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<MediumId> Medium::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/Mood.cpp

@@ -128,14 +128,14 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM mood"));
     }
 
-    RangeResults<MoodId> Mood::findIds(Session& session, const FindParameters& params)
+    std::vector<MoodId> Mood::findIds(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<MoodId>(session, params) };
         return utils::execRangeQuery<MoodId>(query, params.range);
     }
 
-    RangeResults<Mood::pointer> Mood::find(Session& session, const FindParameters& params)
+    std::vector<Mood::pointer> Mood::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<Wt::Dbo::ptr<Mood>>(session, params) };
@@ -165,7 +165,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->find<Mood>().where("name = ?").bind(name));
     }
 
-    RangeResults<MoodId> Mood::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<MoodId> Mood::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
         auto query{ session.getDboSession()->query<MoodId>("SELECT m.id FROM mood m WHERE NOT EXISTS (SELECT 1 FROM track_mood t_m WHERE t_m.mood_id = m.id)") };

src/libs/database/impl/objects/Release.cpp

@@ -150,14 +150,13 @@ namespace lms::db
 
             if (params.starringUser.isValid())
             {
-                assert(params.feedbackBackend);
                 query.join("starred_release s_r ON s_r.release_id = r.id")
+                    .join("user u ON u.id = s_r.user_id")
                     .where("s_r.user_id = ?")
                     .bind(params.starringUser)
-                    .where("s_r.backend = ?")
-                    .bind(*params.feedbackBackend)
                     .where("s_r.sync_state <> ?")
-                    .bind(SyncState::PendingRemove);
+                    .bind(SyncState::PendingRemove)
+                    .where("s_r.backend = u.feedback_backend");
             }
 
             if (params.artist.isValid())
@@ -356,7 +355,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Country>>("SELECT c from country c").where("c.name = ?").bind(name));
     }
 
-    RangeResults<CountryId> Country::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<CountryId> Country::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -418,7 +417,7 @@ namespace lms::db
         });
     }
 
-    RangeResults<LabelId> Label::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<LabelId> Label::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -480,7 +479,7 @@ namespace lms::db
         });
     }
 
-    RangeResults<ReleaseTypeId> ReleaseType::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<ReleaseTypeId> ReleaseType::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -527,7 +526,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM release"));
     }
 
-    RangeResults<ReleaseId> Release::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<ReleaseId> Release::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -574,7 +573,7 @@ namespace lms::db
         return IdRange<ReleaseId>{ .first = std::get<0>(res), .last = std::get<1>(res) };
     }
 
-    RangeResults<Release::pointer> Release::find(Session& session, const FindParameters& params)
+    std::vector<Release::pointer> Release::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
 
@@ -590,7 +589,7 @@ namespace lms::db
         utils::forEachQueryRangeResult(query, params.range, func);
     }
 
-    RangeResults<ReleaseId> Release::findIds(Session& session, const FindParameters& params)
+    std::vector<ReleaseId> Release::findIds(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/StarredTrack.cpp

@@ -78,7 +78,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT 1 from starred_track").where("track_id = ?").bind(trackId).where("user_id = ?").bind(userId).where("backend = ?").bind(backend));
     }
 
-    RangeResults<StarredTrackId> StarredTrack::find(Session& session, const FindParameters& params)
+    std::vector<StarredTrackId> StarredTrack::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/Track.cpp

@@ -77,14 +77,13 @@ namespace lms::db
 
             if (params.starringUser.isValid())
             {
-                assert(params.feedbackBackend);
                 query.join("starred_track s_t ON s_t.track_id = t.id")
+                    .join("user u ON u.id = s_t.user_id")
                     .where("s_t.user_id = ?")
                     .bind(params.starringUser)
-                    .where("s_t.backend = ?")
-                    .bind(*params.feedbackBackend)
                     .where("s_t.sync_state <> ?")
-                    .bind(SyncState::PendingRemove);
+                    .bind(SyncState::PendingRemove)
+                    .where("s_t.backend = u.feedback_backend");
             }
 
             if (params.filters.clusters.size() == 1)
@@ -435,7 +434,7 @@ namespace lms::db
         return utils::fetchQueryResults<Track::pointer>(session.getDboSession()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t").where("t.recording_mbid = ?").bind(mbid));
     }
 
-    RangeResults<TrackId> Track::findIdsTrackMBIDDuplicates(Session& session, std::optional<Range> range)
+    std::vector<TrackId> Track::findIdsTrackMBIDDuplicates(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 
@@ -564,7 +563,7 @@ namespace lms::db
         return _preferredMediaArtwork.id();
     }
 
-    RangeResults<TrackId> Track::findIds(Session& session, const FindParameters& parameters)
+    std::vector<TrackId> Track::findIds(Session& session, const FindParameters& parameters)
     {
         session.checkReadTransaction();
 
@@ -572,7 +571,7 @@ namespace lms::db
         return utils::execRangeQuery<TrackId>(query, parameters.range);
     }
 
-    RangeResults<Track::pointer> Track::find(Session& session, const FindParameters& parameters)
+    std::vector<Track::pointer> Track::find(Session& session, const FindParameters& parameters)
     {
         session.checkReadTransaction();
 
@@ -588,14 +587,6 @@ namespace lms::db
         utils::forEachQueryRangeResult(query, params.range, func);
     }
 
-    void Track::find(Session& session, const FindParameters& params, bool& moreResults, const std::function<void(const Track::pointer&)>& func)
-    {
-        session.checkReadTransaction();
-
-        auto query{ createQuery<Wt::Dbo::ptr<Track>>(session, params) };
-        utils::forEachQueryRangeResult(query, params.range, moreResults, func);
-    }
-
     std::size_t Track::getCount(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();

src/libs/database/impl/objects/TrackBookmark.cpp

@@ -54,7 +54,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM track_bookmark"));
     }
 
-    RangeResults<TrackBookmarkId> TrackBookmark::find(Session& session, UserId userId, std::optional<Range> range)
+    std::vector<TrackBookmarkId> TrackBookmark::find(Session& session, UserId userId, std::optional<Range> range)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/TrackEmbeddedImage.cpp

@@ -150,7 +150,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(query);
     }
 
-    RangeResults<TrackEmbeddedImageId> TrackEmbeddedImage::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<TrackEmbeddedImageId> TrackEmbeddedImage::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/TrackList.cpp

@@ -182,7 +182,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<TrackList>>("select t_l from tracklist t_l").where("t_l.name = ?").bind(name).where("t_l.type = ?").bind(type).where("t_l.user_id = ?").bind(userId));
     }
 
-    RangeResults<TrackListId> TrackList::find(Session& session, const FindParameters& params)
+    std::vector<TrackListId> TrackList::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
         auto query{ createQuery<TrackListId>(session, params) };
@@ -218,13 +218,13 @@ namespace lms::db
         TrackListEntry::pointer res;
 
         auto entries = getEntries(Range{ pos, 1 });
-        if (!entries.results.empty())
-            res = entries.results.front();
+        if (!entries.empty())
+            res = entries.front();
 
         return res;
     }
 
-    RangeResults<ObjectPtr<TrackListEntry>> TrackList::getEntries(std::optional<Range> range) const
+    std::vector<ObjectPtr<TrackListEntry>> TrackList::getEntries(std::optional<Range> range) const
     {
         assert(session());
 

src/libs/database/impl/objects/TrackLyrics.cpp

@@ -121,7 +121,7 @@ namespace lms::db
         });
     }
 
-    RangeResults<TrackLyricsId> TrackLyrics::findOrphanIds(Session& session, std::optional<Range> range)
+    std::vector<TrackLyricsId> TrackLyrics::findOrphanIds(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/TrackMusicNNEmbeddings.cpp

@@ -66,7 +66,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->find<TrackMusicNNEmbeddings>().where("track_id = ?").bind(trackId));
     }
 
-    RangeResults<TrackMusicNNEmbeddingsId> TrackMusicNNEmbeddings::find(Session& session, std::optional<Range> range)
+    std::vector<TrackMusicNNEmbeddingsId> TrackMusicNNEmbeddings::find(Session& session, std::optional<Range> range)
     {
         session.checkReadTransaction();
 

src/libs/database/impl/objects/User.cpp

@@ -61,7 +61,7 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM user"));
     }
 
-    RangeResults<UserId> User::find(Session& session, const FindParameters& params)
+    std::vector<UserId> User::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
 

src/libs/database/include/database/Types.hpp

@@ -38,8 +38,6 @@ namespace lms::db
 
     // Request:
     // 	  size = 0 => means we don't want data
-    // Response (via RangeResults)
-    //    size => results size
     struct Range
     {
         std::size_t offset{};
@@ -65,40 +63,6 @@ namespace lms::db
         }
     }
 
-    template<typename T>
-    struct RangeResults
-    {
-        Range range;
-        std::vector<T> results;
-        bool moreResults{};
-
-        RangeResults getSubRange(Range subRange)
-        {
-            assert(subRange.offset >= range.offset);
-
-            if (!subRange.size)
-                subRange.size = range.size - (subRange.offset - range.offset);
-
-            subRange.offset = std::min(subRange.offset, range.offset + range.size);
-            subRange.size = std::min(subRange.size, range.offset + range.size - subRange.offset);
-
-            RangeResults subResults;
-
-            auto itBegin{ std::cbegin(results) + subRange.offset - range.offset };
-            auto itEnd{ itBegin + subRange.size };
-            subResults.results.reserve(std::distance(itBegin, itEnd));
-            std::copy(itBegin, itEnd, std::back_inserter(subResults.results));
-
-            subResults.range = subRange;
-            if (subRange.offset + subRange.size == range.offset + range.size)
-                subResults.moreResults = moreResults;
-            else
-                subResults.moreResults = true;
-
-            return subResults;
-        }
-    };
-
     struct FileStats
     {
         std::size_t trackCount;

src/libs/database/include/database/objects/Artist.hpp

@@ -66,9 +66,8 @@ namespace lms::db
             ArtistSortMethod sortMethod{ ArtistSortMethod::None };
             std::optional<Range> range;
             Wt::WDateTime writtenAfter;
-            UserId starringUser;                            // only artists starred by this user
-            std::optional<FeedbackBackend> feedbackBackend; // and for this feedback backend
-            TrackId track;                                  // artists involved in this track
+            UserId starringUser; // only artists starred by this user (uses their current feedback backend)
+            TrackId track;       // artists involved in this track
 
             FindParameters& setFilters(const Filters& _filters)
             {
@@ -105,10 +104,9 @@ namespace lms::db
                 writtenAfter = _after;
                 return *this;
             }
-            FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend)
+            FindParameters& setStarringUser(UserId _user)
             {
                 starringUser = _user;
-                feedbackBackend = _feedbackBackend;
                 return *this;
             }
             FindParameters& setTrack(TrackId _track)
@@ -127,13 +125,13 @@ namespace lms::db
         static std::vector<pointer> find(Session& session, std::string_view name); // exact match on name field
         static void find(Session& session, ArtistId& lastRetrievedArtist, std::size_t count, const std::function<void(const Artist::pointer&)>& func, MediaLibraryId library = {});
         static void find(Session& session, const IdRange<ArtistId>& idRange, const std::function<void(const Artist::pointer&)>& func);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
         static IdRange<ArtistId> findNextIdRange(Session& session, ArtistId lastRetrievedId, std::size_t count);
-        static RangeResults<ArtistId> findIds(Session& session, const FindParameters& params);
-        static RangeResults<ArtistId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt); // No track related
+        static std::vector<ArtistId> findIds(Session& session, const FindParameters& params);
+        static std::vector<ArtistId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt); // No track related
         static bool exists(Session& session, ArtistId id);
-        static RangeResults<pointer> findWithMBIDNameVariants(Session& session, ArtistId& lastRetrievedArtist, std::optional<Range> range = std::nullopt);
+        static std::vector<pointer> findWithMBIDNameVariants(Session& session, ArtistId& lastRetrievedArtist, std::optional<Range> range = std::nullopt);
 
         // Updates
         static void updatePreferredArtwork(Session& session, ArtistId artistId, ArtworkId artworkId);

src/libs/database/include/database/objects/Cluster.hpp

@@ -91,11 +91,11 @@ namespace lms::db
 
         // Find utility
         static std::size_t getCount(Session& session);
-        static RangeResults<ClusterId> findIds(Session& session, const FindParameters& params);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<ClusterId> findIds(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, std::function<void(const pointer& cluster)> _func);
         static pointer find(Session& session, ClusterId id);
-        static RangeResults<ClusterId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<ClusterId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         // May be very slow
         static std::size_t computeTrackCount(Session& session, ClusterId id);
@@ -104,7 +104,7 @@ namespace lms::db
         // Accessors
         std::string_view getName() const { return _name; }
         ObjectPtr<ClusterType> getType() const { return _clusterType; }
-        RangeResults<TrackId> getTracks(std::optional<Range> range = std::nullopt) const;
+        std::vector<TrackId> getTracks(std::optional<Range> range = std::nullopt) const;
         void addTrack(ObjectPtr<Track> track);
 
         template<class Action>
@@ -136,12 +136,12 @@ namespace lms::db
 
         // Getters
         static std::size_t getCount(Session& session);
-        static RangeResults<ClusterTypeId> findIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<ClusterTypeId> findIds(Session& session, std::optional<Range> range = std::nullopt);
         static void find(Session& session, const std::function<void(const pointer&)>& func);
         static pointer find(Session& session, std::string_view name);
         static pointer find(Session& session, ClusterTypeId id);
-        static RangeResults<ClusterTypeId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
-        static RangeResults<ClusterTypeId> findUsed(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<ClusterTypeId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<ClusterTypeId> findUsed(Session& session, std::optional<Range> range = std::nullopt);
 
         static void remove(Session& session, const std::string& name);
 

src/libs/database/include/database/objects/Directory.hpp

@@ -122,11 +122,11 @@ namespace lms::db
         static pointer find(Session& session, DirectoryId id);
         static pointer find(Session& session, const std::filesystem::path& path);
         static void find(Session& session, DirectoryId& lastRetrievedDirectory, std::size_t count, const std::function<void(const Directory::pointer&)>& func);
-        static RangeResults<Directory::pointer> find(Session& session, const FindParameters& params);
+        static std::vector<Directory::pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, const std::function<void(const Directory::pointer&)>& func);
-        static RangeResults<DirectoryId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
-        static RangeResults<DirectoryId> findMismatchedLibrary(Session& session, std::optional<Range> range, const std::filesystem::path& rootPath, MediaLibraryId expectedLibraryId);
-        static RangeResults<pointer> findRootDirectories(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<DirectoryId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<DirectoryId> findMismatchedLibrary(Session& session, std::optional<Range> range, const std::filesystem::path& rootPath, MediaLibraryId expectedLibraryId);
+        static std::vector<pointer> findRootDirectories(Session& session, std::optional<Range> range = std::nullopt);
 
         // getters
         const std::filesystem::path& getAbsolutePath() const { return _absolutePath; }

src/libs/database/include/database/objects/Genre.hpp

@@ -82,12 +82,12 @@ namespace lms::db
         Genre() = default;
 
         static std::size_t getCount(Session& session);
-        static RangeResults<GenreId> findIds(Session& session, const FindParameters& params);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<GenreId> findIds(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
         static pointer find(Session& session, GenreId id);
         static pointer find(Session& session, std::string_view name);
-        static RangeResults<GenreId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<GenreId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         static std::size_t computeTrackCount(Session& session, GenreId id);
         static std::size_t computeReleaseCount(Session& session, GenreId id);

src/libs/database/include/database/objects/Grouping.hpp

@@ -82,12 +82,12 @@ namespace lms::db
         Grouping() = default;
 
         static std::size_t getCount(Session& session);
-        static RangeResults<GroupingId> findIds(Session& session, const FindParameters& params);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<GroupingId> findIds(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
         static pointer find(Session& session, GroupingId id);
         static pointer find(Session& session, std::string_view name);
-        static RangeResults<GroupingId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<GroupingId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         std::string_view getName() const { return _name; }
 

src/libs/database/include/database/objects/Image.hpp

@@ -73,7 +73,7 @@ namespace lms::db
         static std::size_t getCount(Session& session);
         static pointer find(Session& session, ImageId id);
         static pointer find(Session& session, const std::filesystem::path& file);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& parameters, const std::function<void(const Image::pointer&)>& func);
         static void find(Session& session, ImageId& lastRetrievedId, std::size_t count, const std::function<void(const Image::pointer&)>& func);
         static void findAbsoluteFilePath(Session& session, ImageId& lastRetrievedId, std::size_t count, const std::function<void(ImageId imageId, const std::filesystem::path& absoluteFilePath)>& func);

src/libs/database/include/database/objects/Language.hpp

@@ -82,12 +82,12 @@ namespace lms::db
         Language() = default;
 
         static std::size_t getCount(Session& session);
-        static RangeResults<LanguageId> findIds(Session& session, const FindParameters& params);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<LanguageId> findIds(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
         static pointer find(Session& session, LanguageId id);
         static pointer find(Session& session, std::string_view name);
-        static RangeResults<LanguageId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<LanguageId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         std::string_view getName() const { return _name; }
 

src/libs/database/include/database/objects/Listen.hpp

@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include <functional>
 #include <optional>
 
 #include <Wt/Dbo/Field.h>
@@ -36,6 +37,8 @@
 
 namespace lms::db
 {
+    class Artist;
+    class Release;
     class Session;
     class Track;
     class User;
@@ -78,13 +81,12 @@ namespace lms::db
         static std::size_t getCount(Session& session);
         static pointer find(Session& session, ListenId id);
         static pointer find(Session& session, UserId userId, TrackId trackId, ScrobblingBackend backend, const Wt::WDateTime& dateTime);
-        static RangeResults<ListenId> find(Session& session, const FindParameters& parameters);
+        static std::vector<ListenId> find(Session& session, const FindParameters& parameters);
 
         // Stats
         struct StatsFindParameters
         {
             UserId user;
-            std::optional<ScrobblingBackend> backend;
             db::Filters filters;
             std::vector<std::string_view> keywords; // if non empty, name must match all of these keywords
             std::optional<Range> range;
@@ -95,11 +97,6 @@ namespace lms::db
                 user = _user;
                 return *this;
             }
-            StatsFindParameters& setScrobblingBackend(std::optional<ScrobblingBackend> _backend)
-            {
-                backend = _backend;
-                return *this;
-            }
             StatsFindParameters& setFilters(const db::Filters& _filters)
             {
                 filters = _filters;
@@ -139,13 +136,19 @@ namespace lms::db
             }
         };
 
-        static RangeResults<ArtistId> getTopArtists(Session& session, const ArtistStatsFindParameters& params);
-        static RangeResults<ReleaseId> getTopReleases(Session& session, const StatsFindParameters& params);
-        static RangeResults<TrackId> getTopTracks(Session& session, const StatsFindParameters& params);
+        static std::vector<ArtistId> getTopArtists(Session& session, const ArtistStatsFindParameters& params);
+        static std::vector<ReleaseId> getTopReleases(Session& session, const StatsFindParameters& params);
+        static std::vector<TrackId> getTopTracks(Session& session, const StatsFindParameters& params);
+        static std::vector<ArtistId> getRecentArtists(Session& session, const ArtistStatsFindParameters& params);
+        static std::vector<ReleaseId> getRecentReleases(Session& session, const StatsFindParameters& params);
+        static std::vector<TrackId> getRecentTracks(Session& session, const StatsFindParameters& params);
 
-        static RangeResults<ArtistId> getRecentArtists(Session& session, const ArtistStatsFindParameters& params);
-        static RangeResults<ReleaseId> getRecentReleases(Session& session, const StatsFindParameters& params);
-        static RangeResults<TrackId> getRecentTracks(Session& session, const StatsFindParameters& params);
+        static void getTopArtists(Session& session, const ArtistStatsFindParameters& params, const std::function<void(const ObjectPtr<Artist>&)>& func);
+        static void getTopReleases(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Release>&)>& func);
+        static void getTopTracks(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Track>&)>& func);
+        static void getRecentArtists(Session& session, const ArtistStatsFindParameters& params, const std::function<void(const ObjectPtr<Artist>&)>& func);
+        static void getRecentReleases(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Release>&)>& func);
+        static void getRecentTracks(Session& session, const StatsFindParameters& params, const std::function<void(const ObjectPtr<Track>&)>& func);
 
         static std::size_t getCount(Session& session, UserId userId, TrackId trackId);   // for the current backend
         static std::size_t getCount(Session& session, UserId userId, ReleaseId trackId); // for the current backend

src/libs/database/include/database/objects/Medium.hpp

@@ -78,7 +78,7 @@ namespace lms::db
         static pointer find(Session& session, ReleaseId id, std::optional<std::size_t> position);
         static void find(Session& session, const IdRange<MediumId>& idRange, const std::function<void(const Medium::pointer&)>& func);
         static IdRange<MediumId> findNextIdRange(Session& session, MediumId lastRetrievedId, std::size_t count);
-        static RangeResults<MediumId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<MediumId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         // Updates
         static void updatePreferredArtwork(Session& session, MediumId mediumId, ArtworkId artworkId);

src/libs/database/include/database/objects/Mood.hpp

@@ -82,12 +82,12 @@ namespace lms::db
         Mood() = default;
 
         static std::size_t getCount(Session& session);
-        static RangeResults<MoodId> findIds(Session& session, const FindParameters& params);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<MoodId> findIds(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
         static pointer find(Session& session, MoodId id);
         static pointer find(Session& session, std::string_view name);
-        static RangeResults<MoodId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<MoodId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         std::string_view getName() const { return _name; }
 

src/libs/database/include/database/objects/Release.hpp

@@ -70,7 +70,7 @@ namespace lms::db
         static std::size_t getCount(Session& session);
         static pointer find(Session& session, CountryId id);
         static pointer find(Session& session, std::string_view name);
-        static RangeResults<CountryId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<CountryId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         // Accessors
         std::string_view getName() const { return _name; }
@@ -102,7 +102,7 @@ namespace lms::db
         static pointer find(Session& session, LabelId id);
         static pointer find(Session& session, std::string_view name);
         static void find(Session& session, LabelSortMethod sortMethod, std::function<void(const Label::pointer& label)> func);
-        static RangeResults<LabelId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<LabelId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         // Accessors
         std::string_view getName() const { return _name; }
@@ -134,7 +134,7 @@ namespace lms::db
         static pointer find(Session& session, ReleaseTypeId id);
         static pointer find(Session& session, std::string_view name);
         static void find(Session& session, ReleaseTypeSortMethod sortMethod, std::function<void(const ReleaseType::pointer& releaseType)> func);
-        static RangeResults<ReleaseTypeId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<ReleaseTypeId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
 
         // Accessors
         std::string_view getName() const { return _name; }
@@ -170,8 +170,7 @@ namespace lms::db
             Wt::WDateTime writtenAfter;
             std::optional<YearRange> dateRange;
             std::optional<YearRange> originalDateRange;
-            UserId starringUser;                                     // only releases starred by this user
-            std::optional<FeedbackBackend> feedbackBackend;          //    and for this backend
+            UserId starringUser;                                     // only releases starred by this user (uses their current feedback backend)
             ArtistId artist;                                         // only releases by this release artist
             ArtistId trackArtist;                                    // only releases that involved this track artist
             core::EnumSet<TrackArtistLinkType> trackArtistLinkTypes; //    and for these link types, if set
@@ -220,10 +219,9 @@ namespace lms::db
                 originalDateRange = _originalDateRange;
                 return *this;
             }
-            FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend)
+            FindParameters& setStarringUser(UserId _user)
             {
                 starringUser = _user;
-                feedbackBackend = _feedbackBackend;
                 return *this;
             }
             FindParameters& setArtist(ArtistId _artist)
@@ -269,11 +267,11 @@ namespace lms::db
         static void find(Session& session, ReleaseId& lastRetrievedRelease, std::size_t count, const std::function<void(const Release::pointer&)>& func, MediaLibraryId library = {});
         static void find(Session& session, const IdRange<ReleaseId>& idRange, const std::function<void(const Release::pointer&)>& func);
         static IdRange<ReleaseId> findNextIdRange(Session& session, ReleaseId lastRetrievedId, std::size_t count);
-        static RangeResults<pointer> find(Session& session, const FindParameters& parameters);
+        static std::vector<pointer> find(Session& session, const FindParameters& parameters);
         static void find(Session& session, const FindParameters& parameters, const std::function<void(const pointer&)>& func);
-        static RangeResults<ReleaseId> findIds(Session& session, const FindParameters& parameters);
+        static std::vector<ReleaseId> findIds(Session& session, const FindParameters& parameters);
         static std::size_t getCount(Session& session, const FindParameters& parameters);
-        static RangeResults<ReleaseId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt); // not track related
+        static std::vector<ReleaseId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt); // not track related
 
         // Updates
         static void updatePreferredArtwork(Session& session, ReleaseId id, ArtworkId artworkId);

src/libs/database/include/database/objects/StarredTrack.hpp

@@ -73,7 +73,7 @@ namespace lms::db
         static pointer find(Session& session, TrackId trackId, UserId userId); // current feedback backend
         static pointer find(Session& session, TrackId trackId, UserId userId, FeedbackBackend backend);
         static bool exists(Session& session, TrackId trackId, UserId userId, FeedbackBackend backend);
-        static RangeResults<StarredTrackId> find(Session& session, const FindParameters& findParams);
+        static std::vector<StarredTrackId> find(Session& session, const FindParameters& findParams);
 
         // Accessors
         ObjectPtr<Track> getTrack() const { return _track; }

src/libs/database/include/database/objects/Track.hpp

@@ -91,8 +91,7 @@ namespace lms::db
             TrackSortMethod sortMethod{ TrackSortMethod::None };
             std::optional<Range> range;
             Wt::WDateTime writtenAfter;
-            UserId starringUser;                                     // only tracks starred by this user
-            std::optional<FeedbackBackend> feedbackBackend;          // and for this feedback backend
+            UserId starringUser;                                     // only tracks starred by this user (uses their current feedback backend)
             ArtistId artist;                                         // only tracks that involve this artist
             std::string artistName;                                  // only tracks that involve this artist name
             core::EnumSet<TrackArtistLinkType> trackArtistLinkTypes; //    and for these link types
@@ -138,10 +137,9 @@ namespace lms::db
                 writtenAfter = _after;
                 return *this;
             }
-            FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend)
+            FindParameters& setStarringUser(UserId _user)
             {
                 starringUser = _user;
-                feedbackBackend = _feedbackBackend;
                 return *this;
             }
             FindParameters& setArtist(ArtistId _artist, core::EnumSet<TrackArtistLinkType> _trackArtistLinkTypes = {})
@@ -231,12 +229,11 @@ namespace lms::db
         static bool exists(Session& session, TrackId id);
         static std::vector<pointer> findByRecordingMBID(Session& session, const core::UUID& MBID);
         static std::vector<pointer> findByMBID(Session& session, const core::UUID& MBID);
-        static RangeResults<TrackId> findIds(Session& session, const FindParameters& params);
-        static RangeResults<pointer> find(Session& session, const FindParameters& params);
+        static std::vector<TrackId> findIds(Session& session, const FindParameters& params);
+        static std::vector<pointer> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, const std::function<void(const Track::pointer&)>& func);
-        static void find(Session& session, const FindParameters& params, bool& moreResults, const std::function<void(const Track::pointer&)>& func);
         static std::size_t getCount(Session& session, const FindParameters& params);
-        static RangeResults<TrackId> findIdsTrackMBIDDuplicates(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<TrackId> findIdsTrackMBIDDuplicates(Session& session, std::optional<Range> range = std::nullopt);
 
         // Update utility functions
         static void updatePreferredArtwork(Session& session, TrackId trackId, ArtworkId artworkId);

src/libs/database/include/database/objects/TrackBookmark.hpp

@@ -46,7 +46,7 @@ namespace lms::db
         // Find utility functions
         static std::size_t getCount(Session& session);
         static pointer find(Session& session, TrackBookmarkId id);
-        static RangeResults<TrackBookmarkId> find(Session& session, UserId userId, std::optional<Range> range = std::nullopt);
+        static std::vector<TrackBookmarkId> find(Session& session, UserId userId, std::optional<Range> range = std::nullopt);
         static pointer find(Session& session, UserId userId, TrackId trackId);
 
         // Setters

src/libs/database/include/database/objects/TrackEmbeddedImage.hpp

@@ -100,7 +100,7 @@ namespace lms::db
         static pointer find(Session& session, TrackEmbeddedImageId id);
         static void find(Session& session, const FindParameters& params, const std::function<void(const pointer&)>& func);
         static pointer find(Session& session, std::size_t size, ImageHashType hash);
-        static RangeResults<TrackEmbeddedImageId> findOrphanIds(Session& session, std::optional<Range> range);
+        static std::vector<TrackEmbeddedImageId> findOrphanIds(Session& session, std::optional<Range> range);
 
         // getters
         ImageHashType getHash() const { return _hash; }

src/libs/database/include/database/objects/TrackList.hpp

@@ -116,7 +116,7 @@ namespace lms::db
         static std::size_t getCount(Session& session);
         static pointer find(Session& session, std::string_view name, TrackListType type, UserId userId);
         static pointer find(Session& session, TrackListId tracklistId);
-        static RangeResults<TrackListId> find(Session& session, const FindParameters& params);
+        static std::vector<TrackListId> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, const std::function<void(const TrackList::pointer&)>& func);
 
         // Accessors
@@ -139,7 +139,7 @@ namespace lms::db
         bool isEmpty() const;
         std::size_t getCount() const;
         ObjectPtr<TrackListEntry> getEntry(std::size_t pos) const;
-        RangeResults<ObjectPtr<TrackListEntry>> getEntries(std::optional<Range> range = {}) const;
+        std::vector<ObjectPtr<TrackListEntry>> getEntries(std::optional<Range> range = {}) const;
         ObjectPtr<TrackListEntry> getEntryByTrackAndDateTime(ObjectPtr<Track> track, const Wt::WDateTime& dateTime) const;
 
         std::vector<TrackId> getTrackIds() const;

src/libs/database/include/database/objects/TrackLyrics.hpp

@@ -83,7 +83,7 @@ namespace lms::db
         static pointer find(Session& session, const std::filesystem::path& file);
         static void find(Session& session, const FindParameters& params, const std::function<void(const TrackLyrics::pointer&)>& func);
         static void find(Session& session, TrackLyricsId& lastRetrievedId, std::size_t count, const std::function<void(const TrackLyrics::pointer&)>& func);
-        static RangeResults<TrackLyricsId> findOrphanIds(Session& session, std::optional<Range> range);
+        static std::vector<TrackLyricsId> findOrphanIds(Session& session, std::optional<Range> range);
         static void findAbsoluteFilePath(Session& session, TrackLyricsId& lastRetrievedId, std::size_t count, const std::function<void(TrackLyricsId trackLyricsId, const std::filesystem::path& absoluteFilePath)>& func);
 
         using SynchronizedLines = std::map<std::chrono::milliseconds, std::string>;

src/libs/database/include/database/objects/TrackMusicNNEmbeddings.hpp

@@ -45,7 +45,7 @@ namespace lms::db
         static std::size_t getCount(Session& session);
         static pointer find(Session& session, TrackMusicNNEmbeddingsId id);
         static pointer find(Session& session, TrackId trackId);
-        static RangeResults<TrackMusicNNEmbeddingsId> find(Session& session, std::optional<Range> range = std::nullopt);
+        static std::vector<TrackMusicNNEmbeddingsId> find(Session& session, std::optional<Range> range = std::nullopt);
         static void find(Session& session, std::function<void(const pointer&)> func);
         static void removeAll(Session& session);
 

src/libs/database/include/database/objects/User.hpp

@@ -88,7 +88,7 @@ namespace lms::db
         static std::size_t getCount(Session& session);
         static pointer find(Session& session, UserId id);
         static pointer find(Session& session, std::string_view loginName);
-        static RangeResults<UserId> find(Session& session, const FindParameters& params);
+        static std::vector<UserId> find(Session& session, const FindParameters& params);
         static void find(Session& session, const FindParameters& params, const std::function<void(const pointer&)>& func);
         static pointer findDemoUser(Session& session);
 

src/libs/database/test/Artist.cpp

@@ -55,20 +55,20 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
 
             artists = Artist::findOrphanIds(session);
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::find(session, Artist::FindParameters{}) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front()->getId(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front()->getId(), artist.getId());
         }
 
         {
@@ -181,10 +181,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            ASSERT_EQ(artists.results.size(), 0);
-            ASSERT_FALSE(artists.moreResults);
-            ASSERT_EQ(artists.range.offset, 0);
-            ASSERT_EQ(artists.range.size, 0);
+            ASSERT_EQ(artists.size(), 0);
         }
 
         ScopedArtist artist1{ session, "MyArtist1" };
@@ -195,43 +192,31 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            ASSERT_EQ(artists.results.size(), 3);
-            ASSERT_FALSE(artists.moreResults);
-            ASSERT_EQ(artists.range.offset, 0);
-            ASSERT_EQ(artists.range.size, 3);
+            ASSERT_EQ(artists.size(), 3);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setRange(Range{ 0, 1 })) };
-            ASSERT_EQ(artists.results.size(), 1);
-            ASSERT_TRUE(artists.moreResults);
-            ASSERT_EQ(artists.range.offset, 0);
-            ASSERT_EQ(artists.range.size, 1);
-            EXPECT_EQ(artists.results[0], artist1.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists[0], artist1.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setRange(Range{ 1, 1 })) };
-            ASSERT_EQ(artists.results.size(), 1);
-            ASSERT_TRUE(artists.moreResults);
-            ASSERT_EQ(artists.range.offset, 1);
-            ASSERT_EQ(artists.range.size, 1);
-            EXPECT_EQ(artists.results[0], artist2.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists[0], artist2.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setRange(Range{ 2, 1 })) };
-            ASSERT_EQ(artists.results.size(), 1);
-            ASSERT_FALSE(artists.moreResults);
-            ASSERT_EQ(artists.range.offset, 2);
-            ASSERT_EQ(artists.range.size, 1);
-            EXPECT_EQ(artists.results[0], artist3.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists[0], artist3.getId());
         }
     }
 
@@ -249,7 +234,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session).size(), 0);
         }
 
         {
@@ -310,29 +295,29 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtist")) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setArtistName("MyArtistFoo")) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackNameFoo").setArtistName("MyArtist")) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setTrack(track->getId())) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).results.size(), 0);
+            EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).size(), 0);
         }
     }
 
@@ -343,7 +328,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::findOrphanIds(session).results, std::vector<db::ArtistId>{ artist.getId() });
+            EXPECT_EQ(Artist::findOrphanIds(session), std::vector<db::ArtistId>{ artist.getId() });
         }
 
         {
@@ -353,7 +338,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session).size(), 0);
         }
     }
 
@@ -374,19 +359,19 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setTrack(track->getId())) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setMediaLibrary(library->getId()))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setMediaLibrary(otherLibrary->getId()))) };
-            EXPECT_EQ(artists.results.size(), 0);
+            EXPECT_EQ(artists.size(), 0);
         }
     }
 
@@ -416,26 +401,26 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setMediaLibrary(library1->getId()))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setMediaLibrary(library2->getId()))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setMediaLibrary(otherLibrary->getId()))) };
-            EXPECT_EQ(artists.results.size(), 0);
+            EXPECT_EQ(artists.size(), 0);
         }
     }
 
@@ -460,15 +445,15 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setMediaLibrary(library->getId()))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
 
         {
@@ -479,8 +464,8 @@ namespace lms::db::tests
             params.setFilters(Filters{}.setMediaLibrary(library.getId()));
 
             auto artists{ Artist::findIds(session, params) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
 
         {
@@ -491,7 +476,7 @@ namespace lms::db::tests
             params.setFilters(Filters{}.setMediaLibrary(library.getId()));
 
             auto artists{ Artist::findIds(session, params) };
-            EXPECT_EQ(artists.results.size(), 0);
+            EXPECT_EQ(artists.size(), 0);
         }
 
         {
@@ -502,8 +487,8 @@ namespace lms::db::tests
             params.setFilters(Filters{}.setMediaLibrary(library.getId()));
 
             auto artists{ Artist::findIds(session, params) };
-            EXPECT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            EXPECT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
     }
 
@@ -521,18 +506,18 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::findOrphanIds(session, Range{}).results.size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session, Range{}).size(), 0);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).results.size(), 1);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Artist)).results.size(), 1);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Producer)).results.size(), 1);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Writer)).results.size(), 1);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Composer)).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).size(), 1);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Artist)).size(), 1);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Producer)).size(), 1);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Writer)).size(), 1);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setTrackArtistLinkType(TrackArtistLinkType::Composer)).size(), 0);
 
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).size(), 0);
         }
 
         {
@@ -549,17 +534,17 @@ namespace lms::db::tests
             EXPECT_EQ(track->getArtistLinks().size(), 3);
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId())) };
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
 
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Producer }));
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Artist }));
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Writer }));
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
 
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer }));
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
 
         {
@@ -609,7 +594,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session).size(), 0);
         }
 
         {
@@ -623,32 +608,32 @@ namespace lms::db::tests
             EXPECT_EQ(track->getArtists({}).size(), 2);
             EXPECT_EQ(track->getArtists({ TrackArtistLinkType::Artist }).size(), 2);
             EXPECT_EQ(track->getArtists({ TrackArtistLinkType::Arranger }).size(), 0);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).results.size(), 2);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).size(), 2);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::Random)).size(), 2);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setArtist(artist1->getId())) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track->getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track->getId());
 
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId()));
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track->getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track->getId());
 
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist1->getId(), { TrackArtistLinkType::Arranger }));
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
 
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist1->getId(), { TrackArtistLinkType::Artist }));
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
 
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId(), { TrackArtistLinkType::Arranger }));
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
 
             tracks = Track::findIds(session, Track::FindParameters{}.setArtist(artist2->getId(), { TrackArtistLinkType::Artist }));
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
         }
 
         {
@@ -697,7 +682,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).results.size(), 0);
+            EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).size(), 0);
         }
 
         {
@@ -707,7 +692,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).results.size(), 1);
+            EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setReleaseArtistsOnly(true)).size(), 1);
         }
     }
 
@@ -734,8 +719,8 @@ namespace lms::db::tests
             params.setFilters(Filters{}.setCodec(core::media::Codec::FLAC));
 
             const auto artists{ Artist::find(session, params) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front()->getId(), artist2.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front()->getId(), artist2.getId());
         }
     }
 
@@ -753,15 +738,15 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "N" })).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "N" })).size(), 0);
 
             const auto artistsByAAA{ Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "A" })) };
-            ASSERT_EQ(artistsByAAA.results.size(), 1);
-            EXPECT_EQ(artistsByAAA.results.front(), artist.getId());
+            ASSERT_EQ(artistsByAAA.size(), 1);
+            EXPECT_EQ(artistsByAAA.front(), artist.getId());
 
             const auto artistsByZZZ{ Artist::Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "Z" })) };
-            ASSERT_EQ(artistsByZZZ.results.size(), 1);
-            EXPECT_EQ(artistsByZZZ.results.front(), artist.getId());
+            ASSERT_EQ(artistsByZZZ.size(), 1);
+            EXPECT_EQ(artistsByZZZ.front(), artist.getId());
 
             EXPECT_EQ(Artist::find(session, "NNN").size(), 0);
             EXPECT_EQ(Artist::find(session, "AAA").size(), 1);
@@ -804,27 +789,27 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
             {
                 const auto artists{ Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "MyArtist" })) };
-                EXPECT_EQ(artists.results.size(), 6);
+                EXPECT_EQ(artists.size(), 6);
             }
 
             {
                 const auto artists{ Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "MyArtist%" }).setSortMethod(ArtistSortMethod::Name)) };
-                ASSERT_EQ(artists.results.size(), 2);
-                EXPECT_EQ(artists.results[0], artist1.getId());
-                EXPECT_EQ(artists.results[1], artist4.getId());
+                ASSERT_EQ(artists.size(), 2);
+                EXPECT_EQ(artists[0], artist1.getId());
+                EXPECT_EQ(artists[1], artist4.getId());
             }
 
             {
                 const auto artists{ Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "%MyArtist" }).setSortMethod(ArtistSortMethod::Name)) };
-                ASSERT_EQ(artists.results.size(), 2);
-                EXPECT_EQ(artists.results[0], artist2.getId());
-                EXPECT_EQ(artists.results[1], artist5.getId());
+                ASSERT_EQ(artists.size(), 2);
+                EXPECT_EQ(artists[0], artist2.getId());
+                EXPECT_EQ(artists[1], artist5.getId());
             }
 
             {
                 const auto artists{ Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "_MyArtist" }).setSortMethod(ArtistSortMethod::Name)) };
-                ASSERT_EQ(artists.results.size(), 1);
-                EXPECT_EQ(artists.results[0], artist3.getId());
+                ASSERT_EQ(artists.size(), 1);
+                EXPECT_EQ(artists[0], artist3.getId());
             }
         }
     }
@@ -934,13 +919,13 @@ namespace lms::db::tests
             auto allArtistsByName{ Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::Name)) };
             auto allArtistsBySortName{ Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::SortName)) };
 
-            ASSERT_EQ(allArtistsByName.results.size(), 2);
-            EXPECT_EQ(allArtistsByName.results.front(), artistA.getId());
-            EXPECT_EQ(allArtistsByName.results.back(), artistB.getId());
+            ASSERT_EQ(allArtistsByName.size(), 2);
+            EXPECT_EQ(allArtistsByName.front(), artistA.getId());
+            EXPECT_EQ(allArtistsByName.back(), artistB.getId());
 
-            ASSERT_EQ(allArtistsBySortName.results.size(), 2);
-            EXPECT_EQ(allArtistsBySortName.results.front(), artistB.getId());
-            EXPECT_EQ(allArtistsBySortName.results.back(), artistA.getId());
+            ASSERT_EQ(allArtistsBySortName.size(), 2);
+            EXPECT_EQ(allArtistsBySortName.front(), artistB.getId());
+            EXPECT_EQ(allArtistsBySortName.back(), artistA.getId());
         }
     }
 
@@ -955,7 +940,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setNonRelease(true).setArtist(artist->getId())) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
 
         {
@@ -971,8 +956,8 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setArtist(artist.getId()).setNonRelease(true)) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track2.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track2.getId());
         }
     }
 
@@ -1033,11 +1018,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto artists{ Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::AddedDesc)) };
-            ASSERT_EQ(artists.results.size(), 4);
-            EXPECT_EQ(artists.results[0], artistD.getId());
-            EXPECT_EQ(artists.results[1], artistA.getId());
-            EXPECT_EQ(artists.results[2], artistB.getId());
-            EXPECT_EQ(artists.results[3], artistC.getId());
+            ASSERT_EQ(artists.size(), 4);
+            EXPECT_EQ(artists[0], artistD.getId());
+            EXPECT_EQ(artists[1], artistA.getId());
+            EXPECT_EQ(artists[2], artistB.getId());
+            EXPECT_EQ(artists[3], artistC.getId());
         }
     }
 
@@ -1073,11 +1058,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto artists{ Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::LastWrittenDesc)) };
-            ASSERT_EQ(artists.results.size(), 4);
-            EXPECT_EQ(artists.results[0], artistA.getId());
-            EXPECT_EQ(artists.results[1], artistD.getId());
-            EXPECT_EQ(artists.results[2], artistB.getId());
-            EXPECT_EQ(artists.results[3], artistC.getId());
+            ASSERT_EQ(artists.size(), 4);
+            EXPECT_EQ(artists[0], artistA.getId());
+            EXPECT_EQ(artists[1], artistD.getId());
+            EXPECT_EQ(artists[2], artistB.getId());
+            EXPECT_EQ(artists[3], artistC.getId());
         }
     }
 
@@ -1144,8 +1129,8 @@ namespace lms::db::tests
             ArtistId lastRetrievedArtist;
             const auto results{ Artist::findWithMBIDNameVariants(session, lastRetrievedArtist) };
 
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results[0]->getId(), artistA.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results[0]->getId(), artistA.getId());
             EXPECT_EQ(lastRetrievedArtist, artistA.getId());
         }
     }

src/libs/database/test/Cluster.cpp

@@ -50,26 +50,26 @@ namespace lms::db::tests
 
                 {
                     const auto clusters{ Cluster::findIds(session, Cluster::FindParameters{}) };
-                    ASSERT_EQ(clusters.results.size(), 1);
-                    EXPECT_EQ(clusters.results.front(), cluster.getId());
+                    ASSERT_EQ(clusters.size(), 1);
+                    EXPECT_EQ(clusters.front(), cluster.getId());
                 }
 
                 {
                     const auto clusters{ Cluster::findOrphanIds(session) };
-                    ASSERT_EQ(clusters.results.size(), 1);
-                    EXPECT_EQ(clusters.results.front(), cluster.getId());
+                    ASSERT_EQ(clusters.size(), 1);
+                    EXPECT_EQ(clusters.front(), cluster.getId());
                 }
 
                 auto clusterTypes{ ClusterType::findIds(session) };
-                ASSERT_EQ(clusterTypes.results.size(), 1);
-                EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
+                ASSERT_EQ(clusterTypes.size(), 1);
+                EXPECT_EQ(clusterTypes.front(), clusterType.getId());
 
                 clusterTypes = ClusterType::findUsed(session);
-                ASSERT_EQ(clusterTypes.results.size(), 1);
-                EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
+                ASSERT_EQ(clusterTypes.size(), 1);
+                EXPECT_EQ(clusterTypes.front(), clusterType.getId());
 
                 clusterTypes = ClusterType::findOrphanIds(session);
-                EXPECT_EQ(clusterTypes.results.size(), 0);
+                EXPECT_EQ(clusterTypes.size(), 0);
             }
         }
 
@@ -77,10 +77,10 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto clusterTypes{ ClusterType::findOrphanIds(session) };
-            ASSERT_EQ(clusterTypes.results.size(), 1);
-            EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
+            ASSERT_EQ(clusterTypes.size(), 1);
+            EXPECT_EQ(clusterTypes.front(), clusterType.getId());
 
-            ASSERT_EQ(ClusterType::findUsed(session).results.size(), 0);
+            ASSERT_EQ(ClusterType::findUsed(session).size(), 0);
         }
     }
 
@@ -155,10 +155,10 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Cluster::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Cluster::findOrphanIds(session).size(), 0);
             auto clusterTypes{ ClusterType::findOrphanIds(session) };
-            ASSERT_EQ(clusterTypes.results.size(), 1);
-            EXPECT_EQ(clusterTypes.results.front(), clusterType.getId());
+            ASSERT_EQ(clusterTypes.size(), 1);
+            EXPECT_EQ(clusterTypes.front(), clusterType.getId());
         }
 
         ScopedCluster cluster1{ session, clusterType.lockAndGet(), "MyCluster1" };
@@ -167,7 +167,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto clusters{ Cluster::findOrphanIds(session) };
-            EXPECT_EQ(clusters.results.size(), 2);
+            EXPECT_EQ(clusters.size(), 2);
             EXPECT_EQ(track->getClusters().size(), 0);
             EXPECT_EQ(track->getClusterIds().size(), 0);
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster1.getId()), 0);
@@ -183,8 +183,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto clusters{ Cluster::findIds(session, Cluster::FindParameters{}.setTrack(track.getId())) };
-            ASSERT_EQ(clusters.results.size(), 1);
-            EXPECT_EQ(clusters.results.front(), cluster1.getId());
+            ASSERT_EQ(clusters.size(), 1);
+            EXPECT_EQ(clusters.front(), cluster1.getId());
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster1.getId()), 1);
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster2.getId()), 0);
         }
@@ -192,21 +192,21 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto clusters{ Cluster::findOrphanIds(session) };
-            ASSERT_EQ(clusters.results.size(), 1);
-            EXPECT_EQ(clusters.results.front(), cluster2.getId());
+            ASSERT_EQ(clusters.size(), 1);
+            EXPECT_EQ(clusters.front(), cluster2.getId());
 
-            EXPECT_EQ(ClusterType::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(ClusterType::findOrphanIds(session).size(), 0);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster1.getId() }))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             tracks = Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster2.getId() })));
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
 
         {
@@ -236,7 +236,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setClusters(clusterIds))) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
 
         {
@@ -249,7 +249,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setClusters(clusterIds))) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster1.getId()), 1);
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster2.getId()), 0);
         }
@@ -264,8 +264,8 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setClusters(clusterIds))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster1.getId()), 1);
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster2.getId()), 1);
         }
@@ -289,11 +289,11 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Cluster::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Cluster::findOrphanIds(session).size(), 0);
 
             EXPECT_EQ(Cluster::computeTrackCount(session, cluster.getId()), tracks.size());
 
-            for (TrackId trackId : cluster->getTracks().results)
+            for (TrackId trackId : cluster->getTracks())
             {
                 auto it{ std::find_if(std::cbegin(tracks), std::cend(tracks), [&](const ScopedTrack& track) { return trackId == track.getId(); }) };
                 EXPECT_TRUE(it != std::cend(tracks));
@@ -333,8 +333,8 @@ namespace lms::db::tests
     {
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Cluster::find(session, Cluster::FindParameters{}).results.size(), 0);
-            EXPECT_EQ(Cluster::find(session, Cluster::FindParameters{}.setClusterTypeName("Foo")).results.size(), 0);
+            EXPECT_EQ(Cluster::find(session, Cluster::FindParameters{}).size(), 0);
+            EXPECT_EQ(Cluster::find(session, Cluster::FindParameters{}.setClusterTypeName("Foo")).size(), 0);
         }
 
         ScopedClusterType clusterType{ session, "MyClusterType" };
@@ -342,18 +342,18 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            auto clusters{ Cluster::findIds(session, Cluster::FindParameters{}).results };
+            auto clusters{ Cluster::findIds(session, Cluster::FindParameters{}) };
             ASSERT_EQ(clusters.size(), 1);
             EXPECT_EQ(clusters.front(), cluster.getId());
 
-            clusters = Cluster::findIds(session, Cluster::FindParameters{}.setClusterType(clusterType.getId())).results;
+            clusters = Cluster::findIds(session, Cluster::FindParameters{}.setClusterType(clusterType.getId()));
             ASSERT_EQ(clusters.size(), 1);
             EXPECT_EQ(clusters.front(), cluster.getId());
 
-            clusters = Cluster::findIds(session, Cluster::FindParameters{}.setClusterTypeName("Foo")).results;
+            clusters = Cluster::findIds(session, Cluster::FindParameters{}.setClusterTypeName("Foo"));
             EXPECT_EQ(clusters.size(), 0);
 
-            clusters = Cluster::findIds(session, Cluster::FindParameters{}.setClusterTypeName("MyClusterType")).results;
+            clusters = Cluster::findIds(session, Cluster::FindParameters{}.setClusterTypeName("MyClusterType"));
             ASSERT_EQ(clusters.size(), 1);
             EXPECT_EQ(clusters.front(), cluster.getId());
         }
@@ -366,7 +366,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Cluster::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Cluster::findOrphanIds(session).size(), 0);
         }
 
         ScopedClusterType clusterType{ session, "MyClusterType" };
@@ -375,9 +375,9 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            ASSERT_EQ(Cluster::findOrphanIds(session).results.size(), 2);
-            EXPECT_EQ(Release::find(session, Release::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ unusedCluster.getId() }))).results.size(), 0);
-            EXPECT_EQ(Release::find(session, Release::FindParameters{}).results.size(), 1);
+            ASSERT_EQ(Cluster::findOrphanIds(session).size(), 2);
+            EXPECT_EQ(Release::find(session, Release::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ unusedCluster.getId() }))).size(), 0);
+            EXPECT_EQ(Release::find(session, Release::FindParameters{}).size(), 1);
             EXPECT_EQ(Cluster::computeReleaseCount(session, cluster.getId()), 0);
             EXPECT_EQ(Cluster::computeReleaseCount(session, unusedCluster.getId()), 0);
         }
@@ -394,8 +394,8 @@ namespace lms::db::tests
 
             {
                 auto clusters{ Cluster::findOrphanIds(session) };
-                ASSERT_EQ(clusters.results.size(), 1);
-                EXPECT_EQ(clusters.results.front(), unusedCluster.getId());
+                ASSERT_EQ(clusters.size(), 1);
+                EXPECT_EQ(clusters.front(), unusedCluster.getId());
             }
             EXPECT_EQ(Cluster::computeReleaseCount(session, cluster.getId()), 1);
             EXPECT_EQ(Cluster::computeReleaseCount(session, unusedCluster.getId()), 0);
@@ -405,23 +405,23 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto clusters{ Cluster::findIds(session, Cluster::FindParameters{}.setRelease(release.getId())) };
-            ASSERT_EQ(clusters.results.size(), 1);
-            EXPECT_EQ(clusters.results.front(), cluster.getId());
+            ASSERT_EQ(clusters.size(), 1);
+            EXPECT_EQ(clusters.front(), cluster.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster.getId() }))) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ unusedCluster.getId() }))) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
 
         {
@@ -451,10 +451,10 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(ClusterType::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(Cluster::findOrphanIds(session).results.size(), 2);
-            EXPECT_EQ(Release::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(Artist::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(ClusterType::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(Cluster::findOrphanIds(session).size(), 2);
+            EXPECT_EQ(Release::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session).size(), 0);
         }
 
         {
@@ -467,11 +467,11 @@ namespace lms::db::tests
             auto transaction{ session.createWriteTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster1.getId() }))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
 
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster2.getId() }))).results.size(), 0);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster3.getId() }))).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster2.getId() }))).size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster3.getId() }))).size(), 0);
 
             cluster2.get().modify()->addTrack(track.get());
         }
@@ -480,18 +480,18 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster1.getId() }))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
 
             artists = Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster2.getId() })));
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
 
             artists = Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster1.getId() })));
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
 
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster3.getId() }))).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster3.getId() }))).size(), 0);
         }
     }
 
@@ -512,17 +512,17 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Cluster::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(Release::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(Artist::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Cluster::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(Release::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session).size(), 0);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster.getId() }))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
     }
 
@@ -552,8 +552,8 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Cluster::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(Artist::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Cluster::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session).size(), 0);
         }
 
         {
@@ -563,8 +563,8 @@ namespace lms::db::tests
             std::transform(std::cbegin(clusters), std::cend(clusters), std::back_inserter(clusterIds), [](const ScopedCluster& cluster) { return cluster.getId(); });
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(clusterIds))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
         }
     }
 
@@ -587,26 +587,26 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            EXPECT_EQ(Cluster::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(ClusterType::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(Artist::findOrphanIds(session).results.size(), 0);
-            EXPECT_EQ(Release::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Cluster::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(ClusterType::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(Artist::findOrphanIds(session).size(), 0);
+            EXPECT_EQ(Release::findOrphanIds(session).size(), 0);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster.getId() }))) };
-            ASSERT_EQ(artists.results.size(), 1);
-            EXPECT_EQ(artists.results.front(), artist.getId());
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists.front(), artist.getId());
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId())) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId()).setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster.getId() })));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
         }
     }
 
@@ -632,12 +632,12 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId())) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId()).setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster1.getId(), cluster2.getId() })));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
         }
     }
 
@@ -743,17 +743,17 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto genres{ Cluster::find(session, Cluster::FindParameters{}.setTrack(track.getId()).setClusterTypeName("GENRE")) };
-            ASSERT_EQ(genres.results.size(), 2);
+            ASSERT_EQ(genres.size(), 2);
 
             const auto moods{ Cluster::find(session, Cluster::FindParameters{}.setTrack(track.getId()).setClusterTypeName("MOOD")) };
-            ASSERT_EQ(moods.results.size(), 1);
-            EXPECT_EQ(moods.results.front()->getId(), mood.getId());
+            ASSERT_EQ(moods.size(), 1);
+            EXPECT_EQ(moods.front()->getId(), mood.getId());
 
             const auto all{ Cluster::find(session, Cluster::FindParameters{}.setTrack(track.getId())) };
-            EXPECT_EQ(all.results.size(), 3);
+            EXPECT_EQ(all.size(), 3);
 
             const auto none{ Cluster::find(session, Cluster::FindParameters{}.setTrack(track.getId()).setClusterTypeName("GROUPING")) };
-            EXPECT_EQ(none.results.size(), 0);
+            EXPECT_EQ(none.size(), 0);
         }
     }
 

src/libs/database/test/Common.cpp

@@ -74,26 +74,6 @@ namespace lms::db::tests
         session.fullAnalyze();
     }
 
-    TEST_F(DatabaseFixture, Common_subRangeEmpty)
-    {
-        RangeResults<int> results;
-        results.range = Range{ 0, 0 };
-        results.results = {};
-        results.moreResults = false;
-
-        {
-            auto subRange{ results.getSubRange(Range{ 0, 0 }) };
-            EXPECT_FALSE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 0);
-            EXPECT_EQ(subRange.range, Range{});
-        }
-        {
-            auto subRange{ results.getSubRange(Range{ 0, 1 }) };
-            EXPECT_FALSE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 0);
-        }
-    }
-
     TEST_F(DatabaseFixture, Common_subRangeForeach)
     {
         struct TestCase
@@ -155,55 +135,4 @@ namespace lms::db::tests
         }
     }
 
-    TEST_F(DatabaseFixture, Common_subRange)
-    {
-        RangeResults<int> results;
-        results.range = Range{ 0, 2 };
-        results.results = { 5, 6 };
-        results.moreResults = false;
-
-        {
-            auto subRange{ results.getSubRange(Range{ 0, 1 }) };
-            EXPECT_TRUE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 1);
-            EXPECT_EQ(subRange.results.front(), 5);
-        }
-        {
-            auto subRange{ results.getSubRange(Range{ 1, 1 }) };
-            EXPECT_FALSE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 1);
-            EXPECT_EQ(subRange.results.front(), 6);
-        }
-        {
-            auto subRange{ results.getSubRange(Range{ 0, 2 }) };
-            EXPECT_FALSE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 2);
-            EXPECT_EQ(subRange.results.front(), 5);
-            EXPECT_EQ(subRange.results.back(), 6);
-        }
-        {
-            auto subRange{ results.getSubRange(Range{}) };
-            EXPECT_FALSE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 2);
-            EXPECT_EQ(subRange.results.front(), 5);
-            EXPECT_EQ(subRange.results.back(), 6);
-            EXPECT_EQ(subRange.range, results.range);
-        }
-
-        {
-            auto subRange{ results.getSubRange(Range{ 1, 0 }) };
-            EXPECT_FALSE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 1);
-            EXPECT_EQ(subRange.results.front(), 6);
-            const Range expectedRange{ 1, 1 };
-            EXPECT_EQ(subRange.range, expectedRange);
-        }
-        {
-            auto subRange{ results.getSubRange(Range{ 3, 2 }) };
-            EXPECT_FALSE(subRange.moreResults);
-            ASSERT_EQ(subRange.results.size(), 0);
-            const Range expectedRange{ 2, 0 };
-            EXPECT_EQ(subRange.range, expectedRange);
-        }
-    }
 } // namespace lms::db::tests

src/libs/database/test/DatabaseTest.cpp

@@ -42,19 +42,19 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_TRUE(Release::findOrphanIds(session).results.empty());
-            EXPECT_TRUE(Artist::findOrphanIds(session).results.empty());
+            EXPECT_TRUE(Release::findOrphanIds(session).empty());
+            EXPECT_TRUE(Artist::findOrphanIds(session).empty());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId())) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
 
             const auto releaseTracks{ Track::find(session, Track::FindParameters{}.setRelease(release.getId())) };
-            EXPECT_EQ(releaseTracks.results.size(), nbTracks);
+            EXPECT_EQ(releaseTracks.size(), nbTracks);
         }
     }
 
@@ -75,8 +75,8 @@ namespace lms::db::tests
             auto transaction{ session.createWriteTransaction() };
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId())) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
 
             auto artists{ release->getTrackArtists() };
             ASSERT_EQ(artists.size(), 1);
@@ -88,7 +88,7 @@ namespace lms::db::tests
     {
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_TRUE(User::find(session, User::FindParameters{}).results.empty());
+            EXPECT_TRUE(User::find(session, User::FindParameters{}).empty());
             EXPECT_EQ(User::getCount(session), 0);
         }
 
@@ -97,7 +97,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            EXPECT_EQ(User::find(session, User::FindParameters{}).results.size(), 1);
+            EXPECT_EQ(User::find(session, User::FindParameters{}).size(), 1);
             EXPECT_EQ(User::getCount(session), 1);
         }
     }

src/libs/database/test/Directory.cpp

@@ -148,7 +148,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            const auto directories{ Directory::findOrphanIds(session).results };
+            const auto directories{ Directory::findOrphanIds(session) };
             EXPECT_EQ(directories.size(), 2);
         }
 
@@ -161,7 +161,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            const auto directories{ Directory::findOrphanIds(session).results };
+            const auto directories{ Directory::findOrphanIds(session) };
             ASSERT_EQ(directories.size(), 1);
             EXPECT_EQ(directories.front(), child.getId());
         }
@@ -182,7 +182,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            const auto directories{ Directory::findRootDirectories(session).results };
+            const auto directories{ Directory::findRootDirectories(session) };
             ASSERT_EQ(directories.size(), 2);
             EXPECT_EQ(directories[0]->getId(), parent1.getId());
             EXPECT_EQ(directories[1]->getId(), parent2.getId());
@@ -209,7 +209,7 @@ namespace lms::db::tests
             Directory::FindParameters params;
             params.setWithNoTrack(true);
 
-            auto res{ Directory::find(session, params).results };
+            auto res{ Directory::find(session, params) };
 
             ASSERT_EQ(res.size(), 3);
             EXPECT_EQ(res[0]->getId(), parent.getId());
@@ -228,7 +228,7 @@ namespace lms::db::tests
             Directory::FindParameters params;
             params.setWithNoTrack(true);
 
-            auto res{ Directory::find(session, params).results };
+            auto res{ Directory::find(session, params) };
             ASSERT_EQ(res.size(), 2);
             EXPECT_EQ(res[0]->getId(), parent.getId());
             EXPECT_EQ(res[1]->getId(), child1.getId());
@@ -247,7 +247,7 @@ namespace lms::db::tests
             Directory::FindParameters params;
             params.setKeywords({ "foo" });
 
-            auto res{ Directory::find(session, params).results };
+            auto res{ Directory::find(session, params) };
 
             ASSERT_EQ(res.size(), 2);
             EXPECT_EQ(res[0]->getId(), child1.getId());
@@ -267,7 +267,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            const auto res{ Directory::findMismatchedLibrary(session, std::nullopt, library->getPath(), library->getId()).results };
+            const auto res{ Directory::findMismatchedLibrary(session, std::nullopt, library->getPath(), library->getId()) };
             ASSERT_EQ(res.size(), 2);
             EXPECT_EQ(res[0], parent1.getId());
             EXPECT_EQ(res[1], child1.getId());
@@ -283,7 +283,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            const auto res{ Directory::findMismatchedLibrary(session, std::nullopt, library->getPath(), library->getId()).results };
+            const auto res{ Directory::findMismatchedLibrary(session, std::nullopt, library->getPath(), library->getId()) };
             EXPECT_EQ(res.size(), 0);
         }
     }

src/libs/database/test/Genre.cpp

@@ -65,8 +65,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto orphans{ Genre::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), genre.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), genre.getId());
         }
     }
 
@@ -78,7 +78,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Genre::findOrphanIds(session).results.size(), 2);
+            EXPECT_EQ(Genre::findOrphanIds(session).size(), 2);
             EXPECT_EQ(track->getGenres().size(), 0);
             EXPECT_EQ(track->getGenreIds().size(), 0);
             EXPECT_EQ(Genre::computeTrackCount(session, genre1.getId()), 0);
@@ -94,15 +94,15 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto genres{ Genre::findIds(session, Genre::FindParameters{}.setTrack(track.getId())) };
-            ASSERT_EQ(genres.results.size(), 1);
-            EXPECT_EQ(genres.results.front(), genre1.getId());
+            ASSERT_EQ(genres.size(), 1);
+            EXPECT_EQ(genres.front(), genre1.getId());
 
             EXPECT_EQ(Genre::computeTrackCount(session, genre1.getId()), 1);
             EXPECT_EQ(Genre::computeTrackCount(session, genre2.getId()), 0);
 
             const auto orphans{ Genre::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), genre2.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), genre2.getId());
 
             const auto trackGenres{ track->getGenres() };
             ASSERT_EQ(trackGenres.size(), 1);
@@ -116,11 +116,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre2.getId()))) };
-            EXPECT_EQ(tracks2.results.size(), 0);
+            EXPECT_EQ(tracks2.size(), 0);
         }
     }
 
@@ -139,7 +139,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
             EXPECT_EQ(Genre::computeTrackCount(session, genre1.getId()), 1);
             EXPECT_EQ(Genre::computeTrackCount(session, genre2.getId()), 1);
-            EXPECT_EQ(Genre::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Genre::findOrphanIds(session).size(), 0);
 
             const auto trackGenres{ track->getGenres() };
             EXPECT_EQ(trackGenres.size(), 2);
@@ -148,12 +148,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre2.getId()))) };
-            ASSERT_EQ(tracks2.results.size(), 1);
-            EXPECT_EQ(tracks2.results.front(), track.getId());
+            ASSERT_EQ(tracks2.size(), 1);
+            EXPECT_EQ(tracks2.front(), track.getId());
         }
     }
 
@@ -200,10 +200,10 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto genres{ Genre::findIds(session, Genre::FindParameters{}.setSortMethod(GenreSortMethod::Name)) };
-            ASSERT_EQ(genres.results.size(), 3);
-            EXPECT_EQ(genres.results[0], g2.getId());
-            EXPECT_EQ(genres.results[1], g3.getId());
-            EXPECT_EQ(genres.results[2], g1.getId());
+            ASSERT_EQ(genres.size(), 3);
+            EXPECT_EQ(genres[0], g2.getId());
+            EXPECT_EQ(genres[1], g3.getId());
+            EXPECT_EQ(genres[2], g1.getId());
         }
     }
 
@@ -225,9 +225,9 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto genres{ Genre::findIds(session, Genre::FindParameters{}.setSortMethod(GenreSortMethod::TrackCountDesc)) };
-            ASSERT_EQ(genres.results.size(), 2);
-            EXPECT_EQ(genres.results[0], g1.getId());
-            EXPECT_EQ(genres.results[1], g2.getId());
+            ASSERT_EQ(genres.size(), 2);
+            EXPECT_EQ(genres[0], g1.getId());
+            EXPECT_EQ(genres[1], g2.getId());
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/Grouping.cpp

@@ -63,8 +63,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto orphans{ Grouping::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), grouping.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), grouping.getId());
         }
     }
 
@@ -76,7 +76,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Grouping::findOrphanIds(session).results.size(), 2);
+            EXPECT_EQ(Grouping::findOrphanIds(session).size(), 2);
             EXPECT_EQ(track->getGroupings().size(), 0);
             EXPECT_EQ(track->getGroupingIds().size(), 0);
         }
@@ -90,12 +90,12 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto groupings{ Grouping::findIds(session, Grouping::FindParameters{}.setTrack(track.getId())) };
-            ASSERT_EQ(groupings.results.size(), 1);
-            EXPECT_EQ(groupings.results.front(), grouping1.getId());
+            ASSERT_EQ(groupings.size(), 1);
+            EXPECT_EQ(groupings.front(), grouping1.getId());
 
             const auto orphans{ Grouping::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), grouping2.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), grouping2.getId());
 
             const auto trackGroupings{ track->getGroupings() };
             ASSERT_EQ(trackGroupings.size(), 1);
@@ -109,11 +109,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping2.getId()))) };
-            EXPECT_EQ(tracks2.results.size(), 0);
+            EXPECT_EQ(tracks2.size(), 0);
         }
     }
 
@@ -130,7 +130,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Grouping::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Grouping::findOrphanIds(session).size(), 0);
 
             const auto trackGroupings{ track->getGroupings() };
             EXPECT_EQ(trackGroupings.size(), 2);
@@ -139,12 +139,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping2.getId()))) };
-            ASSERT_EQ(tracks2.results.size(), 1);
-            EXPECT_EQ(tracks2.results.front(), track.getId());
+            ASSERT_EQ(tracks2.size(), 1);
+            EXPECT_EQ(tracks2.front(), track.getId());
         }
     }
 
@@ -157,10 +157,10 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto groupings{ Grouping::findIds(session, Grouping::FindParameters{}.setSortMethod(GroupingSortMethod::Name)) };
-            ASSERT_EQ(groupings.results.size(), 3);
-            EXPECT_EQ(groupings.results[0], g2.getId());
-            EXPECT_EQ(groupings.results[1], g3.getId());
-            EXPECT_EQ(groupings.results[2], g1.getId());
+            ASSERT_EQ(groupings.size(), 3);
+            EXPECT_EQ(groupings[0], g2.getId());
+            EXPECT_EQ(groupings[1], g3.getId());
+            EXPECT_EQ(groupings[2], g1.getId());
         }
     }
 
@@ -182,9 +182,9 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto groupings{ Grouping::findIds(session, Grouping::FindParameters{}.setSortMethod(GroupingSortMethod::TrackCountDesc)) };
-            ASSERT_EQ(groupings.results.size(), 2);
-            EXPECT_EQ(groupings.results[0], g1.getId());
-            EXPECT_EQ(groupings.results[1], g2.getId());
+            ASSERT_EQ(groupings.size(), 2);
+            EXPECT_EQ(groupings[0], g1.getId());
+            EXPECT_EQ(groupings[1], g2.getId());
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/Image.cpp

@@ -83,7 +83,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Image::find(session, Image::FindParameters{}.setDirectory(directory.getId())).results.size(), 0);
+            EXPECT_EQ(Image::find(session, Image::FindParameters{}.setDirectory(directory.getId())).size(), 0);
         }
 
         {
@@ -93,7 +93,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            const auto results{ Image::find(session, Image::FindParameters{}.setDirectory(directory.getId())).results };
+            const auto results{ Image::find(session, Image::FindParameters{}.setDirectory(directory.getId())) };
             ASSERT_EQ(results.size(), 1);
             EXPECT_EQ(results.front()->getId(), image.getId());
         }
@@ -138,8 +138,8 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem(fileStem);
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results[0]->getId(), image.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results[0]->getId(), image.getId());
         }
 
         {
@@ -147,8 +147,8 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem(fileStem, Image::FindParameters::ProcessWildcards{ true });
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results[0]->getId(), image.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results[0]->getId(), image.getId());
         }
 
         {
@@ -156,7 +156,7 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("nonexistent");
             const auto results{ Image::find(session, params) };
-            EXPECT_EQ(results.results.size(), 0);
+            EXPECT_EQ(results.size(), 0);
         }
 
         {
@@ -164,7 +164,7 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("ima*");
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 0);
+            ASSERT_EQ(results.size(), 0);
         }
 
         {
@@ -172,8 +172,8 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("ima*", Image::FindParameters::ProcessWildcards{ true });
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results[0]->getId(), image.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results[0]->getId(), image.getId());
         }
 
         {
@@ -181,8 +181,8 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("*ge", Image::FindParameters::ProcessWildcards{ true });
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results[0]->getId(), image.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results[0]->getId(), image.getId());
         }
 
         {
@@ -190,8 +190,8 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("*g*", Image::FindParameters::ProcessWildcards{ true });
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results[0]->getId(), image.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results[0]->getId(), image.getId());
         }
 
         {
@@ -199,8 +199,8 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("*", Image::FindParameters::ProcessWildcards{ true });
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results[0]->getId(), image.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results[0]->getId(), image.getId());
         }
 
         {
@@ -208,7 +208,7 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("ima%");
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 0);
+            ASSERT_EQ(results.size(), 0);
         }
 
         {
@@ -216,7 +216,7 @@ namespace lms::db::tests
             Image::FindParameters params;
             params.setFileStem("ima%", Image::FindParameters::ProcessWildcards{ true });
             const auto results{ Image::find(session, params) };
-            ASSERT_EQ(results.results.size(), 0);
+            ASSERT_EQ(results.size(), 0);
         }
     }
 

src/libs/database/test/Language.cpp

@@ -63,8 +63,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto orphans{ Language::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), language.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), language.getId());
         }
     }
 
@@ -76,7 +76,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Language::findOrphanIds(session).results.size(), 2);
+            EXPECT_EQ(Language::findOrphanIds(session).size(), 2);
             EXPECT_EQ(track->getLanguages().size(), 0);
             EXPECT_EQ(track->getLanguageIds().size(), 0);
         }
@@ -90,12 +90,12 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto languages{ Language::findIds(session, Language::FindParameters{}.setTrack(track.getId())) };
-            ASSERT_EQ(languages.results.size(), 1);
-            EXPECT_EQ(languages.results.front(), language1.getId());
+            ASSERT_EQ(languages.size(), 1);
+            EXPECT_EQ(languages.front(), language1.getId());
 
             const auto orphans{ Language::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), language2.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), language2.getId());
 
             const auto trackLanguages{ track->getLanguages() };
             ASSERT_EQ(trackLanguages.size(), 1);
@@ -109,11 +109,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language2.getId()))) };
-            EXPECT_EQ(tracks2.results.size(), 0);
+            EXPECT_EQ(tracks2.size(), 0);
         }
     }
 
@@ -130,7 +130,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Language::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Language::findOrphanIds(session).size(), 0);
 
             const auto trackLanguages{ track->getLanguages() };
             EXPECT_EQ(trackLanguages.size(), 2);
@@ -139,12 +139,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language2.getId()))) };
-            ASSERT_EQ(tracks2.results.size(), 1);
-            EXPECT_EQ(tracks2.results.front(), track.getId());
+            ASSERT_EQ(tracks2.size(), 1);
+            EXPECT_EQ(tracks2.front(), track.getId());
         }
     }
 
@@ -157,10 +157,10 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto languages{ Language::findIds(session, Language::FindParameters{}.setSortMethod(LanguageSortMethod::Name)) };
-            ASSERT_EQ(languages.results.size(), 3);
-            EXPECT_EQ(languages.results[0], l2.getId());
-            EXPECT_EQ(languages.results[1], l3.getId());
-            EXPECT_EQ(languages.results[2], l1.getId());
+            ASSERT_EQ(languages.size(), 3);
+            EXPECT_EQ(languages[0], l2.getId());
+            EXPECT_EQ(languages[1], l3.getId());
+            EXPECT_EQ(languages[2], l1.getId());
         }
     }
 
@@ -182,9 +182,9 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto languages{ Language::findIds(session, Language::FindParameters{}.setSortMethod(LanguageSortMethod::TrackCountDesc)) };
-            ASSERT_EQ(languages.results.size(), 2);
-            EXPECT_EQ(languages.results[0], l1.getId());
-            EXPECT_EQ(languages.results[1], l2.getId());
+            ASSERT_EQ(languages.size(), 2);
+            EXPECT_EQ(languages[0], l1.getId());
+            EXPECT_EQ(languages[1], l2.getId());
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/Mood.cpp

@@ -63,8 +63,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto orphans{ Mood::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), mood.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), mood.getId());
         }
     }
 
@@ -76,7 +76,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Mood::findOrphanIds(session).results.size(), 2);
+            EXPECT_EQ(Mood::findOrphanIds(session).size(), 2);
             EXPECT_EQ(track->getMoods().size(), 0);
             EXPECT_EQ(track->getMoodIds().size(), 0);
         }
@@ -90,12 +90,12 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto moods{ Mood::findIds(session, Mood::FindParameters{}.setTrack(track.getId())) };
-            ASSERT_EQ(moods.results.size(), 1);
-            EXPECT_EQ(moods.results.front(), mood1.getId());
+            ASSERT_EQ(moods.size(), 1);
+            EXPECT_EQ(moods.front(), mood1.getId());
 
             const auto orphans{ Mood::findOrphanIds(session) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results.front(), mood2.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans.front(), mood2.getId());
 
             const auto trackMoods{ track->getMoods() };
             ASSERT_EQ(trackMoods.size(), 1);
@@ -109,11 +109,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood2.getId()))) };
-            EXPECT_EQ(tracks2.results.size(), 0);
+            EXPECT_EQ(tracks2.size(), 0);
         }
     }
 
@@ -130,7 +130,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Mood::findOrphanIds(session).results.size(), 0);
+            EXPECT_EQ(Mood::findOrphanIds(session).size(), 0);
 
             const auto trackMoods{ track->getMoods() };
             EXPECT_EQ(trackMoods.size(), 2);
@@ -139,12 +139,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood1.getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood2.getId()))) };
-            ASSERT_EQ(tracks2.results.size(), 1);
-            EXPECT_EQ(tracks2.results.front(), track.getId());
+            ASSERT_EQ(tracks2.size(), 1);
+            EXPECT_EQ(tracks2.front(), track.getId());
         }
     }
 
@@ -157,10 +157,10 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto moods{ Mood::findIds(session, Mood::FindParameters{}.setSortMethod(MoodSortMethod::Name)) };
-            ASSERT_EQ(moods.results.size(), 3);
-            EXPECT_EQ(moods.results[0], m2.getId());
-            EXPECT_EQ(moods.results[1], m3.getId());
-            EXPECT_EQ(moods.results[2], m1.getId());
+            ASSERT_EQ(moods.size(), 3);
+            EXPECT_EQ(moods[0], m2.getId());
+            EXPECT_EQ(moods[1], m3.getId());
+            EXPECT_EQ(moods[2], m1.getId());
         }
     }
 
@@ -182,9 +182,9 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto moods{ Mood::findIds(session, Mood::FindParameters{}.setSortMethod(MoodSortMethod::TrackCountDesc)) };
-            ASSERT_EQ(moods.results.size(), 2);
-            EXPECT_EQ(moods.results[0], m1.getId());
-            EXPECT_EQ(moods.results[1], m2.getId());
+            ASSERT_EQ(moods.size(), 2);
+            EXPECT_EQ(moods[0], m1.getId());
+            EXPECT_EQ(moods[1], m2.getId());
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/RatedArtist.cpp

@@ -39,7 +39,7 @@ namespace lms::db::tests
             EXPECT_EQ(RatedArtist::getCount(session), 0);
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            EXPECT_EQ(artists.results.size(), 1);
+            EXPECT_EQ(artists.size(), 1);
         }
 
         ScopedRatedArtist ratedArtist{ session, artist.lockAndGet(), user.lockAndGet() };

src/libs/database/test/RatedRelease.cpp

@@ -39,7 +39,7 @@ namespace lms::db::tests
             EXPECT_EQ(RatedRelease::getCount(session), 0);
 
             auto releases{ Release::findIds(session, Release::FindParameters{}) };
-            EXPECT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.size(), 1);
         }
 
         ScopedRatedRelease ratedRelease{ session, release.lockAndGet(), user.lockAndGet() };

src/libs/database/test/RatedTrack.cpp

@@ -39,7 +39,7 @@ namespace lms::db::tests
             EXPECT_EQ(RatedTrack::getCount(session), 0);
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}) };
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
         }
 
         ScopedRatedTrack ratedTrack{ session, track.lockAndGet(), user.lockAndGet() };

src/libs/database/test/Release.cpp

@@ -57,21 +57,21 @@ namespace lms::db::tests
 
             {
                 const auto releases{ Release::findOrphanIds(session) };
-                ASSERT_EQ(releases.results.size(), 1);
-                EXPECT_EQ(releases.results.front(), release.getId());
+                ASSERT_EQ(releases.size(), 1);
+                EXPECT_EQ(releases.front(), release.getId());
             }
 
             {
                 const auto releases{ Release::findIds(session, Release::FindParameters{}) };
-                ASSERT_EQ(releases.results.size(), 1);
-                EXPECT_EQ(releases.results.front(), release.getId());
+                ASSERT_EQ(releases.size(), 1);
+                EXPECT_EQ(releases.front(), release.getId());
                 EXPECT_EQ(release->getDuration(), std::chrono::seconds{ 0 });
             }
 
             {
                 const auto releases{ Release::find(session, Release::FindParameters{}) };
-                ASSERT_EQ(releases.results.size(), 1);
-                EXPECT_EQ(releases.results.front()->getId(), release.getId());
+                ASSERT_EQ(releases.size(), 1);
+                EXPECT_EQ(releases.front()->getId(), release.getId());
             }
 
             {
@@ -280,11 +280,11 @@ namespace lms::db::tests
 
             {
                 auto transaction{ session.createReadTransaction() };
-                EXPECT_EQ(Release::findOrphanIds(session).results.size(), 0);
+                EXPECT_EQ(Release::findOrphanIds(session).size(), 0);
 
                 const auto tracks{ Track::findIds(session, Track::FindParameters{}.setRelease(release.getId())) };
-                ASSERT_EQ(tracks.results.size(), 1);
-                EXPECT_EQ(tracks.results.front(), track.getId());
+                ASSERT_EQ(tracks.size(), 1);
+                EXPECT_EQ(tracks.front(), track.getId());
             }
 
             {
@@ -297,18 +297,18 @@ namespace lms::db::tests
             {
                 auto transaction{ session.createWriteTransaction() };
                 auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseName")) };
-                ASSERT_EQ(tracks.results.size(), 1);
-                EXPECT_EQ(tracks.results.front(), track.getId());
+                ASSERT_EQ(tracks.size(), 1);
+                EXPECT_EQ(tracks.front(), track.getId());
             }
             {
                 auto transaction{ session.createWriteTransaction() };
                 auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseFoo")) };
-                EXPECT_EQ(tracks.results.size(), 0);
+                EXPECT_EQ(tracks.size(), 0);
             }
             {
                 auto transaction{ session.createWriteTransaction() };
                 auto tracks{ Track::findIds(session, Track::FindParameters{}.setName("MyTrackFoo").setReleaseName("MyReleaseName")) };
-                EXPECT_EQ(tracks.results.size(), 0);
+                EXPECT_EQ(tracks.size(), 0);
             }
         }
 
@@ -316,11 +316,11 @@ namespace lms::db::tests
             auto transaction{ session.createWriteTransaction() };
 
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setRelease(release.getId())) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
 
             auto releases{ Release::findOrphanIds(session) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
         }
     }
 
@@ -340,13 +340,13 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto releases{ Release::findIds(session, Release::FindParameters{}.setFilters(Filters{}.setMediaLibrary(library->getId()))) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
             auto releases{ Release::findIds(session, Release::FindParameters{}.setFilters(Filters{}.setMediaLibrary(otherLibrary->getId()))) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
     }
 
@@ -383,35 +383,35 @@ namespace lms::db::tests
 
             {
                 const auto releases{ Release::findIds(session, Release::FindParameters{}.setKeywords({ "Release" })) };
-                EXPECT_EQ(releases.results.size(), 6);
+                EXPECT_EQ(releases.size(), 6);
             }
 
             {
                 const auto releases{ Release::findIds(session, Release::FindParameters{}.setKeywords({ "MyRelease" })) };
-                ASSERT_EQ(releases.results.size(), 5);
-                EXPECT_TRUE(std::none_of(std::cbegin(releases.results), std::cend(releases.results), [&](const ReleaseId releaseId) { return releaseId == release6.getId(); }));
+                ASSERT_EQ(releases.size(), 5);
+                EXPECT_TRUE(std::none_of(std::cbegin(releases), std::cend(releases), [&](const ReleaseId releaseId) { return releaseId == release6.getId(); }));
             }
             {
                 const auto releases{ Release::findIds(session, Release::FindParameters{}.setKeywords({ "MyRelease%" })) };
-                ASSERT_EQ(releases.results.size(), 2);
-                EXPECT_EQ(releases.results[0], release2.getId());
-                EXPECT_EQ(releases.results[1], release4.getId());
+                ASSERT_EQ(releases.size(), 2);
+                EXPECT_EQ(releases[0], release2.getId());
+                EXPECT_EQ(releases[1], release4.getId());
             }
             {
                 const auto releases{ Release::findIds(session, Release::FindParameters{}.setKeywords({ "%MyRelease" })) };
-                ASSERT_EQ(releases.results.size(), 2);
-                EXPECT_EQ(releases.results[0], release3.getId());
-                EXPECT_EQ(releases.results[1], release5.getId());
+                ASSERT_EQ(releases.size(), 2);
+                EXPECT_EQ(releases[0], release3.getId());
+                EXPECT_EQ(releases[1], release5.getId());
             }
             {
                 const auto releases{ Release::findIds(session, Release::FindParameters{}.setKeywords({ "Foo%MyRelease" })) };
-                ASSERT_EQ(releases.results.size(), 1);
-                EXPECT_EQ(releases.results[0], release5.getId());
+                ASSERT_EQ(releases.size(), 1);
+                EXPECT_EQ(releases[0], release5.getId());
             }
             {
                 const auto releases{ Release::findIds(session, Release::FindParameters{}.setKeywords({ "MyRelease%Foo" })) };
-                ASSERT_EQ(releases.results.size(), 1);
-                EXPECT_EQ(releases.results[0], release4.getId());
+                ASSERT_EQ(releases.size(), 1);
+                EXPECT_EQ(releases[0], release4.getId());
             }
         }
     }
@@ -508,8 +508,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            EXPECT_EQ(Track::findIds(session, Track::FindParameters{}.setRelease(release1.getId())).results.size(), 0);
-            EXPECT_EQ(Track::findIds(session, Track::FindParameters{}.setRelease(release2.getId())).results.size(), 0);
+            EXPECT_EQ(Track::findIds(session, Track::FindParameters{}.setRelease(release1.getId())).size(), 0);
+            EXPECT_EQ(Track::findIds(session, Track::FindParameters{}.setRelease(release2.getId())).size(), 0);
         }
 
         {
@@ -538,16 +538,16 @@ namespace lms::db::tests
 
             {
                 const auto tracks{ Track::findIds(session, Track::FindParameters{}.setRelease(release1.getId()).setSortMethod(TrackSortMethod::Release)) };
-                ASSERT_EQ(tracks.results.size(), 2);
-                EXPECT_EQ(tracks.results[0], track1A.getId());
-                EXPECT_EQ(tracks.results[1], track1B.getId());
+                ASSERT_EQ(tracks.size(), 2);
+                EXPECT_EQ(tracks[0], track1A.getId());
+                EXPECT_EQ(tracks[1], track1B.getId());
             }
 
             {
                 const auto tracks{ Track::findIds(session, Track::FindParameters{}.setRelease(release2.getId()).setSortMethod(TrackSortMethod::Release)) };
-                ASSERT_EQ(tracks.results.size(), 2);
-                EXPECT_EQ(tracks.results[0], track2A.getId());
-                EXPECT_EQ(tracks.results[1], track2B.getId());
+                ASSERT_EQ(tracks.size(), 2);
+                EXPECT_EQ(tracks[0], track2A.getId());
+                EXPECT_EQ(tracks[1], track2B.getId());
             }
         }
     }
@@ -568,7 +568,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ -3000, 3000 })) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
 
         {
@@ -595,15 +595,15 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ 1950, 2000 })) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release1.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release1.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ 1994, 1994 }));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release1.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release1.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ 1993, 1993 }));
-            ASSERT_EQ(releases.results.size(), 0);
+            ASSERT_EQ(releases.size(), 0);
         }
     }
 
@@ -624,7 +624,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setOriginalDateRange(YearRange{ -3000, 3000 })) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
 
         {
@@ -649,15 +649,15 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto releases = Release::findIds(session, Release::FindParameters{}.setOriginalDateRange(YearRange{ 1950, 2000 }));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release1.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release1.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setOriginalDateRange(YearRange{ 1993, 1993 }));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release1.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release1.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setOriginalDateRange(YearRange{ 1994, 1994 }));
-            ASSERT_EQ(releases.results.size(), 0);
+            ASSERT_EQ(releases.size(), 0);
         }
     }
 
@@ -677,7 +677,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ 0, 3000 })) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
 
         {
@@ -701,15 +701,15 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ 1950, 2000 })) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release1.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release1.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ 1994, 1994 }));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release1.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release1.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setDateRange(YearRange{ 1993, 1993 }));
-            ASSERT_EQ(releases.results.size(), 0);
+            ASSERT_EQ(releases.size(), 0);
         }
     }
 
@@ -729,19 +729,19 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto releases{ Release::findIds(session, Release::FindParameters{}) };
-            EXPECT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.size(), 1);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setWrittenAfter(dateTime.addSecs(-1))) };
-            EXPECT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.size(), 1);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setWrittenAfter(dateTime.addSecs(+1))) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
     }
 
@@ -760,12 +760,12 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Artist })) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Artist })), 0);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist.getId())), 0);
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist2.getId(), { TrackArtistLinkType::Artist }));
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist2.getId(), { TrackArtistLinkType::Artist })), 0);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist2.getId())), 0);
         }
@@ -782,39 +782,39 @@ namespace lms::db::tests
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}), 1);
 
             auto releases{ Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Artist })) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Artist })), 1);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Remixer })), 0);
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Artist, TrackArtistLinkType::Mixer }));
-            EXPECT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            EXPECT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Artist, TrackArtistLinkType::Mixer })), 1);
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist2.getId(), { TrackArtistLinkType::Artist }));
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist2.getId()));
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Writer, TrackArtistLinkType::Artist }));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId()));
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist.getId())), 1);
             EXPECT_EQ(release->getTrackArtists().size(), 1);
             EXPECT_EQ(release->getTrackArtists(TrackArtistLinkType::Artist).size(), 1);
             EXPECT_EQ(release->getTrackArtists(TrackArtistLinkType::Conductor).size(), 0);
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Composer }));
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
 
             releases = Release::findIds(session, Release::FindParameters{}.setTrackArtist(artist.getId(), { TrackArtistLinkType::Composer, TrackArtistLinkType::Mixer }));
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
 
         {
@@ -850,7 +850,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setArtist(artist1.getId())) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setArtist(artist1.getId())), 0);
             EXPECT_EQ(release->getTrackArtists(TrackArtistLinkType::Conductor).size(), 0);
             EXPECT_EQ(release->getArtistLinks().size(), 0);
@@ -907,8 +907,8 @@ namespace lms::db::tests
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}), 1);
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setArtist(artist1.getId())) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release.getId());
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist1.getId())), 0);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setArtist(artist1.getId())), 1);
             EXPECT_EQ(Release::getCount(session, Release::FindParameters{}.setTrackArtist(artist2.getId())), 0);
@@ -999,8 +999,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto labels{ Label::findOrphanIds(session) };
-            ASSERT_EQ(labels.results.size(), 1);
-            EXPECT_EQ(labels.results.front(), label.getId());
+            ASSERT_EQ(labels.size(), 1);
+            EXPECT_EQ(labels.front(), label.getId());
         }
 
         ScopedRelease release{ session, "MyRelease" };
@@ -1013,7 +1013,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto labels{ Label::findOrphanIds(session) };
-            EXPECT_EQ(labels.results.size(), 0);
+            EXPECT_EQ(labels.size(), 0);
         }
 
         {
@@ -1024,8 +1024,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto labels{ Label::findOrphanIds(session) };
-            ASSERT_EQ(labels.results.size(), 1);
-            EXPECT_EQ(labels.results.front(), label.getId());
+            ASSERT_EQ(labels.size(), 1);
+            EXPECT_EQ(labels.front(), label.getId());
         }
     }
 
@@ -1071,8 +1071,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto countries{ Country::findOrphanIds(session) };
-            ASSERT_EQ(countries.results.size(), 1);
-            EXPECT_EQ(countries.results.front(), country.getId());
+            ASSERT_EQ(countries.size(), 1);
+            EXPECT_EQ(countries.front(), country.getId());
         }
 
         ScopedRelease release{ session, "MyRelease" };
@@ -1085,7 +1085,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto countries{ Country::findOrphanIds(session) };
-            EXPECT_EQ(countries.results.size(), 0);
+            EXPECT_EQ(countries.size(), 0);
         }
 
         {
@@ -1096,8 +1096,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto countries{ Country::findOrphanIds(session) };
-            ASSERT_EQ(countries.results.size(), 1);
-            EXPECT_EQ(countries.results.front(), country.getId());
+            ASSERT_EQ(countries.size(), 1);
+            EXPECT_EQ(countries.front(), country.getId());
         }
     }
 
@@ -1126,8 +1126,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto releaseTypes{ ReleaseType::findOrphanIds(session) };
-            ASSERT_EQ(releaseTypes.results.size(), 1);
-            EXPECT_EQ(releaseTypes.results.front(), releaseType.getId());
+            ASSERT_EQ(releaseTypes.size(), 1);
+            EXPECT_EQ(releaseTypes.front(), releaseType.getId());
         }
 
         ScopedRelease release{ session, "MyRelease" };
@@ -1140,7 +1140,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto releaseTypes{ ReleaseType::findOrphanIds(session) };
-            EXPECT_EQ(releaseTypes.results.size(), 0);
+            EXPECT_EQ(releaseTypes.size(), 0);
         }
 
         {
@@ -1151,8 +1151,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto releaseTypes{ ReleaseType::findOrphanIds(session) };
-            ASSERT_EQ(releaseTypes.results.size(), 1);
-            EXPECT_EQ(releaseTypes.results.front(), releaseType.getId());
+            ASSERT_EQ(releaseTypes.size(), 1);
+            EXPECT_EQ(releaseTypes.front(), releaseType.getId());
         }
     }
 
@@ -1191,7 +1191,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createReadTransaction() };
-            auto releases{ Release::find(session, Release::FindParameters{}.setReleaseType("Foo")).results };
+            auto releases{ Release::find(session, Release::FindParameters{}.setReleaseType("Foo")) };
             EXPECT_EQ(releases.size(), 0);
         }
 
@@ -1205,10 +1205,10 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto releases{ Release::find(session, Release::FindParameters{}.setReleaseType("Foo")).results };
+            auto releases{ Release::find(session, Release::FindParameters{}.setReleaseType("Foo")) };
             EXPECT_EQ(releases.size(), 0);
 
-            releases = Release::find(session, Release::FindParameters{}.setReleaseType("album")).results;
+            releases = Release::find(session, Release::FindParameters{}.setReleaseType("album"));
             ASSERT_EQ(releases.size(), 1);
             EXPECT_EQ(releases.front()->getId(), release.getId());
         }
@@ -1244,51 +1244,51 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::Name)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results.front(), release1.getId());
-            EXPECT_EQ(releases.results.back(), release2.getId());
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases.front(), release1.getId());
+            EXPECT_EQ(releases.back(), release2.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::Random)) };
-            ASSERT_EQ(releases.results.size(), 2);
+            ASSERT_EQ(releases.size(), 2);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::DateAsc)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results.front(), release2.getId());
-            EXPECT_EQ(releases.results.back(), release1.getId());
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases.front(), release2.getId());
+            EXPECT_EQ(releases.back(), release1.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::DateDesc)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results.front(), release1.getId());
-            EXPECT_EQ(releases.results.back(), release2.getId());
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases.front(), release1.getId());
+            EXPECT_EQ(releases.back(), release2.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::OriginalDate)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results.front(), release1.getId());
-            EXPECT_EQ(releases.results.back(), release2.getId());
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases.front(), release1.getId());
+            EXPECT_EQ(releases.back(), release2.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::OriginalDateDesc)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results.front(), release2.getId());
-            EXPECT_EQ(releases.results.back(), release1.getId());
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases.front(), release2.getId());
+            EXPECT_EQ(releases.back(), release1.getId());
         }
     }
 
@@ -1392,8 +1392,8 @@ namespace lms::db::tests
             params.setFilters(Filters{}.setCodec(core::media::Codec::MP3));
 
             auto releases{ Release::findIds(session, params) };
-            ASSERT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results.front(), release2.getId());
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases.front(), release2.getId());
         }
     }
 
@@ -1491,11 +1491,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::AddedDesc)) };
-            ASSERT_EQ(releases.results.size(), 4);
-            EXPECT_EQ(releases.results[0], releaseA.getId());
-            EXPECT_EQ(releases.results[1], releaseD.getId());
-            EXPECT_EQ(releases.results[2], releaseB.getId());
-            EXPECT_EQ(releases.results[3], releaseC.getId());
+            ASSERT_EQ(releases.size(), 4);
+            EXPECT_EQ(releases[0], releaseA.getId());
+            EXPECT_EQ(releases[1], releaseD.getId());
+            EXPECT_EQ(releases[2], releaseB.getId());
+            EXPECT_EQ(releases[3], releaseC.getId());
         }
     }
 
@@ -1531,11 +1531,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto releases{ Release::findIds(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::LastWrittenDesc)) };
-            ASSERT_EQ(releases.results.size(), 4);
-            EXPECT_EQ(releases.results[0], releaseA.getId());
-            EXPECT_EQ(releases.results[1], releaseD.getId());
-            EXPECT_EQ(releases.results[2], releaseB.getId());
-            EXPECT_EQ(releases.results[3], releaseC.getId());
+            ASSERT_EQ(releases.size(), 4);
+            EXPECT_EQ(releases[0], releaseA.getId());
+            EXPECT_EQ(releases[1], releaseD.getId());
+            EXPECT_EQ(releases[2], releaseB.getId());
+            EXPECT_EQ(releases[3], releaseC.getId());
         }
     }
 
@@ -1610,7 +1610,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::find(session, Release::FindParameters{}.setReleaseGroupMBID(groupMBID)) };
-            EXPECT_EQ(releases.results.size(), 0);
+            EXPECT_EQ(releases.size(), 0);
         }
 
         {
@@ -1622,8 +1622,8 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::find(session, Release::FindParameters{}.setReleaseGroupMBID(groupMBID)) };
-            EXPECT_EQ(releases.results.size(), 1);
-            EXPECT_EQ(releases.results[0]->getId(), release->getId());
+            EXPECT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases[0]->getId(), release->getId());
         }
     }
 
@@ -1642,18 +1642,18 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::find(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::Name)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results[0]->getId(), release1->getId());
-            EXPECT_EQ(releases.results[1]->getId(), release2->getId());
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases[0]->getId(), release1->getId());
+            EXPECT_EQ(releases[1]->getId(), release2->getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             const auto releases{ Release::find(session, Release::FindParameters{}.setSortMethod(ReleaseSortMethod::SortName)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results[0]->getId(), release2->getId());
-            EXPECT_EQ(releases.results[1]->getId(), release1->getId());
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases[0]->getId(), release2->getId());
+            EXPECT_EQ(releases[1]->getId(), release1->getId());
         }
     }
 
@@ -1726,4 +1726,5 @@ namespace lms::db::tests
             EXPECT_EQ(mediums[1]->getId(), medium2.getId());
         }
     }
+
 } // namespace lms::db::tests

src/libs/database/test/StarredArtist.cpp

@@ -39,7 +39,7 @@ namespace lms::db::tests
             EXPECT_EQ(StarredArtist::getCount(session), 0);
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            EXPECT_EQ(artists.results.size(), 1);
+            EXPECT_EQ(artists.size(), 1);
         }
 
         ScopedStarredArtist starredArtist{ session, artist.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
@@ -55,13 +55,13 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto artists{ Artist::findIds(session, Artist::FindParameters{}) };
-            EXPECT_EQ(artists.results.size(), 1);
+            EXPECT_EQ(artists.size(), 1);
 
-            artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(artists.results.size(), 1);
+            artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId()));
+            EXPECT_EQ(artists.size(), 1);
 
-            artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(artists.results.size(), 0);
+            artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user2.getId()));
+            EXPECT_EQ(artists.size(), 0);
         }
 
         {
@@ -97,12 +97,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createWriteTransaction() };
 
-            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
-            EXPECT_EQ(artists.results.size(), 1);
+            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(artists.size(), 1);
 
             starredArtist.get().modify()->setSyncState(SyncState::PendingRemove);
-            artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(artists.results.size(), 0);
+            artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId()));
+            EXPECT_EQ(artists.size(), 0);
         }
     }
 
@@ -120,8 +120,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto artists{ Artist::find(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
-            EXPECT_EQ(artists.results.size(), 2);
+            auto artists{ Artist::find(session, Artist::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(artists.size(), 2);
         }
 
         {
@@ -130,10 +130,10 @@ namespace lms::db::tests
             starredArtist1.get().modify()->setDateTime(dateTime);
             starredArtist2.get().modify()->setDateTime(dateTime.addSecs(-1));
 
-            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
-            ASSERT_EQ(artists.results.size(), 2);
-            EXPECT_EQ(artists.results[0], starredArtist1->getArtist()->getId());
-            EXPECT_EQ(artists.results[1], starredArtist2->getArtist()->getId());
+            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId()).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
+            ASSERT_EQ(artists.size(), 2);
+            EXPECT_EQ(artists[0], starredArtist1->getArtist()->getId());
+            EXPECT_EQ(artists[1], starredArtist2->getArtist()->getId());
         }
         {
             auto transaction{ session.createWriteTransaction() };
@@ -141,10 +141,34 @@ namespace lms::db::tests
             starredArtist1.get().modify()->setDateTime(dateTime);
             starredArtist2.get().modify()->setDateTime(dateTime.addSecs(1));
 
-            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
-            ASSERT_EQ(artists.results.size(), 2);
-            EXPECT_EQ(artists.results[0], starredArtist2->getArtist()->getId());
-            EXPECT_EQ(artists.results[1], starredArtist1->getArtist()->getId());
+            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId()).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
+            ASSERT_EQ(artists.size(), 2);
+            EXPECT_EQ(artists[0], starredArtist2->getArtist()->getId());
+            EXPECT_EQ(artists[1], starredArtist1->getArtist()->getId());
+        }
+    }
+    TEST_F(DatabaseFixture, StarredArtist_currentBackend)
+    {
+        ScopedArtist artist{ session, "MyArtist" };
+        ScopedUser user{ session, "MyUser" };
+        ScopedStarredArtist starredArtist{ session, artist.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId())) };
+            ASSERT_EQ(artists.size(), 1);
+            EXPECT_EQ(artists[0], artist->getId());
+        }
+
+        {
+            auto transaction{ session.createWriteTransaction() };
+            user.get().modify()->setFeedbackBackend(FeedbackBackend::ListenBrainz);
+        }
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            auto artists{ Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(artists.size(), 0);
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/StarredRelease.cpp

@@ -39,7 +39,7 @@ namespace lms::db::tests
             EXPECT_EQ(StarredRelease::getCount(session), 0);
 
             auto releases{ Release::find(session, Release::FindParameters{}) };
-            EXPECT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.size(), 1);
         }
 
         ScopedStarredRelease starredRelease{ session, release.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
@@ -55,13 +55,13 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto releases{ Release::find(session, Release::FindParameters{}) };
-            EXPECT_EQ(releases.results.size(), 1);
+            EXPECT_EQ(releases.size(), 1);
 
-            releases = Release::find(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(releases.results.size(), 1);
+            releases = Release::find(session, Release::FindParameters{}.setStarringUser(user.getId()));
+            EXPECT_EQ(releases.size(), 1);
 
-            releases = Release::find(session, Release::FindParameters{}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(releases.results.size(), 0);
+            releases = Release::find(session, Release::FindParameters{}.setStarringUser(user2.getId()));
+            EXPECT_EQ(releases.size(), 0);
         }
 
         {
@@ -86,12 +86,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createWriteTransaction() };
 
-            auto releases{ Release::find(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
-            EXPECT_EQ(releases.results.size(), 1);
+            auto releases{ Release::find(session, Release::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(releases.size(), 1);
 
             starredRelease.get().modify()->setSyncState(SyncState::PendingRemove);
-            releases = Release::find(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(releases.results.size(), 0);
+            releases = Release::find(session, Release::FindParameters{}.setStarringUser(user.getId()));
+            EXPECT_EQ(releases.size(), 0);
         }
     }
 
@@ -109,8 +109,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
-            EXPECT_EQ(releases.results.size(), 2);
+            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(releases.size(), 2);
         }
 
         {
@@ -119,10 +119,10 @@ namespace lms::db::tests
             starredRelease1.get().modify()->setDateTime(dateTime);
             starredRelease2.get().modify()->setDateTime(dateTime.addSecs(-1));
 
-            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results[0], starredRelease1->getRelease()->getId());
-            EXPECT_EQ(releases.results[1], starredRelease2->getRelease()->getId());
+            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId()).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases[0], starredRelease1->getRelease()->getId());
+            EXPECT_EQ(releases[1], starredRelease2->getRelease()->getId());
         }
         {
             auto transaction{ session.createWriteTransaction() };
@@ -130,10 +130,34 @@ namespace lms::db::tests
             starredRelease1.get().modify()->setDateTime(dateTime);
             starredRelease2.get().modify()->setDateTime(dateTime.addSecs(1));
 
-            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
-            ASSERT_EQ(releases.results.size(), 2);
-            EXPECT_EQ(releases.results[0], starredRelease2->getRelease()->getId());
-            EXPECT_EQ(releases.results[1], starredRelease1->getRelease()->getId());
+            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId()).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
+            ASSERT_EQ(releases.size(), 2);
+            EXPECT_EQ(releases[0], starredRelease2->getRelease()->getId());
+            EXPECT_EQ(releases[1], starredRelease1->getRelease()->getId());
+        }
+    }
+    TEST_F(DatabaseFixture, StarredRelease_currentBackend)
+    {
+        ScopedRelease release{ session, "MyRelease" };
+        ScopedUser user{ session, "MyUser" };
+        ScopedStarredRelease starredRelease{ session, release.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId())) };
+            ASSERT_EQ(releases.size(), 1);
+            EXPECT_EQ(releases[0], release->getId());
+        }
+
+        {
+            auto transaction{ session.createWriteTransaction() };
+            user.get().modify()->setFeedbackBackend(FeedbackBackend::ListenBrainz);
+        }
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            auto releases{ Release::findIds(session, Release::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(releases.size(), 0);
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/StarredTrack.cpp

@@ -39,7 +39,7 @@ namespace lms::db::tests
             EXPECT_EQ(StarredTrack::getCount(session), 0);
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}) };
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
         }
 
         ScopedStarredTrack starredTrack{ session, track.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
@@ -55,13 +55,13 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}) };
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
 
-            tracks = Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(tracks.results.size(), 1);
+            tracks = Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId()));
+            EXPECT_EQ(tracks.size(), 1);
 
-            tracks = Track::findIds(session, Track::FindParameters{}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(tracks.results.size(), 0);
+            tracks = Track::findIds(session, Track::FindParameters{}.setStarringUser(user2.getId()));
+            EXPECT_EQ(tracks.size(), 0);
         }
 
         {
@@ -86,12 +86,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createWriteTransaction() };
 
-            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
-            EXPECT_EQ(tracks.results.size(), 1);
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(tracks.size(), 1);
 
             starredTrack.get().modify()->setSyncState(SyncState::PendingRemove);
-            tracks = Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
-            EXPECT_EQ(tracks.results.size(), 0);
+            tracks = Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId()));
+            EXPECT_EQ(tracks.size(), 0);
         }
     }
 
@@ -109,8 +109,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
-            EXPECT_EQ(tracks.results.size(), 2);
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(tracks.size(), 2);
         }
 
         {
@@ -119,10 +119,10 @@ namespace lms::db::tests
             starredTrack1.get().modify()->setDateTime(dateTime);
             starredTrack2.get().modify()->setDateTime(dateTime.addSecs(-1));
 
-            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc)) };
-            ASSERT_EQ(tracks.results.size(), 2);
-            EXPECT_EQ(tracks.results[0], starredTrack1->getTrack()->getId());
-            EXPECT_EQ(tracks.results[1], starredTrack2->getTrack()->getId());
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId()).setSortMethod(TrackSortMethod::StarredDateDesc)) };
+            ASSERT_EQ(tracks.size(), 2);
+            EXPECT_EQ(tracks[0], starredTrack1->getTrack()->getId());
+            EXPECT_EQ(tracks[1], starredTrack2->getTrack()->getId());
         }
         {
             auto transaction{ session.createWriteTransaction() };
@@ -130,10 +130,34 @@ namespace lms::db::tests
             starredTrack1.get().modify()->setDateTime(dateTime);
             starredTrack2.get().modify()->setDateTime(dateTime.addSecs(1));
 
-            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(TrackSortMethod::StarredDateDesc)) };
-            ASSERT_EQ(tracks.results.size(), 2);
-            EXPECT_EQ(tracks.results[0], starredTrack2->getTrack()->getId());
-            EXPECT_EQ(tracks.results[1], starredTrack1->getTrack()->getId());
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId()).setSortMethod(TrackSortMethod::StarredDateDesc)) };
+            ASSERT_EQ(tracks.size(), 2);
+            EXPECT_EQ(tracks[0], starredTrack2->getTrack()->getId());
+            EXPECT_EQ(tracks[1], starredTrack1->getTrack()->getId());
+        }
+    }
+    TEST_F(DatabaseFixture, StarredTrack_currentBackend)
+    {
+        ScopedTrack track{ session };
+        ScopedUser user{ session, "MyUser" };
+        ScopedStarredTrack starredTrack{ session, track.lockAndGet(), user.lockAndGet(), FeedbackBackend::Internal };
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId())) };
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks[0], track->getId());
+        }
+
+        {
+            auto transaction{ session.createWriteTransaction() };
+            user.get().modify()->setFeedbackBackend(FeedbackBackend::ListenBrainz);
+        }
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            auto tracks{ Track::findIds(session, Track::FindParameters{}.setStarringUser(user.getId())) };
+            EXPECT_EQ(tracks.size(), 0);
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/Track.cpp

@@ -37,8 +37,8 @@ namespace lms::db::tests
     {
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(Track::find(session, Track::FindParameters{}).results.size(), 0);
-            EXPECT_EQ(Track::findIds(session, Track::FindParameters{}).results.size(), 0);
+            EXPECT_EQ(Track::find(session, Track::FindParameters{}).size(), 0);
+            EXPECT_EQ(Track::findIds(session, Track::FindParameters{}).size(), 0);
             EXPECT_EQ(Track::getCount(session), 0);
             EXPECT_FALSE(Track::exists(session, 0));
 
@@ -54,7 +54,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            EXPECT_EQ(Track::find(session, Track::FindParameters{}).results.size(), 1);
+            EXPECT_EQ(Track::find(session, Track::FindParameters{}).size(), 1);
             EXPECT_EQ(Track::getCount(session), 1);
             EXPECT_TRUE(Track::exists(session, track.getId()));
             auto myTrack{ Track::find(session, track.getId()) };
@@ -260,8 +260,8 @@ namespace lms::db::tests
             params.setFilters(Filters{}.setCodec(core::media::Codec::FLAC));
 
             const auto tracks{ Track::find(session, params) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results[0]->getId(), track2.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks[0]->getId(), track2.getId());
         }
     }
 
@@ -291,13 +291,13 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMediaLibrary(library->getId()))) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMediaLibrary(otherLibrary->getId()))) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
     }
 
@@ -320,7 +320,7 @@ namespace lms::db::tests
         EXPECT_FALSE(Track::exists(session, TrackId{ 42 }));
         EXPECT_EQ(Track::find(session, TrackId{ 42 }), Track::pointer{});
         EXPECT_FALSE(Track::find(session, TrackId{ 42 }));
-        EXPECT_EQ(Track::find(session, Track::FindParameters{}).results.size(), 0);
+        EXPECT_EQ(Track::find(session, Track::FindParameters{}).size(), 0);
         {
             auto track{ Track::find(session, TrackId{ 42 }) };
             EXPECT_TRUE(!track);
@@ -366,24 +366,24 @@ namespace lms::db::tests
 
             {
                 const auto tracks{ Track::findIds(session, Track::FindParameters{}.setKeywords({ "Track" })) };
-                EXPECT_EQ(tracks.results.size(), 6);
+                EXPECT_EQ(tracks.size(), 6);
             }
             {
                 const auto tracks{ Track::findIds(session, Track::FindParameters{}.setKeywords({ "MyTrack" })) };
-                EXPECT_EQ(tracks.results.size(), 5);
-                EXPECT_TRUE(std::none_of(std::cbegin(tracks.results), std::cend(tracks.results), [&](const TrackId trackId) { return trackId == track6.getId(); }));
+                EXPECT_EQ(tracks.size(), 5);
+                EXPECT_TRUE(std::none_of(std::cbegin(tracks), std::cend(tracks), [&](const TrackId trackId) { return trackId == track6.getId(); }));
             }
             {
                 const auto tracks{ Track::findIds(session, Track::FindParameters{}.setKeywords({ "MyTrack%" })) };
-                ASSERT_EQ(tracks.results.size(), 2);
-                EXPECT_EQ(tracks.results[0], track2.getId());
-                EXPECT_EQ(tracks.results[1], track3.getId());
+                ASSERT_EQ(tracks.size(), 2);
+                EXPECT_EQ(tracks[0], track2.getId());
+                EXPECT_EQ(tracks[1], track3.getId());
             }
             {
                 const auto tracks{ Track::findIds(session, Track::FindParameters{}.setKeywords({ "%MyTrack" })) };
-                ASSERT_EQ(tracks.results.size(), 2);
-                EXPECT_EQ(tracks.results[0], track4.getId());
-                EXPECT_EQ(tracks.results[1], track5.getId());
+                ASSERT_EQ(tracks.size(), 2);
+                EXPECT_EQ(tracks[0], track4.getId());
+                EXPECT_EQ(tracks[1], track5.getId());
             }
         }
     }
@@ -434,19 +434,19 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}) };
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setWrittenAfter(dateTime.addSecs(-1))) };
-            EXPECT_EQ(tracks.results.size(), 1);
+            EXPECT_EQ(tracks.size(), 1);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setWrittenAfter(dateTime.addSecs(+1))) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
     }
 
@@ -525,11 +525,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setSortMethod(TrackSortMethod::AddedDesc)) };
-            ASSERT_EQ(tracks.results.size(), 4);
-            EXPECT_EQ(tracks.results[0], track4.getId());
-            EXPECT_EQ(tracks.results[1], track1.getId());
-            EXPECT_EQ(tracks.results[2], track2.getId());
-            EXPECT_EQ(tracks.results[3], track3.getId());
+            ASSERT_EQ(tracks.size(), 4);
+            EXPECT_EQ(tracks[0], track4.getId());
+            EXPECT_EQ(tracks[1], track1.getId());
+            EXPECT_EQ(tracks[2], track2.getId());
+            EXPECT_EQ(tracks[3], track3.getId());
         }
     }
 
@@ -550,11 +550,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             const auto tracks{ Track::findIds(session, Track::FindParameters{}.setSortMethod(TrackSortMethod::LastWrittenDesc)) };
-            ASSERT_EQ(tracks.results.size(), 4);
-            EXPECT_EQ(tracks.results[0], track4.getId());
-            EXPECT_EQ(tracks.results[1], track1.getId());
-            EXPECT_EQ(tracks.results[2], track2.getId());
-            EXPECT_EQ(tracks.results[3], track3.getId());
+            ASSERT_EQ(tracks.size(), 4);
+            EXPECT_EQ(tracks[0], track4.getId());
+            EXPECT_EQ(tracks[1], track1.getId());
+            EXPECT_EQ(tracks[2], track2.getId());
+            EXPECT_EQ(tracks[3], track3.getId());
         }
     }
 
@@ -619,8 +619,8 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto results{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre.getId()).setMood(mood.getId()).setGrouping(grouping.getId()).setLanguage(language.getId()))) };
-            ASSERT_EQ(results.results.size(), 1);
-            EXPECT_EQ(results.results.front(), track1.getId());
+            ASSERT_EQ(results.size(), 1);
+            EXPECT_EQ(results.front(), track1.getId());
         }
     }
 } // namespace lms::db::tests

src/libs/database/test/TrackBookmark.cpp

@@ -50,8 +50,8 @@ namespace lms::db::tests
             EXPECT_EQ(TrackBookmark::getCount(session), 1);
 
             const auto bookmarks{ TrackBookmark::find(session, user.getId()) };
-            ASSERT_EQ(bookmarks.results.size(), 1);
-            EXPECT_EQ(bookmarks.results.front(), bookmark.getId());
+            ASSERT_EQ(bookmarks.size(), 1);
+            EXPECT_EQ(bookmarks.front(), bookmark.getId());
         }
         {
             auto transaction{ session.createReadTransaction() };

src/libs/database/test/TrackEmbeddedImage.cpp

@@ -364,8 +364,8 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto orphans{ TrackEmbeddedImage::findOrphanIds(session, std::nullopt) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results[0], image.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans[0], image.getId());
         }
 
         {
@@ -376,7 +376,7 @@ namespace lms::db::tests
                 auto transaction{ session.createReadTransaction() };
 
                 auto orphans{ TrackEmbeddedImage::findOrphanIds(session, std::nullopt) };
-                ASSERT_EQ(orphans.results.size(), 0);
+                ASSERT_EQ(orphans.size(), 0);
             }
         }
 
@@ -384,8 +384,8 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto orphans{ TrackEmbeddedImage::findOrphanIds(session, std::nullopt) };
-            ASSERT_EQ(orphans.results.size(), 1);
-            EXPECT_EQ(orphans.results[0], image.getId());
+            ASSERT_EQ(orphans.size(), 1);
+            EXPECT_EQ(orphans[0], image.getId());
         }
     }
 

src/libs/database/test/TrackList.cpp

@@ -53,10 +53,10 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setTrackList(trackList1.getId())) };
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
 
             tracks = Track::findIds(session, Track::FindParameters{}.setTrackList(trackList2.getId()));
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
 
         {
@@ -69,11 +69,11 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto tracks{ Track::findIds(session, Track::FindParameters{}.setTrackList(trackList1.getId())) };
-            ASSERT_EQ(tracks.results.size(), 1);
-            EXPECT_EQ(tracks.results.front(), track.getId());
+            ASSERT_EQ(tracks.size(), 1);
+            EXPECT_EQ(tracks.front(), track.getId());
 
             tracks = Track::findIds(session, Track::FindParameters{}.setTrackList(trackList2.getId()));
-            EXPECT_EQ(tracks.results.size(), 0);
+            EXPECT_EQ(tracks.size(), 0);
         }
     }
 
@@ -87,9 +87,9 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto trackLists{ TrackList::find(session, TrackList::FindParameters{}.setSortMethod(TrackListSortMethod::Name)) };
-            ASSERT_EQ(trackLists.results.size(), 2);
-            EXPECT_EQ(trackLists.results[0], trackList1.getId());
-            EXPECT_EQ(trackLists.results[1], trackList2.getId());
+            ASSERT_EQ(trackLists.size(), 2);
+            EXPECT_EQ(trackLists[0], trackList1.getId());
+            EXPECT_EQ(trackLists[1], trackList2.getId());
         }
 
         {
@@ -103,9 +103,9 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto trackLists{ TrackList::find(session, TrackList::FindParameters{}.setSortMethod(TrackListSortMethod::LastModifiedDesc)) };
-            ASSERT_EQ(trackLists.results.size(), 2);
-            EXPECT_EQ(trackLists.results[0], trackList2.getId());
-            EXPECT_EQ(trackLists.results[1], trackList1.getId());
+            ASSERT_EQ(trackLists.size(), 2);
+            EXPECT_EQ(trackLists[0], trackList2.getId());
+            EXPECT_EQ(trackLists[1], trackList1.getId());
         }
 
         {
@@ -119,9 +119,9 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             const auto trackLists{ TrackList::find(session, TrackList::FindParameters{}.setSortMethod(TrackListSortMethod::LastModifiedDesc)) };
-            ASSERT_EQ(trackLists.results.size(), 2);
-            EXPECT_EQ(trackLists.results[0], trackList1.getId());
-            EXPECT_EQ(trackLists.results[1], trackList2.getId());
+            ASSERT_EQ(trackLists.size(), 2);
+            EXPECT_EQ(trackLists[0], trackList1.getId());
+            EXPECT_EQ(trackLists[1], trackList2.getId());
         }
     }
 
@@ -245,7 +245,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto trackLists{ TrackList::find(session, TrackList::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster.getId() }))) };
-            EXPECT_EQ(trackLists.results.size(), 0);
+            EXPECT_EQ(trackLists.size(), 0);
         }
 
         {
@@ -259,8 +259,8 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             auto trackLists{ TrackList::find(session, TrackList::FindParameters{}.setFilters(Filters{}.setClusters(std::initializer_list<ClusterId>{ cluster.getId() }))) };
-            ASSERT_EQ(trackLists.results.size(), 1);
-            EXPECT_EQ(trackLists.results.front(), trackList1.getId());
+            ASSERT_EQ(trackLists.size(), 1);
+            EXPECT_EQ(trackLists.front(), trackList1.getId());
         }
     }
 
@@ -278,8 +278,8 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto entries{ trackList.get()->getEntries() };
-            ASSERT_EQ(entries.results.size(), 1);
-            EXPECT_EQ(entries.results.front()->getTrack()->getId(), track1.getId());
+            ASSERT_EQ(entries.size(), 1);
+            EXPECT_EQ(entries.front()->getTrack()->getId(), track1.getId());
         }
 
         {
@@ -290,16 +290,16 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             auto entries{ trackList.get()->getEntries() };
-            ASSERT_EQ(entries.results.size(), 2);
-            EXPECT_EQ(entries.results[0]->getTrack()->getId(), track1.getId());
-            EXPECT_EQ(entries.results[1]->getTrack()->getId(), track2.getId());
+            ASSERT_EQ(entries.size(), 2);
+            EXPECT_EQ(entries[0]->getTrack()->getId(), track1.getId());
+            EXPECT_EQ(entries[1]->getTrack()->getId(), track2.getId());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
             auto entries{ trackList.get()->getEntries(Range{ 1, 1 }) };
-            ASSERT_EQ(entries.results.size(), 1);
-            EXPECT_EQ(entries.results[0]->getTrack()->getId(), track2.getId());
+            ASSERT_EQ(entries.size(), 1);
+            EXPECT_EQ(entries[0]->getTrack()->getId(), track2.getId());
         }
     }
 

src/libs/services/artwork/impl/ArtworkService.cpp

@@ -169,7 +169,7 @@ namespace lms::artwork
         }
 
         const auto entries{ trackList->getEntries(db::Range{ 0, 10 }) };
-        for (const auto& entry : entries.results)
+        for (const auto& entry : entries)
         {
             const auto track{ entry->getTrack() };
             if (track->getPreferredMediaArtworkId().isValid())

src/libs/services/feedback/impl/FeedbackService.cpp

@@ -92,13 +92,9 @@ namespace lms::feedback
 
     FeedbackService::ArtistContainer FeedbackService::findStarredArtists(const ArtistFindParameters& params)
     {
-        auto backend{ getUserFeedbackBackend(params.user) };
-        if (!backend)
-            return {};
-
         Artist::FindParameters searchParams;
         searchParams.setFilters(params.filters);
-        searchParams.setStarringUser(params.user, *backend);
+        searchParams.setStarringUser(params.user);
         searchParams.setKeywords(params.keywords);
         searchParams.setTrackArtistLinkType(params.trackArtistLinkType);
         searchParams.setSortMethod(params.sortMethod);
@@ -142,12 +138,8 @@ namespace lms::feedback
 
     FeedbackService::ReleaseContainer FeedbackService::findStarredReleases(const FindParameters& params)
     {
-        auto backend{ getUserFeedbackBackend(params.user) };
-        if (!backend)
-            return {};
-
         Release::FindParameters searchParams;
-        searchParams.setStarringUser(params.user, *backend);
+        searchParams.setStarringUser(params.user);
         searchParams.setFilters(params.filters);
         searchParams.setKeywords(params.keywords);
         searchParams.setSortMethod(ReleaseSortMethod::StarredDateDesc);
@@ -191,12 +183,8 @@ namespace lms::feedback
 
     FeedbackService::TrackContainer FeedbackService::findStarredTracks(const FindParameters& params)
     {
-        auto backend{ getUserFeedbackBackend(params.user) };
-        if (!backend)
-            return {};
-
         Track::FindParameters searchParams;
-        searchParams.setStarringUser(params.user, *backend);
+        searchParams.setStarringUser(params.user);
         searchParams.setFilters(params.filters);
         searchParams.setKeywords(params.keywords);
         searchParams.setSortMethod(TrackSortMethod::StarredDateDesc);

src/libs/services/feedback/impl/listenbrainz/FeedbacksSynchronizer.cpp

@@ -196,7 +196,7 @@ namespace lms::feedback::listenBrainz
         using namespace db;
 
         auto processPendingFeedbacks{ [this](SyncState scrobblingState, FeedbackType feedbackType) {
-            RangeResults<StarredTrackId> pendingFeedbacks;
+            std::vector<StarredTrackId> pendingFeedbacks;
 
             {
                 db::Session& session{ _db.getTLSSession() };
@@ -210,9 +210,9 @@ namespace lms::feedback::listenBrainz
                 pendingFeedbacks = StarredTrack::find(session, params);
             }
 
-            LOG(DEBUG, "Queing " << pendingFeedbacks.results.size() << " pending '" << (feedbackType == FeedbackType::Love ? "love" : "erase") << "' feedbacks");
+            LOG(DEBUG, "Queing " << pendingFeedbacks.size() << " pending '" << (feedbackType == FeedbackType::Love ? "love" : "erase") << "' feedbacks");
 
-            for (const StarredTrackId starredTrackId : pendingFeedbacks.results)
+            for (const StarredTrackId starredTrackId : pendingFeedbacks)
                 enqueFeedback(feedbackType, starredTrackId);
         } };
 
@@ -270,14 +270,14 @@ namespace lms::feedback::listenBrainz
 
         enquePendingFeedbacks();
 
-        db::RangeResults<db::UserId> userIds;
+        std::vector<db::UserId> userIds;
         {
             db::Session& session{ _db.getTLSSession() };
             auto transaction{ session.createReadTransaction() };
             userIds = db::User::find(_db.getTLSSession(), db::User::FindParameters{}.setFeedbackBackend(db::FeedbackBackend::ListenBrainz));
         }
 
-        for (const db::UserId userId : userIds.results)
+        for (const db::UserId userId : userIds)
             startSync(getUserContext(userId));
 
         if (!isSyncing())

src/libs/services/feedback/include/services/feedback/IFeedbackService.hpp

@@ -45,9 +45,9 @@ namespace lms::feedback
     public:
         virtual ~IFeedbackService() = default;
 
-        using ArtistContainer = db::RangeResults<db::ArtistId>;
-        using ReleaseContainer = db::RangeResults<db::ReleaseId>;
-        using TrackContainer = db::RangeResults<db::TrackId>;
+        using ArtistContainer = std::vector<db::ArtistId>;
+        using ReleaseContainer = std::vector<db::ReleaseId>;
+        using TrackContainer = std::vector<db::TrackId>;
 
         struct FindParameters
         {

src/libs/services/recommendation/impl/audio-similarity/AudioSimilarityEngine.impl.hpp

@@ -627,13 +627,13 @@ namespace lms::recommendation
             {
                 db::Release::FindParameters params;
                 params.setArtist(artist->getId());
-                for (const db::ReleaseId releaseId : db::Release::findIds(session, params).results)
+                for (const db::ReleaseId releaseId : db::Release::findIds(session, params))
                 {
                     if (_releaseVectors.contains(releaseId))
                     {
                         db::Track::FindParameters trackParams;
                         trackParams.setRelease(releaseId);
-                        for (const db::TrackId trackId : db::Track::findIds(session, trackParams).results)
+                        for (const db::TrackId trackId : db::Track::findIds(session, trackParams))
                             artistTrackIds.insert(trackId);
                     }
                 }

src/libs/services/recommendation/impl/tags/TagsEngine.cpp

@@ -169,11 +169,11 @@ namespace lms::recommendation
                 db::Release::FindParameters params;
                 params.setArtist(artist->getId());
 
-                for (const db::ReleaseId releaseId : db::Release::findIds(session, params).results)
+                for (const db::ReleaseId releaseId : db::Release::findIds(session, params))
                 {
                     db::Track::FindParameters trackParams;
                     trackParams.setRelease(releaseId);
-                    for (const db::TrackId trackId : db::Track::findIds(session, trackParams).results)
+                    for (const db::TrackId trackId : db::Track::findIds(session, trackParams))
                         artistTrackIds.insert(trackId);
                 }
             }

src/libs/services/scanner/impl/steps/ScanStepArtistReconciliation.cpp

@@ -183,10 +183,10 @@ namespace lms::scanner
                 auto transaction{ session.createReadTransaction() };
 
                 const auto artists{ db::Artist::findWithMBIDNameVariants(session, lastRetrievedArtist, db::Range{ .offset = 0, .size = batchSize }) };
-                if (artists.results.empty())
+                if (artists.empty())
                     break;
 
-                for (const db::Artist::pointer& artist : artists.results)
+                for (const db::Artist::pointer& artist : artists)
                 {
                     bool hasArtistInfo{};
                     db::ArtistInfo::find(session, artist->getId(), db::Range{ .offset = 0, .size = 1 }, [&](const db::ArtistInfo::pointer&) {
@@ -218,7 +218,7 @@ namespace lms::scanner
                     }
                 }
 
-                if (!artists.moreResults)
+                if (artists.size() < batchSize)
                     break;
             }
 

src/libs/services/scanner/impl/steps/ScanStepCheckForDuplicatedFiles.cpp

@@ -41,8 +41,8 @@ namespace lms::scanner
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createReadTransaction() };
 
-        const RangeResults<TrackId> tracks = Track::findIdsTrackMBIDDuplicates(session);
-        for (const TrackId trackId : tracks.results)
+        const std::vector<TrackId> tracks = Track::findIdsTrackMBIDDuplicates(session);
+        for (const TrackId trackId : tracks)
         {
             if (_abortScan)
                 break;

src/libs/services/scanner/impl/steps/ScanStepComputeGenreStats.cpp

@@ -50,7 +50,7 @@ namespace lms::scanner
                 Genre::FindParameters params;
                 params.setRange(range);
                 auto transaction{ dbSession.createReadTransaction() };
-                return std::move(Genre::findIds(dbSession, params).results);
+                return Genre::findIds(dbSession, params);
             }() };
 
             for (const GenreId genreId : genreIds)
@@ -65,6 +65,7 @@ namespace lms::scanner
                     trackCount = Genre::computeTrackCount(dbSession, genreId);
                     releaseCount = Genre::computeReleaseCount(dbSession, genreId);
                 }
+
                 {
                     auto transaction{ dbSession.createWriteTransaction() };
                     auto genre{ Genre::find(dbSession, genreId) };

src/libs/services/scanner/impl/steps/ScanStepRemoveOrphanedDbEntries.cpp

@@ -155,7 +155,7 @@ namespace lms::scanner
 
         db::Session& session{ _db.getTLSSession() };
 
-        db::RangeResults<IdType> entries;
+        std::vector<IdType> entries;
         while (!_abortScan)
         {
             {
@@ -164,16 +164,16 @@ namespace lms::scanner
                 entries = T::findOrphanIds(session, db::Range{ 0, batchSize });
             };
 
-            if (entries.results.empty())
+            if (entries.empty())
                 break;
 
             {
                 auto transaction{ session.createWriteTransaction() };
 
-                session.destroy<T>(entries.results);
+                session.destroy<T>(entries);
             }
 
-            context.currentStepStats.processedElems += entries.results.size();
+            context.currentStepStats.processedElems += entries.size();
             _progressCallback(context.currentStepStats);
         }
     }

src/libs/services/scanner/impl/steps/ScanStepUpdateLibraryFields.cpp

@@ -58,7 +58,7 @@ namespace lms::scanner
 
         constexpr std::size_t batchSize = 100;
 
-        db::RangeResults<db::DirectoryId> entries;
+        std::vector<db::DirectoryId> entries;
         while (!_abortScan)
         {
             {
@@ -67,7 +67,7 @@ namespace lms::scanner
                 entries = db::Directory::findMismatchedLibrary(session, db::Range{ 0, batchSize }, mediaLibrary.rootDirectory, mediaLibrary.id);
             };
 
-            if (entries.results.empty())
+            if (entries.empty())
                 break;
 
             {
@@ -77,7 +77,7 @@ namespace lms::scanner
                 if (!library) // may be legit
                     break;
 
-                for (const db::DirectoryId directoryId : entries.results)
+                for (const db::DirectoryId directoryId : entries)
                 {
                     if (_abortScan)
                         break;
@@ -87,7 +87,7 @@ namespace lms::scanner
                 }
             }
 
-            context.currentStepStats.processedElems += entries.results.size();
+            context.currentStepStats.processedElems += entries.size();
             _progressCallback(context.currentStepStats);
         }
     }

src/libs/services/scrobbling/impl/ScrobblingService.cpp

@@ -156,17 +156,9 @@ namespace lms::scrobbling
     ScrobblingService::ArtistContainer ScrobblingService::getRecentArtists(const ArtistFindParameters& params)
     {
         ArtistContainer res;
-
-        const auto backend{ getUserBackend(params.user) };
-        if (!backend)
-            return res;
-
         db::Listen::ArtistStatsFindParameters listenFindParams{ convertToListenFindParameters(params) };
-        listenFindParams.setScrobblingBackend(backend);
-
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createReadTransaction() };
-
         res = db::Listen::getRecentArtists(session, listenFindParams);
         return res;
     }
@@ -174,17 +166,9 @@ namespace lms::scrobbling
     ScrobblingService::ReleaseContainer ScrobblingService::getRecentReleases(const FindParameters& params)
     {
         ReleaseContainer res;
-
-        const auto backend{ getUserBackend(params.user) };
-        if (!backend)
-            return res;
-
         db::Listen::StatsFindParameters listenFindParams{ convertToListenFindParameters(params) };
-        listenFindParams.setScrobblingBackend(backend);
-
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createReadTransaction() };
-
         res = db::Listen::getRecentReleases(session, listenFindParams);
         return res;
     }
@@ -192,17 +176,9 @@ namespace lms::scrobbling
     ScrobblingService::TrackContainer ScrobblingService::getRecentTracks(const FindParameters& params)
     {
         TrackContainer res;
-
-        const auto backend{ getUserBackend(params.user) };
-        if (!backend)
-            return res;
-
         db::Listen::StatsFindParameters listenFindParams{ convertToListenFindParameters(params) };
-        listenFindParams.setScrobblingBackend(backend);
-
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createReadTransaction() };
-
         res = db::Listen::getRecentTracks(session, listenFindParams);
         return res;
     }
@@ -243,17 +219,9 @@ namespace lms::scrobbling
     ScrobblingService::ArtistContainer ScrobblingService::getTopArtists(const ArtistFindParameters& params)
     {
         ArtistContainer res;
-
-        const auto backend{ getUserBackend(params.user) };
-        if (!backend)
-            return res;
-
         db::Listen::ArtistStatsFindParameters listenFindParams{ convertToListenFindParameters(params) };
-        listenFindParams.setScrobblingBackend(backend);
-
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createReadTransaction() };
-
         res = db::Listen::getTopArtists(session, listenFindParams);
         return res;
     }
@@ -261,17 +229,9 @@ namespace lms::scrobbling
     ScrobblingService::ReleaseContainer ScrobblingService::getTopReleases(const FindParameters& params)
     {
         ReleaseContainer res;
-
-        const auto backend{ getUserBackend(params.user) };
-        if (!backend)
-            return res;
-
         db::Listen::StatsFindParameters listenFindParams{ convertToListenFindParameters(params) };
-        listenFindParams.setScrobblingBackend(backend);
-
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createReadTransaction() };
-
         res = db::Listen::getTopReleases(session, listenFindParams);
         return res;
     }
@@ -279,17 +239,9 @@ namespace lms::scrobbling
     ScrobblingService::TrackContainer ScrobblingService::getTopTracks(const FindParameters& params)
     {
         TrackContainer res;
-
-        const auto backend{ getUserBackend(params.user) };
-        if (!backend)
-            return res;
-
         db::Listen::StatsFindParameters listenFindParams{ convertToListenFindParameters(params) };
-        listenFindParams.setScrobblingBackend(backend);
-
         Session& session{ _db.getTLSSession() };
         auto transaction{ session.createReadTransaction() };
-
         res = db::Listen::getTopTracks(session, listenFindParams);
         return res;
     }

src/libs/services/scrobbling/impl/lastfm/ScrobblingsSynchronizer.cpp

@@ -226,8 +226,8 @@ namespace lms::scrobbling::lastFm
                 .setSyncState(db::SyncState::PendingAdd)
                 .setRange(db::Range{ 0, maxBatchSize * 10 });
 
-            const db::RangeResults results{ db::Listen::find(session, params) };
-            for (const db::ListenId listenId : results.results)
+            const auto results{ db::Listen::find(session, params) };
+            for (const db::ListenId listenId : results)
             {
                 const db::Listen::pointer dbListen{ db::Listen::find(session, listenId) };
 

src/libs/services/scrobbling/impl/listenbrainz/ListensSynchronizer.cpp

@@ -214,12 +214,12 @@ namespace lms::scrobbling::listenBrainz
 
             const auto tracks{ Track::findIds(session, params) };
             // conservative behavior: in case of multiple matches: reject
-            if (tracks.results.size() == 1)
+            if (tracks.size() == 1)
             {
                 LMS_LOG_LISTENBRAINZ(DEBUG, "Matched listen '" << listen << "' using metadata");
-                return tracks.results.front();
+                return tracks.front();
             }
-            else if (tracks.results.size() > 1)
+            else if (tracks.size() > 1)
             {
                 LMS_LOG_LISTENBRAINZ(DEBUG, "Too many matches for listen '" << listen << "' using metadata");
                 return {};
@@ -349,10 +349,10 @@ namespace lms::scrobbling::listenBrainz
                 .setSyncState(db::SyncState::PendingAdd)
                 .setRange(db::Range{ 0, 100 }); // don't flood too much?
 
-            const db::RangeResults results{ db::Listen::find(session, params) };
-            pendingListens.reserve(results.results.size());
+            const auto results{ db::Listen::find(session, params) };
+            pendingListens.reserve(results.size());
 
-            for (db::ListenId listenId : results.results)
+            for (db::ListenId listenId : results)
             {
                 const db::Listen::pointer listen{ db::Listen::find(session, listenId) };
 
@@ -421,14 +421,14 @@ namespace lms::scrobbling::listenBrainz
 
         enquePendingListens();
 
-        db::RangeResults<db::UserId> userIds;
+        std::vector<db::UserId> userIds;
         {
             db::Session& session{ _db.getTLSSession() };
             auto transaction{ session.createReadTransaction() };
             userIds = db::User::find(_db.getTLSSession(), db::User::FindParameters{}.setScrobblingBackend(db::ScrobblingBackend::ListenBrainz));
         }
 
-        for (const db::UserId userId : userIds.results)
+        for (const db::UserId userId : userIds)
             startSync(getUserContext(userId));
 
         if (!isSyncing())

src/libs/services/scrobbling/include/services/scrobbling/IScrobblingService.hpp

@@ -66,9 +66,9 @@ namespace lms::scrobbling
         virtual void visitNowPlayingListens(const std::function<void(Clock::time_point startedAt, const Listen&)>& visitor, db::UserId userId = {}) = 0;
 
         // Stats
-        using ArtistContainer = db::RangeResults<db::ArtistId>;
-        using ReleaseContainer = db::RangeResults<db::ReleaseId>;
-        using TrackContainer = db::RangeResults<db::TrackId>;
+        using ArtistContainer = std::vector<db::ArtistId>;
+        using ReleaseContainer = std::vector<db::ReleaseId>;
+        using TrackContainer = std::vector<db::TrackId>;
 
         struct FindParameters
         {

src/libs/subsonic/impl/endpoints/AlbumSongLists.cpp

@@ -58,7 +58,7 @@ namespace lms::api::subsonic
 
             const Range range{ offset, size };
 
-            RangeResults<ReleaseId> releases;
+            std::vector<ReleaseId> releases;
             scrobbling::IScrobblingService& scrobblingService{ *core::Service<scrobbling::IScrobblingService>::get() };
             feedback::IFeedbackService& feedbackService{ *core::Service<feedback::IFeedbackService>::get() };
 
@@ -166,7 +166,7 @@ namespace lms::api::subsonic
             Response response{ Response::createOkResponse(context.getServerProtocolVersion()) };
             Response::Node& albumListNode{ response.createNode(id3 ? Response::Node::Key{ "albumList2" } : Response::Node::Key{ "albumList" }) };
 
-            for (const ReleaseId releaseId : releases.results)
+            for (const ReleaseId releaseId : releases)
             {
                 const Release::pointer release{ Release::find(context.getDbSession(), releaseId) };
                 albumListNode.addArrayChild("album", createAlbumNode(context, release, id3));
@@ -193,7 +193,7 @@ namespace lms::api::subsonic
                 feedback::IFeedbackService::ArtistFindParameters artistFindParams;
                 artistFindParams.setUser(context.getUser()->getId());
                 artistFindParams.setSortMethod(ArtistSortMethod::SortName);
-                for (const ArtistId artistId : feedbackService.findStarredArtists(artistFindParams).results)
+                for (const ArtistId artistId : feedbackService.findStarredArtists(artistFindParams))
                 {
                     if (auto artist{ Artist::find(context.getDbSession(), artistId) })
                         starredNode.addArrayChild("artist", createArtistNode(context, artist));
@@ -204,13 +204,13 @@ namespace lms::api::subsonic
             findParameters.setUser(context.getUser()->getId());
             findParameters.filters.setMediaLibrary(mediaLibrary);
 
-            for (const ReleaseId releaseId : feedbackService.findStarredReleases(findParameters).results)
+            for (const ReleaseId releaseId : feedbackService.findStarredReleases(findParameters))
             {
                 if (auto release{ Release::find(context.getDbSession(), releaseId) })
                     starredNode.addArrayChild("album", createAlbumNode(context, release, id3));
             }
 
-            for (const TrackId trackId : feedbackService.findStarredTracks(findParameters).results)
+            for (const TrackId trackId : feedbackService.findStarredTracks(findParameters))
             {
                 if (auto track{ Track::find(context.getDbSession(), trackId) })
                     starredNode.addArrayChild("song", createSongNode(context, track, context.getUser()));

src/libs/subsonic/impl/endpoints/Bookmarks.cpp

@@ -41,7 +41,7 @@ namespace lms::api::subsonic
         Response response{ Response::createOkResponse(context.getServerProtocolVersion()) };
         Response::Node& bookmarksNode{ response.createNode("bookmarks") };
 
-        for (const db::TrackBookmarkId bookmarkId : bookmarkIds.results)
+        for (const db::TrackBookmarkId bookmarkId : bookmarkIds)
         {
             const db::TrackBookmark::pointer bookmark{ db::TrackBookmark::find(context.getDbSession(), bookmarkId) };
             Response::Node bookmarkNode{ createBookmarkNode(bookmark) };

src/libs/subsonic/impl/endpoints/Browsing.cpp

@@ -69,7 +69,7 @@ namespace lms::api::subsonic
             }
             else
             {
-                res = Directory::findRootDirectories(session).results;
+                res = Directory::findRootDirectories(session);
             }
 
             return res;
@@ -137,8 +137,8 @@ namespace lms::api::subsonic
 
                 const auto artistTracks{ Track::findIds(context.getDbSession(), params) };
                 tracks.insert(std::end(tracks),
-                              std::begin(artistTracks.results),
-                              std::end(artistTracks.results));
+                              std::begin(artistTracks),
+                              std::end(artistTracks));
             }
 
             return tracks;
@@ -173,8 +173,8 @@ namespace lms::api::subsonic
 
                 const auto releaseTracks{ Track::findIds(context.getDbSession(), params) };
                 tracks.insert(std::end(tracks),
-                              std::begin(releaseTracks.results),
-                              std::end(releaseTracks.results));
+                              std::begin(releaseTracks),
+                              std::end(releaseTracks));
             }
 
             return tracks;
@@ -431,7 +431,7 @@ namespace lms::api::subsonic
 
             parameters.setRange(Range{ currentArtistOffset, batchSize });
             const auto artists{ Artist::find(context.getDbSession(), parameters) };
-            for (const Artist::pointer& artist : artists.results)
+            for (const Artist::pointer& artist : artists)
             {
                 std::string_view sortName{ artist->getSortName() };
 
@@ -439,8 +439,8 @@ namespace lms::api::subsonic
                 artistsSortedByFirstChar[sortChar].push_back(artist->getId());
             }
 
-            hasMoreArtists = artists.moreResults;
-            currentArtistOffset += artists.results.size();
+            hasMoreArtists = (artists.size() == batchSize);
+            currentArtistOffset += artists.size();
         }
 
         // second pass: add each artist
@@ -509,7 +509,7 @@ namespace lms::api::subsonic
         Response::Node albumNode{ createAlbumNode(context, release, true /* id3 */) };
 
         const auto tracks{ Track::find(context.getDbSession(), Track::FindParameters{}.setRelease(id).setSortMethod(TrackSortMethod::Release)) };
-        for (const Track::pointer& track : tracks.results)
+        for (const Track::pointer& track : tracks)
             albumNode.addArrayChild("song", createSongNode(context, track, true /* id3 */));
 
         response.addNode("album", std::move(albumNode));
@@ -660,7 +660,7 @@ namespace lms::api::subsonic
             params.setArtist(artists.front()->getId());
 
             const auto trackIds{ core::Service<scrobbling::IScrobblingService>::get()->getTopTracks(params) };
-            for (const TrackId trackId : trackIds.results)
+            for (const TrackId trackId : trackIds)
             {
                 if (Track::pointer track{ Track::find(context.getDbSession(), trackId) })
                     topSongs.addArrayChild("song", createSongNode(context, track, context.getUser()));

src/libs/subsonic/impl/endpoints/MediaRetrieval.cpp

@@ -248,11 +248,11 @@ namespace lms::api::subsonic
 
         // Choice: we return nothing if there are too many results
         const auto tracks{ db::Track::findIds(context.getDbSession(), params) };
-        if (tracks.results.size() == 1)
+        if (tracks.size() == 1)
         {
             // Choice: we return only the first lyrics if the track has many lyrics
             db::TrackLyrics::FindParameters lyricsParams;
-            lyricsParams.setTrack(tracks.results[0]);
+            lyricsParams.setTrack(tracks[0]);
             lyricsParams.setSortMethod(db::TrackLyricsSortMethod::ExternalFirst);
             lyricsParams.setRange(db::Range{ 0, 1 });
 

src/libs/subsonic/impl/endpoints/Playlists.cpp

@@ -107,7 +107,7 @@ namespace lms::api::subsonic
         Response::Node playlistNode{ createPlaylistNode(context, trackList) };
 
         auto entries{ trackList->getEntries() };
-        for (const TrackListEntry::pointer& entry : entries.results)
+        for (const TrackListEntry::pointer& entry : entries)
             playlistNode.addArrayChild("entry", createSongNode(context, entry->getTrack(), context.getUser()));
 
         response.addNode("playlist", std::move(playlistNode));
@@ -160,7 +160,7 @@ namespace lms::api::subsonic
         Response::Node playlistNode{ createPlaylistNode(context, trackList) };
 
         auto entries{ trackList->getEntries() };
-        for (const TrackListEntry::pointer& entry : entries.results)
+        for (const TrackListEntry::pointer& entry : entries)
             playlistNode.addArrayChild("entry", createSongNode(context, entry->getTrack(), context.getUser()));
 
         response.addNode("playlist", std::move(playlistNode));

src/libs/subsonic/impl/responses/Album.cpp

@@ -134,7 +134,7 @@ namespace lms::api::subsonic
         Genre::FindParameters genreParams;
         genreParams.setRelease(release->getId());
         genreParams.setSortMethod(GenreSortMethod::TrackCountDesc);
-        const auto genres{ Genre::find(context.getDbSession(), genreParams).results };
+        const auto genres{ Genre::find(context.getDbSession(), genreParams) };
         if (!genres.empty())
             albumNode.setAttribute("genre", genres.front()->getName());
 

src/lms/ui/PlayQueue.cpp

@@ -144,7 +144,7 @@ namespace lms::ui
                 auto transaction{ LmsApp->getDbSession().createWriteTransaction() };
 
                 db::TrackList::pointer queue{ getQueue() };
-                auto entries{ queue->getEntries().results };
+                auto entries{ queue->getEntries() };
                 core::random::shuffleContainer(entries);
 
                 queue.modify()->clear();
@@ -404,8 +404,8 @@ namespace lms::ui
 
         db::TrackList::pointer queue{ getQueue() };
         auto entries{ queue->getEntries(db::Range{ _trackPos ? *_trackPos + 1 : 0, getCapacity() }) };
-        tracks.reserve(entries.results.size());
-        for (db::TrackListEntry::pointer& entry : entries.results)
+        tracks.reserve(entries.size());
+        for (db::TrackListEntry::pointer& entry : entries)
         {
             tracks.push_back(entry->getTrack()->getId());
             entry.remove();
@@ -466,10 +466,10 @@ namespace lms::ui
 
         const db::TrackList::pointer queue{ getQueue() };
         const auto entries{ queue->getEntries(db::Range{ _entriesContainer->getCount(), _batchSize }) };
-        for (const db::TrackListEntry::pointer& tracklistEntry : entries.results)
+        for (const db::TrackListEntry::pointer& tracklistEntry : entries)
             addEntry(tracklistEntry);
 
-        _entriesContainer->setHasMore(entries.moreResults);
+        _entriesContainer->setHasMore(entries.size() == _batchSize);
     }
 
     void PlayQueue::addEntry(const db::TrackListEntry::pointer& tracklistEntry)

src/lms/ui/Utils.cpp

@@ -235,7 +235,7 @@ namespace lms::ui::utils
         std::unique_ptr<Wt::WContainerWidget> clusterContainer{ std::make_unique<Wt::WContainerWidget>() };
 
         // TODO: optimize this
-        const auto clusterTypes{ ClusterType::findIds(LmsApp->getDbSession()).results };
+        const auto clusterTypes{ ClusterType::findIds(LmsApp->getDbSession()) };
         const auto clusterGroups{ track->getClusterGroups(clusterTypes, 3) };
 
         for (const auto& clusters : clusterGroups)

src/lms/ui/admin/debug/PcmDecodingBenchmark.cpp

@@ -81,7 +81,7 @@ namespace lms::ui
             const auto results{ db::Track::find(session, params) };
 
             std::vector<TrackEntry> entries;
-            for (const db::Track::pointer& track : results.results)
+            for (const db::Track::pointer& track : results)
             {
                 const auto trackDuration{ track->getDuration() };
                 if (trackDuration >= minTrackDuration && trackDuration <= maxTrackDuration)

src/lms/ui/common/InfiniteScrollingContainer.cpp

@@ -21,6 +21,9 @@
 
 #include <cassert>
 
+#include <Wt/WContainerWidget.h>
+#include <Wt/WText.h>
+
 #include "LoadingIndicator.hpp"
 
 namespace lms::ui
@@ -41,6 +44,7 @@ namespace lms::ui
     void InfiniteScrollingContainer::reset()
     {
         _elements->clear();
+        hideResultHint();
         setHasMore(true);
     }
 
@@ -51,7 +55,8 @@ namespace lms::ui
 
     void InfiniteScrollingContainer::add(std::unique_ptr<Wt::WWidget> result)
     {
-        return _elements->addWidget(std::move(result));
+        _gotItems = true;
+        _elements->addWidget(std::move(result));
     }
 
     void InfiniteScrollingContainer::setHasMore()
@@ -62,9 +67,20 @@ namespace lms::ui
     void InfiniteScrollingContainer::setHasMore(bool hasMore)
     {
         if (hasMore)
+        {
+            _gotItems = false;
             displayLoadingIndicator();
+        }
         else
+        {
             hideLoadingIndicator();
+            if (getCount() == 0)
+                displayResultHint(Wt::WString::tr("Lms.infinite-scrolling-container.no-results"));
+            else if (!_gotItems)
+                displayResultHint(Wt::WString::tr("Lms.infinite-scrolling-container.limit-reached"));
+            else
+                hideResultHint();
+        }
     }
 
     void InfiniteScrollingContainer::remove(Wt::WWidget& widget)
@@ -113,4 +129,18 @@ namespace lms::ui
         _loadingIndicator = nullptr;
         bindEmpty("loading-indicator");
     }
+
+    void InfiniteScrollingContainer::displayResultHint(const Wt::WString& msg)
+    {
+        _loadingIndicator = nullptr;
+        auto container{ std::make_unique<Wt::WContainerWidget>() };
+        container->addStyleClass("my-5 text-center text-muted");
+        container->addNew<Wt::WText>(msg);
+        bindWidget("loading-indicator", std::move(container));
+    }
+
+    void InfiniteScrollingContainer::hideResultHint()
+    {
+        bindEmpty("loading-indicator");
+    }
 } // namespace lms::ui

src/lms/ui/common/InfiniteScrollingContainer.hpp

@@ -45,7 +45,10 @@ namespace lms::ui
         template<typename T, typename... Args>
         T* addNew(Args&&... args)
         {
-            return _elements->addNew<T>(std::forward<Args>(args)...);
+            auto widget{ std::make_unique<T>(std::forward<Args>(args)...) };
+            T* ptr{ widget.get() };
+            add(std::move(widget));
+            return ptr;
         }
 
         void remove(Wt::WWidget& widget);
@@ -63,8 +66,11 @@ namespace lms::ui
         void clear() override;
         void displayLoadingIndicator();
         void hideLoadingIndicator();
+        void displayResultHint(const Wt::WString& msg);
+        void hideResultHint();
 
         Wt::WContainerWidget* _elements;
         Wt::WTemplate* _loadingIndicator;
+        bool _gotItems{};
     };
 } // namespace lms::ui

src/lms/ui/explore/ArtistCollector.cpp

@@ -19,85 +19,97 @@
 
 #include "ArtistCollector.hpp"
 
-#include "core/Service.hpp"
 #include "core/Utils.hpp"
 
 #include "database/Session.hpp"
 #include "database/objects/Artist.hpp"
+#include "database/objects/Listen.hpp"
 #include "database/objects/TrackList.hpp"
 #include "database/objects/Types.hpp"
 #include "database/objects/User.hpp"
-#include "services/feedback/IFeedbackService.hpp"
-#include "services/scrobbling/IScrobblingService.hpp"
 
 #include "LmsApplication.hpp"
 
 namespace lms::ui
 {
-    db::RangeResults<db::ArtistId> ArtistCollector::get(std::optional<db::Range> requestedRange)
+    void ArtistCollector::get(db::Range requestedRange, bool& moreResults, const std::function<void(const db::ObjectPtr<db::Artist>&)>& func)
     {
-        feedback::IFeedbackService& feedbackService{ *core::Service<feedback::IFeedbackService>::get() };
-        scrobbling::IScrobblingService& scrobblingService{ *core::Service<scrobbling::IScrobblingService>::get() };
-
         const Range range{ getActualRange(requestedRange) };
 
-        db::RangeResults<db::ArtistId> artists;
+        auto applyArtistType = [&](auto& params) {
+            std::visit(core::utils::overloads{
+                           [&](AllArtistsTag) {},
+                           [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
+                           [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
+                       _artistType);
+        };
 
         switch (getMode())
         {
         case Mode::Random:
-            artists = getRandomArtists(range);
-            break;
+            {
+                if (!_randomArtists)
+                {
+                    db::Artist::FindParameters params;
+                    params.setFilters(getDbFilters());
+                    params.setKeywords(getSearchKeywords());
+                    params.setSortMethod(db::ArtistSortMethod::Random);
+                    params.setRange(db::Range{ 0, getMaxCount() });
+                    applyArtistType(params);
+                    _randomArtists = db::Artist::findIds(LmsApp->getDbSession(), params);
+                }
+                const auto& all{ *_randomArtists };
+                const std::size_t offset{ std::min(range.offset, all.size()) };
+                const auto slice{ std::span{ all }.subspan(offset, std::min(range.size, all.size() - offset)) };
+                moreResults = (offset + slice.size() < all.size());
+                for (const auto id : slice)
+                {
+                    if (const auto artist{ db::Artist::find(LmsApp->getDbSession(), id) })
+                        func(artist);
+                }
+                break;
+            }
 
         case Mode::Starred:
             {
-                feedback::IFeedbackService::ArtistFindParameters params;
+                db::Artist::FindParameters params;
                 params.setFilters(getDbFilters());
-                params.setUser(LmsApp->getUserId());
                 params.setKeywords(getSearchKeywords());
                 params.setSortMethod(db::ArtistSortMethod::StarredDateDesc);
                 params.setRange(range);
-                std::visit(core::utils::overloads{
-                               [&](AllArtistsTag) {},
-                               [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
-                               [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
-                           _artistType);
-
-                artists = feedbackService.findStarredArtists(params);
+                params.setStarringUser(LmsApp->getUserId());
+                applyArtistType(params);
+                std::size_t count{};
+                db::Artist::find(LmsApp->getDbSession(), params, [&](const auto& a) { func(a); ++count; });
+                moreResults = (count == range.size);
                 break;
             }
 
         case Mode::RecentlyPlayed:
             {
-                scrobbling::IScrobblingService::ArtistFindParameters params;
-                params.setUser(LmsApp->getUserId());
+                db::Listen::ArtistStatsFindParameters params;
                 params.setFilters(getDbFilters());
                 params.setKeywords(getSearchKeywords());
                 params.setRange(range);
-                std::visit(core::utils::overloads{
-                               [&](AllArtistsTag) {},
-                               [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
-                               [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
-                           _artistType);
-
-                artists = scrobblingService.getRecentArtists(params);
+                params.setUser(LmsApp->getUserId());
+                applyArtistType(params);
+                std::size_t count{};
+                db::Listen::getRecentArtists(LmsApp->getDbSession(), params, [&](const auto& a) { func(a); ++count; });
+                moreResults = (count == range.size);
                 break;
             }
 
         case Mode::MostPlayed:
             {
-                scrobbling::IScrobblingService::ArtistFindParameters params;
-                params.setUser(LmsApp->getUserId());
+                db::Listen::ArtistStatsFindParameters params;
                 params.setFilters(getDbFilters());
                 params.setKeywords(getSearchKeywords());
                 params.setRange(range);
-                std::visit(core::utils::overloads{
-                               [&](AllArtistsTag) {},
-                               [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
-                               [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
-                           _artistType);
-
-                artists = scrobblingService.getTopArtists(params);
+                params.setUser(LmsApp->getUserId());
+                applyArtistType(params);
+                std::size_t count{};
+                db::Listen::getTopArtists(LmsApp->getDbSession(), params, [&](const auto& a) { func(a); ++count; });
+                moreResults = (count == range.size);
                 break;
             }
 
@@ -108,16 +120,10 @@ namespace lms::ui
                 params.setKeywords(getSearchKeywords());
                 params.setSortMethod(db::ArtistSortMethod::AddedDesc);
                 params.setRange(range);
-                std::visit(core::utils::overloads{
-                               [&](AllArtistsTag) {},
-                               [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
-                               [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
-                           _artistType);
-
-                {
-                    auto transaction{ LmsApp->getDbSession().createReadTransaction() };
-                    artists = db::Artist::findIds(LmsApp->getDbSession(), params);
-                }
+                applyArtistType(params);
+                std::size_t count{};
+                db::Artist::find(LmsApp->getDbSession(), params, [&](const auto& a) { func(a); ++count; });
+                moreResults = (count == range.size);
                 break;
             }
 
@@ -128,16 +134,10 @@ namespace lms::ui
                 params.setKeywords(getSearchKeywords());
                 params.setSortMethod(db::ArtistSortMethod::LastWrittenDesc);
                 params.setRange(range);
-                std::visit(core::utils::overloads{
-                               [&](AllArtistsTag) {},
-                               [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
-                               [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
-                           _artistType);
-
-                {
-                    auto transaction{ LmsApp->getDbSession().createReadTransaction() };
-                    artists = db::Artist::findIds(LmsApp->getDbSession(), params);
-                }
+                applyArtistType(params);
+                std::size_t count{};
+                db::Artist::find(LmsApp->getDbSession(), params, [&](const auto& a) { func(a); ++count; });
+                moreResults = (count == range.size);
                 break;
             }
 
@@ -148,49 +148,13 @@ namespace lms::ui
                 params.setKeywords(getSearchKeywords());
                 params.setSortMethod(db::ArtistSortMethod::SortName);
                 params.setRange(range);
-                std::visit(core::utils::overloads{
-                               [&](AllArtistsTag) {},
-                               [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
-                               [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
-                           _artistType);
-
-                {
-                    auto transaction{ LmsApp->getDbSession().createReadTransaction() };
-                    artists = db::Artist::findIds(LmsApp->getDbSession(), params);
-                }
+                applyArtistType(params);
+                std::size_t count{};
+                db::Artist::find(LmsApp->getDbSession(), params, [&](const auto& a) { func(a); ++count; });
+                moreResults = (count == range.size);
                 break;
             }
         }
-
-        if (range.offset + range.size == getMaxCount())
-            artists.moreResults = false;
-
-        return artists;
     }
 
-    db::RangeResults<db::ArtistId> ArtistCollector::getRandomArtists(Range range)
-    {
-        assert(getMode() == Mode::Random);
-
-        if (!_randomArtists)
-        {
-            db::Artist::FindParameters params;
-            params.setFilters(getDbFilters());
-            params.setKeywords(getSearchKeywords());
-            params.setSortMethod(db::ArtistSortMethod::Random);
-            params.setRange(db::Range{ 0, getMaxCount() });
-            std::visit(core::utils::overloads{
-                           [&](AllArtistsTag) {},
-                           [&](ReleaseArtistsTag) { params.setReleaseArtistsOnly(true); },
-                           [&](db::TrackArtistLinkType trackArtistLinkType) { params.setTrackArtistLinkType(trackArtistLinkType); } },
-                       _artistType);
-
-            {
-                auto transaction{ LmsApp->getDbSession().createReadTransaction() };
-                _randomArtists = db::Artist::findIds(LmsApp->getDbSession(), params);
-            }
-        }
-
-        return _randomArtists->getSubRange(range);
-    }
 } // namespace lms::ui

src/lms/ui/explore/ArtistCollector.hpp

@@ -19,8 +19,12 @@
 
 #pragma once
 
+#include <functional>
 #include <optional>
+#include <vector>
 
+#include "database/Object.hpp"
+#include "database/Types.hpp"
 #include "database/objects/ArtistId.hpp"
 
 #include "ArtistType.hpp"
@@ -38,13 +42,12 @@ namespace lms::ui
     public:
         using DatabaseCollectorBase::DatabaseCollectorBase;
 
-        db::RangeResults<db::ArtistId> get(std::optional<db::Range> range = std::nullopt);
+        void get(db::Range range, bool& moreResults, const std::function<void(const db::ObjectPtr<db::Artist>&)>& func);
         void reset() { _randomArtists.reset(); }
         void setArtistType(ArtistType artistType) { _artistType = artistType; }
 
     private:
-        db::RangeResults<db::ArtistId> getRandomArtists(Range range);
-        std::optional<db::RangeResults<db::ArtistId>> _randomArtists;
+        std::optional<std::vector<db::ArtistId>> _randomArtists;
         ArtistType _artistType;
     };
 } // namespace lms::ui

src/lms/ui/explore/ArtistView.cpp

@@ -175,7 +175,7 @@ namespace lms::ui
                 });
             });
 
-            auto clusterTypes{ db::ClusterType::findIds(LmsApp->getDbSession()).results };
+            auto clusterTypes{ db::ClusterType::findIds(LmsApp->getDbSession()) };
             auto clusterGroups{ artist->getClusterGroups(clusterTypes, 3) };
 
             for (const auto& clusters : clusterGroups)
@@ -466,7 +466,7 @@ namespace lms::ui
         auto transaction{ LmsApp->getDbSession().createReadTransaction() };
 
         const auto tracks{ db::Track::find(LmsApp->getDbSession(), params) };
-        for (const db::Track::pointer& track : tracks.results)
+        for (const db::Track::pointer& track : tracks)
         {
             // TODO handle this with range
             if (_trackContainer->getCount() == _tracksMaxCount)
@@ -477,7 +477,7 @@ namespace lms::ui
             areTracksAdded = true;
         }
 
-        _trackContainer->setHasMore(tracks.moreResults);
+        _trackContainer->setHasMore(tracks.size() == range.size);
 
         return areTracksAdded;
     }

src/lms/ui/explore/ArtistsView.cpp

@@ -111,19 +111,14 @@ namespace lms::ui
 
     void Artists::addSome()
     {
-        const auto artistIds{ _artistCollector.get(db::Range{ static_cast<std::size_t>(_container->getCount()), _batchSize }) };
-
+        bool moreResults{};
         {
             auto transaction{ LmsApp->getDbSession().createReadTransaction() };
-
-            for (const db::ArtistId artistId : artistIds.results)
-            {
-                if (const auto artist{ db::Artist::find(LmsApp->getDbSession(), artistId) })
-                    _container->add(ArtistListHelpers::createEntry(artist));
-            }
+            _artistCollector.get(db::Range{ static_cast<std::size_t>(_container->getCount()), _batchSize }, moreResults, [&](const db::Artist::pointer& artist) {
+                _container->add(ArtistListHelpers::createEntry(artist));
+            });
         }
-
-        _container->setHasMore(artistIds.moreResults);
+        _container->setHasMore(moreResults);
     }
 
 } // namespace lms::ui

src/lms/ui/explore/ArtistsView.hpp

@@ -44,7 +44,7 @@ namespace lms::ui
         void addSome();
 
         static constexpr std::size_t _batchSize{ 30 };
-        static constexpr std::size_t _maxCount{ 8000 };
+        static constexpr std::size_t _maxCount{ 5'000 };
 
         Wt::WWidget* _currentLinkTypeActiveItem{};
         InfiniteScrollingContainer* _container{};