UI: added away to filter all the views by music library

src/libs/database/impl/Cluster.cpp

@@ -43,17 +43,19 @@ namespace lms::db
             query.groupBy("c.id");
 
             if (params.track.isValid() || params.release.isValid())
-            {
                 query.join("track_cluster t_c ON t_c.cluster_id = c.id");
-                query.join("track t ON t.id = t_c.track_id");
-            }
+            
             if (!params.clusterTypeName.empty())
                 query.join("cluster_type c_t ON c_t.id = c.cluster_type_id");
 
             if (params.track.isValid())
-                query.where("t.id = ?").bind(params.track);
+                query.where("t_c.track_id = ?").bind(params.track);
+
             if (params.release.isValid())
+            {
+                query.join("track t ON t.id = t_c.track_id");
                 query.where("t.release_id = ?").bind(params.release);
+            }
 
             assert(!params.clusterType.isValid() || params.clusterTypeName.empty());
             if (params.clusterType.isValid())
@@ -61,6 +63,17 @@ namespace lms::db
             else if (!params.clusterTypeName.empty())
                 query.where("c_t.name = ?").bind(params.clusterTypeName);
 
+            switch (params.sortMethod)
+            {
+            case ClusterSortMethod::None:
+                break;
+            case ClusterSortMethod::Name:
+                query.orderBy("c.name COLLATE NOCASE");
+                break;
+            }
+
+            query.groupBy("c.id");
+
             return query;
         }
 
@@ -208,6 +221,12 @@ namespace lms::db
         return utils::execRangeQuery<ClusterTypeId>(query, range);
     }
 
+    void ClusterType::find(Session& session, const std::function<void(const pointer&)>& func)
+    {
+        auto query{ session.getDboSession()->find<ClusterType>() };
+        return utils::forEachQueryResult(query, func);
+    }
+
     ClusterType::pointer ClusterType::find(Session& session, std::string_view name)
     {
         session.checkReadTransaction();

src/libs/database/impl/Migration.cpp

@@ -34,7 +34,7 @@ namespace lms::db
 {
     namespace
     {
-        static constexpr Version LMS_DATABASE_VERSION{ 57 };
+        static constexpr Version LMS_DATABASE_VERSION{ 58 };
     }
 
     VersionInfo::VersionInfo()
@@ -455,11 +455,17 @@ SELECT
     void migrateFromV56(Session& session)
     {
         // Make sure we remove all the previoulsy created index, the createIndexesIfNeeded will recreate them all
-        std::vector<std::string> indexeNames{ utils::fetchQueryResults(session.getDboSession()->query<std::string>(R"(SELECT name FROM sqlite_master  WHERE type = 'index' AND name LIKE '%_idx')")) };
+        std::vector<std::string> indexeNames{ utils::fetchQueryResults(session.getDboSession()->query<std::string>(R"(SELECT name FROM sqlite_master WHERE type = 'index' AND name LIKE '%_idx')")) };
         for (const auto& indexName : indexeNames)
             session.getDboSession()->execute("DROP INDEX " + indexName);
     }
 
+    void migrateFromV57(Session& session)
+    {
+        // useless index
+        session.getDboSession()->execute("DROP INDEX cluster_name_idx");
+    }
+
     bool doDbMigration(Session& session)
     {
         static const std::string outdatedMsg{ "Outdated database, please rebuild it (delete the .db file and restart)" };
@@ -494,6 +500,7 @@ SELECT
             {54, migrateFromV54},
             {55, migrateFromV55},
             {56, migrateFromV56},
+            {57, migrateFromV57},
         };
 
         bool migrationPerformed{};

src/libs/database/impl/Session.cpp

@@ -172,7 +172,6 @@ namespace lms::db
         _session.execute("CREATE INDEX IF NOT EXISTS auth_token_value_idx ON auth_token(value)");
 
         _session.execute("CREATE INDEX IF NOT EXISTS cluster_cluster_type_idx ON cluster(cluster_type_id)");
-        _session.execute("CREATE INDEX IF NOT EXISTS cluster_name_idx ON cluster(name)");
         _session.execute("CREATE INDEX IF NOT EXISTS cluster_type_name_idx ON cluster_type(name)");
 
         _session.execute("CREATE INDEX IF NOT EXISTS listen_backend_idx ON listen(backend)");

src/libs/database/impl/TrackList.cpp

@@ -35,6 +35,79 @@
 
 namespace lms::db
 {
+    namespace
+    {
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const TrackList::FindParameters& params)
+        {
+            auto query{ session.getDboSession()->query<ResultType>("SELECT DISTINCT " + std::string{ itemToSelect } + " FROM tracklist t_l") };
+
+            if (!params.clusters.empty() || params.mediaLibrary.isValid())
+                query.join("tracklist_entry t_l_e ON t_l_e.tracklist_id = t_l.id");
+
+            if (params.mediaLibrary.isValid())
+                query.join("track t ON t.id = t_l_e.track_id");
+
+            if (params.mediaLibrary.isValid())
+                query.where("t.media_library_id = ?").bind(params.mediaLibrary);
+
+            if (params.user.isValid())
+                query.where("t_l.user_id = ?").bind(params.user);
+
+            if (params.type)
+                query.where("t_l.type = ?").bind(*params.type);
+
+            if (!params.clusters.empty())
+            {
+                std::ostringstream oss;
+                oss << "t_l_e.track_id IN (SELECT DISTINCT t.id FROM track t"
+                    " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
+                    " INNER JOIN cluster c ON c.id = t_c.cluster_id";
+
+                WhereClause clusterClause;
+                for (const ClusterId clusterId : params.clusters)
+                {
+                    clusterClause.Or(WhereClause("c.id = ?"));
+                    query.bind(clusterId);
+                }
+
+                oss << " " << clusterClause.get();
+                oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
+
+                query.where(oss.str());
+            }
+
+            switch (params.sortMethod)
+            {
+            case TrackListSortMethod::None:
+                break;
+            case TrackListSortMethod::Name:
+                query.orderBy("t_l.name COLLATE NOCASE");
+                break;
+            case TrackListSortMethod::LastModifiedDesc:
+                query.orderBy("t_l.last_modified_date_time DESC");
+                break;
+            }
+
+            return query;
+        }
+
+        template <typename ResultType>
+        Wt::Dbo::Query<ResultType> createQuery(Session& session, const TrackList::FindParameters& params)
+        {
+            std::string_view itemToSelect;
+
+            if constexpr (std::is_same_v<ResultType, TrackListId>)
+                itemToSelect = "t_l.id";
+            else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<TrackList>>)
+                itemToSelect = "t_l";
+            else
+                static_assert("Unhandled type");
+
+            return createQuery<ResultType>(session, itemToSelect, params);
+        }
+    }
+
     TrackList::TrackList(std::string_view name, TrackListType type, bool isPublic, ObjectPtr<User> user)
         : _name{ name }
         , _type{ type }
@@ -58,7 +131,6 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM tracklist"));
     }
 
