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

Extracted genre, mood, language and grouping from generic clusters

Browse Source
This commit is contained in:
emeric
2026-06-17 21:34:29 +02:00
parent 77f9b033ed
commit dbd6e57160
82 changed files with 3648 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/database/CMakeLists.txt
+4
View File
@@ -6,10 +6,14 @@ add_library(lmsdatabase STATIC
impl/objects/AuthToken.cpp
impl/objects/Cluster.cpp
impl/objects/Directory.cpp
impl/objects/Genre.cpp
impl/objects/Grouping.cpp
impl/objects/Image.cpp
impl/objects/Language.cpp
impl/objects/Listen.cpp
impl/objects/MediaLibrary.cpp
impl/objects/Medium.cpp
impl/objects/Mood.cpp
impl/objects/PlayListFile.cpp
impl/objects/PlayQueue.cpp
impl/objects/Podcast.cpp
src/libs/database/impl/Migration.cpp
+123 -1
View File
@@ -35,7 +35,7 @@ namespace lms::db
{
namespace
{
static constexpr Version LMS_DATABASE_VERSION{ 107 };
static constexpr Version LMS_DATABASE_VERSION{ 108 };
}
VersionInfo::VersionInfo()
@@ -1774,6 +1774,127 @@ FROM track)");
utils::executeCommand(*session.getDboSession(), R"(ALTER TABLE track RENAME COLUMN recording_mbid_new TO recording_mbid)");
}
void migrateFromV107(Session& session)
{
// Extract Genre, Mood, Language and Grouping from Cluster (keep it for user tags)
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "genre" (
"id" integer primary key autoincrement,
"version" integer not null,
"name" text not null,
"track_count" integer not null default 0,
"release_count" integer not null default 0
))");
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "track_genre" (
"track_id" bigint,
"genre_id" bigint,
primary key ("track_id", "genre_id"),
constraint "fk_track_genre_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
constraint "fk_track_genre_genre" foreign key ("genre_id") references "genre" ("id") on delete cascade deferrable initially deferred
))");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO genre (version, name, track_count, release_count)
SELECT 0, c.name, c.track_count, c.release_count FROM cluster c
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
WHERE ct.name = 'GENRE')");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO track_genre (track_id, genre_id)
SELECT tc.track_id, g.id FROM track_cluster tc
INNER JOIN cluster c ON c.id = tc.cluster_id
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
INNER JOIN genre g ON g.name = c.name
WHERE ct.name = 'GENRE')");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_genre_genre" ON "track_genre" ("genre_id"))");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_genre_track" ON "track_genre" ("track_id"))");
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "mood" (
"id" integer primary key autoincrement,
"version" integer not null,
"name" text not null
))");
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "track_mood" (
"track_id" bigint,
"mood_id" bigint,
primary key ("track_id", "mood_id"),
constraint "fk_track_mood_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
constraint "fk_track_mood_mood" foreign key ("mood_id") references "mood" ("id") on delete cascade deferrable initially deferred
))");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO mood (version, name)
SELECT 0, c.name FROM cluster c
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
WHERE ct.name = 'MOOD')");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO track_mood (track_id, mood_id)
SELECT tc.track_id, m.id FROM track_cluster tc
INNER JOIN cluster c ON c.id = tc.cluster_id
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
INNER JOIN mood m ON m.name = c.name
WHERE ct.name = 'MOOD')");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_mood_mood" ON "track_mood" ("mood_id"))");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_mood_track" ON "track_mood" ("track_id"))");
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "language" (
"id" integer primary key autoincrement,
"version" integer not null,
"name" text not null
))");
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "track_language" (
"track_id" bigint,
"language_id" bigint,
primary key ("track_id", "language_id"),
constraint "fk_track_language_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
constraint "fk_track_language_language" foreign key ("language_id") references "language" ("id") on delete cascade deferrable initially deferred
))");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO language (version, name)
SELECT 0, c.name FROM cluster c
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
WHERE ct.name = 'LANGUAGE')");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO track_language (track_id, language_id)
SELECT tc.track_id, l.id FROM track_cluster tc
INNER JOIN cluster c ON c.id = tc.cluster_id
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
INNER JOIN language l ON l.name = c.name
WHERE ct.name = 'LANGUAGE')");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_language_language" ON "track_language" ("language_id"))");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_language_track" ON "track_language" ("track_id"))");
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "grouping" (
"id" integer primary key autoincrement,
"version" integer not null,
"name" text not null
))");
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "track_grouping" (
"track_id" bigint,
"grouping_id" bigint,
primary key ("track_id", "grouping_id"),
constraint "fk_track_grouping_track" foreign key ("track_id") references "track" ("id") on delete cascade deferrable initially deferred,
constraint "fk_track_grouping_grouping" foreign key ("grouping_id") references "grouping" ("id") on delete cascade deferrable initially deferred
))");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO grouping (version, name)
SELECT 0, c.name FROM cluster c
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
WHERE ct.name = 'GROUPING')");
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO track_grouping (track_id, grouping_id)
SELECT tc.track_id, g.id FROM track_cluster tc
INNER JOIN cluster c ON c.id = tc.cluster_id
INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id
INNER JOIN grouping g ON g.name = c.name
WHERE ct.name = 'GROUPING')");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_grouping_grouping" ON "track_grouping" ("grouping_id"))");
utils::executeCommand(*session.getDboSession(), R"(CREATE INDEX "track_grouping_track" ON "track_grouping" ("track_id"))");
utils::executeCommand(*session.getDboSession(), R"(DELETE FROM track_cluster WHERE cluster_id IN (SELECT c.id FROM cluster c INNER JOIN cluster_type ct ON ct.id = c.cluster_type_id WHERE ct.name IN ('GENRE', 'MOOD', 'LANGUAGE', 'GROUPING')))");
utils::executeCommand(*session.getDboSession(), R"(ALTER TABLE cluster DROP COLUMN track_count)");
utils::executeCommand(*session.getDboSession(), R"(ALTER TABLE cluster DROP COLUMN release_count)");
utils::executeCommand(*session.getDboSession(), R"(DELETE FROM cluster WHERE cluster_type_id IN (SELECT id FROM cluster_type WHERE name IN ('GENRE', 'MOOD', 'LANGUAGE', 'GROUPING')))");
utils::executeCommand(*session.getDboSession(), R"(DELETE FROM cluster_type WHERE name IN ('GENRE', 'MOOD', 'LANGUAGE', 'GROUPING'))");
}
bool doDbMigration(Session& session)
{
constexpr std::string_view outdatedMsg{ "Outdated database, please rebuild it (delete the .db file and restart)" };
@@ -1857,6 +1978,7 @@ FROM track)");
{ 104, migrateFromV104 },
{ 105, migrateFromV105 },
{ 106, migrateFromV106 },
{ 107, migrateFromV107 },
};
bool migrationPerformed{};
src/libs/database/impl/Session.cpp
+13
View File
@@ -30,10 +30,14 @@
#include "database/objects/AuthToken.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Image.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Listen.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/PlayListFile.hpp"
#include "database/objects/PlayQueue.hpp"
#include "database/objects/Podcast.hpp"
@@ -81,6 +85,10 @@ namespace lms::db
_session.mapClass<AuthToken>("auth_token");
_session.mapClass<Cluster>("cluster");
_session.mapClass<ClusterType>("cluster_type");
_session.mapClass<Genre>("genre");
_session.mapClass<Grouping>("grouping");
_session.mapClass<Language>("language");
_session.mapClass<Mood>("mood");
_session.mapClass<Country>("country");
_session.mapClass<Directory>("directory");
_session.mapClass<Image>("image");
@@ -210,6 +218,11 @@ namespace lms::db
utils::executeCommand(_session, "CREATE INDEX IF NOT EXISTS cluster_cluster_type_idx ON cluster(cluster_type_id)");
utils::executeCommand(_session, "CREATE INDEX IF NOT EXISTS cluster_type_name_idx ON cluster_type(name)");
utils::executeCommand(_session, "CREATE UNIQUE INDEX IF NOT EXISTS genre_name_idx ON genre(name)");
utils::executeCommand(_session, "CREATE UNIQUE INDEX IF NOT EXISTS grouping_name_idx ON grouping(name)");
utils::executeCommand(_session, "CREATE UNIQUE INDEX IF NOT EXISTS language_name_idx ON language(name)");
utils::executeCommand(_session, "CREATE UNIQUE INDEX IF NOT EXISTS mood_name_idx ON mood(name)");
utils::executeCommand(_session, "CREATE INDEX IF NOT EXISTS country_id_idx ON country(id)");
utils::executeCommand(_session, "CREATE INDEX IF NOT EXISTS country_name_idx ON country(name COLLATE NOCASE)");
src/libs/database/impl/objects/Artist.cpp
+36
View File
@@ -26,6 +26,10 @@
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/User.hpp"
@@ -55,6 +59,10 @@ namespace lms::db
|| params.trackArtistLinkType.has_value()
|| params.track.isValid()
|| params.filters.clusters.size() == 1
|| params.filters.genre.isValid()
|| params.filters.grouping.isValid()
|| params.filters.language.isValid()
|| params.filters.mood.isValid()
|| params.filters.codec.has_value()
|| params.filters.label.isValid()
|| params.filters.releaseType.isValid())
@@ -162,6 +170,34 @@ namespace lms::db
query.where(oss.str());
}
if (params.filters.genre.isValid())
{
query.join("track_genre t_g ON t_g.track_id = t_a_l.track_id")
.where("t_g.genre_id = ?")
.bind(params.filters.genre);
}
if (params.filters.grouping.isValid())
{
query.join("track_grouping t_gr ON t_gr.track_id = t_a_l.track_id")
.where("t_gr.grouping_id = ?")
.bind(params.filters.grouping);
}
if (params.filters.language.isValid())
{
query.join("track_language t_l ON t_l.track_id = t_a_l.track_id")
.where("t_l.language_id = ?")
.bind(params.filters.language);
}
if (params.filters.mood.isValid())
{
query.join("track_mood t_m ON t_m.track_id = t_a_l.track_id")
.where("t_m.mood_id = ?")
.bind(params.filters.mood);
}
if (params.track.isValid())
query.where("t_a_l.track_id = ?").bind(params.track);
src/libs/database/impl/objects/Cluster.cpp
+4
View File
@@ -25,8 +25,12 @@
#include "database/objects/Artist.hpp"
#include "database/objects/Artwork.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
src/libs/database/impl/objects/Genre.cpp
+187
View File
@@ -0,0 +1,187 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "database/objects/Genre.hpp"
#include <Wt/Dbo/Impl.h>
#include "core/ILogger.hpp"
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
#include "database/objects/TrackEmbeddedImage.hpp"
#include "database/objects/TrackEmbeddedImageLink.hpp"
#include "database/objects/TrackLyrics.hpp"
#include "Utils.hpp"
#include "traits/IdTypeTraits.hpp"
#include "traits/StringViewTraits.hpp"
DBO_INSTANTIATE_TEMPLATES(lms::db::Genre)
namespace lms::db
{
namespace
{
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Genre::FindParameters& params)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<ResultType>("SELECT " + std::string{ itemToSelect } + " FROM genre g") };
if (params.artist.isValid() || params.track.isValid() || params.release.isValid()
|| params.sortMethod == GenreSortMethod::TrackCountDesc)
query.join("track_genre t_g ON t_g.genre_id = g.id");
if (params.track.isValid())
query.where("t_g.track_id = ?").bind(params.track);
if (params.release.isValid() || params.artist.isValid())
query.join("track t ON t.id = t_g.track_id");
if (params.release.isValid())
query.where("t.release_id = ?").bind(params.release);
if (params.artist.isValid())
{
query.join("track_artist_link t_a_l ON t_a_l.track_id = t.id");
query.where("t_a_l.artist_id = ?").bind(params.artist);
}
switch (params.sortMethod)
{
case GenreSortMethod::None:
break;
case GenreSortMethod::Name:
query.orderBy("g.name COLLATE NOCASE");
break;
case GenreSortMethod::TrackCountDesc:
query.orderBy("COUNT(t_g.track_id) DESC");
break;
}
// track_genre has a UNIQUE constraint on (track_id, genre_id), so no duplicates when filtering by track
if (!params.track.isValid())
query.groupBy("g.id");
return query;
}
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, const Genre::FindParameters& params)
{
std::string_view itemToSelect;
if constexpr (std::is_same_v<ResultType, GenreId>)
itemToSelect = "g.id";
else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Genre>>)
itemToSelect = "g";
else
static_assert("Unhandled type");
return createQuery<ResultType>(session, itemToSelect, params);
}
} // namespace
Genre::Genre(std::string_view name)
: _name{ name.substr(0, maxNameLength) }
{
LMS_LOG_IF(DB, WARNING, name.size() > maxNameLength, "Genre name too long, truncated to '" << _name << "'");
}
Genre::pointer Genre::create(Session& session, std::string_view name)
{
return session.getDboSession()->add(std::unique_ptr<Genre>{ new Genre{ name } });
}
std::size_t Genre::getCount(Session& session)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM genre"));
}
RangeResults<GenreId> Genre::findIds(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<GenreId>(session, params) };
return utils::execRangeQuery<GenreId>(query, params.range);
}
RangeResults<Genre::pointer> Genre::find(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Genre>>(session, params) };
return utils::execRangeQuery<Genre::pointer>(query, params.range);
}
void Genre::find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Genre>>(session, params) };
utils::forEachQueryRangeResult(query, params.range, func);
}
Genre::pointer Genre::find(Session& session, GenreId id)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->find<Genre>().where("id = ?").bind(id));
}
Genre::pointer Genre::find(Session& session, std::string_view name)
{
session.checkReadTransaction();
if (name.size() > maxNameLength)
name = name.substr(0, maxNameLength);
return utils::fetchQuerySingleResult(session.getDboSession()->find<Genre>().where("name = ?").bind(name));
}
RangeResults<GenreId> Genre::findOrphanIds(Session& session, std::optional<Range> range)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<GenreId>("SELECT g.id FROM genre g WHERE NOT EXISTS (SELECT 1 FROM track_genre t_g WHERE t_g.genre_id = g.id)") };
return utils::execRangeQuery<GenreId>(query, range);
}
std::size_t Genre::computeTrackCount(Session& session, GenreId id)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(t.id) FROM track t INNER JOIN track_genre t_g ON t_g.track_id = t.id").where("t_g.genre_id = ?").bind(id));
}
std::size_t Genre::computeReleaseCount(Session& session, GenreId id)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(DISTINCT t.release_id) FROM track t INNER JOIN track_genre t_g ON t_g.track_id = t.id").where("t_g.genre_id = ?").bind(id));
}
} // namespace lms::db
src/libs/database/impl/objects/Grouping.cpp
+175
View File
@@ -0,0 +1,175 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "database/objects/Grouping.hpp"
#include <Wt/Dbo/Impl.h>
#include "core/ILogger.hpp"
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
#include "database/objects/TrackEmbeddedImage.hpp"
#include "database/objects/TrackEmbeddedImageLink.hpp"
#include "database/objects/TrackLyrics.hpp"
#include "Utils.hpp"
#include "traits/IdTypeTraits.hpp"
#include "traits/StringViewTraits.hpp"
DBO_INSTANTIATE_TEMPLATES(lms::db::Grouping)
namespace lms::db
{
namespace
{
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Grouping::FindParameters& params)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<ResultType>("SELECT " + std::string{ itemToSelect } + " FROM grouping g") };
if (params.artist.isValid() || params.track.isValid() || params.release.isValid()
|| params.sortMethod == GroupingSortMethod::TrackCountDesc)
query.join("track_grouping t_gr ON t_gr.grouping_id = g.id");
if (params.track.isValid())
query.where("t_gr.track_id = ?").bind(params.track);
if (params.release.isValid() || params.artist.isValid())
query.join("track t ON t.id = t_gr.track_id");
if (params.release.isValid())
query.where("t.release_id = ?").bind(params.release);
if (params.artist.isValid())
{
query.join("track_artist_link t_a_l ON t_a_l.track_id = t.id");
query.where("t_a_l.artist_id = ?").bind(params.artist);
}
switch (params.sortMethod)
{
case GroupingSortMethod::None:
break;
case GroupingSortMethod::Name:
query.orderBy("g.name COLLATE NOCASE");
break;
case GroupingSortMethod::TrackCountDesc:
query.orderBy("COUNT(t_gr.track_id) DESC");
break;
}
// track_grouping has a UNIQUE constraint on (track_id, grouping_id), so no duplicates when filtering by track
if (!params.track.isValid())
query.groupBy("g.id");
return query;
}
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, const Grouping::FindParameters& params)
{
std::string_view itemToSelect;
if constexpr (std::is_same_v<ResultType, GroupingId>)
itemToSelect = "g.id";
else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Grouping>>)
itemToSelect = "g";
else
static_assert("Unhandled type");
return createQuery<ResultType>(session, itemToSelect, params);
}
} // namespace
Grouping::Grouping(std::string_view name)
: _name{ name.substr(0, maxNameLength) }
{
LMS_LOG_IF(DB, WARNING, name.size() > maxNameLength, "Grouping name too long, truncated to '" << _name << "'");
}
Grouping::pointer Grouping::create(Session& session, std::string_view name)
{
return session.getDboSession()->add(std::unique_ptr<Grouping>{ new Grouping{ name } });
}
std::size_t Grouping::getCount(Session& session)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM grouping"));
}
RangeResults<GroupingId> Grouping::findIds(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<GroupingId>(session, params) };
return utils::execRangeQuery<GroupingId>(query, params.range);
}
RangeResults<Grouping::pointer> Grouping::find(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Grouping>>(session, params) };
return utils::execRangeQuery<Grouping::pointer>(query, params.range);
}
void Grouping::find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Grouping>>(session, params) };
utils::forEachQueryRangeResult(query, params.range, func);
}
Grouping::pointer Grouping::find(Session& session, GroupingId id)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->find<Grouping>().where("id = ?").bind(id));
}
Grouping::pointer Grouping::find(Session& session, std::string_view name)
{
session.checkReadTransaction();
if (name.size() > maxNameLength)
name = name.substr(0, maxNameLength);
return utils::fetchQuerySingleResult(session.getDboSession()->find<Grouping>().where("name = ?").bind(name));
}
RangeResults<GroupingId> Grouping::findOrphanIds(Session& session, std::optional<Range> range)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<GroupingId>("SELECT g.id FROM grouping g WHERE NOT EXISTS (SELECT 1 FROM track_grouping t_gr WHERE t_gr.grouping_id = g.id)") };
return utils::execRangeQuery<GroupingId>(query, range);
}
} // namespace lms::db
src/libs/database/impl/objects/Language.cpp
+175
View File
@@ -0,0 +1,175 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "database/objects/Language.hpp"
#include <Wt/Dbo/Impl.h>
#include "core/ILogger.hpp"
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
#include "database/objects/TrackEmbeddedImage.hpp"
#include "database/objects/TrackEmbeddedImageLink.hpp"
#include "database/objects/TrackLyrics.hpp"
#include "Utils.hpp"
#include "traits/IdTypeTraits.hpp"
#include "traits/StringViewTraits.hpp"
DBO_INSTANTIATE_TEMPLATES(lms::db::Language)
namespace lms::db
{
namespace
{
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Language::FindParameters& params)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<ResultType>("SELECT " + std::string{ itemToSelect } + " FROM language l") };
if (params.artist.isValid() || params.track.isValid() || params.release.isValid()
|| params.sortMethod == LanguageSortMethod::TrackCountDesc)
query.join("track_language t_l ON t_l.language_id = l.id");
if (params.track.isValid())
query.where("t_l.track_id = ?").bind(params.track);
if (params.release.isValid() || params.artist.isValid())
query.join("track t ON t.id = t_l.track_id");
if (params.release.isValid())
query.where("t.release_id = ?").bind(params.release);
if (params.artist.isValid())
{
query.join("track_artist_link t_a_l ON t_a_l.track_id = t.id");
query.where("t_a_l.artist_id = ?").bind(params.artist);
}
switch (params.sortMethod)
{
case LanguageSortMethod::None:
break;
case LanguageSortMethod::Name:
query.orderBy("l.name COLLATE NOCASE");
break;
case LanguageSortMethod::TrackCountDesc:
query.orderBy("COUNT(t_l.track_id) DESC");
break;
}
// track_language has a UNIQUE constraint on (track_id, language_id), so no duplicates when filtering by track
if (!params.track.isValid())
query.groupBy("l.id");
return query;
}
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, const Language::FindParameters& params)
{
std::string_view itemToSelect;
if constexpr (std::is_same_v<ResultType, LanguageId>)
itemToSelect = "l.id";
else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Language>>)
itemToSelect = "l";
else
static_assert("Unhandled type");
return createQuery<ResultType>(session, itemToSelect, params);
}
} // namespace
Language::Language(std::string_view name)
: _name{ name.substr(0, maxNameLength) }
{
LMS_LOG_IF(DB, WARNING, name.size() > maxNameLength, "Language name too long, truncated to '" << _name << "'");
}
Language::pointer Language::create(Session& session, std::string_view name)
{
return session.getDboSession()->add(std::unique_ptr<Language>{ new Language{ name } });
}
std::size_t Language::getCount(Session& session)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM language"));
}
RangeResults<LanguageId> Language::findIds(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<LanguageId>(session, params) };
return utils::execRangeQuery<LanguageId>(query, params.range);
}
RangeResults<Language::pointer> Language::find(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Language>>(session, params) };
return utils::execRangeQuery<Language::pointer>(query, params.range);
}
void Language::find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Language>>(session, params) };
utils::forEachQueryRangeResult(query, params.range, func);
}
Language::pointer Language::find(Session& session, LanguageId id)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->find<Language>().where("id = ?").bind(id));
}
Language::pointer Language::find(Session& session, std::string_view name)
{
session.checkReadTransaction();
if (name.size() > maxNameLength)
name = name.substr(0, maxNameLength);
return utils::fetchQuerySingleResult(session.getDboSession()->find<Language>().where("name = ?").bind(name));
}
RangeResults<LanguageId> Language::findOrphanIds(Session& session, std::optional<Range> range)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<LanguageId>("SELECT l.id FROM language l WHERE NOT EXISTS (SELECT 1 FROM track_language t_l WHERE t_l.language_id = l.id)") };
return utils::execRangeQuery<LanguageId>(query, range);
}
} // namespace lms::db
src/libs/database/impl/objects/Listen.cpp
+81 -1
View File
@@ -23,6 +23,10 @@
#include <Wt/Dbo/WtSqlTraits.h>
#include "database/Session.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/User.hpp"
@@ -53,7 +57,11 @@ namespace lms::db
|| params.filters.codec.has_value()
|| params.filters.label.isValid()
|| params.filters.releaseType.isValid()
|| params.trackArtistLinkType.has_value())
|| params.trackArtistLinkType.has_value()
|| params.filters.genre.isValid()
|| params.filters.grouping.isValid()
|| params.filters.language.isValid()
|| params.filters.mood.isValid())
{
query.join("track t ON t.id = t_a_l.track_id");
@@ -74,6 +82,30 @@ namespace lms::db
query.join("release_release_type r_r_t ON r_r_t.release_id = t.release_id");
query.where("r_r_t.release_type_id = ?").bind(params.filters.releaseType);
}
if (params.filters.genre.isValid())
{
query.join("track_genre t_g ON t_g.track_id = t.id");
query.where("t_g.genre_id = ?").bind(params.filters.genre);
}
if (params.filters.grouping.isValid())
{
query.join("track_grouping t_gr ON t_gr.track_id = t.id");
query.where("t_gr.grouping_id = ?").bind(params.filters.grouping);
}
if (params.filters.language.isValid())
{
query.join("track_language t_l ON t_l.track_id = t.id");
query.where("t_l.language_id = ?").bind(params.filters.language);
}
if (params.filters.mood.isValid())
{
query.join("track_mood t_m ON t_m.track_id = t.id");
query.where("t_m.mood_id = ?").bind(params.filters.mood);
}
}
if (params.releaseArtistsOnly)
@@ -156,6 +188,30 @@ namespace lms::db
query.where("r_r_t.release_type_id = ?").bind(params.filters.releaseType);
}
if (params.filters.genre.isValid())
{
query.join("track_genre t_g ON t_g.track_id = t.id");
query.where("t_g.genre_id = ?").bind(params.filters.genre);
}
if (params.filters.grouping.isValid())
{
query.join("track_grouping t_gr ON t_gr.track_id = t.id");
query.where("t_gr.grouping_id = ?").bind(params.filters.grouping);
}
if (params.filters.language.isValid())
{
query.join("track_language t_l ON t_l.track_id = t.id");
query.where("t_l.language_id = ?").bind(params.filters.language);
}
if (params.filters.mood.isValid())
{
query.join("track_mood t_m ON t_m.track_id = t.id");
query.where("t_m.mood_id = ?").bind(params.filters.mood);
}
if (!params.filters.clusters.empty())
{
std::ostringstream oss;
@@ -215,6 +271,30 @@ namespace lms::db
query.where("r_r_t.release_type_id = ?").bind(params.filters.releaseType);
}
if (params.filters.genre.isValid())
{
query.join("track_genre t_g ON t_g.track_id = t.id");
query.where("t_g.genre_id = ?").bind(params.filters.genre);
}
if (params.filters.grouping.isValid())
{
query.join("track_grouping t_gr ON t_gr.track_id = t.id");
query.where("t_gr.grouping_id = ?").bind(params.filters.grouping);
}
if (params.filters.language.isValid())
{
query.join("track_language t_l ON t_l.track_id = t.id");
query.where("t_l.language_id = ?").bind(params.filters.language);
}
if (params.filters.mood.isValid())
{
query.join("track_mood t_m ON t_m.track_id = t.id");
query.where("t_m.mood_id = ?").bind(params.filters.mood);
}
if (!params.filters.clusters.empty())
{
std::ostringstream oss;
src/libs/database/impl/objects/MediaLibrary.cpp
+4
View File
@@ -22,6 +22,10 @@
#include <Wt/Dbo/Impl.h>
#include "database/Session.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "Utils.hpp"
src/libs/database/impl/objects/Medium.cpp
+4
View File
@@ -26,7 +26,11 @@
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
src/libs/database/impl/objects/Mood.cpp
+175
View File
@@ -0,0 +1,175 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "database/objects/Mood.hpp"
#include <Wt/Dbo/Impl.h>
#include "core/ILogger.hpp"
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
#include "database/objects/TrackEmbeddedImage.hpp"
#include "database/objects/TrackEmbeddedImageLink.hpp"
#include "database/objects/TrackLyrics.hpp"
#include "Utils.hpp"
#include "traits/IdTypeTraits.hpp"
#include "traits/StringViewTraits.hpp"
DBO_INSTANTIATE_TEMPLATES(lms::db::Mood)
namespace lms::db
{
namespace
{
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, std::string_view itemToSelect, const Mood::FindParameters& params)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<ResultType>("SELECT " + std::string{ itemToSelect } + " FROM mood m") };
if (params.artist.isValid() || params.track.isValid() || params.release.isValid()
|| params.sortMethod == MoodSortMethod::TrackCountDesc)
query.join("track_mood t_m ON t_m.mood_id = m.id");
if (params.track.isValid())
query.where("t_m.track_id = ?").bind(params.track);
if (params.release.isValid() || params.artist.isValid())
query.join("track t ON t.id = t_m.track_id");
if (params.release.isValid())
query.where("t.release_id = ?").bind(params.release);
if (params.artist.isValid())
{
query.join("track_artist_link t_a_l ON t_a_l.track_id = t.id");
query.where("t_a_l.artist_id = ?").bind(params.artist);
}
switch (params.sortMethod)
{
case MoodSortMethod::None:
break;
case MoodSortMethod::Name:
query.orderBy("m.name COLLATE NOCASE");
break;
case MoodSortMethod::TrackCountDesc:
query.orderBy("COUNT(t_m.track_id) DESC");
break;
}
// track_mood has a UNIQUE constraint on (track_id, mood_id), so no duplicates when filtering by track
if (!params.track.isValid())
query.groupBy("m.id");
return query;
}
template<typename ResultType>
Wt::Dbo::Query<ResultType> createQuery(Session& session, const Mood::FindParameters& params)
{
std::string_view itemToSelect;
if constexpr (std::is_same_v<ResultType, MoodId>)
itemToSelect = "m.id";
else if constexpr (std::is_same_v<ResultType, Wt::Dbo::ptr<Mood>>)
itemToSelect = "m";
else
static_assert("Unhandled type");
return createQuery<ResultType>(session, itemToSelect, params);
}
} // namespace
Mood::Mood(std::string_view name)
: _name{ name.substr(0, maxNameLength) }
{
LMS_LOG_IF(DB, WARNING, name.size() > maxNameLength, "Mood name too long, truncated to '" << _name << "'");
}
Mood::pointer Mood::create(Session& session, std::string_view name)
{
return session.getDboSession()->add(std::unique_ptr<Mood>{ new Mood{ name } });
}
std::size_t Mood::getCount(Session& session)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM mood"));
}
RangeResults<MoodId> Mood::findIds(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<MoodId>(session, params) };
return utils::execRangeQuery<MoodId>(query, params.range);
}
RangeResults<Mood::pointer> Mood::find(Session& session, const FindParameters& params)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Mood>>(session, params) };
return utils::execRangeQuery<Mood::pointer>(query, params.range);
}
void Mood::find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func)
{
session.checkReadTransaction();
auto query{ createQuery<Wt::Dbo::ptr<Mood>>(session, params) };
utils::forEachQueryRangeResult(query, params.range, func);
}
Mood::pointer Mood::find(Session& session, MoodId id)
{
session.checkReadTransaction();
return utils::fetchQuerySingleResult(session.getDboSession()->find<Mood>().where("id = ?").bind(id));
}
Mood::pointer Mood::find(Session& session, std::string_view name)
{
session.checkReadTransaction();
if (name.size() > maxNameLength)
name = name.substr(0, maxNameLength);
return utils::fetchQuerySingleResult(session.getDboSession()->find<Mood>().where("name = ?").bind(name));
}
RangeResults<MoodId> Mood::findOrphanIds(Session& session, std::optional<Range> range)
{
session.checkReadTransaction();
auto query{ session.getDboSession()->query<MoodId>("SELECT m.id FROM mood m WHERE NOT EXISTS (SELECT 1 FROM track_mood t_m WHERE t_m.mood_id = m.id)") };
return utils::execRangeQuery<MoodId>(query, range);
}
} // namespace lms::db
src/libs/database/impl/objects/PlayListFile.cpp
+4
View File
@@ -26,7 +26,11 @@
#include "database/Session.hpp"
#include "database/objects/Artwork.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackList.hpp"
#include "database/objects/User.hpp"
src/libs/database/impl/objects/PlayQueue.cpp
+4
View File
@@ -27,8 +27,12 @@
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
src/libs/database/impl/objects/RatedTrack.cpp
+4
View File
@@ -23,6 +23,10 @@
#include <Wt/Dbo/WtSqlTraits.h>
#include "database/Session.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/User.hpp"
src/libs/database/impl/objects/Release.cpp
+36
View File
@@ -29,8 +29,12 @@
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/ReleaseArtistLink.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackArtistLink.hpp"
@@ -77,7 +81,11 @@ namespace lms::db
|| params.originalDateRange
|| params.trackArtist.isValid()
|| params.filters.clusters.size() == 1
|| params.filters.genre.isValid()
|| params.filters.grouping.isValid()
|| params.filters.language.isValid()
|| params.filters.mediaLibrary.isValid()
|| params.filters.mood.isValid()
|| params.filters.codec.has_value()
|| params.directory.isValid()
|| params.parentDirectory.isValid())
@@ -215,6 +223,34 @@ namespace lms::db
query.where(oss.str());
}
if (params.filters.genre.isValid())
{
query.join("track_genre t_g ON t_g.track_id = t.id")
.where("t_g.genre_id = ?")
.bind(params.filters.genre);
}
if (params.filters.grouping.isValid())
{
query.join("track_grouping t_gr ON t_gr.track_id = t.id")
.where("t_gr.grouping_id = ?")
.bind(params.filters.grouping);
}
if (params.filters.language.isValid())
{
query.join("track_language t_l ON t_l.track_id = t.id")
.where("t_l.language_id = ?")
.bind(params.filters.language);
}
if (params.filters.mood.isValid())
{
query.join("track_mood t_m ON t_m.track_id = t.id")
.where("t_m.mood_id = ?")
.bind(params.filters.mood);
}
if (params.filters.codec.has_value())
query.where("t.codec = ?").bind(detail::getDbCodec(params.filters.codec.value()));
src/libs/database/impl/objects/ReleaseArtistLink.cpp
+4
View File
@@ -24,6 +24,10 @@
#include "core/ILogger.hpp"
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
src/libs/database/impl/objects/StarredTrack.cpp
+4
View File
@@ -23,6 +23,10 @@
#include <Wt/Dbo/WtSqlTraits.h>
#include "database/Session.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/User.hpp"
src/libs/database/impl/objects/Track.cpp
+116
View File
@@ -30,8 +30,12 @@
#include "database/objects/Artwork.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Medium.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/TrackArtistLink.hpp"
#include "database/objects/TrackEmbeddedImage.hpp"
@@ -109,6 +113,34 @@ namespace lms::db
query.where(oss.str());
}
if (params.filters.genre.isValid())
{
query.join("track_genre t_g ON t_g.track_id = t.id")
.where("t_g.genre_id = ?")
.bind(params.filters.genre);
}
if (params.filters.grouping.isValid())
{
query.join("track_grouping t_gr ON t_gr.track_id = t.id")
.where("t_gr.grouping_id = ?")
.bind(params.filters.grouping);
}
if (params.filters.language.isValid())
{
query.join("track_language t_l ON t_l.track_id = t.id")
.where("t_l.language_id = ?")
.bind(params.filters.language);
}
if (params.filters.mood.isValid())
{
query.join("track_mood t_m ON t_m.track_id = t.id")
.where("t_m.mood_id = ?")
.bind(params.filters.mood);
}
if (params.artist.isValid() || !params.artistName.empty())
{
query.join("artist a ON a.id = t_a_l.artist_id")
@@ -446,6 +478,62 @@ namespace lms::db
return utils::fetchQueryResults(query);
}
std::vector<Genre::pointer> Track::getGenres() const
{
return utils::fetchQueryResults<Genre::pointer>(_genres.find());
}
std::vector<GenreId> Track::getGenreIds() const
{
assert(session());
const auto query{ session()->query<GenreId>("SELECT t_g.genre_id FROM track_genre t_g").where("t_g.track_id = ?").bind(getId()) };
return utils::fetchQueryResults(query);
}
std::vector<Grouping::pointer> Track::getGroupings() const
{
return utils::fetchQueryResults<Grouping::pointer>(_groupings.find());
}
std::vector<GroupingId> Track::getGroupingIds() const
{
assert(session());
const auto query{ session()->query<GroupingId>("SELECT t_gr.grouping_id FROM track_grouping t_gr").where("t_gr.track_id = ?").bind(getId()) };
return utils::fetchQueryResults(query);
}
std::vector<Language::pointer> Track::getLanguages() const
{
return utils::fetchQueryResults<Language::pointer>(_languages.find());
}
std::vector<LanguageId> Track::getLanguageIds() const
{
assert(session());
const auto query{ session()->query<LanguageId>("SELECT t_l.language_id FROM track_language t_l").where("t_l.track_id = ?").bind(getId()) };
return utils::fetchQueryResults(query);
}
std::vector<Mood::pointer> Track::getMoods() const
{
return utils::fetchQueryResults<Mood::pointer>(_moods.find());
}
std::vector<MoodId> Track::getMoodIds() const
{
assert(session());
const auto query{ session()->query<MoodId>("SELECT t_m.mood_id FROM track_mood t_m").where("t_m.track_id = ?").bind(getId()) };
return utils::fetchQueryResults(query);
}
ObjectPtr<MediaLibrary> Track::getMediaLibrary() const
{
return _mediaLibrary;
@@ -566,6 +654,34 @@ namespace lms::db
_clusters.insert(getDboPtr(cluster));
}
void Track::setGenres(std::span<const ObjectPtr<Genre>> genres)
{
_genres.clear();
for (const ObjectPtr<Genre>& genre : genres)
_genres.insert(getDboPtr(genre));
}
void Track::setGroupings(std::span<const ObjectPtr<Grouping>> groupings)
{
_groupings.clear();
for (const ObjectPtr<Grouping>& grouping : groupings)
_groupings.insert(getDboPtr(grouping));
}
void Track::setLanguages(std::span<const ObjectPtr<Language>> languages)
{
_languages.clear();
for (const ObjectPtr<Language>& language : languages)
_languages.insert(getDboPtr(language));
}
void Track::setMoods(std::span<const ObjectPtr<Mood>> moods)
{
_moods.clear();
for (const ObjectPtr<Mood>& mood : moods)
_moods.insert(getDboPtr(mood));
}
void Track::clearLyrics()
{
_trackLyrics.clear();
src/libs/database/impl/objects/TrackArtistLink.cpp
+4
View File
@@ -24,6 +24,10 @@
#include "core/ILogger.hpp"
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "Utils.hpp"
src/libs/database/impl/objects/TrackBookmark.cpp
+4
View File
@@ -22,6 +22,10 @@
#include <Wt/Dbo/Impl.h>
#include "database/Session.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/User.hpp"
src/libs/database/impl/objects/TrackEmbeddedImage.cpp
+4
View File
@@ -23,6 +23,10 @@
#include "database/Session.hpp"
#include "database/Types.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackEmbeddedImageLink.hpp"
src/libs/database/impl/objects/TrackEmbeddedImageLink.cpp
+4
View File
@@ -23,6 +23,10 @@
#include <Wt/Dbo/WtSqlTraits.h>
#include "database/Session.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/TrackEmbeddedImage.hpp"
src/libs/database/impl/objects/TrackList.cpp
+4
View File
@@ -25,6 +25,10 @@
#include "database/Session.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/PlayListFile.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/User.hpp"
src/libs/database/impl/objects/TrackLyrics.cpp
+4
View File
@@ -25,6 +25,10 @@
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Directory.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
src/libs/database/impl/objects/TrackMusicNNEmbeddings.cpp
+4
View File
@@ -22,6 +22,10 @@
#include <Wt/Dbo/Impl.h>
#include "database/Session.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Track.hpp"
#include "Utils.hpp"
src/libs/database/impl/objects/User.cpp
+4
View File
@@ -27,6 +27,10 @@
#include "database/Session.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/AuthToken.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/Track.hpp"
#include "database/objects/UIState.hpp"
src/libs/database/include/database/objects/Cluster.hpp
-10
View File
@@ -104,21 +104,13 @@ namespace lms::db
// Accessors
std::string_view getName() const { return _name; }
ObjectPtr<ClusterType> getType() const { return _clusterType; }
std::size_t getTrackCount() const { return _trackCount; }
RangeResults<TrackId> getTracks(std::optional<Range> range = std::nullopt) const;
std::size_t getReleasesCount() const { return _releaseCount; };
void setReleaseCount(std::size_t releaseCount) { _releaseCount = releaseCount; }
void setTrackCount(std::size_t trackCount) { _trackCount = trackCount; }
void addTrack(ObjectPtr<Track> track);
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _name, "name");
// cached field since queries are too long
Wt::Dbo::field(a, _trackCount, "track_count");
Wt::Dbo::field(a, _releaseCount, "release_count");
Wt::Dbo::belongsTo(a, _clusterType, "cluster_type", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToMany, "track_cluster", "", Wt::Dbo::OnDeleteCascade);
@@ -130,8 +122,6 @@ namespace lms::db
static pointer create(Session& session, ObjectPtr<ClusterType> type, std::string_view name);
std::string _name;
int _trackCount{};
int _releaseCount{};
Wt::Dbo::ptr<ClusterType> _clusterType;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks;
src/libs/database/include/database/objects/Filters.hpp
+28
View File
@@ -26,8 +26,12 @@
#include "core/media/Codec.hpp"
#include "database/objects/ClusterId.hpp"
#include "database/objects/GenreId.hpp"
#include "database/objects/GroupingId.hpp"
#include "database/objects/LabelId.hpp"
#include "database/objects/LanguageId.hpp"
#include "database/objects/MediaLibraryId.hpp"
#include "database/objects/MoodId.hpp"
#include "database/objects/ReleaseTypeId.hpp"
namespace lms::db
@@ -36,7 +40,11 @@ namespace lms::db
{
MediaLibraryId mediaLibrary; // tracks that belongs to this library
std::vector<ClusterId> clusters; // tracks that belong to *all* these clusters
GenreId genre; // tracks that belong to this genre
GroupingId grouping; // tracks that belong to this grouping
LabelId label; // tracks which release has this label
LanguageId language; // tracks that belong to this language
MoodId mood; // tracks that belong to this mood
ReleaseTypeId releaseType; // tracks which release has this type
std::optional<core::media::Codec> codec; // tracks that match this codec
@@ -45,6 +53,26 @@ namespace lms::db
clusters.assign(std::cbegin(_clusters), std::cend(_clusters));
return *this;
}
Filters& setGenre(GenreId _genre)
{
genre = _genre;
return *this;
}
Filters& setGrouping(GroupingId _grouping)
{
grouping = _grouping;
return *this;
}
Filters& setLanguage(LanguageId _language)
{
language = _language;
return *this;
}
Filters& setMood(MoodId _mood)
{
mood = _mood;
return *this;
}
Filters& setMediaLibrary(MediaLibraryId _mediaLibrary)
{
mediaLibrary = _mediaLibrary;
src/libs/database/include/database/objects/Genre.hpp
+123
View File
@@ -0,0 +1,123 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <optional>
#include <string>
#include <string_view>
#include <Wt/Dbo/Field.h>
#include <Wt/Dbo/collection.h>
#include "database/Object.hpp"
#include "database/Types.hpp"
#include "database/objects/ArtistId.hpp"
#include "database/objects/GenreId.hpp"
#include "database/objects/ReleaseId.hpp"
#include "database/objects/TrackId.hpp"
#include "database/objects/Types.hpp"
namespace lms::db
{
class Session;
class Track;
class Genre final : public Object<Genre, GenreId>
{
public:
static constexpr std::size_t maxNameLength{ 512 };
struct FindParameters
{
std::optional<Range> range;
GenreSortMethod sortMethod{ GenreSortMethod::None };
ArtistId artist; // if set, genres of tracks by this artist
TrackId track; // if set, genres of this track
ReleaseId release; // if set, genres involved in this release
FindParameters& setRange(std::optional<Range> _range)
{
range = _range;
return *this;
}
FindParameters& setSortMethod(GenreSortMethod _method)
{
sortMethod = _method;
return *this;
}
FindParameters& setTrack(TrackId _track)
{
track = _track;
return *this;
}
FindParameters& setArtist(ArtistId _artist)
{
artist = _artist;
return *this;
}
FindParameters& setRelease(ReleaseId _release)
{
release = _release;
return *this;
}
};
Genre() = default;
static std::size_t getCount(Session& session);
static RangeResults<GenreId> findIds(Session& session, const FindParameters& params);
static RangeResults<pointer> find(Session& session, const FindParameters& params);
static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
static pointer find(Session& session, GenreId id);
static pointer find(Session& session, std::string_view name);
static RangeResults<GenreId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
static std::size_t computeTrackCount(Session& session, GenreId id);
static std::size_t computeReleaseCount(Session& session, GenreId id);
std::string_view getName() const { return _name; }
std::size_t getTrackCount() const { return _trackCount; }
std::size_t getReleaseCount() const { return _releaseCount; }
void setTrackCount(std::size_t count) { _trackCount = count; }
void setReleaseCount(std::size_t count) { _releaseCount = count; }
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _name, "name");
Wt::Dbo::field(a, _trackCount, "track_count");
Wt::Dbo::field(a, _releaseCount, "release_count");
Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToMany, "track_genre", "", Wt::Dbo::OnDeleteCascade);
}
private:
friend class Session;
Genre(std::string_view name);
static pointer create(Session& session, std::string_view name);
std::string _name;
int _trackCount{};
int _releaseCount{};
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks;
};
} // namespace lms::db
src/libs/database/include/database/objects/GenreId.hpp
+24
View File
@@ -0,0 +1,24 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "database/IdType.hpp"
LMS_DECLARE_IDTYPE(GenreId)
src/libs/database/include/database/objects/Grouping.hpp
+110
View File
@@ -0,0 +1,110 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <optional>
#include <string>
#include <string_view>
#include <Wt/Dbo/Field.h>
#include <Wt/Dbo/collection.h>
#include "database/Object.hpp"
#include "database/Types.hpp"
#include "database/objects/ArtistId.hpp"
#include "database/objects/GroupingId.hpp"
#include "database/objects/ReleaseId.hpp"
#include "database/objects/TrackId.hpp"
#include "database/objects/Types.hpp"
namespace lms::db
{
class Session;
class Track;
class Grouping final : public Object<Grouping, GroupingId>
{
public:
static constexpr std::size_t maxNameLength{ 512 };
struct FindParameters
{
std::optional<Range> range;
GroupingSortMethod sortMethod{ GroupingSortMethod::None };
ArtistId artist; // if set, groupings of tracks by this artist
TrackId track; // if set, groupings of this track
ReleaseId release; // if set, groupings involved in this release
FindParameters& setRange(std::optional<Range> _range)
{
range = _range;
return *this;
}
FindParameters& setSortMethod(GroupingSortMethod _method)
{
sortMethod = _method;
return *this;
}
FindParameters& setTrack(TrackId _track)
{
track = _track;
return *this;
}
FindParameters& setArtist(ArtistId _artist)
{
artist = _artist;
return *this;
}
FindParameters& setRelease(ReleaseId _release)
{
release = _release;
return *this;
}
};
Grouping() = default;
static std::size_t getCount(Session& session);
static RangeResults<GroupingId> findIds(Session& session, const FindParameters& params);
static RangeResults<pointer> find(Session& session, const FindParameters& params);
static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
static pointer find(Session& session, GroupingId id);
static pointer find(Session& session, std::string_view name);
static RangeResults<GroupingId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
std::string_view getName() const { return _name; }
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _name, "name");
Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToMany, "track_grouping", "", Wt::Dbo::OnDeleteCascade);
}
private:
friend class Session;
Grouping(std::string_view name);
static pointer create(Session& session, std::string_view name);
std::string _name;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks;
};
} // namespace lms::db
src/libs/database/include/database/objects/GroupingId.hpp
+24
View File
@@ -0,0 +1,24 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "database/IdType.hpp"
LMS_DECLARE_IDTYPE(GroupingId)
src/libs/database/include/database/objects/Language.hpp
+110
View File
@@ -0,0 +1,110 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <optional>
#include <string>
#include <string_view>
#include <Wt/Dbo/Field.h>
#include <Wt/Dbo/collection.h>
#include "database/Object.hpp"
#include "database/Types.hpp"
#include "database/objects/ArtistId.hpp"
#include "database/objects/LanguageId.hpp"
#include "database/objects/ReleaseId.hpp"
#include "database/objects/TrackId.hpp"
#include "database/objects/Types.hpp"
namespace lms::db
{
class Session;
class Track;
class Language final : public Object<Language, LanguageId>
{
public:
static constexpr std::size_t maxNameLength{ 512 };
struct FindParameters
{
std::optional<Range> range;
LanguageSortMethod sortMethod{ LanguageSortMethod::None };
ArtistId artist; // if set, languages of tracks by this artist
TrackId track; // if set, languages of this track
ReleaseId release; // if set, languages involved in this release
FindParameters& setRange(std::optional<Range> _range)
{
range = _range;
return *this;
}
FindParameters& setSortMethod(LanguageSortMethod _method)
{
sortMethod = _method;
return *this;
}
FindParameters& setTrack(TrackId _track)
{
track = _track;
return *this;
}
FindParameters& setArtist(ArtistId _artist)
{
artist = _artist;
return *this;
}
FindParameters& setRelease(ReleaseId _release)
{
release = _release;
return *this;
}
};
Language() = default;
static std::size_t getCount(Session& session);
static RangeResults<LanguageId> findIds(Session& session, const FindParameters& params);
static RangeResults<pointer> find(Session& session, const FindParameters& params);
static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
static pointer find(Session& session, LanguageId id);
static pointer find(Session& session, std::string_view name);
static RangeResults<LanguageId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
std::string_view getName() const { return _name; }
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _name, "name");
Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToMany, "track_language", "", Wt::Dbo::OnDeleteCascade);
}
private:
friend class Session;
Language(std::string_view name);
static pointer create(Session& session, std::string_view name);
std::string _name;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks;
};
} // namespace lms::db
src/libs/database/include/database/objects/LanguageId.hpp
+24
View File
@@ -0,0 +1,24 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "database/IdType.hpp"
LMS_DECLARE_IDTYPE(LanguageId)
src/libs/database/include/database/objects/Mood.hpp
+110
View File
@@ -0,0 +1,110 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <optional>
#include <string>
#include <string_view>
#include <Wt/Dbo/Field.h>
#include <Wt/Dbo/collection.h>
#include "database/Object.hpp"
#include "database/Types.hpp"
#include "database/objects/ArtistId.hpp"
#include "database/objects/MoodId.hpp"
#include "database/objects/ReleaseId.hpp"
#include "database/objects/TrackId.hpp"
#include "database/objects/Types.hpp"
namespace lms::db
{
class Session;
class Track;
class Mood final : public Object<Mood, MoodId>
{
public:
static constexpr std::size_t maxNameLength{ 512 };
struct FindParameters
{
std::optional<Range> range;
MoodSortMethod sortMethod{ MoodSortMethod::None };
ArtistId artist; // if set, moods of tracks by this artist
TrackId track; // if set, moods of this track
ReleaseId release; // if set, moods involved in this release
FindParameters& setRange(std::optional<Range> _range)
{
range = _range;
return *this;
}
FindParameters& setSortMethod(MoodSortMethod _method)
{
sortMethod = _method;
return *this;
}
FindParameters& setTrack(TrackId _track)
{
track = _track;
return *this;
}
FindParameters& setArtist(ArtistId _artist)
{
artist = _artist;
return *this;
}
FindParameters& setRelease(ReleaseId _release)
{
release = _release;
return *this;
}
};
Mood() = default;
static std::size_t getCount(Session& session);
static RangeResults<MoodId> findIds(Session& session, const FindParameters& params);
static RangeResults<pointer> find(Session& session, const FindParameters& params);
static void find(Session& session, const FindParameters& params, std::function<void(const pointer&)> func);
static pointer find(Session& session, MoodId id);
static pointer find(Session& session, std::string_view name);
static RangeResults<MoodId> findOrphanIds(Session& session, std::optional<Range> range = std::nullopt);
std::string_view getName() const { return _name; }
template<class Action>
void persist(Action& a)
{
Wt::Dbo::field(a, _name, "name");
Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToMany, "track_mood", "", Wt::Dbo::OnDeleteCascade);
}
private:
friend class Session;
Mood(std::string_view name);
static pointer create(Session& session, std::string_view name);
std::string _name;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks;
};
} // namespace lms::db
src/libs/database/include/database/objects/MoodId.hpp
+24
View File
@@ -0,0 +1,24 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "database/IdType.hpp"
LMS_DECLARE_IDTYPE(MoodId)
src/libs/database/include/database/objects/Track.hpp
+28
View File
@@ -45,8 +45,12 @@
#include "database/objects/ClusterId.hpp"
#include "database/objects/DirectoryId.hpp"
#include "database/objects/Filters.hpp"
#include "database/objects/GenreId.hpp"
#include "database/objects/GroupingId.hpp"
#include "database/objects/LanguageId.hpp"
#include "database/objects/MediaLibraryId.hpp"
#include "database/objects/MediumId.hpp"
#include "database/objects/MoodId.hpp"
#include "database/objects/ReleaseId.hpp"
#include "database/objects/TrackEmbeddedImageId.hpp"
#include "database/objects/TrackId.hpp"
@@ -62,6 +66,10 @@ namespace lms::db
class Cluster;
class ClusterType;
class Directory;
class Genre;
class Grouping;
class Language;
class Mood;
class TrackEmbeddedImageLink;
class MediaLibrary;
class Medium;
@@ -270,6 +278,10 @@ namespace lms::db
void setRelease(ObjectPtr<Release> release) { _release = getDboPtr(release); }
void setMedium(ObjectPtr<Medium> medium) { _medium = getDboPtr(medium); }
void setClusters(const std::vector<ObjectPtr<Cluster>>& clusters);
void setGenres(std::span<const ObjectPtr<Genre>> genres);
void setGroupings(std::span<const ObjectPtr<Grouping>> groupings);
void setLanguages(std::span<const ObjectPtr<Language>> languages);
void setMoods(std::span<const ObjectPtr<Mood>> moods);
void clearLyrics();
void clearEmbeddedLyrics();
void addLyrics(const ObjectPtr<TrackLyrics>& lyrics);
@@ -330,6 +342,14 @@ namespace lms::db
ObjectPtr<Medium> getMedium() const { return _medium; }
std::vector<ObjectPtr<Cluster>> getClusters() const;
std::vector<ClusterId> getClusterIds() const;
std::vector<ObjectPtr<Genre>> getGenres() const;
std::vector<GenreId> getGenreIds() const;
std::vector<ObjectPtr<Grouping>> getGroupings() const;
std::vector<GroupingId> getGroupingIds() const;
std::vector<ObjectPtr<Language>> getLanguages() const;
std::vector<LanguageId> getLanguageIds() const;
std::vector<ObjectPtr<Mood>> getMoods() const;
std::vector<MoodId> getMoodIds() const;
ObjectPtr<MediaLibrary> getMediaLibrary() const;
ObjectPtr<Directory> getDirectory() const;
ObjectPtr<Artwork> getPreferredArtwork() const;
@@ -378,6 +398,10 @@ namespace lms::db
Wt::Dbo::belongsTo(a, _preferredMediaArtwork, "preferred_media_artwork", Wt::Dbo::OnDeleteSetNull);
Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "track");
Wt::Dbo::hasMany(a, _clusters, Wt::Dbo::ManyToMany, "track_cluster", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _genres, Wt::Dbo::ManyToMany, "track_genre", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _groupings, Wt::Dbo::ManyToMany, "track_grouping", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _languages, Wt::Dbo::ManyToMany, "track_language", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _moods, Wt::Dbo::ManyToMany, "track_mood", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _trackLyrics, Wt::Dbo::ManyToOne, "track");
Wt::Dbo::hasMany(a, _embeddedImageLinks, Wt::Dbo::ManyToOne, "track");
}
@@ -429,6 +453,10 @@ namespace lms::db
Wt::Dbo::ptr<Artwork> _preferredMediaArtwork;
Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks;
Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> _clusters;
Wt::Dbo::collection<Wt::Dbo::ptr<Genre>> _genres;
Wt::Dbo::collection<Wt::Dbo::ptr<Grouping>> _groupings;
Wt::Dbo::collection<Wt::Dbo::ptr<Language>> _languages;
Wt::Dbo::collection<Wt::Dbo::ptr<Mood>> _moods;
Wt::Dbo::collection<Wt::Dbo::ptr<TrackLyrics>> _trackLyrics;
Wt::Dbo::collection<Wt::Dbo::ptr<TrackEmbeddedImageLink>> _embeddedImageLinks;
};
src/libs/database/include/database/objects/Types.hpp
+28
View File
@@ -65,6 +65,20 @@ namespace lms::db
Name,
};
enum class GenreSortMethod
{
None,
Name,
TrackCountDesc,
};
enum class GroupingSortMethod
{
None,
Name,
TrackCountDesc,
};
using ImageHashType = core::TaggedType<class ImageHash, std::uint64_t>;
enum class LabelSortMethod
@@ -73,6 +87,20 @@ namespace lms::db
Name,
};
enum class LanguageSortMethod
{
None,
Name,
TrackCountDesc,
};
enum class MoodSortMethod
{
None,
Name,
TrackCountDesc,
};
enum class MediumSortMethod
{
None,
src/libs/database/test/CMakeLists.txt
+4
View File
@@ -8,10 +8,14 @@ add_executable(test-database
Common.cpp
DatabaseTest.cpp
Directory.cpp
Genre.cpp
Grouping.cpp
Image.cpp
Language.cpp
Listen.cpp
Medium.cpp
Migration.cpp
Mood.cpp
PlayListFile.cpp
Podcast.cpp
RatedArtist.cpp
src/libs/database/test/Common.cpp
-2
View File
@@ -59,8 +59,6 @@ namespace lms::db::tests
void DatabaseFixture::testDatabaseEmpty()
{
using namespace db;
auto transaction{ session.createReadTransaction() };
EXPECT_TRUE(session.areAllTablesEmpty());
src/libs/database/test/Common.hpp
+4
View File
@@ -29,8 +29,12 @@
#include "database/Types.hpp"
#include "database/objects/Artist.hpp"
#include "database/objects/Cluster.hpp"
#include "database/objects/Genre.hpp"
#include "database/objects/Grouping.hpp"
#include "database/objects/Language.hpp"
#include "database/objects/Listen.hpp"
#include "database/objects/MediaLibrary.hpp"
#include "database/objects/Mood.hpp"
#include "database/objects/Release.hpp"
#include "database/objects/ScanSettings.hpp"
#include "database/objects/Track.hpp"
src/libs/database/test/Genre.cpp
+233
View File
@@ -0,0 +1,233 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
namespace lms::db::tests
{
using ScopedGenre = ScopedEntity<db::Genre>;
TEST_F(DatabaseFixture, Genre_create)
{
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Genre::getCount(session), 0);
}
ScopedGenre genre{ session, "Rock" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Genre::getCount(session), 1);
const Genre::pointer found{ Genre::find(session, genre.getId()) };
ASSERT_TRUE(found);
EXPECT_EQ(found->getName(), "Rock");
EXPECT_EQ(found->getTrackCount(), 0);
EXPECT_EQ(found->getReleaseCount(), 0);
}
}
TEST_F(DatabaseFixture, Genre_findByName)
{
ScopedGenre genre{ session, "Jazz" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_TRUE(Genre::find(session, "Jazz"));
EXPECT_FALSE(Genre::find(session, "jazz"));
EXPECT_FALSE(Genre::find(session, ""));
EXPECT_FALSE(Genre::find(session, "Jaz"));
}
}
TEST_F(DatabaseFixture, Genre_orphan)
{
ScopedGenre genre{ session, "Blues" };
{
auto transaction{ session.createReadTransaction() };
const auto orphans{ Genre::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), genre.getId());
}
}
TEST_F(DatabaseFixture, Genre_singleTrack)
{
ScopedTrack track{ session };
ScopedGenre genre1{ session, "Metal" };
ScopedGenre genre2{ session, "Punk" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Genre::findOrphanIds(session).results.size(), 2);
EXPECT_EQ(track->getGenres().size(), 0);
EXPECT_EQ(track->getGenreIds().size(), 0);
EXPECT_EQ(Genre::computeTrackCount(session, genre1.getId()), 0);
EXPECT_EQ(Genre::computeTrackCount(session, genre2.getId()), 0);
}
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setGenres(std::array{ genre1.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto genres{ Genre::findIds(session, Genre::FindParameters{}.setTrack(track.getId())) };
ASSERT_EQ(genres.results.size(), 1);
EXPECT_EQ(genres.results.front(), genre1.getId());
EXPECT_EQ(Genre::computeTrackCount(session, genre1.getId()), 1);
EXPECT_EQ(Genre::computeTrackCount(session, genre2.getId()), 0);
const auto orphans{ Genre::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), genre2.getId());
const auto trackGenres{ track->getGenres() };
ASSERT_EQ(trackGenres.size(), 1);
EXPECT_EQ(trackGenres.front()->getId(), genre1.getId());
const auto trackGenreIds{ track->getGenreIds() };
ASSERT_EQ(trackGenreIds.size(), 1);
EXPECT_EQ(trackGenreIds.front(), genre1.getId());
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre2.getId()))) };
EXPECT_EQ(tracks2.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Genre_multipleGenresOnTrack)
{
ScopedTrack track{ session };
ScopedGenre genre1{ session, "Electronic" };
ScopedGenre genre2{ session, "Ambient" };
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setGenres(std::array{ genre1.get(), genre2.get() });
}
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Genre::computeTrackCount(session, genre1.getId()), 1);
EXPECT_EQ(Genre::computeTrackCount(session, genre2.getId()), 1);
EXPECT_EQ(Genre::findOrphanIds(session).results.size(), 0);
const auto trackGenres{ track->getGenres() };
EXPECT_EQ(trackGenres.size(), 2);
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre2.getId()))) };
ASSERT_EQ(tracks2.results.size(), 1);
EXPECT_EQ(tracks2.results.front(), track.getId());
}
}
TEST_F(DatabaseFixture, Genre_computeReleaseCount)
{
ScopedRelease release{ session, "MyRelease" };
ScopedTrack track{ session };
ScopedGenre genre{ session, "Classical" };
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setRelease(release.get());
track.get().modify()->setGenres(std::array{ genre.get() });
}
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Genre::computeTrackCount(session, genre.getId()), 1);
EXPECT_EQ(Genre::computeReleaseCount(session, genre.getId()), 1);
}
}
TEST_F(DatabaseFixture, Genre_nameTruncation)
{
const std::string longName(Genre::maxNameLength + 100, 'x');
const std::string expectedName(Genre::maxNameLength, 'x');
{
auto transaction{ session.createWriteTransaction() };
Genre::pointer genre{ session.create<Genre>(longName) };
ASSERT_TRUE(genre);
EXPECT_EQ(genre->getName().size(), Genre::maxNameLength);
EXPECT_EQ(genre->getName(), expectedName);
genre.remove();
}
}
TEST_F(DatabaseFixture, Genre_sortByName)
{
ScopedGenre g1{ session, "Zzz" };
ScopedGenre g2{ session, "Aaa" };
ScopedGenre g3{ session, "Mmm" };
{
auto transaction{ session.createReadTransaction() };
const auto genres{ Genre::findIds(session, Genre::FindParameters{}.setSortMethod(GenreSortMethod::Name)) };
ASSERT_EQ(genres.results.size(), 3);
EXPECT_EQ(genres.results[0], g2.getId());
EXPECT_EQ(genres.results[1], g3.getId());
EXPECT_EQ(genres.results[2], g1.getId());
}
}
TEST_F(DatabaseFixture, Genre_sortByTrackCount)
{
ScopedGenre g1{ session, "Rock" };
ScopedGenre g2{ session, "Jazz" };
ScopedTrack track1{ session };
ScopedTrack track2{ session };
ScopedTrack track3{ session };
{
auto transaction{ session.createWriteTransaction() };
track1.get().modify()->setGenres(std::array{ g1.get() });
track2.get().modify()->setGenres(std::array{ g1.get() });
track3.get().modify()->setGenres(std::array{ g2.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto genres{ Genre::findIds(session, Genre::FindParameters{}.setSortMethod(GenreSortMethod::TrackCountDesc)) };
ASSERT_EQ(genres.results.size(), 2);
EXPECT_EQ(genres.results[0], g1.getId());
EXPECT_EQ(genres.results[1], g2.getId());
}
}
} // namespace lms::db::tests
src/libs/database/test/Grouping.cpp
+190
View File
@@ -0,0 +1,190 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
namespace lms::db::tests
{
using ScopedGrouping = ScopedEntity<db::Grouping>;
TEST_F(DatabaseFixture, Grouping_create)
{
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Grouping::getCount(session), 0);
}
ScopedGrouping grouping{ session, "Soundtrack" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Grouping::getCount(session), 1);
const Grouping::pointer found{ Grouping::find(session, grouping.getId()) };
ASSERT_TRUE(found);
EXPECT_EQ(found->getName(), "Soundtrack");
}
}
TEST_F(DatabaseFixture, Grouping_findByName)
{
ScopedGrouping grouping{ session, "Live" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_TRUE(Grouping::find(session, "Live"));
EXPECT_FALSE(Grouping::find(session, "live"));
EXPECT_FALSE(Grouping::find(session, ""));
EXPECT_FALSE(Grouping::find(session, "Liv"));
}
}
TEST_F(DatabaseFixture, Grouping_orphan)
{
ScopedGrouping grouping{ session, "Podcast" };
{
auto transaction{ session.createReadTransaction() };
const auto orphans{ Grouping::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), grouping.getId());
}
}
TEST_F(DatabaseFixture, Grouping_singleTrack)
{
ScopedTrack track{ session };
ScopedGrouping grouping1{ session, "Audiobook" };
ScopedGrouping grouping2{ session, "Remix" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Grouping::findOrphanIds(session).results.size(), 2);
EXPECT_EQ(track->getGroupings().size(), 0);
EXPECT_EQ(track->getGroupingIds().size(), 0);
}
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setGroupings(std::array{ grouping1.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto groupings{ Grouping::findIds(session, Grouping::FindParameters{}.setTrack(track.getId())) };
ASSERT_EQ(groupings.results.size(), 1);
EXPECT_EQ(groupings.results.front(), grouping1.getId());
const auto orphans{ Grouping::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), grouping2.getId());
const auto trackGroupings{ track->getGroupings() };
ASSERT_EQ(trackGroupings.size(), 1);
EXPECT_EQ(trackGroupings.front()->getId(), grouping1.getId());
const auto trackGroupingIds{ track->getGroupingIds() };
ASSERT_EQ(trackGroupingIds.size(), 1);
EXPECT_EQ(trackGroupingIds.front(), grouping1.getId());
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping2.getId()))) };
EXPECT_EQ(tracks2.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Grouping_multipleGroupingsOnTrack)
{
ScopedTrack track{ session };
ScopedGrouping grouping1{ session, "Soundtrack" };
ScopedGrouping grouping2{ session, "Live" };
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setGroupings(std::array{ grouping1.get(), grouping2.get() });
}
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Grouping::findOrphanIds(session).results.size(), 0);
const auto trackGroupings{ track->getGroupings() };
EXPECT_EQ(trackGroupings.size(), 2);
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGrouping(grouping2.getId()))) };
ASSERT_EQ(tracks2.results.size(), 1);
EXPECT_EQ(tracks2.results.front(), track.getId());
}
}
TEST_F(DatabaseFixture, Grouping_sortByName)
{
ScopedGrouping g1{ session, "Zzz" };
ScopedGrouping g2{ session, "Aaa" };
ScopedGrouping g3{ session, "Mmm" };
{
auto transaction{ session.createReadTransaction() };
const auto groupings{ Grouping::findIds(session, Grouping::FindParameters{}.setSortMethod(GroupingSortMethod::Name)) };
ASSERT_EQ(groupings.results.size(), 3);
EXPECT_EQ(groupings.results[0], g2.getId());
EXPECT_EQ(groupings.results[1], g3.getId());
EXPECT_EQ(groupings.results[2], g1.getId());
}
}
TEST_F(DatabaseFixture, Grouping_sortByTrackCount)
{
ScopedGrouping g1{ session, "Compilation" };
ScopedGrouping g2{ session, "Live" };
ScopedTrack track1{ session };
ScopedTrack track2{ session };
ScopedTrack track3{ session };
{
auto transaction{ session.createWriteTransaction() };
track1.get().modify()->setGroupings(std::array{ g1.get() });
track2.get().modify()->setGroupings(std::array{ g1.get() });
track3.get().modify()->setGroupings(std::array{ g2.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto groupings{ Grouping::findIds(session, Grouping::FindParameters{}.setSortMethod(GroupingSortMethod::TrackCountDesc)) };
ASSERT_EQ(groupings.results.size(), 2);
EXPECT_EQ(groupings.results[0], g1.getId());
EXPECT_EQ(groupings.results[1], g2.getId());
}
}
} // namespace lms::db::tests
src/libs/database/test/Language.cpp
+190
View File
@@ -0,0 +1,190 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
namespace lms::db::tests
{
using ScopedLanguage = ScopedEntity<db::Language>;
TEST_F(DatabaseFixture, Language_create)
{
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Language::getCount(session), 0);
}
ScopedLanguage language{ session, "eng" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Language::getCount(session), 1);
const Language::pointer found{ Language::find(session, language.getId()) };
ASSERT_TRUE(found);
EXPECT_EQ(found->getName(), "eng");
}
}
TEST_F(DatabaseFixture, Language_findByName)
{
ScopedLanguage language{ session, "fra" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_TRUE(Language::find(session, "fra"));
EXPECT_FALSE(Language::find(session, "FRA"));
EXPECT_FALSE(Language::find(session, ""));
EXPECT_FALSE(Language::find(session, "fr"));
}
}
TEST_F(DatabaseFixture, Language_orphan)
{
ScopedLanguage language{ session, "jpn" };
{
auto transaction{ session.createReadTransaction() };
const auto orphans{ Language::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), language.getId());
}
}
TEST_F(DatabaseFixture, Language_singleTrack)
{
ScopedTrack track{ session };
ScopedLanguage language1{ session, "eng" };
ScopedLanguage language2{ session, "spa" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Language::findOrphanIds(session).results.size(), 2);
EXPECT_EQ(track->getLanguages().size(), 0);
EXPECT_EQ(track->getLanguageIds().size(), 0);
}
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setLanguages(std::array{ language1.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto languages{ Language::findIds(session, Language::FindParameters{}.setTrack(track.getId())) };
ASSERT_EQ(languages.results.size(), 1);
EXPECT_EQ(languages.results.front(), language1.getId());
const auto orphans{ Language::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), language2.getId());
const auto trackLanguages{ track->getLanguages() };
ASSERT_EQ(trackLanguages.size(), 1);
EXPECT_EQ(trackLanguages.front()->getId(), language1.getId());
const auto trackLanguageIds{ track->getLanguageIds() };
ASSERT_EQ(trackLanguageIds.size(), 1);
EXPECT_EQ(trackLanguageIds.front(), language1.getId());
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language2.getId()))) };
EXPECT_EQ(tracks2.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Language_multipleLanguagesOnTrack)
{
ScopedTrack track{ session };
ScopedLanguage language1{ session, "eng" };
ScopedLanguage language2{ session, "fra" };
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setLanguages(std::array{ language1.get(), language2.get() });
}
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Language::findOrphanIds(session).results.size(), 0);
const auto trackLanguages{ track->getLanguages() };
EXPECT_EQ(trackLanguages.size(), 2);
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setLanguage(language2.getId()))) };
ASSERT_EQ(tracks2.results.size(), 1);
EXPECT_EQ(tracks2.results.front(), track.getId());
}
}
TEST_F(DatabaseFixture, Language_sortByName)
{
ScopedLanguage l1{ session, "zho" };
ScopedLanguage l2{ session, "ara" };
ScopedLanguage l3{ session, "por" };
{
auto transaction{ session.createReadTransaction() };
const auto languages{ Language::findIds(session, Language::FindParameters{}.setSortMethod(LanguageSortMethod::Name)) };
ASSERT_EQ(languages.results.size(), 3);
EXPECT_EQ(languages.results[0], l2.getId());
EXPECT_EQ(languages.results[1], l3.getId());
EXPECT_EQ(languages.results[2], l1.getId());
}
}
TEST_F(DatabaseFixture, Language_sortByTrackCount)
{
ScopedLanguage l1{ session, "eng" };
ScopedLanguage l2{ session, "fra" };
ScopedTrack track1{ session };
ScopedTrack track2{ session };
ScopedTrack track3{ session };
{
auto transaction{ session.createWriteTransaction() };
track1.get().modify()->setLanguages(std::array{ l1.get() });
track2.get().modify()->setLanguages(std::array{ l1.get() });
track3.get().modify()->setLanguages(std::array{ l2.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto languages{ Language::findIds(session, Language::FindParameters{}.setSortMethod(LanguageSortMethod::TrackCountDesc)) };
ASSERT_EQ(languages.results.size(), 2);
EXPECT_EQ(languages.results[0], l1.getId());
EXPECT_EQ(languages.results[1], l2.getId());
}
}
} // namespace lms::db::tests
src/libs/database/test/Mood.cpp
+190
View File
@@ -0,0 +1,190 @@
/*
* Copyright (C) 2025 Emeric Poupon
*
* This file is part of LMS.
*
* LMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Common.hpp"
namespace lms::db::tests
{
using ScopedMood = ScopedEntity<db::Mood>;
TEST_F(DatabaseFixture, Mood_create)
{
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Mood::getCount(session), 0);
}
ScopedMood mood{ session, "Happy" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Mood::getCount(session), 1);
const Mood::pointer found{ Mood::find(session, mood.getId()) };
ASSERT_TRUE(found);
EXPECT_EQ(found->getName(), "Happy");
}
}
TEST_F(DatabaseFixture, Mood_findByName)
{
ScopedMood mood{ session, "Chill" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_TRUE(Mood::find(session, "Chill"));
EXPECT_FALSE(Mood::find(session, "chill"));
EXPECT_FALSE(Mood::find(session, ""));
EXPECT_FALSE(Mood::find(session, "Chil"));
}
}
TEST_F(DatabaseFixture, Mood_orphan)
{
ScopedMood mood{ session, "Sad" };
{
auto transaction{ session.createReadTransaction() };
const auto orphans{ Mood::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), mood.getId());
}
}
TEST_F(DatabaseFixture, Mood_singleTrack)
{
ScopedTrack track{ session };
ScopedMood mood1{ session, "Dark" };
ScopedMood mood2{ session, "Upbeat" };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Mood::findOrphanIds(session).results.size(), 2);
EXPECT_EQ(track->getMoods().size(), 0);
EXPECT_EQ(track->getMoodIds().size(), 0);
}
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setMoods(std::array{ mood1.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto moods{ Mood::findIds(session, Mood::FindParameters{}.setTrack(track.getId())) };
ASSERT_EQ(moods.results.size(), 1);
EXPECT_EQ(moods.results.front(), mood1.getId());
const auto orphans{ Mood::findOrphanIds(session) };
ASSERT_EQ(orphans.results.size(), 1);
EXPECT_EQ(orphans.results.front(), mood2.getId());
const auto trackMoods{ track->getMoods() };
ASSERT_EQ(trackMoods.size(), 1);
EXPECT_EQ(trackMoods.front()->getId(), mood1.getId());
const auto trackMoodIds{ track->getMoodIds() };
ASSERT_EQ(trackMoodIds.size(), 1);
EXPECT_EQ(trackMoodIds.front(), mood1.getId());
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood2.getId()))) };
EXPECT_EQ(tracks2.results.size(), 0);
}
}
TEST_F(DatabaseFixture, Mood_multipleMoodsOnTrack)
{
ScopedTrack track{ session };
ScopedMood mood1{ session, "Melancholic" };
ScopedMood mood2{ session, "Romantic" };
{
auto transaction{ session.createWriteTransaction() };
track.get().modify()->setMoods(std::array{ mood1.get(), mood2.get() });
}
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Mood::findOrphanIds(session).results.size(), 0);
const auto trackMoods{ track->getMoods() };
EXPECT_EQ(trackMoods.size(), 2);
}
{
auto transaction{ session.createReadTransaction() };
const auto tracks{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood1.getId()))) };
ASSERT_EQ(tracks.results.size(), 1);
EXPECT_EQ(tracks.results.front(), track.getId());
const auto tracks2{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setMood(mood2.getId()))) };
ASSERT_EQ(tracks2.results.size(), 1);
EXPECT_EQ(tracks2.results.front(), track.getId());
}
}
TEST_F(DatabaseFixture, Mood_sortByName)
{
ScopedMood m1{ session, "Zzz" };
ScopedMood m2{ session, "Aaa" };
ScopedMood m3{ session, "Mmm" };
{
auto transaction{ session.createReadTransaction() };
const auto moods{ Mood::findIds(session, Mood::FindParameters{}.setSortMethod(MoodSortMethod::Name)) };
ASSERT_EQ(moods.results.size(), 3);
EXPECT_EQ(moods.results[0], m2.getId());
EXPECT_EQ(moods.results[1], m3.getId());
EXPECT_EQ(moods.results[2], m1.getId());
}
}
TEST_F(DatabaseFixture, Mood_sortByTrackCount)
{
ScopedMood m1{ session, "Energetic" };
ScopedMood m2{ session, "Chill" };
ScopedTrack track1{ session };
ScopedTrack track2{ session };
ScopedTrack track3{ session };
{
auto transaction{ session.createWriteTransaction() };
track1.get().modify()->setMoods(std::array{ m1.get() });
track2.get().modify()->setMoods(std::array{ m1.get() });
track3.get().modify()->setMoods(std::array{ m2.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto moods{ Mood::findIds(session, Mood::FindParameters{}.setSortMethod(MoodSortMethod::TrackCountDesc)) };
ASSERT_EQ(moods.results.size(), 2);
EXPECT_EQ(moods.results[0], m1.getId());
EXPECT_EQ(moods.results[1], m2.getId());
}
}
} // namespace lms::db::tests
src/libs/database/test/Track.cpp
+33
View File
@@ -27,7 +27,11 @@
namespace lms::db::tests
{
using ScopedArtwork = ScopedEntity<db::Artwork>;
using ScopedGenre = ScopedEntity<db::Genre>;
using ScopedGrouping = ScopedEntity<db::Grouping>;
using ScopedImage = ScopedEntity<db::Image>;
using ScopedLanguage = ScopedEntity<db::Language>;
using ScopedMood = ScopedEntity<db::Mood>;
TEST_F(DatabaseFixture, Track)
{
@@ -590,4 +594,33 @@ namespace lms::db::tests
EXPECT_EQ(track->getPreferredMediaArtwork(), Artwork::pointer{});
}
}
TEST_F(DatabaseFixture, Track_combinedTagFilters)
{
ScopedTrack track1{ session };
ScopedTrack track2{ session };
ScopedGenre genre{ session, "Rock" };
ScopedMood mood{ session, "Energetic" };
ScopedGrouping grouping{ session, "Compilation" };
ScopedLanguage language{ session, "eng" };
{
auto transaction{ session.createWriteTransaction() };
track1.get().modify()->setGenres(std::array{ genre.get() });
track1.get().modify()->setMoods(std::array{ mood.get() });
track1.get().modify()->setGroupings(std::array{ grouping.get() });
track1.get().modify()->setLanguages(std::array{ language.get() });
track2.get().modify()->setGenres(std::array{ genre.get() });
track2.get().modify()->setMoods(std::array{ mood.get() });
track2.get().modify()->setGroupings(std::array{ grouping.get() });
}
{
auto transaction{ session.createReadTransaction() };
const auto results{ Track::findIds(session, Track::FindParameters{}.setFilters(Filters{}.setGenre(genre.getId()).setMood(mood.getId()).setGrouping(grouping.getId()).setLanguage(language.getId()))) };
ASSERT_EQ(results.results.size(), 1);
EXPECT_EQ(results.results.front(), track1.getId());
}
}
} // namespace lms::db::tests