owen/lms
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

SubsonicAPI: optimized search for albums

Browse Source
This commit is contained in:
emeric
2023-11-04 16:15:39 +01:00
parent 4089f07c16
commit c4d2d20447
14 changed files with 735 additions and 718 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/database/impl/Release.cpp
+32 -7
View File
@@ -34,10 +34,12 @@
namespace Database namespace Database
{ {
namespace
Wt::Dbo::Query<ReleaseId> createQuery(Session& session, const Release::FindParameters& params)
{ {
auto query{ session.getDboSession().query<ReleaseId>("SELECT DISTINCT r.id from release r") }; template <typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Release::FindParameters& params)
{
auto query{ session.getDboSession().query<ResultType>("SELECT DISTINCT " + std::string{ itemToSelect } + " from release r") };
if (params.sortMethod == ReleaseSortMethod::LastWritten if (params.sortMethod == ReleaseSortMethod::LastWritten
|| params.sortMethod == ReleaseSortMethod::Date || params.sortMethod == ReleaseSortMethod::Date
@@ -182,6 +184,22 @@ namespace Database
return query; return query;
} }
template <typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, const Release::FindParameters& params)
{
std::string_view itemToSelect;
if constexpr (std::is_same_v<ResultType, ReleaseId>)
itemToSelect = "r.id";
else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Release>>)
itemToSelect = "r";
else
static_assert("Unhandled type");
return createQuery<ResultType>(session, itemToSelect, params);
}
}
Release::Release(const std::string& name, const std::optional<UUID>& MBID) Release::Release(const std::string& name, const std::optional<UUID>& MBID)
: _name{ std::string(name, 0 , _maxNameLength) }, : _name{ std::string(name, 0 , _maxNameLength) },
_MBID{ MBID ? MBID->getAsString() : "" } _MBID{ MBID ? MBID->getAsString() : "" }
@@ -238,7 +256,7 @@ namespace Database
return session.getDboSession().query<int>("SELECT COUNT(*) FROM release"); return session.getDboSession().query<int>("SELECT COUNT(*) FROM release");
} }
RangeResults<ReleaseId> Release::findOrderedByArtist(Session& session, Range range) RangeResults<ReleaseId> Release::findIdsOrderedByArtist(Session& session, Range range)
{ {
session.checkSharedLocked(); session.checkSharedLocked();
@@ -253,7 +271,7 @@ namespace Database
return Utils::execQuery(query, range); return Utils::execQuery(query, range);
} }
RangeResults<ReleaseId> Release::findOrphans(Session& session, Range range) RangeResults<ReleaseId> Release::findOrphanIds(Session& session, Range range)
{ {
session.checkSharedLocked(); session.checkSharedLocked();
@@ -261,12 +279,19 @@ namespace Database
return Utils::execQuery(query, range); return Utils::execQuery(query, range);
} }
RangeResults<ReleaseId> Release::find(Session& session, const FindParameters& params) RangeResults<Release::pointer> Release::find(Session& session, const FindParameters& params)
{ {
session.checkSharedLocked(); session.checkSharedLocked();
auto query{ createQuery(session, params) }; auto query{ createQuery<Wt::Dbo::ptr<Release>>(session, params) };
return Utils::execQuery(query, params.range);
}
RangeResults<ReleaseId> Release::findIds(Session& session, const FindParameters& params)
{
session.checkSharedLocked();
auto query{ createQuery<ReleaseId>(session, params) };
return Utils::execQuery(query, params.range); return Utils::execQuery(query, params.range);
} }
src/libs/services/database/include/services/database/Release.hpp
+4 -3
View File
@@ -88,9 +88,10 @@ namespace Database
static pointer find(Session& session, const UUID& MBID); static pointer find(Session& session, const UUID& MBID);
static std::vector<pointer> find(Session& session, const std::string& name); static std::vector<pointer> find(Session& session, const std::string& name);
static pointer find(Session& session, ReleaseId id); static pointer find(Session& session, ReleaseId id);
static RangeResults<ReleaseId> find(Session& session, const FindParameters& parameters); static RangeResults<pointer> find(Session& session, const FindParameters& parameters);
static RangeResults<ReleaseId> findOrphans(Session& session, Range range); // no track related static RangeResults<ReleaseId> findIds(Session& session, const FindParameters& parameters);
static RangeResults<ReleaseId> findOrderedByArtist(Session& session, Range range); static RangeResults<ReleaseId> findOrphanIds(Session& session, Range range); // not track related
static RangeResults<ReleaseId> findIdsOrderedByArtist(Session& session, Range range);
// Get the cluster of the tracks that belong to this release // Get the cluster of the tracks that belong to this release
// Each clusters are grouped by cluster type, sorted by the number of occurence (max to min) // Each clusters are grouped by cluster type, sorted by the number of occurence (max to min)
src/libs/services/database/test/Cluster.cpp
+9 -9
View File
@@ -374,7 +374,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrackSingleReleaseSingleCluster)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto releases{ Release::find(session, Release::FindParameters {}.setClusters({cluster.getId()})) }; const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters({cluster.getId()})) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
} }
@@ -382,7 +382,7 @@ TEST_F(DatabaseFixture, Cluster_singleTrackSingleReleaseSingleCluster)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto releases{ Release::find(session, Release::FindParameters {}.setClusters({unusedCluster.getId()})) }; const auto releases{ Release::findIds(session, Release::FindParameters {}.setClusters({unusedCluster.getId()})) };
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
} }
@@ -415,7 +415,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(ClusterType::findOrphans(session, Range{}).results.empty()); EXPECT_TRUE(ClusterType::findOrphans(session, Range{}).results.empty());
EXPECT_EQ(Cluster::findOrphans(session, Range{}).results.size(), 2); EXPECT_EQ(Cluster::findOrphans(session, Range{}).results.size(), 2);
EXPECT_TRUE(Release::findOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
} }
@@ -475,7 +475,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiRolesMultiClusters)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Cluster::findOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Cluster::findOrphans(session, Range{}).results.empty());
EXPECT_TRUE(Release::findOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
} }
@@ -628,7 +628,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtistSingleCluster)
EXPECT_TRUE(Cluster::findOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Cluster::findOrphans(session, Range{}).results.empty());
EXPECT_TRUE(ClusterType::findOrphans(session, Range{}).results.empty()); EXPECT_TRUE(ClusterType::findOrphans(session, Range{}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty());
EXPECT_TRUE(Release::findOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
} }
{ {
@@ -638,11 +638,11 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtistSingleCluster)
ASSERT_EQ(artists.results.size(), 1); ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist.getId()); EXPECT_EQ(artists.results.front(), artist.getId());
auto releases{ Release::find(session, Release::FindParameters {}.setArtist(artist.getId())) }; auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId())) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
releases = Release::find(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster.getId() })); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster.getId() }));
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
} }
@@ -669,11 +669,11 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtistMultiClusters)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto releases{ Release::find(session, Release::FindParameters {}.setArtist(artist.getId())) }; auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId())) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
releases = Release::find(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster1.getId(), cluster2.getId() })); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()).setClusters({ cluster1.getId(), cluster2.getId() }));
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
} }
src/libs/services/database/test/DatabaseTest.cpp
+3 -3
View File
@@ -42,14 +42,14 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistSingleRelease)
{ {
auto transaction {session.createSharedTransaction()}; auto transaction {session.createSharedTransaction()};
EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range {}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty()); EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction {session.createSharedTransaction()};
auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId()))}; auto releases {Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId()))};
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
@@ -74,7 +74,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtist)
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction {session.createUniqueTransaction()};
auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId()))}; auto releases {Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId()))};
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
src/libs/services/database/test/Release.cpp
+154 -148
View File
@@ -24,44 +24,50 @@ using namespace Database;
TEST_F(DatabaseFixture, Release) TEST_F(DatabaseFixture, Release)
{ {
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(Release::getCount(session), 0); EXPECT_EQ(Release::getCount(session), 0);
EXPECT_FALSE(Release::exists(session, 0)); EXPECT_FALSE(Release::exists(session, 0));
EXPECT_FALSE(Release::exists(session, 1)); EXPECT_FALSE(Release::exists(session, 1));
} }
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(Release::getCount(session), 1); EXPECT_EQ(Release::getCount(session), 1);
EXPECT_TRUE(Release::exists(session, release.getId())); EXPECT_TRUE(Release::exists(session, release.getId()));
{ {
auto releases {Release::findOrphans(session, Range {})}; const auto releases{ Release::findOrphanIds(session, Range {}) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
} }
{ {
auto releases {Release::find(session, Release::FindParameters {})}; const auto releases{ Release::findIds(session, Release::FindParameters {}) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
EXPECT_EQ(release->getDuration(), std::chrono::seconds {0}); 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());
} }
} }
} }
TEST_F(DatabaseFixture, Release_singleTrack) TEST_F(DatabaseFixture, Release_singleTrack)
{ {
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
{ {
ScopedTrack track {session, "MyTrack"}; ScopedTrack track{ session, "MyTrack" };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setRelease(release.get()); track.get().modify()->setRelease(release.get());
track.get().modify()->setName("MyTrackName"); track.get().modify()->setName("MyTrackName");
@@ -69,46 +75,46 @@ TEST_F(DatabaseFixture, Release_singleTrack)
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Release::findOrphans(session, Range {}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release.getId()))}; const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release.getId())) };
ASSERT_EQ(tracks.results.size(), 1); ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId()); EXPECT_EQ(tracks.results.front(), track.getId());
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
ASSERT_TRUE(track->getRelease()); ASSERT_TRUE(track->getRelease());
EXPECT_EQ(track->getRelease()->getId(), release.getId()); EXPECT_EQ(track->getRelease()->getId(), release.getId());
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseName"))}; auto tracks{ Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseName")) };
ASSERT_EQ(tracks.results.size(), 1); ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId()); EXPECT_EQ(tracks.results.front(), track.getId());
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseFoo"))}; auto tracks{ Track::find(session, Track::FindParameters{}.setName("MyTrackName").setReleaseName("MyReleaseFoo")) };
EXPECT_EQ(tracks.results.size(), 0); EXPECT_EQ(tracks.results.size(), 0);
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
auto tracks {Track::find(session, Track::FindParameters{}.setName("MyTrackFoo").setReleaseName("MyReleaseName"))}; auto tracks{ Track::find(session, Track::FindParameters{}.setName("MyTrackFoo").setReleaseName("MyReleaseName")) };
EXPECT_EQ(tracks.results.size(), 0); EXPECT_EQ(tracks.results.size(), 0);
} }
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release.getId()))}; const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release.getId())) };
EXPECT_TRUE(tracks.results.empty()); EXPECT_TRUE(tracks.results.empty());
auto releases {Release::findOrphans(session, Range {})}; auto releases{ Release::findOrphanIds(session, Range {}) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
} }
@@ -116,23 +122,23 @@ TEST_F(DatabaseFixture, Release_singleTrack)
TEST_F(DatabaseFixture, MulitpleReleaseSearchByName) TEST_F(DatabaseFixture, MulitpleReleaseSearchByName)
{ {
ScopedRelease release1 {session, "MyRelease"}; ScopedRelease release1{ session, "MyRelease" };
ScopedRelease release2 {session, "MyRelease%"}; ScopedRelease release2{ session, "MyRelease%" };
ScopedRelease release3 {session, "%MyRelease"}; ScopedRelease release3{ session, "%MyRelease" };
ScopedRelease release4 {session, "MyRelease%Foo"}; ScopedRelease release4{ session, "MyRelease%Foo" };
ScopedRelease release5 {session, "Foo%MyRelease"}; ScopedRelease release5{ session, "Foo%MyRelease" };
ScopedRelease release6 {session, "_yRelease"}; ScopedRelease release6{ session, "_yRelease" };
// filters does not work on orphans // filters does not work on orphans
ScopedTrack track1 {session, "MyTrack"}; ScopedTrack track1{ session, "MyTrack" };
ScopedTrack track2 {session, "MyTrack"}; ScopedTrack track2{ session, "MyTrack" };
ScopedTrack track3 {session, "MyTrack"}; ScopedTrack track3{ session, "MyTrack" };
ScopedTrack track4 {session, "MyTrack"}; ScopedTrack track4{ session, "MyTrack" };
ScopedTrack track5 {session, "MyTrack"}; ScopedTrack track5{ session, "MyTrack" };
ScopedTrack track6 {session, "MyTrack"}; ScopedTrack track6{ session, "MyTrack" };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track1.get().modify()->setRelease(release1.get()); track1.get().modify()->setRelease(release1.get());
track2.get().modify()->setRelease(release2.get()); track2.get().modify()->setRelease(release2.get());
@@ -143,37 +149,37 @@ TEST_F(DatabaseFixture, MulitpleReleaseSearchByName)
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
{ {
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"Release"}))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"Release"})) };
EXPECT_EQ(releases.results.size(), 6); EXPECT_EQ(releases.results.size(), 6);
} }
{ {
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease"}))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"MyRelease"})) };
ASSERT_EQ(releases.results.size(), 5); 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(); })); EXPECT_TRUE(std::none_of(std::cbegin(releases.results), std::cend(releases.results), [&](const ReleaseId releaseId) { return releaseId == release6.getId(); }));
} }
{ {
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease%"}))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"MyRelease%"})) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release2.getId()); EXPECT_EQ(releases.results[0], release2.getId());
EXPECT_EQ(releases.results[1], release4.getId()); EXPECT_EQ(releases.results[1], release4.getId());
} }
{ {
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"%MyRelease"}))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"%MyRelease"})) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], release3.getId()); EXPECT_EQ(releases.results[0], release3.getId());
EXPECT_EQ(releases.results[1], release5.getId()); EXPECT_EQ(releases.results[1], release5.getId());
} }
{ {
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"Foo%MyRelease"}))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"Foo%MyRelease"})) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release5.getId()); EXPECT_EQ(releases.results[0], release5.getId());
} }
{ {
const auto releases {Release::find(session, Release::FindParameters {}.setKeywords({"MyRelease%Foo"}))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setKeywords({"MyRelease%Foo"})) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results[0], release4.getId()); EXPECT_EQ(releases.results[0], release4.getId());
} }
@@ -182,36 +188,36 @@ TEST_F(DatabaseFixture, MulitpleReleaseSearchByName)
TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack) TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
{ {
ScopedRelease release1 {session, "MyRelease"}; ScopedRelease release1{ session, "MyRelease" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_FALSE(release1->getTotalDisc()); EXPECT_FALSE(release1->getTotalDisc());
} }
ScopedTrack track1 {session, "MyTrack"}; ScopedTrack track1{ session, "MyTrack" };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track1.get().modify()->setRelease(release1.get()); track1.get().modify()->setRelease(release1.get());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_FALSE(release1->getTotalDisc()); EXPECT_FALSE(release1->getTotalDisc());
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track1.get().modify()->setTotalTrack(36); track1.get().modify()->setTotalTrack(36);
release1.get().modify()->setTotalDisc(6); release1.get().modify()->setTotalDisc(6);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
ASSERT_TRUE(track1->getTotalTrack()); ASSERT_TRUE(track1->getTotalTrack());
EXPECT_EQ(*track1->getTotalTrack(), 36); EXPECT_EQ(*track1->getTotalTrack(), 36);
@@ -219,9 +225,9 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
EXPECT_EQ(*release1->getTotalDisc(), 6); EXPECT_EQ(*release1->getTotalDisc(), 6);
} }
ScopedTrack track2 {session, "MyTrack2"}; ScopedTrack track2{ session, "MyTrack2" };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track2.get().modify()->setRelease(release1.get()); track2.get().modify()->setRelease(release1.get());
track2.get().modify()->setTotalTrack(37); track2.get().modify()->setTotalTrack(37);
@@ -229,7 +235,7 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
ASSERT_TRUE(track1->getTotalTrack()); ASSERT_TRUE(track1->getTotalTrack());
EXPECT_EQ(*track1->getTotalTrack(), 36); EXPECT_EQ(*track1->getTotalTrack(), 36);
@@ -237,23 +243,23 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
EXPECT_EQ(*release1->getTotalDisc(), 67); EXPECT_EQ(*release1->getTotalDisc(), 67);
} }
ScopedRelease release2 {session, "MyRelease2"}; ScopedRelease release2{ session, "MyRelease2" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_FALSE(release2->getTotalDisc()); EXPECT_FALSE(release2->getTotalDisc());
} }
ScopedTrack track3 {session, "MyTrack3"}; ScopedTrack track3{ session, "MyTrack3" };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track3.get().modify()->setRelease(release2.get()); track3.get().modify()->setRelease(release2.get());
track3.get().modify()->setTotalTrack(7); track3.get().modify()->setTotalTrack(7);
release2.get().modify()->setTotalDisc(5); release2.get().modify()->setTotalDisc(5);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
ASSERT_TRUE(track1->getTotalTrack()); ASSERT_TRUE(track1->getTotalTrack());
EXPECT_EQ(*track1->getTotalTrack(), 36); EXPECT_EQ(*track1->getTotalTrack(), 36);
@@ -268,23 +274,23 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseTotalDiscTrack)
TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack) TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
{ {
ScopedRelease release1 {session, "MyRelease1"}; ScopedRelease release1{ session, "MyRelease1" };
ScopedRelease release2 {session, "MyRelease2"}; ScopedRelease release2{ session, "MyRelease2" };
ScopedTrack track1A {session, "MyTrack1A"}; ScopedTrack track1A{ session, "MyTrack1A" };
ScopedTrack track1B {session, "MyTrack1B"}; ScopedTrack track1B{ session, "MyTrack1B" };
ScopedTrack track2A {session, "MyTrack2A"}; ScopedTrack track2A{ session, "MyTrack2A" };
ScopedTrack track2B {session, "MyTrack2B"}; ScopedTrack track2B{ session, "MyTrack2B" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Track::find(session, Track::FindParameters {}.setRelease(release1.getId())).results.empty()); EXPECT_TRUE(Track::find(session, Track::FindParameters{}.setRelease(release1.getId())).results.empty());
EXPECT_TRUE(Track::find(session, Track::FindParameters {}.setRelease(release2.getId())).results.empty()); EXPECT_TRUE(Track::find(session, Track::FindParameters{}.setRelease(release2.getId())).results.empty());
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track1A.get().modify()->setRelease(release1.get()); track1A.get().modify()->setRelease(release1.get());
track1B.get().modify()->setRelease(release1.get()); track1B.get().modify()->setRelease(release1.get());
@@ -301,16 +307,16 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
{ {
const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release1.getId()).setSortMethod(TrackSortMethod::Release))}; const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release1.getId()).setSortMethod(TrackSortMethod::Release)) };
ASSERT_FALSE(tracks.results.empty()); ASSERT_FALSE(tracks.results.empty());
EXPECT_EQ(tracks.results.front(), track1A.getId()); EXPECT_EQ(tracks.results.front(), track1A.getId());
} }
{ {
const auto tracks {Track::find(session, Track::FindParameters {}.setRelease(release2.getId()).setSortMethod(TrackSortMethod::Release))}; const auto tracks{ Track::find(session, Track::FindParameters {}.setRelease(release2.getId()).setSortMethod(TrackSortMethod::Release)) };
ASSERT_FALSE(tracks.results.empty()); ASSERT_FALSE(tracks.results.empty());
EXPECT_EQ(tracks.results.front(), track2B.getId()); EXPECT_EQ(tracks.results.front(), track2B.getId());
} }
@@ -319,25 +325,25 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseFirstTrack)
TEST_F(DatabaseFixture, MultiTracksSingleReleaseDate) TEST_F(DatabaseFixture, MultiTracksSingleReleaseDate)
{ {
ScopedRelease release1 {session, "MyRelease1"}; ScopedRelease release1{ session, "MyRelease1" };
ScopedRelease release2 {session, "MyRelease2"}; ScopedRelease release2{ session, "MyRelease2" };
const Wt::WDate release1Date {Wt::WDate {1994, 2, 3}}; const Wt::WDate release1Date{ Wt::WDate {1994, 2, 3} };
const Wt::WDate release1OriginalDate {Wt::WDate {1993, 4, 5}}; const Wt::WDate release1OriginalDate{ Wt::WDate {1993, 4, 5} };
ScopedTrack track1A {session, "MyTrack1A"}; ScopedTrack track1A{ session, "MyTrack1A" };
ScopedTrack track1B {session, "MyTrack1B"}; ScopedTrack track1B{ session, "MyTrack1B" };
ScopedTrack track2A {session, "MyTrack2A"}; ScopedTrack track2A{ session, "MyTrack2A" };
ScopedTrack track2B {session, "MyTrack2B"}; ScopedTrack track2B{ session, "MyTrack2B" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(0, 3000)))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(0, 3000))) };
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track1A.get().modify()->setRelease(release1.get()); track1A.get().modify()->setRelease(release1.get());
track1B.get().modify()->setRelease(release1.get()); track1B.get().modify()->setRelease(release1.get());
@@ -355,177 +361,177 @@ TEST_F(DatabaseFixture, MultiTracksSingleReleaseDate)
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
auto releases {Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1950, 2000)))}; auto releases{ Release::findIds(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1950, 2000))) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release1.getId()); EXPECT_EQ(releases.results.front(), release1.getId());
releases = Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1994, 1994))); releases = Release::findIds(session, Release::FindParameters{}.setDateRange(DateRange::fromYearRange(1994, 1994)));
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release1.getId()); EXPECT_EQ(releases.results.front(), release1.getId());
releases = Release::find(session, Release::FindParameters {}.setDateRange(DateRange::fromYearRange(1993, 1993))); releases = Release::findIds(session, Release::FindParameters{}.setDateRange(DateRange::fromYearRange(1993, 1993)));
ASSERT_EQ(releases.results.size(), 0); ASSERT_EQ(releases.results.size(), 0);
} }
} }
TEST_F(DatabaseFixture, Release_writtenAfter) TEST_F(DatabaseFixture, Release_writtenAfter)
{ {
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
ScopedTrack track {session, "MyTrack"}; ScopedTrack track{ session, "MyTrack" };
const Wt::WDateTime dateTime {Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20}}; const Wt::WDateTime dateTime{ Wt::WDate {1950, 1, 1}, Wt::WTime {12, 30, 20} };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setLastWriteTime(dateTime); track.get().modify()->setLastWriteTime(dateTime);
track.get().modify()->setRelease(release.get()); track.get().modify()->setRelease(release.get());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {})}; const auto releases{ Release::findIds(session, Release::FindParameters {}) };
EXPECT_EQ(releases.results.size(), 1); EXPECT_EQ(releases.results.size(), 1);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1)))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(-1))) };
EXPECT_EQ(releases.results.size(), 1); EXPECT_EQ(releases.results.size(), 1);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1)))}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setWrittenAfter(dateTime.addSecs(+1))) };
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
} }
} }
TEST_F(DatabaseFixture, Release_artist) TEST_F(DatabaseFixture, Release_artist)
{ {
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
ScopedTrack track {session, "MyTrack"}; ScopedTrack track{ session, "MyTrack" };
ScopedArtist artist {session, "MyArtist"}; ScopedArtist artist{ session, "MyArtist" };
ScopedArtist artist2 {session, "MyArtist2"}; ScopedArtist artist2{ session, "MyArtist2" };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setRelease(release.get()); track.get().modify()->setRelease(release.get());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist}))}; auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist})) };
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
releases = Release::find(session, Release::FindParameters {}.setArtist(artist2.getId(), {TrackArtistLinkType::Artist})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist2.getId(), { TrackArtistLinkType::Artist }));
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist); TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist);
auto releases {Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist}))}; auto releases{ Release::findIds(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist})) };
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Artist, TrackArtistLinkType::Mixer})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Artist, TrackArtistLinkType::Mixer }));
EXPECT_EQ(releases.results.size(), 1); EXPECT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
releases = Release::find(session, Release::FindParameters {}.setArtist(artist2.getId(), {TrackArtistLinkType::Artist})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist2.getId(), { TrackArtistLinkType::Artist }));
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
releases = Release::find(session, Release::FindParameters {}.setArtist(artist2.getId())); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist2.getId()));
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::ReleaseArtist, TrackArtistLinkType::Artist})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::ReleaseArtist, TrackArtistLinkType::Artist }));
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId())); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId()));
ASSERT_EQ(releases.results.size(), 1); ASSERT_EQ(releases.results.size(), 1);
EXPECT_EQ(releases.results.front(), release.getId()); EXPECT_EQ(releases.results.front(), release.getId());
releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Composer})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer }));
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {TrackArtistLinkType::Composer, TrackArtistLinkType::Mixer})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), { TrackArtistLinkType::Composer, TrackArtistLinkType::Mixer }));
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {}, {TrackArtistLinkType::Artist})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), {}, { TrackArtistLinkType::Artist }));
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
releases = Release::find(session, Release::FindParameters {}.setArtist(artist.getId(), {}, {TrackArtistLinkType::Artist, TrackArtistLinkType::Composer})); releases = Release::findIds(session, Release::FindParameters{}.setArtist(artist.getId(), {}, { TrackArtistLinkType::Artist, TrackArtistLinkType::Composer }));
EXPECT_EQ(releases.results.size(), 0); EXPECT_EQ(releases.results.size(), 0);
} }
} }
TEST_F(DatabaseFixture, Release_getDiscCount) TEST_F(DatabaseFixture, Release_getDiscCount)
{ {
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
ScopedTrack track {session, "MyTrack"}; ScopedTrack track{ session, "MyTrack" };
ScopedTrack track2 {session, "MyTrack2"}; ScopedTrack track2{ session, "MyTrack2" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release.get()->getDiscCount(), 0); EXPECT_EQ(release.get()->getDiscCount(), 0);
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setRelease(release.get()); track.get().modify()->setRelease(release.get());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release.get()->getDiscCount(), 0); EXPECT_EQ(release.get()->getDiscCount(), 0);
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track.get().modify()->setDiscNumber(5); track.get().modify()->setDiscNumber(5);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release.get()->getDiscCount(), 1); EXPECT_EQ(release.get()->getDiscCount(), 1);
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track2.get().modify()->setRelease(release.get()); track2.get().modify()->setRelease(release.get());
track2.get().modify()->setDiscNumber(5); track2.get().modify()->setDiscNumber(5);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release.get()->getDiscCount(), 1); EXPECT_EQ(release.get()->getDiscCount(), 1);
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track2.get().modify()->setDiscNumber(6); track2.get().modify()->setDiscNumber(6);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release.get()->getDiscCount(), 2); EXPECT_EQ(release.get()->getDiscCount(), 2);
} }
} }
TEST_F(DatabaseFixture, Release_releaseType) TEST_F(DatabaseFixture, Release_releaseType)
{ {
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release.get()->getPrimaryType(), std::nullopt); EXPECT_EQ(release.get()->getPrimaryType(), std::nullopt);
EXPECT_EQ(release.get()->getSecondaryTypes(), EnumSet<ReleaseTypeSecondary> {}); EXPECT_EQ(release.get()->getSecondaryTypes(), EnumSet<ReleaseTypeSecondary> {});
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
release.get().modify()->setPrimaryType({ ReleaseTypePrimary::Album }); release.get().modify()->setPrimaryType({ ReleaseTypePrimary::Album });
release.get().modify()->setSecondaryTypes({ ReleaseTypeSecondary::Compilation }); release.get().modify()->setSecondaryTypes({ ReleaseTypeSecondary::Compilation });
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release.get()->getPrimaryType(), ReleaseTypePrimary::Album); EXPECT_EQ(release.get()->getPrimaryType(), ReleaseTypePrimary::Album);
EXPECT_TRUE(release.get()->getSecondaryTypes().contains(ReleaseTypeSecondary::Compilation)); EXPECT_TRUE(release.get()->getSecondaryTypes().contains(ReleaseTypeSecondary::Compilation));
} }
@@ -533,21 +539,21 @@ TEST_F(DatabaseFixture, Release_releaseType)
TEST_F(DatabaseFixture, ReleaseSortOrder) TEST_F(DatabaseFixture, ReleaseSortOrder)
{ {
ScopedRelease release1 {session, "MyRelease1"}; ScopedRelease release1{ session, "MyRelease1" };
const Wt::WDate release1Date {Wt::WDate {2000, 2, 3}}; const Wt::WDate release1Date{ Wt::WDate {2000, 2, 3} };
const Wt::WDate release1OriginalDate {Wt::WDate {1993, 4, 5}}; const Wt::WDate release1OriginalDate{ Wt::WDate {1993, 4, 5} };
ScopedRelease release2 {session, "MyRelease2"}; ScopedRelease release2{ session, "MyRelease2" };
const Wt::WDate release2Date {Wt::WDate {1994, 2, 3}}; const Wt::WDate release2Date{ Wt::WDate {1994, 2, 3} };
ScopedTrack track1 {session, "MyTrack1"}; ScopedTrack track1{ session, "MyTrack1" };
ScopedTrack track2 {session, "MyTrack2"}; ScopedTrack track2{ session, "MyTrack2" };
ASSERT_LT(release2Date, release1Date); ASSERT_LT(release2Date, release1Date);
ASSERT_GT(release2Date, release1OriginalDate); ASSERT_GT(release2Date, release1OriginalDate);
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
track1.get().modify()->setRelease(release1.get()); track1.get().modify()->setRelease(release1.get());
track1.get().modify()->setOriginalDate(release1OriginalDate); track1.get().modify()->setOriginalDate(release1OriginalDate);
@@ -558,42 +564,42 @@ TEST_F(DatabaseFixture, ReleaseSortOrder)
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Name) )}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Name)) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results.front(), release1.getId()); EXPECT_EQ(releases.results.front(), release1.getId());
EXPECT_EQ(releases.results.back(), release2.getId()); EXPECT_EQ(releases.results.back(), release2.getId());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Random) )}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Random)) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Date) )}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::Date)) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results.front(), release2.getId()); EXPECT_EQ(releases.results.front(), release2.getId());
EXPECT_EQ(releases.results.back(), release1.getId()); EXPECT_EQ(releases.results.back(), release1.getId());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDate) )}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDate)) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results.front(), release1.getId()); EXPECT_EQ(releases.results.front(), release1.getId());
EXPECT_EQ(releases.results.back(), release2.getId()); EXPECT_EQ(releases.results.back(), release2.getId());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const auto releases {Release::find(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDateDesc) )}; const auto releases{ Release::findIds(session, Release::FindParameters {}.setSortMethod(ReleaseSortMethod::OriginalDateDesc)) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results.front(), release2.getId()); EXPECT_EQ(releases.results.front(), release2.getId());
EXPECT_EQ(releases.results.back(), release1.getId()); EXPECT_EQ(releases.results.back(), release1.getId());
src/libs/services/database/test/StarredRelease.cpp
+3 -3
View File
@@ -96,7 +96,7 @@ TEST_F(DatabaseFixture, StarredRelease_dateTime)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto releases{ Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) }; auto releases{ Release::findIds(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
EXPECT_EQ(releases.results.size(), 2); EXPECT_EQ(releases.results.size(), 2);
} }
@@ -106,7 +106,7 @@ TEST_F(DatabaseFixture, StarredRelease_dateTime)
starredRelease1.get().modify()->setDateTime(dateTime); starredRelease1.get().modify()->setDateTime(dateTime);
starredRelease2.get().modify()->setDateTime(dateTime.addSecs(-1)); starredRelease2.get().modify()->setDateTime(dateTime.addSecs(-1));
auto releases{ Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) }; auto releases{ Release::findIds(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], starredRelease1->getRelease()->getId()); EXPECT_EQ(releases.results[0], starredRelease1->getRelease()->getId());
EXPECT_EQ(releases.results[1], starredRelease2->getRelease()->getId()); EXPECT_EQ(releases.results[1], starredRelease2->getRelease()->getId());
@@ -117,7 +117,7 @@ TEST_F(DatabaseFixture, StarredRelease_dateTime)
starredRelease1.get().modify()->setDateTime(dateTime); starredRelease1.get().modify()->setDateTime(dateTime);
starredRelease2.get().modify()->setDateTime(dateTime.addSecs(1)); starredRelease2.get().modify()->setDateTime(dateTime.addSecs(1));
auto releases{ Release::find(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) }; auto releases{ Release::findIds(session, Release::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ReleaseSortMethod::StarredDateDesc)) };
ASSERT_EQ(releases.results.size(), 2); ASSERT_EQ(releases.results.size(), 2);
EXPECT_EQ(releases.results[0], starredRelease2->getRelease()->getId()); EXPECT_EQ(releases.results[0], starredRelease2->getRelease()->getId());
EXPECT_EQ(releases.results[1], starredRelease1->getRelease()->getId()); EXPECT_EQ(releases.results[1], starredRelease1->getRelease()->getId());
src/libs/services/feedback/impl/FeedbackService.cpp
+1 -1
View File
@@ -141,7 +141,7 @@ namespace Feedback
Session& session{ _db.getTLSSession() }; Session& session{ _db.getTLSSession() };
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
return Release::find(session, params); return Release::findIds(session, params);
} }
void FeedbackService::star(UserId userId, TrackId trackId) void FeedbackService::star(UserId userId, TrackId trackId)
src/libs/services/scanner/impl/ScanStepRemoveOrphanDbFiles.cpp
+2 -1
View File
@@ -153,10 +153,11 @@ namespace Scanner
LMS_LOG(DBUPDATER, DEBUG) << "Checking orphan releases..."; LMS_LOG(DBUPDATER, DEBUG) << "Checking orphan releases...";
// TODO, by batch
Session& session {_db.getTLSSession()}; Session& session {_db.getTLSSession()};
auto transaction {session.createUniqueTransaction()}; auto transaction {session.createUniqueTransaction()};
auto releases {Release::findOrphans(session, Range {})}; auto releases {Release::findOrphanIds(session, Range {})};
for (const ReleaseId releaseId : releases.results) for (const ReleaseId releaseId : releases.results)
{ {
Release::pointer release {Release::find(session, releaseId)}; Release::pointer release {Release::find(session, releaseId)};
src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp
+6 -6
View File
@@ -66,11 +66,11 @@ namespace API::Subsonic
params.setSortMethod(ReleaseSortMethod::Name); params.setSortMethod(ReleaseSortMethod::Name);
params.setRange(range); params.setRange(range);
releases = Release::find(context.dbSession, params); releases = Release::findIds(context.dbSession, params);
} }
else if (type == "alphabeticalByArtist") else if (type == "alphabeticalByArtist")
{ {
releases = Release::findOrderedByArtist(context.dbSession, range); releases = Release::findIdsOrderedByArtist(context.dbSession, range);
} }
else if (type == "byGenre") else if (type == "byGenre")
{ {
@@ -86,7 +86,7 @@ namespace API::Subsonic
params.setSortMethod(ReleaseSortMethod::Name); params.setSortMethod(ReleaseSortMethod::Name);
params.setRange(range); params.setRange(range);
releases = Release::find(context.dbSession, params); releases = Release::findIds(context.dbSession, params);
} }
} }
} }
@@ -100,7 +100,7 @@ namespace API::Subsonic
params.setRange(range); params.setRange(range);
params.setDateRange(DateRange::fromYearRange(fromYear, toYear)); params.setDateRange(DateRange::fromYearRange(fromYear, toYear));
releases = Release::find(context.dbSession, params); releases = Release::findIds(context.dbSession, params);
} }
else if (type == "frequent") else if (type == "frequent")
{ {
@@ -112,7 +112,7 @@ namespace API::Subsonic
params.setSortMethod(ReleaseSortMethod::LastWritten); params.setSortMethod(ReleaseSortMethod::LastWritten);
params.setRange(range); params.setRange(range);
releases = Release::find(context.dbSession, params); releases = Release::findIds(context.dbSession, params);
} }
else if (type == "random") else if (type == "random")
{ {
@@ -122,7 +122,7 @@ namespace API::Subsonic
params.setSortMethod(ReleaseSortMethod::Random); params.setSortMethod(ReleaseSortMethod::Random);
params.setRange({ 0, size }); params.setRange({ 0, size });
releases = Release::find(context.dbSession, params); releases = Release::findIds(context.dbSession, params);
} }
else if (type == "recent") else if (type == "recent")
{ {
src/libs/subsonic/impl/entrypoints/Browsing.cpp
+2 -8
View File
@@ -335,12 +335,9 @@ namespace API::Subsonic
directoryNode.setAttribute("name", Utils::makeNameFilesystemCompatible(artist->getName())); directoryNode.setAttribute("name", Utils::makeNameFilesystemCompatible(artist->getName()));
const auto artistReleases{ Release::find(context.dbSession, Release::FindParameters {}.setArtist(*artistId)) }; const auto artistReleases{ Release::find(context.dbSession, Release::FindParameters {}.setArtist(*artistId)) };
for (const ReleaseId artistReleaseId : artistReleases.results) for (const Release::pointer& release : artistReleases.results)
{
const Release::pointer release{ Release::find(context.dbSession, artistReleaseId) };
directoryNode.addArrayChild("child", createAlbumNode(context, release, user, false /* no id3 */)); directoryNode.addArrayChild("child", createAlbumNode(context, release, user, false /* no id3 */));
} }
}
else if (releaseId) else if (releaseId)
{ {
directoryNode.setAttribute("id", idToString(*releaseId)); directoryNode.setAttribute("id", idToString(*releaseId));
@@ -408,11 +405,8 @@ namespace API::Subsonic
Response::Node artistNode{ createArtistNode(context, artist, user, true /* id3 */) }; Response::Node artistNode{ createArtistNode(context, artist, user, true /* id3 */) };
const auto releases{ Release::find(context.dbSession, Release::FindParameters {}.setArtist(artist->getId())) }; const auto releases{ Release::find(context.dbSession, Release::FindParameters {}.setArtist(artist->getId())) };
for (const ReleaseId releaseId : releases.results) for (const Release::pointer& release : releases.results)
{
const Release::pointer release{ Release::find(context.dbSession, releaseId) };
artistNode.addArrayChild("album", createAlbumNode(context, release, user, true /* id3 */)); artistNode.addArrayChild("album", createAlbumNode(context, release, user, true /* id3 */));
}
response.addNode("artist", std::move(artistNode)); response.addNode("artist", std::move(artistNode));
src/libs/subsonic/impl/entrypoints/Searching.cpp
+2 -7
View File
@@ -70,7 +70,6 @@ namespace API::Subsonic
{ {
Artist::FindParameters params; Artist::FindParameters params;
params.setKeywords(keywords); params.setKeywords(keywords);
params.setSortMethod(ArtistSortMethod::BySortName);
params.setRange({ artistOffset, artistCount }); params.setRange({ artistOffset, artistCount });
RangeResults<ArtistId> artistIds{ Artist::find(context.dbSession, params) }; RangeResults<ArtistId> artistIds{ Artist::find(context.dbSession, params) };
@@ -85,16 +84,12 @@ namespace API::Subsonic
{ {
Release::FindParameters params; Release::FindParameters params;
params.setKeywords(keywords); params.setKeywords(keywords);
params.setSortMethod(ReleaseSortMethod::Name);
params.setRange({ albumOffset, albumCount }); params.setRange({ albumOffset, albumCount });
RangeResults<ReleaseId> releaseIds{ Release::find(context.dbSession, params) }; RangeResults<Release::pointer> releases{ Release::find(context.dbSession, params) };
for (const ReleaseId releaseId : releaseIds.results) for (const Release::pointer& release : releases.results)
{
const auto release{ Release::find(context.dbSession, releaseId) };
searchResult2Node.addArrayChild("album", createAlbumNode(context, release, user, id3)); searchResult2Node.addArrayChild("album", createAlbumNode(context, release, user, id3));
} }
}
if (songCount > 0) if (songCount > 0)
{ {
src/lms/ui/explore/ArtistView.cpp
+2 -2
View File
@@ -216,7 +216,7 @@ Artist::refreshReleases()
params.setArtist(_artistId, {TrackArtistLinkType::ReleaseArtist}, {}); params.setArtist(_artistId, {TrackArtistLinkType::ReleaseArtist}, {});
params.setSortMethod(ReleaseSortMethod::OriginalDateDesc); params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
const auto releases {Release::find(LmsApp->getDbSession(), params)}; const auto releases {Release::findIds(LmsApp->getDbSession(), params)};
if (!releases.results.empty()) if (!releases.results.empty())
{ {
// first pass: gather all ids and sort by type // first pass: gather all ids and sort by type
@@ -276,7 +276,7 @@ Artist::refreshAppearsOnReleases()
params.setArtist(_artistId, types, {TrackArtistLinkType::ReleaseArtist}); params.setArtist(_artistId, types, {TrackArtistLinkType::ReleaseArtist});
params.setSortMethod(ReleaseSortMethod::OriginalDateDesc); params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
const auto releases {Release::find(LmsApp->getDbSession(), params)}; const auto releases {Release::findIds(LmsApp->getDbSession(), params)};
if (!releases.results.empty()) if (!releases.results.empty())
{ {
Wt::WTemplate* releaseContainer {bindNew<Wt::WTemplate>("appears-on-releases", Wt::WString::tr("Lms.Explore.Artist.template.release-container"))}; Wt::WTemplate* releaseContainer {bindNew<Wt::WTemplate>("appears-on-releases", Wt::WString::tr("Lms.Explore.Artist.template.release-container"))};
src/lms/ui/explore/ReleaseCollector.cpp
+6 -11
View File
@@ -19,12 +19,9 @@
#include "ReleaseCollector.hpp" #include "ReleaseCollector.hpp"
#include <algorithm>
#include "services/database/Release.hpp" #include "services/database/Release.hpp"
#include "services/database/Session.hpp" #include "services/database/Session.hpp"
#include "services/database/User.hpp" #include "services/database/User.hpp"
#include "services/database/TrackList.hpp"
#include "services/feedback/IFeedbackService.hpp" #include "services/feedback/IFeedbackService.hpp"
#include "services/scrobbling/IScrobblingService.hpp" #include "services/scrobbling/IScrobblingService.hpp"
#include "utils/Service.hpp" #include "utils/Service.hpp"
@@ -35,8 +32,7 @@ namespace UserInterface
{ {
using namespace Database; using namespace Database;
RangeResults<ReleaseId> RangeResults<ReleaseId> ReleaseCollector::get(Database::Range range)
ReleaseCollector::get(Database::Range range)
{ {
Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() }; Feedback::IFeedbackService& feedbackService{ *Service<Feedback::IFeedbackService>::get() };
Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() }; Scrobbling::IScrobblingService& scrobblingService{ *Service<Scrobbling::IScrobblingService>::get() };
@@ -73,7 +69,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
releases = Release::find(LmsApp->getDbSession(), params); releases = Release::findIds(LmsApp->getDbSession(), params);
} }
break; break;
} }
@@ -87,7 +83,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
releases = Release::find(LmsApp->getDbSession(), params); releases = Release::findIds(LmsApp->getDbSession(), params);
} }
break; break;
} }
@@ -101,7 +97,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
releases = Release::find(LmsApp->getDbSession(), params); releases = Release::findIds(LmsApp->getDbSession(), params);
} }
break; break;
} }
@@ -113,8 +109,7 @@ namespace UserInterface
return releases; return releases;
} }
RangeResults<ReleaseId> RangeResults<ReleaseId> ReleaseCollector::getRandomReleases(Range range)
ReleaseCollector::getRandomReleases(Range range)
{ {
assert(getMode() == Mode::Random); assert(getMode() == Mode::Random);
@@ -127,7 +122,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
_randomReleases = Release::find(LmsApp->getDbSession(), params); _randomReleases = Release::findIds(LmsApp->getDbSession(), params);
} }
} }
src/tools/recommendation/LmsRecommendation.cpp
+28 -28
View File
@@ -42,11 +42,11 @@ static
void void
dumpTracksRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount) dumpTracksRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
{ {
const RangeResults<TrackId> trackIds {[&]() const RangeResults<TrackId> trackIds{ [&]
{ {
auto transaction {session.createSharedTransaction()}; auto transaction {session.createSharedTransaction()};
return Track::find(session, Track::FindParameters {}); return Track::find(session, Track::FindParameters {});
}()}; }() };
std::cout << "*** Tracks (" << trackIds.results.size() << ") ***" << std::endl; std::cout << "*** Tracks (" << trackIds.results.size() << ") ***" << std::endl;
for (const TrackId trackId : trackIds.results) for (const TrackId trackId : trackIds.results)
@@ -54,22 +54,22 @@ dumpTracksRecommendation(Session session, Recommendation::IRecommendationService
auto trackToString = [&](const TrackId trackId) auto trackToString = [&](const TrackId trackId)
{ {
std::string res; std::string res;
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
const Track::pointer track {Track::find(session, trackId)}; const Track::pointer track{ Track::find(session, trackId) };
res += track->getName(); res += track->getName();
if (track->getRelease()) if (track->getRelease())
res += " [" + track->getRelease()->getName() + "]"; res += " [" + track->getRelease()->getName() + "]";
for (auto artist : track->getArtists({TrackArtistLinkType::Artist})) for (auto artist : track->getArtists({ TrackArtistLinkType::Artist }))
res += " - " + artist->getName(); res += " - " + artist->getName();
for (auto cluster : track->getClusters()) for (auto cluster : track->getClusters())
res += " {" + cluster->getType()->getName() + "-"+ cluster->getName() + "}"; res += " {" + cluster->getType()->getName() + "-" + cluster->getName() + "}";
return res; return res;
}; };
std::cout << "Processing track '" << trackToString(trackId) << std::endl; std::cout << "Processing track '" << trackToString(trackId) << std::endl;
for (TrackId similarTrackId : recommendationService.findSimilarTracks({trackId}, maxSimilarityCount)) for (TrackId similarTrackId : recommendationService.findSimilarTracks({ trackId }, maxSimilarityCount))
std::cout << "\t- Similar track '" << trackToString(similarTrackId) << std::endl; std::cout << "\t- Similar track '" << trackToString(similarTrackId) << std::endl;
} }
} }
@@ -78,25 +78,25 @@ static
void void
dumpReleasesRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount) dumpReleasesRecommendation(Session session, Recommendation::IRecommendationService& recommendationService, unsigned maxSimilarityCount)
{ {
const RangeResults<ReleaseId> releaseIds {std::invoke([&]() const RangeResults<ReleaseId> releaseIds{ std::invoke([&]
{ {
auto transaction {session.createSharedTransaction()}; auto transaction {session.createSharedTransaction()};
return Release::find(session, Release::FindParameters {}); return Release::findIds(session, Release::FindParameters {});
})}; }) };
std::cout << "*** Releases ***" << std::endl; std::cout << "*** Releases ***" << std::endl;
for (ReleaseId releaseId : releaseIds.results) for (const ReleaseId releaseId : releaseIds.results)
{ {
auto releaseToString = [&](ReleaseId releaseId) -> std::string auto releaseToString = [&](ReleaseId releaseId) -> std::string
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
Release::pointer release {Release::find(session, releaseId)}; Release::pointer release{ Release::find(session, releaseId) };
return release->getName(); return release->getName();
}; };
std::cout << "Processing release '" << releaseToString(releaseId) << "'" << std::endl; std::cout << "Processing release '" << releaseToString(releaseId) << "'" << std::endl;
for (ReleaseId similarReleaseId : recommendationService.getSimilarReleases(releaseId, maxSimilarityCount)) for (const ReleaseId similarReleaseId : recommendationService.getSimilarReleases(releaseId, maxSimilarityCount))
std::cout << "\t- Similar release '" << releaseToString(similarReleaseId) << "'" << std::endl; std::cout << "\t- Similar release '" << releaseToString(similarReleaseId) << "'" << std::endl;
} }
} }
@@ -107,8 +107,8 @@ dumpArtistsRecommendation(Session session, Recommendation::IRecommendationServic
{ {
const RangeResults<ArtistId> artistIds = std::invoke([&]() const RangeResults<ArtistId> artistIds = std::invoke([&]()
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
return Artist::find(session, Artist::FindParameters {}); return Artist::find(session, Artist::FindParameters{});
}); });
std::cout << "*** Artists ***" << std::endl; std::cout << "*** Artists ***" << std::endl;
@@ -116,14 +116,14 @@ dumpArtistsRecommendation(Session session, Recommendation::IRecommendationServic
{ {
auto artistToString = [&](ArtistId artistId) auto artistToString = [&](ArtistId artistId)
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
Artist::pointer artist {Artist::find(session, artistId)}; Artist::pointer artist{ Artist::find(session, artistId) };
return artist->getName(); return artist->getName();
}; };
std::cout << "Processing artist '" << artistToString(artistId) << "'" << std::endl; std::cout << "Processing artist '" << artistToString(artistId) << "'" << std::endl;
for (ArtistId similarArtistId : recommendationService.getSimilarArtists(artistId, {TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}, maxSimilarityCount)) for (ArtistId similarArtistId : recommendationService.getSimilarArtists(artistId, { TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist }, maxSimilarityCount))
{ {
std::cout << "\t- Similar artist '" << artistToString(similarArtistId) << "'" << std::endl; std::cout << "\t- Similar artist '" << artistToString(similarArtistId) << "'" << std::endl;
} }
@@ -131,16 +131,16 @@ dumpArtistsRecommendation(Session session, Recommendation::IRecommendationServic
} }
int main(int argc, char *argv[]) int main(int argc, char* argv[])
{ {
try try
{ {
namespace po = boost::program_options; namespace po = boost::program_options;
// log to stdout // log to stdout
Service<Logger> logger {std::make_unique<StreamLogger>(std::cout)}; Service<Logger> logger{ std::make_unique<StreamLogger>(std::cout) };
po::options_description desc{"Allowed options"}; po::options_description desc{ "Allowed options" };
desc.add_options() desc.add_options()
("help,h", "print usage message") ("help,h", "print usage message")
("conf,c", po::value<std::string>()->default_value("/etc/lms.conf"), "LMS config file") ("conf,c", po::value<std::string>()->default_value("/etc/lms.conf"), "LMS config file")
@@ -159,19 +159,19 @@ int main(int argc, char *argv[])
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
Service<IConfig> config {createConfig(vm["conf"].as<std::string>())}; Service<IConfig> config{ createConfig(vm["conf"].as<std::string>()) };
Db db {config->getPath("working-dir") / "lms.db"}; Db db{ config->getPath("working-dir") / "lms.db" };
Session session {db}; Session session{ db };
std::cout << "Creating recommendation recommendationService..." << std::endl; std::cout << "Creating recommendation recommendationService..." << std::endl;
const auto recommendationService {Recommendation::createRecommendationService(db)}; const auto recommendationService{ Recommendation::createRecommendationService(db) };
std::cout << "Recommendation recommendationService created!" << std::endl; std::cout << "Recommendation recommendationService created!" << std::endl;
std::cout << "Loading recommendation recommendationService..." << std::endl; std::cout << "Loading recommendation recommendationService..." << std::endl;
recommendationService->load(false); recommendationService->load(false);
unsigned maxSimilarityCount {vm["max"].as<unsigned>()}; unsigned maxSimilarityCount{ vm["max"].as<unsigned>() };
std::cout << "Recommendation recommendationService loaded!" << std::endl; std::cout << "Recommendation recommendationService loaded!" << std::endl;
@@ -184,7 +184,7 @@ int main(int argc, char *argv[])
if (vm.count("artists")) if (vm.count("artists"))
dumpArtistsRecommendation(db, *recommendationService, maxSimilarityCount); dumpArtistsRecommendation(db, *recommendationService, maxSimilarityCount);
} }
catch( std::exception& e) catch (std::exception& e)
{ {
std::cerr << "Caught exception: " << e.what() << std::endl; std::cerr << "Caught exception: " << e.what() << std::endl;
return EXIT_FAILURE; return EXIT_FAILURE;