-
     TrackList::pointer TrackList::find(Session& session, std::string_view name, TrackListType type, UserId userId)
     {
         session.checkReadTransaction();
@@ -73,53 +145,17 @@ namespace lms::db
     RangeResults<TrackListId> TrackList::find(Session& session, const FindParameters& params)
     {
         session.checkReadTransaction();
-
-        auto query{ session.getDboSession()->query<TrackListId>("SELECT DISTINCT t_l.id FROM tracklist t_l") };
-
-        if (params.user.isValid())
-            query.where("t_l.user_id = ?").bind(params.user);
-
-        if (params.type)
-            query.where("t_l.type = ?").bind(*params.type);
-
-        if (!params.clusters.empty())
-        {
-            query.join("tracklist_entry t_l_e ON t_l_e.tracklist_id = t_l.id");
-            query.join("track t ON t.id = t_l_e.track_id");
-
-            std::ostringstream oss;
-            oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
-                " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
-                " INNER JOIN cluster c ON c.id = t_c.cluster_id";
-
-            WhereClause clusterClause;
-            for (const ClusterId clusterId : params.clusters)
-            {
-                clusterClause.Or(WhereClause("c.id = ?"));
-                query.bind(clusterId);
-            }
-
-            oss << " " << clusterClause.get();
-            oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
-
-            query.where(oss.str());
-        }
-
-        switch (params.sortMethod)
-        {
-        case TrackListSortMethod::None:
-            break;
-        case TrackListSortMethod::Name:
-            query.orderBy("t_l.name COLLATE NOCASE");
-            break;
-        case TrackListSortMethod::LastModifiedDesc:
-            query.orderBy("t_l.last_modified_date_time DESC");
-            break;
-        }
-
+        auto query{ createQuery<TrackListId>(session, params) };
         return utils::execRangeQuery<TrackListId>(query, params.range);
     }
 
+    void TrackList::find(Session& session, const FindParameters& params, const std::function<void(const TrackList::pointer&)>& func)
+    {
+        session.checkReadTransaction();
+        auto query{ createQuery<Wt::Dbo::ptr<TrackList>>(session, params) };
+        utils::forEachQueryRangeResult(query, params.range, func);
+    }
+
     TrackList::pointer TrackList::find(Session& session, TrackListId id)
     {
         session.checkReadTransaction();

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

@@ -20,6 +20,7 @@
 #pragma once
 
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -67,7 +68,7 @@ namespace lms::db
             ReleaseId							release;	// artists involved in this release
             MediaLibraryId                      mediaLibrary; // artists that belong to this library
 
-            FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
+            FindParameters& setClusters(std::span<const ClusterId> _clusters) { clusters.assign(std::cbegin(_clusters), std::cend(_clusters)); return *this; }
             FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
             FindParameters& setLinkType(std::optional<TrackArtistLinkType> _linkType) { linkType = _linkType; return *this; }
             FindParameters& setSortMethod(ArtistSortMethod _sortMethod) { sortMethod = _sortMethod; return *this; }

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

@@ -46,12 +46,14 @@ namespace lms::db
         struct FindParameters
         {
             std::optional<Range>    range;
+            ClusterSortMethod       sortMethod;
             ClusterTypeId           clusterType;    // if non empty, clusters that belong to this cluster type
             std::string             clusterTypeName; // if non empty, clusters that belong to this cluster type
             TrackId                 track;        // if set, clusters involved in this track
             ReleaseId               release;      // if set, clusters involved in this release
 
             FindParameters& setRange(std::optional<Range> _range) { range = _range; return *this; }
+            FindParameters& setSortMethod(ClusterSortMethod _method) { sortMethod = _method; return *this; }
             FindParameters& setClusterType(ClusterTypeId _clusterType) { clusterType = _clusterType; return *this; }
             FindParameters& setClusterTypeName(std::string_view _name) { clusterTypeName = _name; return *this; }
             FindParameters& setTrack(TrackId _track) { track = _track; return *this; }
@@ -119,6 +121,7 @@ namespace lms::db
         // Getters
         static std::size_t					getCount(Session& session);
         static RangeResults<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);

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

@@ -21,6 +21,7 @@
 
 #include <filesystem>
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -96,7 +97,7 @@ namespace lms::db
             std::string                         releaseType;    // If set, albums that has this release type
             MediaLibraryId                      mediaLibrary;   // If set, releases that has at least a track in this library
 
-            FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
+            FindParameters& setClusters(std::span<const ClusterId> _clusters) { clusters.assign(std::cbegin(_clusters), std::cend(_clusters)); return *this; }
             FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
             FindParameters& setSortMethod(ReleaseSortMethod _sortMethod) { sortMethod = _sortMethod; return *this; }
             FindParameters& setRange(std::optional<Range> _range) { range = _range; return *this; }

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

@@ -23,6 +23,7 @@
 #include <filesystem>
 #include <ostream>
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -80,7 +81,7 @@ namespace lms::db
             std::optional<int>					discNumber;	    // matching this disc number
             MediaLibraryId                      mediaLibrary;   // If set, tracks in this library
 
-            FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
+            FindParameters& setClusters(std::span<const ClusterId> _clusters) { clusters.assign(std::cbegin(_clusters), std::cend(_clusters)); return *this; }
             FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; return *this; }
             FindParameters& setName(std::string_view _name) { name = _name; return *this; }
             FindParameters& setSortMethod(TrackSortMethod _method) { sortMethod = _method; return *this; }

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

@@ -20,6 +20,7 @@
 #pragma once
 
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -28,6 +29,7 @@
 #include <Wt/WDateTime.h>
 
 #include "database/ClusterId.hpp"
+#include "database/MediaLibraryId.hpp"
 #include "database/Object.hpp"
 #include "database/TrackId.hpp"
 #include "database/TrackListId.hpp"
@@ -57,18 +59,21 @@ namespace lms::db
             std::optional<Range>            range;
             std::optional<TrackListType>	type;
             UserId							user;		// only tracklists owned by this user
+            MediaLibraryId                  mediaLibrary; // only tracklists that have songs in this media library
             TrackListSortMethod				sortMethod{ TrackListSortMethod::None };
 
-            FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
+            FindParameters& setClusters(std::span<const ClusterId> _clusters) { clusters.assign(std::cbegin(_clusters), std::cend(_clusters)); return *this; }
             FindParameters& setRange(std::optional<Range> _range) { range = _range; return *this; }
             FindParameters& setType(TrackListType _type) { type = _type; return *this; }
             FindParameters& setUser(UserId _user) { user = _user; return *this; }
+            FindParameters& setMediaLibrary(MediaLibraryId  _mediaLibrary) { mediaLibrary = _mediaLibrary; return *this; }
             FindParameters& setSortMethod(TrackListSortMethod _sortMethod) { sortMethod = _sortMethod; return *this; }
         };
         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 void                         find(Session& session, const FindParameters& params, const std::function<void(const TrackList::pointer&)>& func);
 
         // Accessors
         std::string_view	getName() const { return _name; }

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

