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

SubsonicAPI: optimized search for artists

Browse Source
This commit is contained in:
emeric
2023-11-04 19:07:21 +01:00
parent bd59dc3bc9
commit 48ee8e3556
17 changed files with 745 additions and 737 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/database/impl/Artist.cpp
+243 -229
View File
@@ -33,284 +33,298 @@
namespace Database namespace Database
{ {
namespace
{
template <typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Artist::FindParameters& params)
{
session.checkSharedLocked();
Artist::Artist(const std::string& name, const std::optional<UUID>& MBID) auto query{ session.getDboSession().query<ResultType>("SELECT DISTINCT " + std::string{ itemToSelect } + " FROM artist a") };
: _name {std::string(name, 0 , _maxNameLength)}, if (params.sortMethod == ArtistSortMethod::LastWritten
_sortName {_name}, || params.writtenAfter.isValid()
_MBID {MBID ? MBID->getAsString() : ""} || params.linkType
{ || params.track.isValid()
} || params.release.isValid()
|| params.clusters.size() == 1)
{
query.join("track t ON t.id = t_a_l.track_id");
query.join("track_artist_link t_a_l ON t_a_l.artist_id = a.id");
}
Artist::pointer if (params.linkType)
Artist::create(Session& session, const std::string& name, const std::optional<UUID>& MBID) query.where("t_a_l.type = ?").bind(*params.linkType);
{
return session.getDboSession().add(std::unique_ptr<Artist> {new Artist {name, MBID}});
}
std::size_t if (params.writtenAfter.isValid())
Artist::getCount(Session& session) query.where("t.file_last_write > ?").bind(params.writtenAfter);
{
session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT COUNT(*) FROM artist"); if (!params.keywords.empty())
} {
std::vector<std::string> clauses;
std::vector<std::string> sortClauses;
std::vector<Artist::pointer> for (std::string_view keyword : params.keywords)
Artist::find(Session& session, const std::string& name) {
{ clauses.push_back("a.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
session.checkSharedLocked(); query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
}
Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>() for (std::string_view keyword : params.keywords)
.where("name = ?").bind(std::string {name, 0, _maxNameLength}) {
.orderBy("LENGTH(mbid) DESC"); // put mbid entries first sortClauses.push_back("a.sort_name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
}
return std::vector<Artist::pointer>(res.begin(), res.end()); query.where("(" + StringUtils::joinStrings(clauses, " AND ") + ") OR (" + StringUtils::joinStrings(sortClauses, " AND ") + ")");
} }
Artist::pointer if (params.starringUser.isValid())
Artist::find(Session& session, const UUID& mbid) {
{ assert(params.feedbackBackend);
session.checkSharedLocked(); query.join("starred_artist s_a ON s_a.artist_id = a.id")
return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string {mbid.getAsString()}).resultValue(); .where("s_a.user_id = ?").bind(params.starringUser)
} .where("s_a.backend = ?").bind(*params.feedbackBackend)
.where("s_a.sync_state <> ?").bind(SyncState::PendingRemove);
}
Artist::pointer if (params.clusters.size() == 1)
Artist::find(Session& session, ArtistId id) {
{ query.join("track_cluster t_c ON t_c.track_id = t.id")
session.checkSharedLocked(); .where("t_c.cluster_id = ?").bind(params.clusters.front());
return session.getDboSession().find<Artist>().where("id = ?").bind(id).resultValue(); }
} else if (params.clusters.size() > 1)
{
std::ostringstream oss;
oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
" INNER JOIN track t ON t.id = t_a_l.track_id"
" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
" INNER JOIN cluster c ON c.id = t_c.cluster_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
bool WhereClause clusterClause;
Artist::exists(Session& session, ArtistId id) for (const ClusterId clusterId : params.clusters)
{ {
session.checkSharedLocked(); clusterClause.Or(WhereClause("c.id = ?"));
return session.getDboSession().query<int>("SELECT 1 FROM artist").where("id = ?").bind(id).resultValue() == 1; query.bind(clusterId);
} }
static oss << " " << clusterClause.get();
Wt::Dbo::Query<ArtistId> oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << params.clusters.size() << ")";
createQuery(Session& session, const Artist::FindParameters& params)
{
session.checkSharedLocked();
auto query {session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a")}; query.where(oss.str());
if (params.sortMethod == ArtistSortMethod::LastWritten }
|| params.writtenAfter.isValid()
|| params.linkType
|| params.track.isValid()
|| params.release.isValid()
|| params.clusters.size() == 1)
{
query.join("track t ON t.id = t_a_l.track_id");
query.join("track_artist_link t_a_l ON t_a_l.artist_id = a.id");
}
if (params.linkType) if (params.track.isValid())
query.where("t_a_l.type = ?").bind(*params.linkType); query.where("t.id = ?").bind(params.track);
if (params.writtenAfter.isValid()) if (params.release.isValid())
query.where("t.file_last_write > ?").bind(params.writtenAfter); query.where("t.release_id = ?").bind(params.release);
if (!params.keywords.empty()) switch (params.sortMethod)
{ {
std::vector<std::string> clauses; case ArtistSortMethod::None:
std::vector<std::string> sortClauses; break;
case ArtistSortMethod::ByName:
query.orderBy("a.name COLLATE NOCASE");
break;
case ArtistSortMethod::BySortName:
query.orderBy("a.sort_name COLLATE NOCASE");
break;
case ArtistSortMethod::Random:
query.orderBy("RANDOM()");
break;
case ArtistSortMethod::LastWritten:
query.orderBy("t.file_last_write DESC");
break;
case ArtistSortMethod::StarredDateDesc:
assert(params.starringUser.isValid());
query.orderBy("s_a.date_time DESC");
break;
}
for (std::string_view keyword : params.keywords) return query;
{ }
clauses.push_back("a.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'");
query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
}
for (std::string_view keyword : params.keywords) template <typename ResultType>
{ Wt::Dbo::Query<ResultType> createQuery(Session& session, const Artist::FindParameters& params)
sortClauses.push_back("a.sort_name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'"); {
query.bind("%" + Utils::escapeLikeKeyword(keyword) + "%"); std::string_view itemToSelect;
}
if constexpr (std::is_same_v<ResultType, ArtistId>)
itemToSelect = "a.id";
else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Artist>>)
itemToSelect = "a";
else
static_assert("Unhandled type");
query.where("(" + StringUtils::joinStrings(clauses, " AND ") + ") OR (" + StringUtils::joinStrings(sortClauses, " AND ") + ")"); return createQuery<ResultType>(session, itemToSelect, params);
} }
}
if (params.starringUser.isValid()) Artist::Artist(const std::string& name, const std::optional<UUID>& MBID)
{ : _name{ std::string(name, 0 , _maxNameLength) },
assert(params.feedbackBackend); _sortName{ _name },
query.join("starred_artist s_a ON s_a.artist_id = a.id") _MBID{ MBID ? MBID->getAsString() : "" }
.where("s_a.user_id = ?").bind(params.starringUser) {
.where("s_a.backend = ?").bind(*params.feedbackBackend) }
.where("s_a.sync_state <> ?").bind(SyncState::PendingRemove);
}
if(params.clusters.size() == 1) Artist::pointer Artist::create(Session& session, const std::string& name, const std::optional<UUID>& MBID)
{ {
query.join("track_cluster t_c ON t_c.track_id = t.id") return session.getDboSession().add(std::unique_ptr<Artist> {new Artist{ name, MBID }});
.where("t_c.cluster_id = ?").bind(params.clusters.front()); }
}
else if (params.clusters.size() > 1)
{
std::ostringstream oss;
oss << "a.id IN (SELECT DISTINCT a.id FROM artist a"
" INNER JOIN track t ON t.id = t_a_l.track_id"
" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
" INNER JOIN cluster c ON c.id = t_c.cluster_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
WhereClause clusterClause; std::size_t Artist::getCount(Session& session)
for (const ClusterId clusterId : params.clusters) {
{ session.checkSharedLocked();
clusterClause.Or(WhereClause("c.id = ?"));
query.bind(clusterId);
}
oss << " " << clusterClause.get(); return session.getDboSession().query<int>("SELECT COUNT(*) FROM artist");
oss << " GROUP BY t.id,a.id HAVING COUNT(DISTINCT c.id) = " << params.clusters.size() << ")"; }
query.where(oss.str()); std::vector<Artist::pointer> Artist::find(Session& session, const std::string& name)
} {
session.checkSharedLocked();
if (params.track.isValid()) Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>()
query.where("t.id = ?").bind(params.track); .where("name = ?").bind(std::string{ name, 0, _maxNameLength })
.orderBy("LENGTH(mbid) DESC"); // put mbid entries first
if (params.release.isValid()) return std::vector<Artist::pointer>(res.begin(), res.end());
query.where("t.release_id = ?").bind(params.release); }
switch (params.sortMethod) Artist::pointer Artist::find(Session& session, const UUID& mbid)
{ {
case ArtistSortMethod::None: session.checkSharedLocked();
break; return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string{ mbid.getAsString() }).resultValue();
case ArtistSortMethod::ByName: }
query.orderBy("a.name COLLATE NOCASE");
break;
case ArtistSortMethod::BySortName:
query.orderBy("a.sort_name COLLATE NOCASE");
break;
case ArtistSortMethod::Random:
query.orderBy("RANDOM()");
break;
case ArtistSortMethod::LastWritten:
query.orderBy("t.file_last_write DESC");
break;
case ArtistSortMethod::StarredDateDesc:
assert(params.starringUser.isValid());
query.orderBy("s_a.date_time DESC");
break;
}
return query; Artist::pointer Artist::find(Session& session, ArtistId id)
} {
session.checkSharedLocked();
return session.getDboSession().find<Artist>().where("id = ?").bind(id).resultValue();
}
RangeResults<ArtistId> bool Artist::exists(Session& session, ArtistId id)
Artist::findAllOrphans(Session& session, Range range) {
{ session.checkSharedLocked();
session.checkSharedLocked(); return session.getDboSession().query<int>("SELECT 1 FROM artist").where("id = ?").bind(id).resultValue() == 1;
auto query {session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a WHERE NOT EXISTS(SELECT 1 FROM track t INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id WHERE t.id = t_a_l.track_id)")}; }
return Utils::execQuery(query, range);
}
RangeResults<ArtistId> RangeResults<ArtistId> Artist::findOrphanIds(Session& session, Range range)
Artist::find(Session& session, const FindParameters& params) {
{ session.checkSharedLocked();
session.checkSharedLocked(); auto query{ session.getDboSession().query<ArtistId>("SELECT DISTINCT a.id FROM artist a WHERE NOT EXISTS(SELECT 1 FROM track t INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id WHERE t.id = t_a_l.track_id)") };
auto query {createQuery(session, params)}; return Utils::execQuery(query, range);
return Utils::execQuery(query, params.range); }
}
RangeResults<ArtistId> RangeResults<ArtistId> Artist::findIds(Session& session, const FindParameters& params)
Artist::findSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, Range range) const {
{ session.checkSharedLocked();
assert(session());
std::ostringstream oss; auto query{ createQuery<ArtistId>(session, params) };
oss << return Utils::execQuery(query, params.range);
"SELECT a.id FROM artist a" }
" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
" INNER JOIN track t ON t.id = t_a_l.track_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
" WHERE "
" t_c.cluster_id IN (SELECT DISTINCT c.id from cluster c"
" INNER JOIN track t ON c.id = t_c.cluster_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
" INNER JOIN artist a ON a.id = t_a_l.artist_id"
" INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
" WHERE a.id = ?)"
" AND a.id <> ?";
if (!artistLinkTypes.empty()) RangeResults<Artist::pointer> Artist::find(Session& session, const FindParameters& params)
{ {
oss << " AND t_a_l.type IN ("; session.checkSharedLocked();
bool first {true}; auto query{ createQuery<Wt::Dbo::ptr<Artist>>(session, params) };
for (TrackArtistLinkType type : artistLinkTypes) return Utils::execQuery(query, params.range);
{ }
(void) type;
if (!first)
oss << ", ";
oss << "?";
first = false;
}
oss << ")";
}
auto query {session()->query<ArtistId>(oss.str()) RangeResults<ArtistId> Artist::findSimilarArtistIds(EnumSet<TrackArtistLinkType> artistLinkTypes, Range range) const
.bind(getId()) {
.bind(getId()) assert(session());
.groupBy("a.id")
.orderBy("COUNT(*) DESC, RANDOM()")};
for (TrackArtistLinkType type : artistLinkTypes) std::ostringstream oss;
query.bind(type); oss <<
"SELECT a.id FROM artist a"
" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
" INNER JOIN track t ON t.id = t_a_l.track_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
" WHERE "
" t_c.cluster_id IN (SELECT DISTINCT c.id from cluster c"
" INNER JOIN track t ON c.id = t_c.cluster_id"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
" INNER JOIN artist a ON a.id = t_a_l.artist_id"
" INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
" WHERE a.id = ?)"
" AND a.id <> ?";
return Utils::execQuery(query, range); if (!artistLinkTypes.empty())
} {
oss << " AND t_a_l.type IN (";
std::vector<std::vector<Cluster::pointer>> bool first{ true };
Artist::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const for (TrackArtistLinkType type : artistLinkTypes)
{ {
assert(session()); (void)type;
if (!first)
oss << ", ";
oss << "?";
first = false;
}
oss << ")";
}
WhereClause where; auto query{ session()->query<ArtistId>(oss.str())
.bind(getId())
.bind(getId())
.groupBy("a.id")
.orderBy("COUNT(*) DESC, RANDOM()") };
std::ostringstream oss; for (TrackArtistLinkType type : artistLinkTypes)
oss << "SELECT c FROM cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id INNER JOIN artist a ON t_a_l.artist_id = a.id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"; query.bind(type);
where.And(WhereClause("a.id = ?")).bind(getId().toString()); return Utils::execQuery(query, range);
{ }
WhereClause clusterClause;
for (auto clusterType : clusterTypes)
clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
where.And(clusterClause); std::vector<std::vector<Cluster::pointer>> Artist::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const
} {
oss << " " << where.get(); assert(session());
oss << "GROUP BY c.id ORDER BY COUNT(DISTINCT c.id) DESC";
Wt::Dbo::Query<Wt::Dbo::ptr<Cluster>> query = session()->query<Wt::Dbo::ptr<Cluster>>( oss.str() ); WhereClause where;
for (const std::string& bindArg : where.getBindArgs()) std::ostringstream oss;
query.bind(bindArg); oss << "SELECT c FROM cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id INNER JOIN artist a ON t_a_l.artist_id = a.id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id";
Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> queryRes = query; where.And(WhereClause("a.id = ?")).bind(getId().toString());
{
WhereClause clusterClause;
for (auto clusterType : clusterTypes)
clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType; where.And(clusterClause);
for (Cluster::pointer cluster : queryRes) }
{ oss << " " << where.get();
if (clustersByType[cluster->getType()->getId()].size() < size) oss << "GROUP BY c.id ORDER BY COUNT(DISTINCT c.id) DESC";
clustersByType[cluster->getType()->getId()].push_back(cluster);
}
std::vector<std::vector<Cluster::pointer>> res; Wt::Dbo::Query<Wt::Dbo::ptr<Cluster>> query = session()->query<Wt::Dbo::ptr<Cluster>>(oss.str());
for (const auto& [clusterTypeId, clusters] : clustersByType)
res.push_back(clusters);
return res; for (const std::string& bindArg : where.getBindArgs())
} query.bind(bindArg);
void Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> queryRes = query;
Artist::setSortName(const std::string& sortName)
{ std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
_sortName = std::string(sortName, 0 , _maxNameLength); for (Cluster::pointer cluster : queryRes)
} {
if (clustersByType[cluster->getType()->getId()].size() < size)
clustersByType[cluster->getType()->getId()].push_back(cluster);
}
std::vector<std::vector<Cluster::pointer>> res;
for (const auto& [clusterTypeId, clusters] : clustersByType)
res.push_back(clusters);
return res;
}
void Artist::setSortName(const std::string& sortName)
{
_sortName = std::string(sortName, 0, _maxNameLength);
}
} // namespace Database } // namespace Database
src/libs/services/database/include/services/database/Artist.hpp
+77 -76
View File
@@ -40,96 +40,97 @@
namespace Database namespace Database
{ {
class Cluster; class Cluster;
class ClusterType; class ClusterType;
class Release; class Release;
class Session; class Session;
class StarredArtist; class StarredArtist;
class Track; class Track;
class TrackArtistLink; class TrackArtistLink;
class User; class User;
class Artist final : public Object<Artist, ArtistId> class Artist final : public Object<Artist, ArtistId>
{ {
public: public:
struct FindParameters struct FindParameters
{ {
std::vector<ClusterId> clusters; // if non empty, at least one artist that belongs to these clusters std::vector<ClusterId> clusters; // if non empty, at least one artist that belongs to these clusters
std::vector<std::string_view> keywords; // if non empty, name must match all of these keywords (on either name field OR sort name field) std::vector<std::string_view> keywords; // if non empty, name must match all of these keywords (on either name field OR sort name field)
std::optional<TrackArtistLinkType> linkType; // if set, only artists that have produced at least one track with this link type std::optional<TrackArtistLinkType> linkType; // if set, only artists that have produced at least one track with this link type
ArtistSortMethod sortMethod {ArtistSortMethod::None}; ArtistSortMethod sortMethod{ ArtistSortMethod::None };
Range range; Range range;
Wt::WDateTime writtenAfter; Wt::WDateTime writtenAfter;
UserId starringUser; // only artists starred by this user UserId starringUser; // only artists starred by this user
std::optional<FeedbackBackend> feedbackBackend; // and for this feedback backend std::optional<FeedbackBackend> feedbackBackend; // and for this feedback backend
TrackId track; // artists involved in this track TrackId track; // artists involved in this track
ReleaseId release; // artists involved in this release ReleaseId release; // artists involved in this release
FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; } FindParameters& setClusters(const std::vector<ClusterId>& _clusters) { clusters = _clusters; return *this; }
FindParameters& setKeywords(const std::vector<std::string_view>& _keywords) { keywords = _keywords; 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& setLinkType(std::optional<TrackArtistLinkType> _linkType) { linkType = _linkType; return *this; }
FindParameters& setSortMethod(ArtistSortMethod _sortMethod) {sortMethod = _sortMethod; return *this; } FindParameters& setSortMethod(ArtistSortMethod _sortMethod) { sortMethod = _sortMethod; return *this; }
FindParameters& setRange(Range _range) {range = _range; return *this; } FindParameters& setRange(Range _range) { range = _range; return *this; }
FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; } FindParameters& setWrittenAfter(const Wt::WDateTime& _after) { writtenAfter = _after; return *this; }
FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend) { starringUser = _user; feedbackBackend = _feedbackBackend; return *this; } FindParameters& setStarringUser(UserId _user, FeedbackBackend _feedbackBackend) { starringUser = _user; feedbackBackend = _feedbackBackend; return *this; }
FindParameters& setTrack(TrackId _track) { track = _track; return *this; } FindParameters& setTrack(TrackId _track) { track = _track; return *this; }
FindParameters& setRelease(ReleaseId _release) { release = _release; return *this; } FindParameters& setRelease(ReleaseId _release) { release = _release; return *this; }
}; };
Artist() = default; Artist() = default;
// Accessors // Accessors
static std::size_t getCount(Session& session); static std::size_t getCount(Session& session);
static pointer find(Session& session, const UUID& MBID); static pointer find(Session& session, const UUID& MBID);
static pointer find(Session& session, ArtistId id); static pointer find(Session& session, ArtistId id);
static std::vector<pointer> find(Session& session, const std::string& name); // exact match on name field static std::vector<pointer> find(Session& session, const std::string& name); // exact match on name field
static RangeResults<ArtistId> find(Session& session, const FindParameters& parameters); static RangeResults<pointer> find(Session& session, const FindParameters& parameters);
static RangeResults<ArtistId> findAllOrphans(Session& session, Range range); // No track related static RangeResults<ArtistId> findIds(Session& session, const FindParameters& parameters);
static bool exists(Session& session, ArtistId id); static RangeResults<ArtistId> findOrphanIds(Session& session, Range range); // No track related
static bool exists(Session& session, ArtistId id);
// Accessors // Accessors
const std::string& getName() const { return _name; } const std::string& getName() const { return _name; }
const std::string& getSortName() const { return _sortName; } const std::string& getSortName() const { return _sortName; }
std::optional<UUID> getMBID() const { return UUID::fromString(_MBID); } std::optional<UUID> getMBID() const { return UUID::fromString(_MBID); }
// No artistLinkTypes means get them all // No artistLinkTypes means get them all
RangeResults<ArtistId> findSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, Range range = {}) const; RangeResults<ArtistId> findSimilarArtistIds(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, Range range = {}) const;
// Get the cluster of the tracks made by this artist // Get the cluster of the tracks made by this artist
// Each clusters are grouped by cluster type, sorted by the number of occurence // Each clusters are grouped by cluster type, sorted by the number of occurence
// size is the max number of cluster per cluster type // size is the max number of cluster per cluster type
std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(std::vector<ObjectPtr<ClusterType>> clusterTypes, std::size_t size) const; std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(std::vector<ObjectPtr<ClusterType>> clusterTypes, std::size_t size) const;
void setName(std::string_view name) { _name = name; } void setName(std::string_view name) { _name = name; }
void setMBID(const std::optional<UUID>& mbid) { _MBID = mbid ? mbid->getAsString() : ""; } void setMBID(const std::optional<UUID>& mbid) { _MBID = mbid ? mbid->getAsString() : ""; }
void setSortName(const std::string& sortName); void setSortName(const std::string& sortName);
template<class Action> template<class Action>
void persist(Action& a) void persist(Action& a)
{ {
Wt::Dbo::field(a, _name, "name"); Wt::Dbo::field(a, _name, "name");
Wt::Dbo::field(a, _sortName, "sort_name"); Wt::Dbo::field(a, _sortName, "sort_name");
Wt::Dbo::field(a, _MBID, "mbid"); Wt::Dbo::field(a, _MBID, "mbid");
Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "artist"); Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "artist");
Wt::Dbo::hasMany(a, _starredArtists, Wt::Dbo::ManyToMany, "user_starred_artists", "", Wt::Dbo::OnDeleteCascade); Wt::Dbo::hasMany(a, _starredArtists, Wt::Dbo::ManyToMany, "user_starred_artists", "", Wt::Dbo::OnDeleteCascade);
} }
private: private:
static constexpr std::size_t _maxNameLength {128}; static constexpr std::size_t _maxNameLength{ 128 };
friend class Session; friend class Session;
// Create // Create
Artist(const std::string& name, const std::optional<UUID>& MBID = {}); Artist(const std::string& name, const std::optional<UUID>& MBID = {});
static pointer create(Session& session, const std::string& name, const std::optional<UUID>& UUID = {}); static pointer create(Session& session, const std::string& name, const std::optional<UUID>& UUID = {});
std::string _name; std::string _name;
std::string _sortName; std::string _sortName;
std::string _MBID; // Musicbrainz Identifier std::string _MBID; // Musicbrainz Identifier
Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks; // Tracks involving this artist Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks; // Tracks involving this artist
Wt::Dbo::collection<Wt::Dbo::ptr<StarredArtist>> _starredArtists; // starred entries for this artist Wt::Dbo::collection<Wt::Dbo::ptr<StarredArtist>> _starredArtists; // starred entries for this artist
}; };
} // namespace Database } // namespace Database
src/libs/services/database/test/Artist.cpp
+46 -37
View File
@@ -47,14 +47,23 @@ TEST_F(DatabaseFixture, Artist)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}) };
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());
artists = Artist::findAllOrphans(session, Range{}); artists = Artist::findOrphanIds(session, Range{});
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 transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}) };
ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front()->getId(), artist.getId());
}
} }
TEST_F(DatabaseFixture, Artist_singleTrack) TEST_F(DatabaseFixture, Artist_singleTrack)
@@ -71,7 +80,7 @@ TEST_F(DatabaseFixture, Artist_singleTrack)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
} }
{ {
@@ -121,7 +130,7 @@ TEST_F(DatabaseFixture, Artist_singleTrack)
} }
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters{}.setTrack(track->getId())) }; auto artists{ Artist::findIds(session, Artist::FindParameters{}.setTrack(track->getId())) };
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());
} }
@@ -141,16 +150,16 @@ TEST_F(DatabaseFixture, Artist_singleTracktMultiRoles)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
} }
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}).results.size(), 1); EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Artist)).results.size(), 1); EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Artist)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::ReleaseArtist)).results.size(), 1); EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::ReleaseArtist)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Writer)).results.size(), 1); EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Writer)).results.size(), 1);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Composer)).results.size(), 0); EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setLinkType(TrackArtistLinkType::Composer)).results.size(), 0);
} }
{ {
@@ -206,7 +215,7 @@ TEST_F(DatabaseFixture, Artist_singleTrackMultiArtists)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
} }
{ {
@@ -220,8 +229,8 @@ TEST_F(DatabaseFixture, Artist_singleTrackMultiArtists)
EXPECT_EQ(track->getArtists({}).size(), 2); EXPECT_EQ(track->getArtists({}).size(), 2);
EXPECT_EQ(track->getArtists({ TrackArtistLinkType::Artist }).size(), 2); EXPECT_EQ(track->getArtists({ TrackArtistLinkType::Artist }).size(), 2);
EXPECT_TRUE(track->getArtists({ TrackArtistLinkType::ReleaseArtist }).empty()); EXPECT_TRUE(track->getArtists({ TrackArtistLinkType::ReleaseArtist }).empty());
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}).results.size(), 2); EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}).results.size(), 2);
EXPECT_EQ(Artist::find(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2); EXPECT_EQ(Artist::findIds(session, Artist::FindParameters{}.setSortMethod(ArtistSortMethod::Random)).results.size(), 2);
} }
{ {
@@ -263,13 +272,13 @@ TEST_F(DatabaseFixture, Artist_findByName)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setKeywords({ "N" })).results.empty()); EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setKeywords({ "N" })).results.empty());
const auto artistsByAAA{ Artist::find(session, Artist::FindParameters {}.setKeywords({"A"})) }; const auto artistsByAAA{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"A"})) };
ASSERT_EQ(artistsByAAA.results.size(), 1); ASSERT_EQ(artistsByAAA.results.size(), 1);
EXPECT_EQ(artistsByAAA.results.front(), artist.getId()); EXPECT_EQ(artistsByAAA.results.front(), artist.getId());
const auto artistsByZZZ{ Artist::Artist::find(session, Artist::FindParameters {}.setKeywords({"Z"})) }; const auto artistsByZZZ{ Artist::Artist::findIds(session, Artist::FindParameters {}.setKeywords({"Z"})) };
ASSERT_EQ(artistsByZZZ.results.size(), 1); ASSERT_EQ(artistsByZZZ.results.size(), 1);
EXPECT_EQ(artistsByZZZ.results.front(), artist.getId()); EXPECT_EQ(artistsByZZZ.results.front(), artist.getId());
@@ -280,59 +289,59 @@ TEST_F(DatabaseFixture, Artist_findByName)
TEST_F(DatabaseFixture, Artist_findByNameEscaped) TEST_F(DatabaseFixture, Artist_findByNameEscaped)
{ {
ScopedArtist artist1{ session, "MyArtist%" }; ScopedArtist artist1{ session, R"(MyArtist%)" };
ScopedArtist artist2{ session, "%MyArtist" }; ScopedArtist artist2{ session, R"(%MyArtist)" };
ScopedArtist artist3{ session, "%_MyArtist" }; ScopedArtist artist3{ session, R"(%_MyArtist)" };
ScopedArtist artist4{ session, "MyArtist%foo" }; ScopedArtist artist4{ session, R"(MyArtist%foo)" };
ScopedArtist artist5{ session, "foo%MyArtist" }; ScopedArtist artist5{ session, R"(foo%MyArtist)" };
ScopedArtist artist6{ session, "%AMyArtist" }; ScopedArtist artist6{ session, R"(%AMyArtist)" };
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
{ {
const auto artists{ Artist::find(session, "MyArtist%") }; const auto artists{ Artist::find(session, R"(MyArtist%)") };
ASSERT_TRUE(artists.size() == 1); ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist1.getId()); EXPECT_EQ(artists.front()->getId(), artist1.getId());
EXPECT_TRUE(Artist::find(session, "MyArtistFoo").empty()); EXPECT_TRUE(Artist::find(session, R"(MyArtistFoo)").empty());
} }
{ {
const auto artists{ Artist::find(session, "%MyArtist") }; const auto artists{ Artist::find(session, R"(%MyArtist)") };
ASSERT_TRUE(artists.size() == 1); ASSERT_TRUE(artists.size() == 1);
EXPECT_EQ(artists.front()->getId(), artist2.getId()); EXPECT_EQ(artists.front()->getId(), artist2.getId());
EXPECT_TRUE(Artist::find(session, "FooMyArtist").empty()); EXPECT_TRUE(Artist::find(session, R"(FooMyArtist)").empty());
} }
{ {
const auto artists{ Artist::find(session, "%_MyArtist") }; const auto artists{ Artist::find(session, R"(%_MyArtist)") };
ASSERT_TRUE(artists.size() == 1); ASSERT_TRUE(artists.size() == 1);
ASSERT_EQ(artists.front()->getId(), artist3.getId()); ASSERT_EQ(artists.front()->getId(), artist3.getId());
EXPECT_TRUE(Artist::find(session, "%CMyArtist").empty()); EXPECT_TRUE(Artist::find(session, R"(%CMyArtist)").empty());
} }
} }
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
{ {
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist"})) }; const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"MyArtist"})) };
EXPECT_EQ(artists.results.size(), 6); EXPECT_EQ(artists.results.size(), 6);
} }
{ {
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"MyArtist%"}).setSortMethod(ArtistSortMethod::ByName)) }; const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"MyArtist%"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 2); ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist1.getId()); EXPECT_EQ(artists.results[0], artist1.getId());
EXPECT_EQ(artists.results[1], artist4.getId()); EXPECT_EQ(artists.results[1], artist4.getId());
} }
{ {
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"%MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) }; const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"%MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 2); ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist2.getId()); EXPECT_EQ(artists.results[0], artist2.getId());
EXPECT_EQ(artists.results[1], artist5.getId()); EXPECT_EQ(artists.results[1], artist5.getId());
} }
{ {
const auto artists{ Artist::find(session, Artist::FindParameters {}.setKeywords({"_MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) }; const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setKeywords({"_MyArtist"}).setSortMethod(ArtistSortMethod::ByName)) };
ASSERT_EQ(artists.results.size(), 1); ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results[0], artist3.getId()); EXPECT_EQ(artists.results[0], artist3.getId());
} }
@@ -354,8 +363,8 @@ TEST_F(DatabaseFixture, Artist_sortMethod)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto allArtistsByName{ Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::ByName)) }; auto allArtistsByName{ Artist::findIds(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::ByName)) };
auto allArtistsBySortName{ Artist::find(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) }; auto allArtistsBySortName{ Artist::findIds(session, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) };
ASSERT_EQ(allArtistsByName.results.size(), 2); ASSERT_EQ(allArtistsByName.results.size(), 2);
EXPECT_EQ(allArtistsByName.results.front(), artistA.getId()); EXPECT_EQ(allArtistsByName.results.front(), artistA.getId());
@@ -407,7 +416,7 @@ TEST_F(DatabaseFixture, Artist_findByRelease)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
const auto artists{ Artist::find(session, Artist::FindParameters {}.setRelease(release.getId())) }; const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setRelease(release.getId())) };
EXPECT_EQ(artists.results.size(), 0); EXPECT_EQ(artists.results.size(), 0);
} }
@@ -418,7 +427,7 @@ TEST_F(DatabaseFixture, Artist_findByRelease)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
const auto artists{ Artist::find(session, Artist::FindParameters {}.setRelease(release.getId())) }; const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setRelease(release.getId())) };
EXPECT_EQ(artists.results.size(), 0); EXPECT_EQ(artists.results.size(), 0);
} }
@@ -429,7 +438,7 @@ TEST_F(DatabaseFixture, Artist_findByRelease)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
const auto artists{ Artist::find(session, Artist::FindParameters {}.setRelease(release.getId())) }; const auto artists{ Artist::findIds(session, Artist::FindParameters {}.setRelease(release.getId())) };
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());
} }
src/libs/services/database/test/Cluster.cpp
+23 -23
View File
@@ -416,7 +416,7 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
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::findOrphanIds(session, Range{}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
} }
{ {
@@ -428,12 +428,12 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
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());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setClusters({ cluster2.getId() })).results.empty()); EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster2.getId() })).results.empty());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty()); EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty());
cluster2.get().modify()->addTrack(track.get()); cluster2.get().modify()->addTrack(track.get());
} }
@@ -441,19 +441,19 @@ TEST_F(DatabaseFixture, SingleTrackSingleArtistMultiClusters)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster1.getId()})) };
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());
artists = Artist::find(session, Artist::FindParameters{}.setClusters({ cluster2.getId() })); artists = Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster2.getId() }));
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());
artists = Artist::find(session, Artist::FindParameters{}.setClusters({ cluster1.getId() })); artists = Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster1.getId() }));
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());
EXPECT_TRUE(Artist::find(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty()); EXPECT_TRUE(Artist::findIds(session, Artist::FindParameters{}.setClusters({ cluster3.getId() })).results.empty());
} }
} }
@@ -476,13 +476,13 @@ 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::findOrphanIds(session, Range{}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
} }
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster.getId()})) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
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());
} }
@@ -515,7 +515,7 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistMultiClusters)
{ {
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(Artist::findAllOrphans(session, Range{}).results.empty()); EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
} }
{ {
@@ -524,7 +524,7 @@ TEST_F(DatabaseFixture, MultiTracksSingleArtistMultiClusters)
std::vector<ClusterId> clusterIds; std::vector<ClusterId> clusterIds;
std::transform(std::cbegin(clusters), std::cend(clusters), std::back_inserter(clusterIds), [](const ScopedCluster& cluster) { return cluster.getId(); }); std::transform(std::cbegin(clusters), std::cend(clusters), std::back_inserter(clusterIds), [](const ScopedCluster& cluster) { return cluster.getId(); });
auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters(clusterIds)) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters(clusterIds)) };
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());
} }
@@ -627,14 +627,14 @@ 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::findOrphanIds(session, Range{}).results.empty());
EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
} }
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}.setClusters({cluster.getId()})) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setClusters({cluster.getId()})) };
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());
@@ -1027,9 +1027,9 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleArtistsMultiClusters)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(artist1->findSimilarArtists().results.empty()); EXPECT_TRUE(artist1->findSimilarArtistIds().results.empty());
EXPECT_TRUE(artist2->findSimilarArtists().results.empty()); EXPECT_TRUE(artist2->findSimilarArtistIds().results.empty());
EXPECT_TRUE(artist3->findSimilarArtists().results.empty()); EXPECT_TRUE(artist3->findSimilarArtistIds().results.empty());
} }
std::list<ScopedTrack> tracks; std::list<ScopedTrack> tracks;
@@ -1061,35 +1061,35 @@ TEST_F(DatabaseFixture, MultipleTracksMultipleArtistsMultiClusters)
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
{ {
auto artists{ artist1->findSimilarArtists() }; auto artists{ artist1->findSimilarArtistIds() };
ASSERT_EQ(artists.results.size(), 1); ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist2.getId()); EXPECT_EQ(artists.results.front(), artist2.getId());
} }
{ {
auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::Artist}) }; auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::Artist}) };
ASSERT_EQ(artists.results.size(), 1); ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist2.getId()); EXPECT_EQ(artists.results.front(), artist2.getId());
} }
{ {
auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::ReleaseArtist}) }; auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::ReleaseArtist}) };
EXPECT_EQ(artists.results.empty(), 1); EXPECT_EQ(artists.results.empty(), 1);
} }
{ {
auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}) }; auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}) };
ASSERT_EQ(artists.results.size(), 1); ASSERT_EQ(artists.results.size(), 1);
EXPECT_EQ(artists.results.front(), artist2.getId()); EXPECT_EQ(artists.results.front(), artist2.getId());
} }
{ {
auto artists{ artist1->findSimilarArtists({TrackArtistLinkType::Composer}) }; auto artists{ artist1->findSimilarArtistIds({TrackArtistLinkType::Composer}) };
EXPECT_TRUE(artists.results.empty()); EXPECT_TRUE(artists.results.empty());
} }
{ {
auto artists{ artist2->findSimilarArtists() }; auto artists{ artist2->findSimilarArtistIds() };
ASSERT_EQ(artists.results.size(), 2); ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], artist1.getId()); EXPECT_EQ(artists.results[0], artist1.getId());
EXPECT_EQ(artists.results[1], artist3.getId()); EXPECT_EQ(artists.results[1], artist3.getId());
src/libs/services/database/test/DatabaseTest.cpp
+55 -55
View File
@@ -25,85 +25,85 @@ using namespace Database;
TEST_F(DatabaseFixture, MultiTracksSingleArtistSingleRelease) TEST_F(DatabaseFixture, MultiTracksSingleArtistSingleRelease)
{ {
constexpr std::size_t nbTracks {10}; constexpr std::size_t nbTracks{ 10 };
std::list<ScopedTrack> tracks; std::list<ScopedTrack> tracks;
ScopedArtist artist {session, "MyArtst"}; ScopedArtist artist{ session, "MyArtst" };
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
for (std::size_t i {}; i < nbTracks; ++i) for (std::size_t i{}; i < nbTracks; ++i)
{ {
tracks.emplace_back(session, "MyTrack" + std::to_string(i)); tracks.emplace_back(session, "MyTrack" + std::to_string(i));
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
TrackArtistLink::create(session, tracks.back().get(), artist.get(), TrackArtistLinkType::Artist); TrackArtistLink::create(session, tracks.back().get(), artist.get(), TrackArtistLinkType::Artist);
tracks.back().get().modify()->setRelease(release.get()); tracks.back().get().modify()->setRelease(release.get());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(Release::findOrphanIds(session, Range {}).results.empty()); EXPECT_TRUE(Release::findOrphanIds(session, Range{}).results.empty());
EXPECT_TRUE(Artist::findAllOrphans(session, Range {}).results.empty()); EXPECT_TRUE(Artist::findOrphanIds(session, Range{}).results.empty());
} }
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
auto releases {Release::findIds(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());
const auto releaseTracks {Track::find(session, Track::FindParameters {}.setRelease(release.getId()))}; const auto releaseTracks{ Track::find(session, Track::FindParameters {}.setRelease(release.getId())) };
EXPECT_EQ(releaseTracks.results.size(), nbTracks); EXPECT_EQ(releaseTracks.results.size(), nbTracks);
} }
} }
TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtist) TEST_F(DatabaseFixture, SingleTrackSingleReleaseSingleArtist)
{ {
ScopedTrack track {session, "MyTrack"}; ScopedTrack track{ session, "MyTrack" };
ScopedRelease release {session, "MyRelease"}; ScopedRelease release{ session, "MyRelease" };
ScopedArtist artist {session, "MyArtist"}; ScopedArtist artist{ session, "MyArtist" };
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
auto trackArtistLink {TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist)}; auto trackArtistLink{ TrackArtistLink::create(session, track.get(), artist.get(), TrackArtistLinkType::Artist) };
track.get().modify()->setRelease(release.get()); track.get().modify()->setRelease(release.get());
} }
{ {
auto transaction {session.createUniqueTransaction()}; auto transaction{ session.createUniqueTransaction() };
auto releases {Release::findIds(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());
auto artists {release->getArtists()}; auto artists{ release->getArtists() };
ASSERT_EQ(artists.size(), 1); ASSERT_EQ(artists.size(), 1);
ASSERT_EQ(artists.front()->getId(), artist.getId()); ASSERT_EQ(artists.front()->getId(), artist.getId());
} }
} }
TEST_F(DatabaseFixture, SingleUser) TEST_F(DatabaseFixture, SingleUser)
{ {
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_TRUE(User::find(session, User::FindParameters {}).results.empty()); EXPECT_TRUE(User::find(session, User::FindParameters{}).results.empty());
EXPECT_EQ(User::getCount(session), 0); EXPECT_EQ(User::getCount(session), 0);
} }
ScopedUser user {session, "MyUser"}; ScopedUser user{ session, "MyUser" };
{ {
auto transaction {session.createSharedTransaction()}; auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(User::find(session, User::FindParameters {}).results.size(), 1); EXPECT_EQ(User::find(session, User::FindParameters{}).results.size(), 1);
EXPECT_EQ(User::getCount(session), 1); EXPECT_EQ(User::getCount(session), 1);
} }
} }
int main(int argc, char **argv) int main(int argc, char** argv)
{ {
::testing::InitGoogleTest(&argc, argv); ::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }
src/libs/services/database/test/StarredArtist.cpp
+8 -8
View File
@@ -37,7 +37,7 @@ TEST_F(DatabaseFixture, StarredArtist)
EXPECT_FALSE(starredArtist); EXPECT_FALSE(starredArtist);
EXPECT_EQ(StarredArtist::getCount(session), 0); EXPECT_EQ(StarredArtist::getCount(session), 0);
auto artists{ Artist::find(session, Artist::FindParameters {}) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}) };
EXPECT_EQ(artists.results.size(), 1); EXPECT_EQ(artists.results.size(), 1);
} }
@@ -53,13 +53,13 @@ TEST_F(DatabaseFixture, StarredArtist)
{ {
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}) };
EXPECT_EQ(artists.results.size(), 1); EXPECT_EQ(artists.results.size(), 1);
artists = Artist::find(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)); artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
EXPECT_EQ(artists.results.size(), 1); EXPECT_EQ(artists.results.size(), 1);
artists = Artist::find(session, Artist::FindParameters{}.setStarringUser(user2.getId(), FeedbackBackend::Internal)); artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user2.getId(), FeedbackBackend::Internal));
EXPECT_EQ(artists.results.size(), 0); EXPECT_EQ(artists.results.size(), 0);
} }
} }
@@ -73,11 +73,11 @@ TEST_F(DatabaseFixture, StarredArtist_PendingDestroy)
{ {
auto transaction{ session.createUniqueTransaction() }; auto transaction{ session.createUniqueTransaction() };
auto artists{ Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal)) };
EXPECT_EQ(artists.results.size(), 1); EXPECT_EQ(artists.results.size(), 1);
starredArtist.get().modify()->setSyncState(SyncState::PendingRemove); starredArtist.get().modify()->setSyncState(SyncState::PendingRemove);
artists = Artist::find(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal)); artists = Artist::findIds(session, Artist::FindParameters{}.setStarringUser(user.getId(), FeedbackBackend::Internal));
EXPECT_EQ(artists.results.size(), 0); EXPECT_EQ(artists.results.size(), 0);
} }
} }
@@ -106,7 +106,7 @@ TEST_F(DatabaseFixture, StarredArtist_dateTime)
starredArtist1.get().modify()->setDateTime(dateTime); starredArtist1.get().modify()->setDateTime(dateTime);
starredArtist2.get().modify()->setDateTime(dateTime.addSecs(-1)); starredArtist2.get().modify()->setDateTime(dateTime.addSecs(-1));
auto artists{ Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
ASSERT_EQ(artists.results.size(), 2); ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], starredArtist1->getArtist()->getId()); EXPECT_EQ(artists.results[0], starredArtist1->getArtist()->getId());
EXPECT_EQ(artists.results[1], starredArtist2->getArtist()->getId()); EXPECT_EQ(artists.results[1], starredArtist2->getArtist()->getId());
@@ -117,7 +117,7 @@ TEST_F(DatabaseFixture, StarredArtist_dateTime)
starredArtist1.get().modify()->setDateTime(dateTime); starredArtist1.get().modify()->setDateTime(dateTime);
starredArtist2.get().modify()->setDateTime(dateTime.addSecs(1)); starredArtist2.get().modify()->setDateTime(dateTime.addSecs(1));
auto artists{ Artist::find(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) }; auto artists{ Artist::findIds(session, Artist::FindParameters {}.setStarringUser(user.getId(), FeedbackBackend::Internal).setSortMethod(ArtistSortMethod::StarredDateDesc)) };
ASSERT_EQ(artists.results.size(), 2); ASSERT_EQ(artists.results.size(), 2);
EXPECT_EQ(artists.results[0], starredArtist2->getArtist()->getId()); EXPECT_EQ(artists.results[0], starredArtist2->getArtist()->getId());
EXPECT_EQ(artists.results[1], starredArtist1->getArtist()->getId()); EXPECT_EQ(artists.results[1], starredArtist1->getArtist()->getId());
src/libs/services/feedback/impl/FeedbackService.cpp
+1 -1
View File
@@ -103,7 +103,7 @@ namespace Feedback
Session& session{ _db.getTLSSession() }; Session& session{ _db.getTLSSession() };
auto transaction{ session.createSharedTransaction() }; auto transaction{ session.createSharedTransaction() };
return Artist::find(session, params); return Artist::findIds(session, params);
} }
void FeedbackService::star(UserId userId, ReleaseId releaseId) void FeedbackService::star(UserId userId, ReleaseId releaseId)
src/libs/services/recommendation/impl/clusters/ClustersEngine.cpp
+1 -1
View File
@@ -104,7 +104,7 @@ namespace Recommendation {
if (!artist) if (!artist)
return {}; return {};
const auto similarArtistIds{ artist->findSimilarArtists(artistLinkTypes, Range {0, maxCount}) }; const auto similarArtistIds{ artist->findSimilarArtistIds(artistLinkTypes, Range {0, maxCount}) };
return std::move(similarArtistIds.results); return std::move(similarArtistIds.results);
} }
src/libs/services/scanner/impl/ScanStepRemoveOrphanDbFiles.cpp
+1 -1
View File
@@ -137,7 +137,7 @@ namespace Scanner
Session& session {_db.getTLSSession()}; Session& session {_db.getTLSSession()};
auto transaction {session.createUniqueTransaction()}; auto transaction {session.createUniqueTransaction()};
auto artistIds {Artist::findAllOrphans(session, Range {})}; auto artistIds {Artist::findOrphanIds(session, Range {})};
for (const ArtistId artistId : artistIds.results) for (const ArtistId artistId : artistIds.results)
{ {
Artist::pointer artist {Artist::find(session, artistId)}; Artist::pointer artist {Artist::find(session, artistId)};
src/libs/subsonic/impl/entrypoints/Browsing.cpp
+5 -9
View File
@@ -132,10 +132,9 @@ namespace API::Subsonic
auto transaction{ context.dbSession.createSharedTransaction() }; auto transaction{ context.dbSession.createSharedTransaction() };
parameters.setRange(Range{ currentArtistOffset, batchSize }); parameters.setRange(Range{ currentArtistOffset, batchSize });
const RangeResults<ArtistId> artists{ Artist::find(context.dbSession, parameters) }; const auto artists{ Artist::find(context.dbSession, parameters) };
for (const ArtistId artistId : artists.results) for (const Artist::pointer& artist : artists.results)
{ {
const Artist::pointer artist{ Artist::find(context.dbSession, artistId) };
std::string_view sortName{ artist->getSortName() }; std::string_view sortName{ artist->getSortName() };
char sortChar; char sortChar;
@@ -144,7 +143,7 @@ namespace API::Subsonic
else else
sortChar = std::toupper(sortName[0]); sortChar = std::toupper(sortName[0]);
artistsSortedByFirstChar[sortChar].push_back(artistId); artistsSortedByFirstChar[sortChar].push_back(artist->getId());
} }
hasMoreArtists = artists.moreResults; hasMoreArtists = artists.moreResults;
@@ -317,12 +316,9 @@ namespace API::Subsonic
directoryNode.setAttribute("id", idToString(RootId{})); directoryNode.setAttribute("id", idToString(RootId{}));
directoryNode.setAttribute("name", "Music"); directoryNode.setAttribute("name", "Music");
auto rootArtistIds{ Artist::find(context.dbSession, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) }; const auto rootArtistIds{ Artist::find(context.dbSession, Artist::FindParameters {}.setSortMethod(ArtistSortMethod::BySortName)) };
for (const ArtistId rootArtistId : rootArtistIds.results) for (const Artist::pointer& artist : rootArtistIds.results)
{
const Artist::pointer artist{ Artist::find(context.dbSession, rootArtistId) };
directoryNode.addArrayChild("child", createArtistNode(context, artist, user, false /* no id3 */)); directoryNode.addArrayChild("child", createArtistNode(context, artist, user, false /* no id3 */));
}
} }
else if (artistId) else if (artistId)
{ {
src/libs/subsonic/impl/entrypoints/Searching.cpp
+1 -5
View File
@@ -72,12 +72,8 @@ namespace API::Subsonic
params.setKeywords(keywords); params.setKeywords(keywords);
params.setRange({ artistOffset, artistCount }); params.setRange({ artistOffset, artistCount });
RangeResults<ArtistId> artistIds{ Artist::find(context.dbSession, params) }; for (const Artist::pointer& artist : Artist::find(context.dbSession, params).results)
for (const ArtistId artistId : artistIds.results)
{
const auto artist{ Artist::find(context.dbSession, artistId) };
searchResult2Node.addArrayChild("artist", createArtistNode(context, artist, user, id3)); searchResult2Node.addArrayChild("artist", createArtistNode(context, artist, user, id3));
}
} }
if (albumCount > 0) if (albumCount > 0)
src/lms/ui/Utils.cpp
+2 -2
View File
@@ -191,7 +191,7 @@ namespace UserInterface::Utils
params.setRelease(release->getId()); params.setRelease(release->getId());
params.setLinkType(TrackArtistLinkType::ReleaseArtist); params.setLinkType(TrackArtistLinkType::ReleaseArtist);
if (const auto releaseArtists{ Artist::find(LmsApp->getDbSession(), params) }; !releaseArtists.results.empty()) if (const auto releaseArtists{ Artist::findIds(LmsApp->getDbSession(), params) }; !releaseArtists.results.empty())
{ {
if (releaseArtists.results.size() == 1 && releaseArtists.results.front() == omitIfMatchThisArtist) if (releaseArtists.results.size() == 1 && releaseArtists.results.front() == omitIfMatchThisArtist)
return {}; return {};
@@ -200,7 +200,7 @@ namespace UserInterface::Utils
} }
params.setLinkType(TrackArtistLinkType::Artist); params.setLinkType(TrackArtistLinkType::Artist);
const auto artists{ Artist::find(LmsApp->getDbSession(), params) }; const auto artists{ Artist::findIds(LmsApp->getDbSession(), params) };
if (artists.results.size() == 1) if (artists.results.size() == 1)
{ {
if (artists.results.front() == omitIfMatchThisArtist) if (artists.results.front() == omitIfMatchThisArtist)
src/lms/ui/explore/ArtistCollector.cpp
+4 -4
View File
@@ -72,7 +72,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
artists = Artist::find(LmsApp->getDbSession(), params); artists = Artist::findIds(LmsApp->getDbSession(), params);
} }
break; break;
} }
@@ -87,7 +87,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
artists = Artist::find(LmsApp->getDbSession(), params); artists = Artist::findIds(LmsApp->getDbSession(), params);
} }
break; break;
} }
@@ -102,7 +102,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
artists = Artist::find(LmsApp->getDbSession(), params); artists = Artist::findIds(LmsApp->getDbSession(), params);
} }
break; break;
} }
@@ -128,7 +128,7 @@ namespace UserInterface
{ {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() }; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
_randomArtists = Artist::find(LmsApp->getDbSession(), params); _randomArtists = Artist::findIds(LmsApp->getDbSession(), params);
} }
} }
src/lms/ui/explore/ArtistView.cpp
+275 -283
View File
@@ -46,342 +46,334 @@
using namespace Database; using namespace Database;
namespace UserInterface { namespace UserInterface
bool
Artist::ReleaseType::operator<(const ReleaseType& other) const
{ {
if (!primaryType && other.primaryType) namespace
return false; {
else if (primaryType && !other.primaryType) std::optional<ArtistId> extractArtistIdFromInternalPath()
return true; {
else if (*primaryType == *other.primaryType) if (wApp->internalPathMatches("/artist/mbid/"))
return secondaryTypes.getBitfield() < other.secondaryTypes.getBitfield(); {
else const auto mbid{ UUID::fromString(wApp->internalPathNextPart("/artist/mbid/")) };
return static_cast<int>(*primaryType) < static_cast<int>(*other.primaryType); if (mbid)
} {
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
if (const Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), *mbid) })
return artist->getId();
}
Artist::Artist(Filters& filters, PlayQueueController& controller) return std::nullopt;
: Template {Wt::WString::tr("Lms.Explore.Artist.template")} }
, _filters {filters}
, _playQueueController {controller}
{
addFunction("tr", &Wt::WTemplate::Functions::tr);
addFunction("id", &Wt::WTemplate::Functions::id);
LmsApp->internalPathChanged().connect(this, [this] return StringUtils::readAs<ArtistId::ValueType>(wApp->internalPathNextPart("/artist/"));
{ }
refreshView(); }
});
filters.updated().connect([this] bool Artist::ReleaseType::operator<(const ReleaseType& other) const
{ {
_needForceRefresh = true; if (!primaryType && other.primaryType)
refreshView(); return false;
}); else if (primaryType && !other.primaryType)
return true;
else if (*primaryType == *other.primaryType)
return secondaryTypes.getBitfield() < other.secondaryTypes.getBitfield();
else
return static_cast<int>(*primaryType) < static_cast<int>(*other.primaryType);
}
refreshView(); Artist::Artist(Filters& filters, PlayQueueController& controller)
} : Template{ Wt::WString::tr("Lms.Explore.Artist.template") }
, _filters{ filters }
, _playQueueController{ controller }
{
addFunction("tr", &Wt::WTemplate::Functions::tr);
addFunction("id", &Wt::WTemplate::Functions::id);
static LmsApp->internalPathChanged().connect(this, [this]
std::optional<ArtistId> {
extractArtistIdFromInternalPath() refreshView();
{ });
if (wApp->internalPathMatches("/artist/mbid/"))
{
const auto mbid {UUID::fromString(wApp->internalPathNextPart("/artist/mbid/"))};
if (mbid)
{
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
if (const Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), *mbid)})
return artist->getId();
}
return std::nullopt; filters.updated().connect([this]
} {
_needForceRefresh = true;
refreshView();
});
return StringUtils::readAs<ArtistId::ValueType>(wApp->internalPathNextPart("/artist/")); refreshView();
} }
void void Artist::refreshView()
Artist::refreshView() {
{ if (!wApp->internalPathMatches("/artist/"))
if (!wApp->internalPathMatches("/artist/")) return;
return;
const auto artistId {extractArtistIdFromInternalPath()}; const auto artistId{ extractArtistIdFromInternalPath() };
// consider everything is up to date is the same artist is being rendered // consider everything is up to date is the same artist is being rendered
if (!_needForceRefresh && artistId && *artistId == _artistId) if (!_needForceRefresh && artistId && *artistId == _artistId)
return; return;
clear(); clear();
_artistId = {}; _artistId = {};
_trackContainer = nullptr; _trackContainer = nullptr;
_needForceRefresh = false; _needForceRefresh = false;
if (!artistId) if (!artistId)
throw ArtistNotFoundException {}; throw ArtistNotFoundException{};
const auto similarArtistIds {Service<Recommendation::IRecommendationService>::get()->getSimilarArtists(*artistId, {TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}, 5)}; const auto similarArtistIds{ Service<Recommendation::IRecommendationService>::get()->getSimilarArtists(*artistId, {TrackArtistLinkType::Artist, TrackArtistLinkType::ReleaseArtist}, 5) };
auto transaction {LmsApp->getDbSession().createSharedTransaction()}; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
const Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), *artistId)}; const Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), *artistId) };
if (!artist) if (!artist)
throw ArtistNotFoundException {}; throw ArtistNotFoundException{};
LmsApp->setTitle(artist->getName()); LmsApp->setTitle(artist->getName());
_artistId = *artistId; _artistId = *artistId;
refreshReleases(); refreshReleases();
refreshAppearsOnReleases(); refreshAppearsOnReleases();
refreshNonReleaseTracks(); refreshNonReleaseTracks();
refreshLinks(artist); refreshLinks(artist);
refreshSimilarArtists(similarArtistIds); refreshSimilarArtists(similarArtistIds);
Wt::WContainerWidget* clusterContainers {bindNew<Wt::WContainerWidget>("clusters")}; Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
{ {
auto clusterTypes = ScanSettings::get(LmsApp->getDbSession())->getClusterTypes(); auto clusterTypes = ScanSettings::get(LmsApp->getDbSession())->getClusterTypes();
auto clusterGroups = artist->getClusterGroups(clusterTypes, 3); auto clusterGroups = artist->getClusterGroups(clusterTypes, 3);
for (auto clusters : clusterGroups) for (auto clusters : clusterGroups)
{ {
for (const Database::Cluster::pointer& cluster : clusters) for (const Database::Cluster::pointer& cluster : clusters)
{ {
const Database::ClusterId clusterId = cluster->getId(); const Database::ClusterId clusterId = cluster->getId();
Wt::WInteractWidget* entry {clusterContainers->addWidget(Utils::createCluster(clusterId))}; Wt::WInteractWidget* entry{ clusterContainers->addWidget(Utils::createCluster(clusterId)) };
entry->clicked().connect([=] entry->clicked().connect([=]
{ {
_filters.add(clusterId); _filters.add(clusterId);
}); });
} }
} }
} }
bindString("name", Wt::WString::fromUTF8(artist->getName()), Wt::TextFormat::Plain); bindString("name", Wt::WString::fromUTF8(artist->getName()), Wt::TextFormat::Plain);
bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML) bindNew<Wt::WPushButton>("play-btn", Wt::WString::tr("Lms.Explore.play"), Wt::TextFormat::XHTML)
->clicked().connect([=] ->clicked().connect([=]
{ {
_playQueueController.processCommand(PlayQueueController::Command::Play, {_artistId}); _playQueueController.processCommand(PlayQueueController::Command::Play, { _artistId });
}); });
bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain) bindNew<Wt::WPushButton>("play-shuffled", Wt::WString::tr("Lms.Explore.play-shuffled"), Wt::TextFormat::Plain)
->clicked().connect([=] ->clicked().connect([=]
{ {
_playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, {_artistId}); _playQueueController.processCommand(PlayQueueController::Command::PlayShuffled, { _artistId });
}); });
bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain) bindNew<Wt::WPushButton>("play-next", Wt::WString::tr("Lms.Explore.play-next"), Wt::TextFormat::Plain)
->clicked().connect([=] ->clicked().connect([=]
{ {
_playQueueController.processCommand(PlayQueueController::Command::PlayNext, {_artistId}); _playQueueController.processCommand(PlayQueueController::Command::PlayNext, { _artistId });
}); });
bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain) bindNew<Wt::WPushButton>("play-last", Wt::WString::tr("Lms.Explore.play-last"), Wt::TextFormat::Plain)
->clicked().connect([=] ->clicked().connect([=]
{ {
_playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, {_artistId}); _playQueueController.processCommand(PlayQueueController::Command::PlayOrAddLast, { _artistId });
}); });
bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download")) bindNew<Wt::WPushButton>("download", Wt::WString::tr("Lms.Explore.download"))
->setLink(Wt::WLink {std::make_unique<DownloadArtistResource>(_artistId)}); ->setLink(Wt::WLink{ std::make_unique<DownloadArtistResource>(_artistId) });
{ {
auto isStarred {[=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), _artistId); }}; auto isStarred{ [=] { return Service<Feedback::IFeedbackService>::get()->isStarred(LmsApp->getUserId(), _artistId); } };
Wt::WPushButton* starBtn {bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star"))}; Wt::WPushButton* starBtn{ bindNew<Wt::WPushButton>("star", Wt::WString::tr(isStarred() ? "Lms.Explore.unstar" : "Lms.Explore.star")) };
starBtn->clicked().connect([=] starBtn->clicked().connect([=]
{ {
if (isStarred()) if (isStarred())
{ {
Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), _artistId); Service<Feedback::IFeedbackService>::get()->unstar(LmsApp->getUserId(), _artistId);
starBtn->setText(Wt::WString::tr("Lms.Explore.star")); starBtn->setText(Wt::WString::tr("Lms.Explore.star"));
} }
else else
{ {
Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), _artistId); Service<Feedback::IFeedbackService>::get()->star(LmsApp->getUserId(), _artistId);
starBtn->setText(Wt::WString::tr("Lms.Explore.unstar")); starBtn->setText(Wt::WString::tr("Lms.Explore.unstar"));
} }
}); });
} }
} }
void void Artist::refreshReleases()
Artist::refreshReleases() {
{ _releaseContainers.clear();
_releaseContainers.clear();
Release::FindParameters params; Release::FindParameters params;
params.setClusters(_filters.getClusterIds()); params.setClusters(_filters.getClusterIds());
params.setArtist(_artistId, {TrackArtistLinkType::ReleaseArtist}, {}); params.setArtist(_artistId, { TrackArtistLinkType::ReleaseArtist }, {});
params.setSortMethod(ReleaseSortMethod::OriginalDateDesc); params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
const auto releases {Release::findIds(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
for (const ReleaseId releaseId : releases.results) for (const ReleaseId releaseId : releases.results)
{ {
const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseId)}; const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseId) };
ReleaseType releaseType {release->getPrimaryType(), release->getSecondaryTypes()}; ReleaseType releaseType{ release->getPrimaryType(), release->getSecondaryTypes() };
_releaseContainers[releaseType].releases.push_back(releaseId); _releaseContainers[releaseType].releases.push_back(releaseId);
} }
// second pass: construct widgets // second pass: construct widgets
Wt::WContainerWidget* releaseContainers {bindNew<Wt::WContainerWidget>("release-containers")}; Wt::WContainerWidget* releaseContainers{ bindNew<Wt::WContainerWidget>("release-containers") };
for (auto& [releaseType, releases] : _releaseContainers) for (auto& [releaseType, releases] : _releaseContainers)
{ {
Wt::WTemplate* releaseContainer {releaseContainers->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Artist.template.release-container"))}; Wt::WTemplate* releaseContainer{ releaseContainers->addNew<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Artist.template.release-container")) };
if (releaseType.primaryType) if (releaseType.primaryType)
releaseContainer->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*releaseType.primaryType, releaseType.secondaryTypes)); releaseContainer->bindString("release-type", ReleaseHelpers::buildReleaseTypeString(*releaseType.primaryType, releaseType.secondaryTypes));
else else
releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.releases")); // fallback when not tagged with MB releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.releases")); // fallback when not tagged with MB
releases.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container")); releases.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container"));
releases.container->onRequestElements.connect(this, [this, &releases = releases] releases.container->onRequestElements.connect(this, [this, &releases = releases]
{ {
addSomeReleases(releases); addSomeReleases(releases);
}); });
} }
} }
else else
{ {
bindEmpty("release-containers"); bindEmpty("release-containers");
} }
} }
void void Artist::refreshAppearsOnReleases()
Artist::refreshAppearsOnReleases() {
{ constexpr EnumSet<TrackArtistLinkType> types
constexpr EnumSet<TrackArtistLinkType> types {
{ TrackArtistLinkType::Artist,
TrackArtistLinkType::Artist, TrackArtistLinkType::Arranger,
TrackArtistLinkType::Arranger, TrackArtistLinkType::Composer,
TrackArtistLinkType::Composer, TrackArtistLinkType::Conductor,
TrackArtistLinkType::Conductor, TrackArtistLinkType::Lyricist,
TrackArtistLinkType::Lyricist, TrackArtistLinkType::Mixer,
TrackArtistLinkType::Mixer, TrackArtistLinkType::Performer,
TrackArtistLinkType::Performer, TrackArtistLinkType::Producer,
TrackArtistLinkType::Producer, TrackArtistLinkType::Remixer,
TrackArtistLinkType::Remixer, TrackArtistLinkType::Writer,
TrackArtistLinkType::Writer, };
};
_appearsOnReleaseContainer = {}; _appearsOnReleaseContainer = {};
Release::FindParameters params; Release::FindParameters params;
params.setClusters(_filters.getClusterIds()); params.setClusters(_filters.getClusterIds());
params.setArtist(_artistId, types, {TrackArtistLinkType::ReleaseArtist}); params.setArtist(_artistId, types, { TrackArtistLinkType::ReleaseArtist });
params.setSortMethod(ReleaseSortMethod::OriginalDateDesc); params.setSortMethod(ReleaseSortMethod::OriginalDateDesc);
const auto releases {Release::findIds(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")) };
releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.Artist.appears-on")); releaseContainer->bindString("release-type", Wt::WString::tr("Lms.Explore.Artist.appears-on"));
_appearsOnReleaseContainer.releases = releases.results; _appearsOnReleaseContainer.releases = releases.results;
_appearsOnReleaseContainer.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container")); _appearsOnReleaseContainer.container = releaseContainer->bindNew<InfiniteScrollingContainer>("releases", Wt::WString::tr("Lms.Explore.Releases.template.container"));
_appearsOnReleaseContainer.container->onRequestElements.connect(this, [this] _appearsOnReleaseContainer.container->onRequestElements.connect(this, [this]
{ {
addSomeReleases(_appearsOnReleaseContainer); addSomeReleases(_appearsOnReleaseContainer);
}); });
} }
else else
{ {
bindEmpty("appears-on-releases"); bindEmpty("appears-on-releases");
} }
} }
void void Artist::refreshNonReleaseTracks()
Artist::refreshNonReleaseTracks() {
{ setCondition("if-has-non-release-tracks", true);
setCondition("if-has-non-release-tracks", true); _trackContainer = bindNew<InfiniteScrollingContainer>("tracks");
_trackContainer = bindNew<InfiniteScrollingContainer>("tracks"); _trackContainer->onRequestElements.connect(this, [this]
_trackContainer->onRequestElements.connect(this, [this] {
{ addSomeNonReleaseTracks();
addSomeNonReleaseTracks(); });
});
const bool added {addSomeNonReleaseTracks()}; const bool added{ addSomeNonReleaseTracks() };
setCondition("if-has-non-release-tracks", added); setCondition("if-has-non-release-tracks", added);
} }
void void Artist::refreshSimilarArtists(const std::vector<ArtistId>& similarArtistsId)
Artist::refreshSimilarArtists(const std::vector<ArtistId>& similarArtistsId) {
{ if (similarArtistsId.empty())
if (similarArtistsId.empty()) return;
return;
setCondition("if-has-similar-artists", true); setCondition("if-has-similar-artists", true);
Wt::WContainerWidget* similarArtistsContainer {bindNew<Wt::WContainerWidget>("similar-artists")}; Wt::WContainerWidget* similarArtistsContainer{ bindNew<Wt::WContainerWidget>("similar-artists") };
for (const ArtistId artistId : similarArtistsId) for (const ArtistId artistId : similarArtistsId)
{ {
const Database::Artist::pointer similarArtist {Database::Artist::find(LmsApp->getDbSession(), artistId)}; const Database::Artist::pointer similarArtist{ Database::Artist::find(LmsApp->getDbSession(), artistId) };
if (!similarArtist) if (!similarArtist)
continue; continue;
similarArtistsContainer->addWidget(ArtistListHelpers::createEntry(similarArtist)); similarArtistsContainer->addWidget(ArtistListHelpers::createEntry(similarArtist));
} }
} }
void void Artist::refreshLinks(const Database::Artist::pointer& artist)
Artist::refreshLinks(const Database::Artist::pointer& artist) {
{ const auto mbid{ artist->getMBID() };
const auto mbid {artist->getMBID()}; if (mbid)
if (mbid) {
{ setCondition("if-has-mbid", true);
setCondition("if-has-mbid", true); bindString("mbid-link", std::string{ "https://musicbrainz.org/artist/" } + std::string{ mbid->getAsString() });
bindString("mbid-link", std::string {"https://musicbrainz.org/artist/"} + std::string {mbid->getAsString()}); }
} }
}
void void Artist::addSomeReleases(ReleaseContainer& releaseContainer)
Artist::addSomeReleases(ReleaseContainer& releaseContainer) {
{ auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
if (const Database::Artist::pointer artist {Database::Artist::find(LmsApp->getDbSession(), _artistId)}) if (const Database::Artist::pointer artist{ Database::Artist::find(LmsApp->getDbSession(), _artistId) })
{ {
for (std::size_t i {static_cast<std::size_t>(releaseContainer.container->getCount())}; i < releaseContainer.releases.size(); ++i) for (std::size_t i{ static_cast<std::size_t>(releaseContainer.container->getCount()) }; i < releaseContainer.releases.size(); ++i)
{ {
const Database::Release::pointer release {Database::Release::find(LmsApp->getDbSession(), releaseContainer.releases[i])}; const Database::Release::pointer release{ Database::Release::find(LmsApp->getDbSession(), releaseContainer.releases[i]) };
releaseContainer.container->add(ReleaseListHelpers::createEntryForArtist(release, artist)); releaseContainer.container->add(ReleaseListHelpers::createEntryForArtist(release, artist));
} }
} }
} }
bool bool Artist::addSomeNonReleaseTracks()
Artist::addSomeNonReleaseTracks() {
{ bool areTracksAdded{};
bool areTracksAdded{}; auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
const Range range {static_cast<std::size_t>(_trackContainer->getCount()), _tracksBatchSize}; const Range range{ static_cast<std::size_t>(_trackContainer->getCount()), _tracksBatchSize };
Track::FindParameters params; Track::FindParameters params;
params.setClusters(_filters.getClusterIds()); params.setClusters(_filters.getClusterIds());
params.setArtist(_artistId); params.setArtist(_artistId);
params.setRange(range); params.setRange(range);
params.setSortMethod(TrackSortMethod::Name); params.setSortMethod(TrackSortMethod::Name);
params.setNonRelease(true); params.setNonRelease(true);
const auto tracks {Track::find(LmsApp->getDbSession(), params)}; const auto tracks{ Track::find(LmsApp->getDbSession(), params) };
for (const Track::pointer& track : tracks.results) for (const Track::pointer& track : tracks.results)
{ {
// TODO handle this with range // TODO handle this with range
if (_trackContainer->getCount() == _tracksMaxCount) if (_trackContainer->getCount() == _tracksMaxCount)
break; break;
_trackContainer->add(TrackListHelpers::createEntry(track, _playQueueController, _filters)); _trackContainer->add(TrackListHelpers::createEntry(track, _playQueueController, _filters));
areTracksAdded = true; areTracksAdded = true;
} }
return areTracksAdded; return areTracksAdded;
} }
} // namespace UserInterface } // namespace UserInterface
src/lms/ui/explore/ReleaseView.cpp
+1 -1
View File
@@ -79,7 +79,7 @@ namespace UserInterface
Artist::FindParameters params; Artist::FindParameters params;
params.setRelease(releaseId); params.setRelease(releaseId);
params.setLinkType(linkType); params.setLinkType(linkType);
const auto artistIds{ Artist::find(LmsApp->getDbSession(), params) }; const auto artistIds{ Artist::findIds(LmsApp->getDbSession(), params) };
if (artistIds.results.empty()) if (artistIds.results.empty())
return; return;
src/lms/ui/explore/TrackListHelpers.cpp
+1 -1
View File
@@ -67,7 +67,7 @@ namespace UserInterface::TrackListHelpers
Artist::FindParameters params; Artist::FindParameters params;
params.setTrack(trackId); params.setTrack(trackId);
params.setLinkType(linkType); params.setLinkType(linkType);
const auto artistIds {Artist::find(LmsApp->getDbSession(), params)}; const auto artistIds {Artist::findIds(LmsApp->getDbSession(), params)};
if (artistIds.results.empty()) if (artistIds.results.empty())
return; return;
src/tools/recommendation/LmsRecommendation.cpp
+1 -1
View File
@@ -102,7 +102,7 @@ static void dumpArtistsRecommendation(Session session, Recommendation::IRecommen
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::findIds(session, Artist::FindParameters{});
}); });
std::cout << "*** Artists ***" << std::endl; std::cout << "*** Artists ***" << std::endl;