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

Remove unnecessary joins

Browse Source
This commit is contained in:
emeric
2023-11-02 17:18:44 +01:00
parent 8b35e61c7d
commit 2acba9d0cc
3 changed files with 518 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/database/impl/Release.cpp
+1 -2
View File
@@ -125,13 +125,12 @@ namespace Database
std::ostringstream oss; std::ostringstream oss;
oss << "r.id IN (SELECT DISTINCT r.id FROM release r" oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
" INNER JOIN track t ON t.release_id = r.id" " INNER JOIN track t ON t.release_id = r.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"; " INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
WhereClause clusterClause; WhereClause clusterClause;
for (const ClusterId clusterId : params.clusters) for (const ClusterId clusterId : params.clusters)
{ {
clusterClause.Or(WhereClause("c.id = ?")); clusterClause.Or(WhereClause("t_c.cluster_id = ?"));
query.bind(clusterId); query.bind(clusterId);
} }
src/libs/services/database/impl/Track.cpp
+472 -498
View File
@@ -35,504 +35,478 @@
#include "StringViewTraits.hpp" #include "StringViewTraits.hpp"
#include "Utils.hpp" #include "Utils.hpp"
namespace Database { namespace Database
static
Wt::Dbo::Query<TrackId>
createQuery(Session& session, const Track::FindParameters& params)
{ {
session.checkSharedLocked(); namespace
{
auto query {session.getDboSession().query<TrackId>(params.distinct ? "SELECT DISTINCT t.id FROM track t" : "SELECT t.id FROM track t")}; Wt::Dbo::Query<TrackId> createQuery(Session& session, const Track::FindParameters& params)
{
assert(params.keywords.empty() || params.name.empty()); session.checkSharedLocked();
for (std::string_view keyword : params.keywords)
query.where("t.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + Utils::escapeLikeKeyword(keyword) + "%"); auto query{ session.getDboSession().query<TrackId>(params.distinct ? "SELECT DISTINCT t.id FROM track t" : "SELECT t.id FROM track t") };
if (!params.name.empty()) assert(params.keywords.empty() || params.name.empty());
query.where("t.name = ?").bind(params.name); for (std::string_view keyword : params.keywords)
query.where("t.name LIKE ? ESCAPE '" ESCAPE_CHAR_STR "'").bind("%" + Utils::escapeLikeKeyword(keyword) + "%");
if (params.writtenAfter.isValid())
query.where("t.file_last_write > ?").bind(params.writtenAfter); if (!params.name.empty())
query.where("t.name = ?").bind(params.name);
if (params.starringUser.isValid())
{ if (params.writtenAfter.isValid())
assert(params.feedbackBackend); query.where("t.file_last_write > ?").bind(params.writtenAfter);
query.join("starred_track s_t ON s_t.track_id = t.id")
.where("s_t.user_id = ?").bind(params.starringUser) if (params.starringUser.isValid())
.where("s_t.backend = ?").bind(*params.feedbackBackend) {
.where("s_t.sync_state <> ?").bind(SyncState::PendingRemove); assert(params.feedbackBackend);
} query.join("starred_track s_t ON s_t.track_id = t.id")
.where("s_t.user_id = ?").bind(params.starringUser)
if (!params.clusters.empty()) .where("s_t.backend = ?").bind(*params.feedbackBackend)
{ .where("s_t.sync_state <> ?").bind(SyncState::PendingRemove);
std::ostringstream oss; }
oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id" if (!params.clusters.empty())
" INNER JOIN cluster c ON c.id = t_c.cluster_id"; {
std::ostringstream oss;
WhereClause clusterClause; oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
for (const ClusterId clusterId : params.clusters) " INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
{
clusterClause.Or(WhereClause("c.id = ?")); WhereClause clusterClause;
query.bind(clusterId); for (const ClusterId clusterId : params.clusters)
} {
clusterClause.Or(WhereClause("t_c.cluster_id = ?"));
oss << " " << clusterClause.get(); query.bind(clusterId);
oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")"; }
query.where(oss.str()); oss << " " << clusterClause.get();
} oss << " GROUP BY t.id HAVING COUNT(*) = " << params.clusters.size() << ")";
if (params.artist.isValid() || !params.artistName.empty()) query.where(oss.str());
{ }
query.join("artist a ON a.id = t_a_l.artist_id")
.join("track_artist_link t_a_l ON t_a_l.track_id = t.id"); if (params.artist.isValid() || !params.artistName.empty())
{
if (params.artist.isValid()) query.join("artist a ON a.id = t_a_l.artist_id")
query.where("a.id = ?").bind(params.artist); .join("track_artist_link t_a_l ON t_a_l.track_id = t.id");
if (!params.artistName.empty())
query.where("a.name = ?").bind(params.artistName); if (params.artist.isValid())
query.where("a.id = ?").bind(params.artist);
if (!params.trackArtistLinkTypes.empty()) if (!params.artistName.empty())
{ query.where("a.name = ?").bind(params.artistName);
std::ostringstream oss;
if (!params.trackArtistLinkTypes.empty())
bool first {true}; {
for (TrackArtistLinkType linkType : params.trackArtistLinkTypes) std::ostringstream oss;
{
if (!first) bool first{ true };
oss << " OR "; for (TrackArtistLinkType linkType : params.trackArtistLinkTypes)
oss << "t_a_l.type = ?"; {
query.bind(linkType); if (!first)
oss << " OR ";
first = false; oss << "t_a_l.type = ?";
} query.bind(linkType);
query.where(oss.str());
} first = false;
} }
query.where(oss.str());
assert(!(params.nonRelease && params.release.isValid())); }
if (params.nonRelease) }
query.where("t.release_id IS NULL");
else if (params.release.isValid()) assert(!(params.nonRelease && params.release.isValid()));
query.where("t.release_id = ?").bind(params.release); if (params.nonRelease)
else if (!params.releaseName.empty()) query.where("t.release_id IS NULL");
{ else if (params.release.isValid())
query.join("release r ON t.release_id = r.id"); query.where("t.release_id = ?").bind(params.release);
query.where("r.name = ?").bind(params.releaseName); else if (!params.releaseName.empty())
} {
query.join("release r ON t.release_id = r.id");
if (params.trackList.isValid()) query.where("r.name = ?").bind(params.releaseName);
{ }
query.join("tracklist t_l ON t_l_e.tracklist_id = t_l.id");
query.join("tracklist_entry t_l_e ON t.id = t_l_e.track_id"); if (params.trackList.isValid())
query.where("t_l.id = ?").bind(params.trackList); {
} query.join("tracklist t_l ON t_l_e.tracklist_id = t_l.id");
query.join("tracklist_entry t_l_e ON t.id = t_l_e.track_id");
if (params.trackNumber) query.where("t_l.id = ?").bind(params.trackList);
query.where("t.track_number = ?").bind(*params.trackNumber); }
switch (params.sortMethod) if (params.trackNumber)
{ query.where("t.track_number = ?").bind(*params.trackNumber);
case TrackSortMethod::None:
break; switch (params.sortMethod)
case TrackSortMethod::LastWritten: {
query.orderBy("t.file_last_write DESC"); case TrackSortMethod::None:
break; break;
case TrackSortMethod::Random: case TrackSortMethod::LastWritten:
query.orderBy("RANDOM()"); query.orderBy("t.file_last_write DESC");
break; break;
case TrackSortMethod::StarredDateDesc: case TrackSortMethod::Random:
assert(params.starringUser.isValid()); query.orderBy("RANDOM()");
query.orderBy("s_t.date_time DESC"); break;
break; case TrackSortMethod::StarredDateDesc:
case TrackSortMethod::Name: assert(params.starringUser.isValid());
query.orderBy("t.name COLLATE NOCASE"); query.orderBy("s_t.date_time DESC");
break; break;
case TrackSortMethod::DateDescAndRelease: case TrackSortMethod::Name:
query.orderBy("t.date DESC,t.release_id,t.disc_number,t.track_number"); query.orderBy("t.name COLLATE NOCASE");
break; break;
case TrackSortMethod::Release: case TrackSortMethod::DateDescAndRelease:
query.orderBy("t.disc_number,t.track_number"); query.orderBy("t.date DESC,t.release_id,t.disc_number,t.track_number");
break; break;
case TrackSortMethod::TrackList: case TrackSortMethod::Release:
assert(params.trackList.isValid()); query.orderBy("t.disc_number,t.track_number");
query.orderBy("t_l.id"); break;
} case TrackSortMethod::TrackList:
assert(params.trackList.isValid());
return query; query.orderBy("t_l.id");
} }
Track::Track(const std::filesystem::path& p) return query;
: _filePath {p.string()} }
{ }
}
Track::Track(const std::filesystem::path& p)
Track::pointer : _filePath{ p.string() }
Track::create(Session& session, const std::filesystem::path& p) {
{ }
return session.getDboSession().add(std::unique_ptr<Track> {new Track {p}});
} Track::pointer Track::create(Session& session, const std::filesystem::path& p)
{
std::size_t return session.getDboSession().add(std::unique_ptr<Track> {new Track{ p }});
Track::getCount(Session& session) }
{
session.checkSharedLocked(); std::size_t
Track::getCount(Session& session)
return session.getDboSession().query<int>("SELECT COUNT(*) FROM track"); {
} session.checkSharedLocked();
Track::pointer return session.getDboSession().query<int>("SELECT COUNT(*) FROM track");
Track::findByPath(Session& session, const std::filesystem::path& p) }
{
session.checkSharedLocked(); Track::pointer Track::findByPath(Session& session, const std::filesystem::path& p)
{
return session.getDboSession().find<Track>().where("file_path = ?").bind(p.string()).resultValue(); session.checkSharedLocked();
}
return session.getDboSession().find<Track>().where("file_path = ?").bind(p.string()).resultValue();
Track::pointer }
Track::find(Session& session, TrackId id)
{ Track::pointer Track::find(Session& session, TrackId id)
session.checkSharedLocked(); {
session.checkSharedLocked();
return session.getDboSession().find<Track>()
.where("id = ?").bind(id) return session.getDboSession().find<Track>()
.resultValue(); .where("id = ?").bind(id)
} .resultValue();
}
bool
Track::exists(Session& session, TrackId id) bool Track::exists(Session& session, TrackId id)
{ {
session.checkSharedLocked(); session.checkSharedLocked();
return session.getDboSession().query<int>("SELECT 1 from track").where("id = ?").bind(id).resultValue() == 1; return session.getDboSession().query<int>("SELECT 1 from track").where("id = ?").bind(id).resultValue() == 1;
} }
std::vector<Track::pointer> std::vector<Track::pointer> Track::findByMBID(Session& session, const UUID& mbid)
Track::findByMBID(Session& session, const UUID& mbid) {
{ session.checkSharedLocked();
session.checkSharedLocked();
auto res{ session.getDboSession().find<Track>()
auto res {session.getDboSession().find<Track>() .where("mbid = ?").bind(std::string {mbid.getAsString()})
.where("mbid = ?").bind(std::string {mbid.getAsString()}) .resultList() };
.resultList()};
return std::vector<Track::pointer>(res.begin(), res.end());
return std::vector<Track::pointer>(res.begin(), res.end()); }
}
std::vector<Track::pointer> Track::findByRecordingMBID(Session& session, const UUID& mbid)
std::vector<Track::pointer> {
Track::findByRecordingMBID(Session& session, const UUID& mbid) session.checkSharedLocked();
{
session.checkSharedLocked(); auto res{ session.getDboSession().find<Track>()
.where("recording_mbid = ?").bind(std::string {mbid.getAsString()})
auto res {session.getDboSession().find<Track>() .resultList() };
.where("recording_mbid = ?").bind(std::string {mbid.getAsString()})
.resultList()}; return std::vector<Track::pointer>(res.begin(), res.end());
}
return std::vector<Track::pointer>(res.begin(), res.end());
} RangeResults<Track::PathResult> Track::findPaths(Session& session, Range range)
{
RangeResults<Track::PathResult> using QueryResultType = std::tuple<TrackId, std::string>;
Track::findPaths(Session& session, Range range) session.checkSharedLocked();
{
using QueryResultType = std::tuple<TrackId, std::string>; // TODO Dbo traits on filesystem
session.checkSharedLocked(); auto query{ session.getDboSession().query<QueryResultType>("SELECT id, file_path FROM track") };
// TODO Dbo traits on filesystem RangeResults<QueryResultType> queryResults{ Utils::execQuery(query, range) };
auto query {session.getDboSession().query<QueryResultType>("SELECT id, file_path FROM track")};
RangeResults<PathResult> res;
RangeResults<QueryResultType> queryResults {Utils::execQuery(query, range)}; res.range = queryResults.range;
res.moreResults = queryResults.moreResults;
RangeResults<PathResult> res; res.results.reserve(queryResults.results.size());
res.range = queryResults.range;
res.moreResults = queryResults.moreResults; std::transform(std::cbegin(queryResults.results), std::cend(queryResults.results), std::back_inserter(res.results),
res.results.reserve(queryResults.results.size()); [](const QueryResultType& queryResult)
{
std::transform(std::cbegin(queryResults.results), std::cend(queryResults.results), std::back_inserter(res.results), return PathResult{ std::get<0>(queryResult), std::get<1>(queryResult) };
[](const QueryResultType& queryResult) });
{
return PathResult {std::get<0>(queryResult), std::get<1>(queryResult)}; return res;
}); }
return res; RangeResults<TrackId> Track::findTrackMBIDDuplicates(Session& session, Range range)
} {
session.checkSharedLocked();
RangeResults<TrackId>
Track::findTrackMBIDDuplicates(Session& session, Range range) auto query{ session.getDboSession().query<TrackId>("SELECT track.id FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)")
{ .orderBy("track.release_id,track.disc_number,track.track_number,track.mbid") };
session.checkSharedLocked();
return Utils::execQuery(query, range);
auto query {session.getDboSession().query<TrackId>( "SELECT track.id FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)") }
.orderBy("track.release_id,track.disc_number,track.track_number,track.mbid")};
RangeResults<TrackId> Track::findWithRecordingMBIDAndMissingFeatures(Session& session, Range range)
return Utils::execQuery(query, range); {
} session.checkSharedLocked();
RangeResults<TrackId> auto query{ session.getDboSession().query<TrackId>("SELECT t.id FROM track t")
Track::findWithRecordingMBIDAndMissingFeatures(Session& session, Range range) .where("LENGTH(t.recording_mbid) > 0")
{ .where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)") };
session.checkSharedLocked();
return Utils::execQuery(query, range);
auto query {session.getDboSession().query<TrackId>("SELECT t.id FROM track t") }
.where("LENGTH(t.recording_mbid) > 0")
.where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)")}; std::vector<Cluster::pointer> Track::getClusters() const
{
return Utils::execQuery(query, range); return std::vector<Cluster::pointer>(_clusters.begin(), _clusters.end());
} }
std::vector<Cluster::pointer> std::vector<ClusterId> Track::getClusterIds() const
Track::getClusters() const {
{ assert(session());
return std::vector<Cluster::pointer>(_clusters.begin(), _clusters.end());
} auto res{ session()->query<ClusterId>
("SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id INNER JOIN track t ON t.id = t_c.track_id")
std::vector<ClusterId> .where("t.id = ?").bind(getId())
Track::getClusterIds() const .resultList() };
{
assert(session()); return std::vector<ClusterId>(res.begin(), res.end());
}
auto res {session()->query<ClusterId>
("SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id INNER JOIN track t ON t.id = t_c.track_id") RangeResults<TrackId> Track::find(Session& session, const FindParameters& parameters)
.where("t.id = ?").bind(getId()) {
.resultList()}; session.checkSharedLocked();
return std::vector<ClusterId>(res.begin(), res.end()); auto query{ createQuery(session, parameters) };
}
return Utils::execQuery(query, parameters.range);
RangeResults<TrackId> }
Track::find(Session& session, const FindParameters& parameters)
{ RangeResults<TrackId> Track::findSimilarTracks(Session& session, const std::vector<TrackId>& tracks, Range range)
session.checkSharedLocked(); {
assert(!tracks.empty());
auto query {createQuery(session, parameters)}; session.checkSharedLocked();
return Utils::execQuery(query, parameters.range); std::ostringstream oss;
} for (std::size_t i{}; i < tracks.size(); ++i)
{
RangeResults<TrackId> if (!oss.str().empty())
Track::findSimilarTracks(Session& session, const std::vector<TrackId>& tracks, Range range) oss << ", ";
{ oss << "?";
assert(!tracks.empty()); }
session.checkSharedLocked();
auto query{ session.getDboSession().query<TrackId>(
std::ostringstream oss; "SELECT t.id FROM track t"
for (std::size_t i {}; i < tracks.size(); ++i) " INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
{ " AND t_c.cluster_id IN (SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id WHERE t_c.track_id IN (" + oss.str() + "))"
if (!oss.str().empty()) " AND t.id NOT IN (" + oss.str() + ")")
oss << ", "; .groupBy("t.id")
oss << "?"; .orderBy("COUNT(*) DESC, RANDOM()") };
}
for (TrackId trackId : tracks)
auto query {session.getDboSession().query<TrackId>( query.bind(trackId);
"SELECT t.id FROM track t"
" INNER JOIN track_cluster t_c ON t_c.track_id = t.id" for (TrackId trackId : tracks)
" AND t_c.cluster_id IN (SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id WHERE t_c.track_id IN (" + oss.str() + "))" query.bind(trackId);
" AND t.id NOT IN (" + oss.str() + ")")
.groupBy("t.id") return Utils::execQuery(query, range);
.orderBy("COUNT(*) DESC, RANDOM()")}; }
for (TrackId trackId : tracks) void Track::clearArtistLinks()
query.bind(trackId); {
_trackArtistLinks.clear();
for (TrackId trackId : tracks) }
query.bind(trackId);
void Track::addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink)
return Utils::execQuery(query, range); {
} _trackArtistLinks.insert(getDboPtr(artistLink));
}
void
Track::clearArtistLinks() void Track::setClusters(const std::vector<ObjectPtr<Cluster>>& clusters)
{ {
_trackArtistLinks.clear(); _clusters.clear();
} for (const ObjectPtr<Cluster>& cluster : clusters)
_clusters.insert(getDboPtr(cluster));
void }
Track::addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink)
{ std::optional<int> Track::getYear() const
_trackArtistLinks.insert(getDboPtr(artistLink)); {
} return (_date.isValid() ? std::make_optional<int>(_date.year()) : std::nullopt);
}
void
Track::setClusters(const std::vector<ObjectPtr<Cluster>>& clusters) std::optional<int> Track::getOriginalYear() const
{ {
_clusters.clear(); return (_originalDate.isValid() ? std::make_optional<int>(_originalDate.year()) : std::nullopt);
for (const ObjectPtr<Cluster>& cluster : clusters) }
_clusters.insert(getDboPtr(cluster));
} std::optional<std::string> Track::getCopyright() const
{
std::optional<int> return _copyright != "" ? std::make_optional<std::string>(_copyright) : std::nullopt;
Track::getYear() const }
{
return (_date.isValid() ? std::make_optional<int>(_date.year()) : std::nullopt); std::optional<std::string> Track::getCopyrightURL() const
} {
return _copyrightURL != "" ? std::make_optional<std::string>(_copyrightURL) : std::nullopt;
std::optional<int> }
Track::getOriginalYear() const
{ std::vector<Artist::pointer> Track::getArtists(EnumSet<TrackArtistLinkType> linkTypes) const
return (_originalDate.isValid() ? std::make_optional<int>(_originalDate.year()) : std::nullopt); {
} assert(session());
std::optional<std::string> std::ostringstream oss;
Track::getCopyright() const oss <<
{ "SELECT a from artist a"
return _copyright != "" ? std::make_optional<std::string>(_copyright) : std::nullopt; " INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id"
} " INNER JOIN track t ON t.id = t_a_l.track_id";
std::optional<std::string> if (!linkTypes.empty())
Track::getCopyrightURL() const {
{ oss << " AND t_a_l.type IN (";
return _copyrightURL != "" ? std::make_optional<std::string>(_copyrightURL) : std::nullopt;
} bool first{ true };
for ([[maybe_unused]] TrackArtistLinkType type : linkTypes)
std::vector<Artist::pointer> {
Track::getArtists(EnumSet<TrackArtistLinkType> linkTypes) const if (!first)
{ oss << ", ";
assert(session()); oss << "?";
first = false;
std::ostringstream oss; }
oss << oss << ")";
"SELECT a from artist a" }
" INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id"
" INNER JOIN track t ON t.id = t_a_l.track_id"; auto query{ session()->query<Wt::Dbo::ptr<Artist>>(oss.str()) };
for (TrackArtistLinkType type : linkTypes)
if (!linkTypes.empty()) query.bind(type);
{
oss << " AND t_a_l.type IN ("; query.where("t.id = ?").bind(getId());
bool first {true}; auto res{ query.resultList() };
for ([[maybe_unused]] TrackArtistLinkType type : linkTypes) return std::vector<Artist::pointer>(std::begin(res), std::end(res));
{ }
if (!first)
oss << ", "; std::vector<ArtistId> Track::getArtistIds(EnumSet<TrackArtistLinkType> linkTypes) const
oss << "?"; {
first = false; assert(self());
} assert(session());
oss << ")";
} std::ostringstream oss;
oss <<
auto query {session()->query<Wt::Dbo::ptr<Artist>>(oss.str())}; "SELECT DISTINCT a.id from artist a"
for (TrackArtistLinkType type : linkTypes) " INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id"
query.bind(type); " INNER JOIN track t ON t.id = t_a_l.track_id";
query.where("t.id = ?").bind(getId()); if (!linkTypes.empty())
{
auto res {query.resultList()}; oss << " AND t_a_l.type IN (";
return std::vector<Artist::pointer>(std::begin(res), std::end(res));
} bool first{ true };
for ([[maybe_unused]] TrackArtistLinkType type : linkTypes)
std::vector<ArtistId> {
Track::getArtistIds(EnumSet<TrackArtistLinkType> linkTypes) const if (!first)
{ oss << ", ";
assert(self()); oss << "?";
assert(session()); first = false;
}
std::ostringstream oss; oss << ")";
oss << }
"SELECT DISTINCT a.id from artist a"
" INNER JOIN track_artist_link t_a_l ON a.id = t_a_l.artist_id" auto query{ session()->query<ArtistId>(oss.str()) };
" INNER JOIN track t ON t.id = t_a_l.track_id"; for (TrackArtistLinkType type : linkTypes)
query.bind(type);
if (!linkTypes.empty())
{ query.where("t.id = ?").bind(getId());
oss << " AND t_a_l.type IN (";
auto res{ query.resultList() };
bool first {true}; return std::vector<ArtistId>(std::cbegin(res), std::cend(res));
for ([[maybe_unused]] TrackArtistLinkType type : linkTypes) }
{
if (!first) std::vector<TrackArtistLink::pointer> Track::getArtistLinks() const
oss << ", "; {
oss << "?"; return std::vector<TrackArtistLink::pointer>(_trackArtistLinks.begin(), _trackArtistLinks.end());
first = false; }
}
oss << ")"; std::vector<std::vector<Cluster::pointer>> Track::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
} {
assert(self());
auto query {session()->query<ArtistId>(oss.str())}; assert(session());
for (TrackArtistLinkType type : linkTypes)
query.bind(type); WhereClause where;
query.where("t.id = ?").bind(getId()); std::ostringstream oss;
auto res {query.resultList()}; 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";
return std::vector<ArtistId>(std::cbegin(res), std::cend(res));
} where.And(WhereClause("t.id = ?")).bind(getId().toString());
{
std::vector<TrackArtistLink::pointer> WhereClause clusterClause;
Track::getArtistLinks() const for (auto clusterType : clusterTypes)
{ clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
return std::vector<TrackArtistLink::pointer>(_trackArtistLinks.begin(), _trackArtistLinks.end()); where.And(clusterClause);
} }
oss << " " << where.get();
std::vector<std::vector<Cluster::pointer>> oss << " GROUP BY c.id ORDER BY COUNT(c.id) DESC";
Track::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
{ auto query{ session()->query<Wt::Dbo::ptr<Cluster>>(oss.str()) };
assert(self()); for (const std::string& bindArg : where.getBindArgs())
assert(session()); query.bind(bindArg);
WhereClause where; auto queryRes{ query.resultList() };
std::ostringstream oss; std::map<ClusterTypeId, std::vector<Cluster::pointer>> clusters;
for (const Wt::Dbo::ptr<Cluster>& cluster : queryRes)
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"; {
if (clusters[cluster->getType()->getId()].size() < size)
where.And(WhereClause("t.id = ?")).bind(getId().toString()); clusters[cluster->getType()->getId()].push_back(cluster);
{ }
WhereClause clusterClause;
for (auto clusterType : clusterTypes) std::vector<std::vector<Cluster::pointer>> res;
clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString()); for (auto cluster_list : clusters)
where.And(clusterClause); res.push_back(cluster_list.second);
}
oss << " " << where.get(); return res;
oss << " GROUP BY c.id ORDER BY COUNT(c.id) DESC"; }
auto query {session()->query<Wt::Dbo::ptr<Cluster>>(oss.str())}; namespace Debug
for (const std::string& bindArg : where.getBindArgs()) {
query.bind(bindArg); std::ostream& operator<<(std::ostream& os, const TrackInfo& trackInfo)
{
auto queryRes {query.resultList()}; auto transaction{ trackInfo.session.createSharedTransaction() };
std::map<ClusterTypeId, std::vector<Cluster::pointer>> clusters; const Track::pointer track{ Track::find(trackInfo.session, trackInfo.trackId) };
for (const Wt::Dbo::ptr<Cluster>& cluster : queryRes) if (track)
{ {
if (clusters[cluster->getType()->getId()].size() < size) os << track->getName();
clusters[cluster->getType()->getId()].push_back(cluster);
} if (const Release::pointer release{ track->getRelease() })
os << " [" << release->getName() << "]";
std::vector<std::vector<Cluster::pointer>> res; for (auto artist : track->getArtists({ TrackArtistLinkType::Artist }))
for (auto cluster_list : clusters) os << " - " << artist->getName();
res.push_back(cluster_list.second); for (auto cluster : track->getClusters())
os << " {" + cluster->getType()->getName() << "-" << cluster->getName() << "}";
return res; }
} else
{
namespace Debug os << "*unknown*";
{ }
std::ostream&
operator<<(std::ostream& os, const TrackInfo& trackInfo) return os;
{ }
auto transaction {trackInfo.session.createSharedTransaction()}; }
const Track::pointer track {Track::find(trackInfo.session, trackInfo.trackId)};
if (track)
{
os << track->getName();
if (const Release::pointer release {track->getRelease()})
os << " [" << release->getName() << "]";
for (auto artist : track->getArtists({TrackArtistLinkType::Artist}))
os << " - " << artist->getName();
for (auto cluster : track->getClusters())
os << " {" + cluster->getType()->getName() << "-" << cluster->getName() << "}";
}
else
{
os << "*unknown*";
}
return os;
}
}
} // namespace Database } // namespace Database
src/libs/services/database/test/Cluster.cpp
+45
View File
@@ -154,6 +154,51 @@ TEST_F(DatabaseFixture, Cluster_singleTrack)
} }
} }
TEST_F(DatabaseFixture, Cluster_singleTrackWithSeveralClusters)
{
ScopedTrack track{ session, "MyTrack" };
ScopedClusterType clusterType{ session, "MyClusterType" };
ScopedCluster cluster1{ session, clusterType.lockAndGet(), "MyCluster1" };
ScopedCluster cluster2{ session, clusterType.lockAndGet(), "MyCluster2" };
const std::vector<ClusterId> clusterIds{ cluster1.getId(), cluster2.getId() };
{
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters{}.setClusters(clusterIds)) };
EXPECT_TRUE(tracks.results.empty());
}
{
auto transaction{ session.createUniqueTransaction() };
cluster1.get().modify()->addTrack(track.get());
}
{
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters{}.setClusters(clusterIds)) };
EXPECT_TRUE(tracks.results.empty());
}
{
auto transaction{ session.createUniqueTransaction() };
cluster2.get().modify()->addTrack(track.get());
}
{
auto transaction{ session.createSharedTransaction() };
const auto tracks{ Track::find(session, Track::FindParameters{}.setClusters(clusterIds)) };
ASSERT_FALSE(tracks.results.empty());
EXPECT_EQ(tracks.results.front(), track.getId());
}
}
TEST_F(DatabaseFixture, Cluster_multiTracks) TEST_F(DatabaseFixture, Cluster_multiTracks)
{ {
std::list<ScopedTrack> tracks; std::list<ScopedTrack> tracks;