@@ -116,6 +116,12 @@ namespace lms::db
         StarredDateDesc,
     };
 
+    enum class ClusterSortMethod
+    {
+        None,
+        Name,
+    };
+
     enum class ReleaseSortMethod
     {
         None,

src/libs/database/test/Cluster.cpp

@@ -137,11 +137,11 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto tracks{ Track::findIds(session, Track::FindParameters {}.setClusters({cluster1.getId()})) };
+            auto tracks{ Track::findIds(session, Track::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster1.getId()})) };
             ASSERT_EQ(tracks.results.size(), 1);
             EXPECT_EQ(tracks.results.front(), track.getId());
 
-            tracks = Track::findIds(session, Track::FindParameters{}.setClusters({ cluster2.getId() }));
+            tracks = Track::findIds(session, Track::FindParameters{}.setClusters(std::initializer_list<ClusterId>{ cluster2.getId() }));
             EXPECT_EQ(tracks.results.size(), 0);
         }
 
@@ -237,6 +237,35 @@ namespace lms::db::tests
         }
     }
 
+    TEST_F(DatabaseFixture, ClusterType)
+    {
+        {
+            auto transaction{ session.createReadTransaction() };
+
+            bool visited{};
+            ClusterType::find(session, [&](const ClusterType::pointer&)
+                {
+                    visited = true;
+                });
+            EXPECT_FALSE(visited);
+        }
+
+        ScopedClusterType clusterType1{ session, "MyClusterType1" };
+        ScopedClusterType clusterType2{ session, "MyClusterType2" };
+
+        {
+            auto transaction{ session.createReadTransaction() };
+
+            std::vector<ClusterTypeId> visitedClusterTypes;
+            ClusterType::find(session, [&](const ClusterType::pointer& clusterType)
+                {
+                    visitedClusterTypes.push_back(clusterType->getId());
+                });
+            ASSERT_EQ(visitedClusterTypes.size(), 2);
+            EXPECT_EQ(visitedClusterTypes[0], clusterType1->getId());
+            EXPECT_EQ(visitedClusterTypes[1], clusterType2->getId());
+        }
+    }
 
     TEST_F(DatabaseFixture, ClusterType_singleTrack)
     {
@@ -285,7 +314,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
             ASSERT_EQ(Cluster::findOrphanIds(session).results.size(), 2);
-            EXPECT_EQ(Release::find(session, Release::FindParameters{}.setClusters({ unusedCluster.getId() })).results.size(), 0);
+            EXPECT_EQ(Release::find(session, Release::FindParameters{}.setClusters(std::initializer_list<ClusterId>{ unusedCluster.getId() })).results.size(), 0);
             EXPECT_EQ(Release::find(session, Release::FindParameters{}).results.size(), 1);
             EXPECT_EQ(Cluster::computeReleaseCount(session, cluster.getId()), 0);
             EXPECT_EQ(Cluster::computeReleaseCount(session, unusedCluster.getId()), 0);
@@ -321,7 +350,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters({cluster.getId()})) };
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster.getId()})) };
             ASSERT_EQ(releases.results.size(), 1);
             EXPECT_EQ(releases.results.front(), release.getId());
         }
@@ -329,7 +358,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters({unusedCluster.getId()})) };
+            const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters(std::initializer_list<ClusterId>{unusedCluster.getId()})) };
             EXPECT_EQ(releases.results.size(), 0);
         }
 
@@ -375,12 +404,12 @@ namespace lms::db::tests
         {
             auto transaction{ session.createWriteTransaction() };
 
-            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
+            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster1.getId()})) };
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist.getId());
 
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster2.getId() })).results.size(), 0);
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setClusters(std::initializer_list<ClusterId>{ cluster2.getId() })).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setClusters(std::initializer_list<ClusterId>{ cluster3.getId() })).results.size(), 0);
 
             cluster2.get().modify()->addTrack(track.get());
         }
@@ -388,19 +417,19 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
+            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster1.getId()})) };
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist.getId());
 
-            artists = Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster2.getId() }));
+            artists = Artist::findIds(session, Artist::FindParameters{}.setClusters(std::initializer_list<ClusterId>{ cluster2.getId() }));
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist.getId());
 
-            artists = Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster1.getId() }));
+            artists = Artist::findIds(session, Artist::FindParameters{}.setClusters(std::initializer_list<ClusterId>{ cluster1.getId() }));
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist.getId());
 
-            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.size(), 0);
+            EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setClusters(std::initializer_list<ClusterId>{ cluster3.getId() })).results.size(), 0);
         }
     }
 
@@ -429,7 +458,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
+            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster.getId()})) };
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist.getId());
         }
@@ -581,7 +610,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
+            auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster.getId()})) };
             ASSERT_EQ(artists.results.size(), 1);
             EXPECT_EQ(artists.results.front(), artist.getId());
 
@@ -589,7 +618,7 @@ namespace lms::db::tests
             ASSERT_EQ(releases.results.size(), 1);
             EXPECT_EQ(releases.results.front(), release.getId());
 
-            releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster.getId() }));
+            releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters(std::initializer_list<ClusterId>{ cluster.getId() }));
             ASSERT_EQ(releases.results.size(), 1);
             EXPECT_EQ(releases.results.front(), release.getId());
         }
@@ -620,7 +649,7 @@ namespace lms::db::tests
             ASSERT_EQ(releases.results.size(), 1);
             EXPECT_EQ(releases.results.front(), release.getId());
 
-            releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster1.getId(), cluster2.getId() }));
+            releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters(std::initializer_list<ClusterId>{ cluster1.getId(), cluster2.getId() }));
             ASSERT_EQ(releases.results.size(), 1);
             EXPECT_EQ(releases.results.front(), release.getId());
         }

src/libs/database/test/TrackList.cpp

@@ -151,6 +151,46 @@ namespace lms::db::tests
         }
     }
 
+    TEST_F(DatabaseFixture, TrackList_MediaLibrary)
+    {
+        ScopedUser user{ session, "MyUser" };
+        ScopedTrackList trackList1{ session, "MytrackList1", TrackListType::Playlist, false, user.lockAndGet() };
+        ScopedTrackList trackList2{ session, "MytrackList2", TrackListType::Playlist, false, user.lockAndGet() };
+        ScopedTrack track1{ session };
+        ScopedTrack track2{ session };
+        ScopedMediaLibrary library{ session };
+
+        {
+            auto transaction{ session.createWriteTransaction() };
+            session.create<TrackListEntry>(track1.get(), trackList1.get());
+            session.create<TrackListEntry>(track2.get(), trackList2.get());
+            track2.get().modify()->setMediaLibrary(library.get());
+        }
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            std::vector<TrackListId> visitedTrackLists;
+            TrackList::find(session, TrackList::FindParameters{}, [&](const TrackList::pointer& trackList)
+                {
+                    visitedTrackLists.push_back(trackList->getId());
+                });
+            ASSERT_EQ(visitedTrackLists.size(), 2);
+            EXPECT_EQ(visitedTrackLists[0], trackList1->getId());
+            EXPECT_EQ(visitedTrackLists[1], trackList2->getId());
+        }
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            std::vector<TrackListId> visitedTrackLists;
+            TrackList::find(session, TrackList::FindParameters{}.setMediaLibrary(library->getId()), [&](const TrackList::pointer& trackList)
+                {
+                    visitedTrackLists.push_back(trackList->getId());
+                });
+            ASSERT_EQ(visitedTrackLists.size(), 1);
+            EXPECT_EQ(visitedTrackLists[0], trackList2->getId());
+        }
+    }
+
     TEST_F(DatabaseFixture, SingleTrackListSingleTrackWithCluster)
     {
         ScopedUser user{ session, "MyUser" };
@@ -163,7 +203,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto trackLists{ TrackList::find(session, TrackList::FindParameters {}.setClusters({cluster.getId()})) };
+            auto trackLists{ TrackList::find(session, TrackList::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster.getId()})) };
             EXPECT_EQ(trackLists.results.size(), 0);
         }
 
@@ -177,7 +217,7 @@ namespace lms::db::tests
         {
             auto transaction{ session.createReadTransaction() };
 
-            auto trackLists{ TrackList::find(session, TrackList::FindParameters {}.setClusters({cluster.getId()})) };
+            auto trackLists{ TrackList::find(session, TrackList::FindParameters {}.setClusters(std::initializer_list<ClusterId>{cluster.getId()})) };
             ASSERT_EQ(trackLists.results.size(), 1);
             EXPECT_EQ(trackLists.results.front(), trackList1.getId());
         }