Put all directories and images in database, use the info to associate an image to each artist

src/libs/database/impl/Artist.cpp

@@ -22,6 +22,7 @@
 
 #include "core/ILogger.hpp"
 #include "database/Cluster.hpp"
+#include "database/Directory.hpp"
 #include "database/Image.hpp"
 #include "database/Release.hpp"
 #include "database/Session.hpp"
@@ -222,19 +223,19 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQueryResults<Artist::pointer>(session.getDboSession()->find<Artist>().where("name = ?").bind(std::string{ name, 0, _maxNameLength }).orderBy("LENGTH(mbid) DESC")); // put mbid entries first
+        return utils::fetchQueryResults<Artist::pointer>(session.getDboSession()->query<Wt::Dbo::ptr<Artist>>("SELECT a FROM artist a").where("a.name = ?").bind(std::string{ name, 0, _maxNameLength }).orderBy("LENGTH(a.mbid) DESC")); // put mbid entries first
     }
 
     Artist::pointer Artist::find(Session& session, const core::UUID& mbid)
     {
         session.checkReadTransaction();
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Artist>().where("mbid = ?").bind(std::string{ mbid.getAsString() }));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Artist>>("SELECT a FROM artist a").where("a.mbid = ?").bind(std::string{ mbid.getAsString() }));
     }
 
     Artist::pointer Artist::find(Session& session, ArtistId id)
     {
         session.checkReadTransaction();
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Artist>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Artist>>("SELECT a FROM artist a").where("a.id = ?").bind(id));
     }
 
     bool Artist::exists(Session& session, ArtistId id)
@@ -364,4 +365,9 @@ namespace lms::db
         _sortName = std::string(sortName, 0, _maxNameLength);
     }
 
+    void Artist::setImage(ObjectPtr<Image> image)
+    {
+        _image = getDboPtr(image);
+    }
+
 } // namespace lms::db

src/libs/database/impl/Cluster.cpp

@@ -20,6 +20,7 @@
 #include "database/Cluster.hpp"
 
 #include "database/Artist.hpp"
+#include "database/Directory.hpp"
 #include "database/MediaLibrary.hpp"
 #include "database/Release.hpp"
 #include "database/ScanSettings.hpp"

src/libs/database/impl/Directory.cpp

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2024 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/Directory.hpp"
+
+#include "database/Session.hpp"
+
+#include "IdTypeTraits.hpp"
+#include "PathTraits.hpp"
+#include "Utils.hpp"
+
+namespace lms::db
+{
+    namespace
+    {
+        Wt::Dbo::Query<Wt::Dbo::ptr<Directory>> createQuery(Session& session, const Directory::FindParameters& params)
+        {
+            auto query{ session.getDboSession()->query<Wt::Dbo::ptr<Directory>>("SELECT d FROM directory d") };
+
+            if (params.artist.isValid())
+            {
+                query.join("track t ON t.directory_id = d.id")
+                    .join("artist a ON a.id = t_a_l.artist_id")
+                    .join("track_artist_link t_a_l ON t_a_l.track_id = t.id")
+                    .where("a.id = ?")
+                    .bind(params.artist);
+
+                if (!params.trackArtistLinkTypes.empty())
+                {
+                    std::ostringstream oss;
+
+                    bool first{ true };
+                    for (TrackArtistLinkType linkType : params.trackArtistLinkTypes)
+                    {
+                        if (!first)
+                            oss << " OR ";
+                        oss << "t_a_l.type = ?";
+                        query.bind(linkType);
+
+                        first = false;
+                    }
+                    query.where(oss.str());
+                }
+
+                query.groupBy("d.id");
+            }
+
+            return query;
+        }
+    } // namespace
+
+    Directory::Directory(const std::filesystem::path& p)
+    {
+        setAbsolutePath(p);
+    }
+
+    Directory::pointer Directory::create(Session& session, const std::filesystem::path& p)
+    {
+        return session.getDboSession()->add(std::unique_ptr<Directory>{ new Directory{ p } });
+    }
+
+    std::size_t Directory::getCount(Session& session)
+    {
+        session.checkReadTransaction();
+
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<int>("SELECT COUNT(*) FROM directory"));
+    }
+
+    Directory::pointer Directory::find(Session& session, DirectoryId id)
+    {
+        session.checkReadTransaction();
+
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Directory>>("SELECT d from directory d").where("d.id = ?").bind(id));
+    }
+
+    Directory::pointer Directory::find(Session& session, const std::filesystem::path& path)
+    {
+        session.checkReadTransaction();
+
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Directory>>("SELECT d from directory d").where("d.absolute_path = ?").bind(path));
+    }
+
+    void Directory::find(Session& session, DirectoryId& lastRetrievedDirectory, std::size_t count, const std::function<void(const Directory::pointer&)>& func)
+    {
+        session.checkReadTransaction();
+
+        auto query{ session.getDboSession()->query<Wt::Dbo::ptr<Directory>>("SELECT d from directory d").orderBy("d.id").where("d.id > ?").bind(lastRetrievedDirectory).limit(static_cast<int>(count)) };
+
+        utils::forEachQueryResult(query, [&](const Directory::pointer& image) {
+            func(image);
+            lastRetrievedDirectory = image->getId();
+        });
+    }
+
+    void Directory::find(Session& session, const FindParameters& params, const std::function<void(const Directory::pointer&)>& func)
+    {
+        auto query{ createQuery(session, params) };
+        utils::forEachQueryResult(query, [&func](const Directory::pointer& dir) {
+            func(dir);
+        });
+    }
+
+    RangeResults<DirectoryId> Directory::findOrphanIds(Session& session, std::optional<Range> range)
+    {
+        session.checkReadTransaction();
+
+        auto query{ session.getDboSession()->query<DirectoryId>("SELECT d.id FROM directory d") };
+        query.leftJoin("directory d_child ON d.id = d_child.parent_directory_id");
+        query.leftJoin("track t ON d.id = t.directory_id");
+        query.leftJoin("image i ON d.id = i.directory_id");
+        query.where("d_child.id IS NULL");
+        query.where("t.directory_id IS NULL");
+        query.where("i.directory_id IS NULL");
+
+        return utils::execRangeQuery<DirectoryId>(query, range);
+    }
+
+    void Directory::setAbsolutePath(const std::filesystem::path& p)
+    {
+        assert(p.is_absolute());
+
+        if (!p.has_filename() && p.has_parent_path())
+        {
+            _absolutePath = p.parent_path();
+            _name = _absolutePath.filename();
+        }
+        else
+        {
+            _absolutePath = p;
+            _name = p.filename();
+        }
+    }
+
+    void Directory::setParent(ObjectPtr<Directory> parent)
+    {
+#ifndef NDEBUG
+        if (parent)
+        {
+            assert(_absolutePath.has_parent_path());
+            assert(parent->getAbsolutePath() == _absolutePath.parent_path());
+        }
+#endif
+
+        _parent = getDboPtr(parent);
+    }
+} // namespace lms::db

src/libs/database/impl/Image.cpp

@@ -22,6 +22,7 @@
 #include <Wt/Dbo/WtSqlTraits.h>
 
 #include "database/Artist.hpp"
+#include "database/Directory.hpp"
 #include "database/Session.hpp"
 
 #include "IdTypeTraits.hpp"
@@ -30,9 +31,24 @@
 
 namespace lms::db
 {
-    Image::Image(const std::filesystem::path& p)
-        : _path{ p }
+    namespace
     {
+        Wt::Dbo::Query<Wt::Dbo::ptr<Image>> createQuery(Session& session, const Image::FindParameters& params)
+        {
+            auto query{ session.getDboSession()->query<Wt::Dbo::ptr<Image>>("SELECT i FROM image i") };
+
+            if (params.directory.isValid())
+                query.where("i.directory_id = ?").bind(params.directory);
+            if (!params.fileStem.empty())
+                query.where("i.stem = ?").bind(params.fileStem);
+
+            return query;
+        }
+    } // namespace
+
+    Image::Image(const std::filesystem::path& p)
+    {
+        setAbsoluteFilePath(p);
     }
 
     Image::pointer Image::create(Session& session, const std::filesystem::path& p)
@@ -51,6 +67,49 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Image>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Image>>("SELECT i from image i").where("i.id = ?").bind(id));
     }
+
+    Image::pointer Image::find(Session& session, const std::filesystem::path& path)
+    {
+        session.checkReadTransaction();
+
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Image>>("SELECT i from image i").where("i.absolute_file_path = ?").bind(path));
+    }
+
+    void Image::find(Session& session, ImageId& lastRetrievedImage, std::size_t count, const std::function<void(const Image::pointer&)>& func)
+    {
+        session.checkReadTransaction();
+
+        auto query{ session.getDboSession()->query<Wt::Dbo::ptr<Image>>("SELECT i from image i").orderBy("i.id").where("i.id > ?").bind(lastRetrievedImage).limit(static_cast<int>(count)) };
+
+        utils::forEachQueryResult(query, [&](const Image::pointer& image) {
+            func(image);
+            lastRetrievedImage = image->getId();
+        });
+    }
+
+    RangeResults<Image::pointer> Image::find(Session& session, const FindParameters& params)
+    {
+        session.checkReadTransaction();
+
+        auto query{ createQuery(session, params) };
+        return utils::execRangeQuery<Image::pointer>(query, params.range);
+    }
+
+    void Image::find(Session& session, const FindParameters& params, const std::function<void(const Image::pointer&)>& func)
+    {
+        auto query{ createQuery(session, params) };
+        utils::forEachQueryResult(query, [&](const Image::pointer& image) {
+            func(image);
+        });
+    }
+
+    void Image::setAbsoluteFilePath(const std::filesystem::path& p)
+    {
+        assert(p.is_absolute());
+        _fileAbsolutePath = p;
+        _fileStem = p.stem().string();
+    }
+
 } // namespace lms::db

src/libs/database/impl/Listen.cpp

@@ -210,7 +210,7 @@ namespace lms::db
     Listen::pointer Listen::find(Session& session, ListenId id)
     {
         session.checkReadTransaction();
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Listen>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Listen>>("SELECT l from listen l").where("l.id = ?").bind(id));
     }
 
     RangeResults<ListenId> Listen::find(Session& session, const FindParameters& parameters)

src/libs/database/impl/Migration.cpp

@@ -35,7 +35,7 @@ namespace lms::db
 {
     namespace
     {
-        static constexpr Version LMS_DATABASE_VERSION{ 60 };
+        static constexpr Version LMS_DATABASE_VERSION{ 61 };
     }
 
     VersionInfo::VersionInfo()
@@ -485,6 +485,7 @@ SELECT
   "id" integer primary key autoincrement,
   "version" integer not null,
   "path" text not null,
+  "stem" text not null,
   "file_last_write" text,
   "file_size" integer not null,
   "width" integer not null,
@@ -496,6 +497,138 @@ SELECT
             // Just increment the scan version of the settings to make the next scheduled scan rescan everything
             session.getDboSession()->execute("UPDATE scan_settings SET scan_version = scan_version + 1");
         }
+
+        void migrateFromV60(Session& session)
+        {
+            // Dedicated directory table
+            session.getDboSession()->execute(R"(CREATE TABLE IF NOT EXISTS "directory" (
+  "id" integer primary key autoincrement,
+  "version" integer not null,
+  "absolute_path" text not null,
+  "name" text not null,
+  "parent_directory_id" bigint,
+  constraint "fk_directory_directory" foreign key ("parent_directory_id") references "directory" ("id") on delete cascade deferrable initially deferred
+))");
+
+            // Add a ref in track, need to recreate a new table
+            session.getDboSession()->execute(R"(
+CREATE TABLE IF NOT EXISTS "track_backup" (
+  "id" integer primary key autoincrement,
+  "version" integer not null,
+  "scan_version" integer not null,
+  "track_number" integer,
+  "disc_number" integer,
+  "total_track" integer,
+  "disc_subtitle" text not null,
+  "name" text not null,
+  "duration" integer,
+  "bitrate" integer not null,
+  "bits_per_sample" integer not null,
+  "channel_count" integer not null,
+  "sample_rate" integer not null,
+  "date" text,
+  "year" integer,
+  "original_date" text,
+  "original_year" integer,
+  "absolute_file_path" text not null,
+  "relative_file_path" text not null,
+  "file_size" bigint not null,
+  "file_last_write" text,
+  "file_added" text,
+  "has_cover" boolean not null,
+  "mbid" text not null,
+  "recording_mbid" text not null,
+  "copyright" text not null,
+  "copyright_url" text not null,
+  "track_replay_gain" real,
+  "release_replay_gain" real,
+  "artist_display_name" text not null,
+  "release_id" bigint,
+  "media_library_id" bigint,
+  "directory_id" bigint,
+  constraint "fk_track_release" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred,
+  constraint "fk_track_media_library" foreign key ("media_library_id") references "media_library" ("id") on delete set null deferrable initially deferred,
+  constraint "fk_track_directory" foreign key ("directory_id") references "directory" ("id") on delete cascade deferrable initially deferred
+))");
+            // Migrate data, with the new directory_id field set to null
+            session.getDboSession()->execute(R"(INSERT INTO track_backup 
+SELECT
+ id,
+ version,
+ scan_version,
+ track_number,
+ disc_number,
+ total_track,
+ disc_subtitle,
+ name,
+ duration,
+ bitrate,
+ bits_per_sample,
+ channel_count,
+ sample_rate,
+ date,
+ year,
+ original_date,
+ original_year,
+ absolute_file_path,
+ relative_file_path,
+ file_size,
+ file_last_write,
+ file_added,
+ has_cover,
+ mbid,
+ recording_mbid,
+ copyright,
+ copyright_url,
+ track_replay_gain,
+ release_replay_gain,
+ artist_display_name,
+ release_id,
+ media_library_id,
+ NULL
+ FROM track)");
+            session.getDboSession()->execute("DROP TABLE track");
+            session.getDboSession()->execute("ALTER TABLE track_backup RENAME TO track");
+
+            // Add a ref in image + rename path to absolute_file_path, need to recreate a new table
+            session.getDboSession()->execute(R"(
+            CREATE TABLE IF NOT EXISTS "image_backup" (
+  "id" integer primary key autoincrement,
+  "version" integer not null,
+  "absolute_file_path" text not null,
+  "stem" text not null,
+  "file_last_write" text,
+  "file_size" integer not null,
+  "width" integer not null,
+  "height" integer not null,
+  "artist_id" bigint,
+  "directory_id" bigint,
+  constraint "fk_image_artist" foreign key ("artist_id") references "artist" ("id") on delete cascade deferrable initially deferred,
+  constraint "fk_image_directory" foreign key ("directory_id") references "directory" ("id") on delete cascade deferrable initially deferred
+))");
+
+            // Migrate data, with the new directory_id field set to null
+            session.getDboSession()->execute(R"(INSERT INTO image_backup 
+SELECT
+ id,
+ version,
+ path,
+ stem,
+ file_last_write,
+ file_size,
+ width,
+ height,
+ artist_id,
+ NULL
+ FROM image
+ )");
+            session.getDboSession()->execute("DROP TABLE image");
+            session.getDboSession()->execute("ALTER TABLE image_backup RENAME TO image");
+
+            // Just increment the scan version of the settings to make the next scheduled scan rescan everything
+            session.getDboSession()->execute("UPDATE scan_settings SET scan_version = scan_version + 1");
+        }
+
     } // namespace
 
     bool doDbMigration(Session& session)
@@ -534,6 +667,7 @@ SELECT
             { 57, migrateFromV57 },
             { 58, migrateFromV58 },
             { 59, migrateFromV59 },
+            { 60, migrateFromV60 },
         };
 
         bool migrationPerformed{};

src/libs/database/impl/Release.cpp

@@ -226,14 +226,14 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<ReleaseType>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<ReleaseType>>("SELECT r_t from release_type r_t").where("r_t.id = ?").bind(id));
     }
 
     ReleaseType::pointer ReleaseType::find(Session& session, std::string_view name)
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<ReleaseType>().where("name = ?").bind(name));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<ReleaseType>>("SELECT r_t from release_type r_t").where("r_t.name = ?").bind(name));
     }
 
     Release::Release(const std::string& name, const std::optional<core::UUID>& MBID)
@@ -258,14 +258,14 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Release>().where("mbid = ?").bind(mbid.getAsString()));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Release>>("SELECT r from release r").where("r.mbid = ?").bind(mbid.getAsString()));
     }
 
     Release::pointer Release::find(Session& session, ReleaseId id)
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Release>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Release>>("SELECT r from release r").where("r.id = ?").bind(id));
     }
 
     bool Release::exists(Session& session, ReleaseId id)

src/libs/database/impl/Session.cpp

@@ -26,6 +26,7 @@
 #include "database/AuthToken.hpp"
 #include "database/Cluster.hpp"
 #include "database/Db.hpp"
+#include "database/Directory.hpp"
 #include "database/Image.hpp"
 #include "database/Listen.hpp"
 #include "database/MediaLibrary.hpp"
@@ -93,6 +94,7 @@ namespace lms::db
         _session.mapClass<AuthToken>("auth_token");
         _session.mapClass<Cluster>("cluster");
         _session.mapClass<ClusterType>("cluster_type");
+        _session.mapClass<Directory>("directory");
         _session.mapClass<Image>("image");
         _session.mapClass<Listen>("listen");
         _session.mapClass<MediaLibrary>("media_library");
@@ -179,7 +181,14 @@ namespace lms::db
         _session.execute("CREATE INDEX IF NOT EXISTS cluster_cluster_type_idx ON cluster(cluster_type_id)");
         _session.execute("CREATE INDEX IF NOT EXISTS cluster_type_name_idx ON cluster_type(name)");
 
+        _session.execute("CREATE INDEX IF NOT EXISTS directory_id_idx ON directory(id)");
+        _session.execute("CREATE INDEX IF NOT EXISTS directory_path_idx ON directory(absolute_path)");
+
         _session.execute("CREATE INDEX IF NOT EXISTS image_artist_idx ON image(artist_id)");
+        _session.execute("CREATE INDEX IF NOT EXISTS image_directory_idx ON image(directory_id)");
+        _session.execute("CREATE INDEX IF NOT EXISTS image_id_idx ON image(id)");
+        _session.execute("CREATE INDEX IF NOT EXISTS image_path_idx ON image(absolute_file_path)");
+        _session.execute("CREATE INDEX IF NOT EXISTS image_stem_idx ON image(stem)");
 
         _session.execute("CREATE INDEX IF NOT EXISTS listen_backend_idx ON listen(backend)");
         _session.execute("CREATE INDEX IF NOT EXISTS listen_id_idx ON listen(id)");

src/libs/database/impl/Track.cpp

@@ -24,6 +24,7 @@
 #include "core/ILogger.hpp"
 #include "database/Artist.hpp"
 #include "database/Cluster.hpp"
+#include "database/Directory.hpp"
 #include "database/MediaLibrary.hpp"
 #include "database/Release.hpp"
 #include "database/Session.hpp"
@@ -219,21 +220,21 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Track>().where("absolute_file_path = ?").bind(p.string()));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t").where("t.absolute_file_path = ?").bind(p.string()));
     }
 
     Track::pointer Track::find(Session& session, TrackId id)
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<Track>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t").where("t.id = ?").bind(id));
     }
 
     void Track::find(Session& session, TrackId& lastRetrievedTrack, std::size_t count, const std::function<void(const Track::pointer&)>& func, MediaLibraryId library)
     {
         session.checkReadTransaction();
 
-        auto query{ session.getDboSession()->find<Track>().orderBy("id").where("id > ?").bind(lastRetrievedTrack).limit(static_cast<int>(count)) };
+        auto query{ session.getDboSession()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t").orderBy("t.id").where("t.id > ?").bind(lastRetrievedTrack).limit(static_cast<int>(count)) };
 
         if (library.isValid())
             query.where("media_library_id = ?").bind(library);
@@ -255,14 +256,14 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQueryResults<Track::pointer>(session.getDboSession()->find<Track>().where("mbid = ?").bind(mbid.getAsString()));
+        return utils::fetchQueryResults<Track::pointer>(session.getDboSession()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t").where("t.mbid = ?").bind(mbid.getAsString()));
     }
 
     std::vector<Track::pointer> Track::findByRecordingMBID(Session& session, const core::UUID& mbid)
     {
         session.checkReadTransaction();
 
-        return utils::fetchQueryResults<Track::pointer>(session.getDboSession()->find<Track>().where("recording_mbid = ?").bind(mbid.getAsString()));
+        return utils::fetchQueryResults<Track::pointer>(session.getDboSession()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t").where("t.recording_mbid = ?").bind(mbid.getAsString()));
     }
 
     RangeResults<TrackId> Track::findIdsTrackMBIDDuplicates(Session& session, std::optional<Range> range)

src/libs/database/impl/TrackFeatures.cpp

@@ -23,6 +23,7 @@
 #include <boost/property_tree/ptree.hpp>
 
 #include "core/ILogger.hpp"
+#include "database/Directory.hpp"
 #include "database/Session.hpp"
 #include "database/Track.hpp"
 

src/libs/database/impl/TrackList.cpp

@@ -136,7 +136,7 @@ namespace lms::db
         session.checkReadTransaction();
         assert(userId.isValid());
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<TrackList>().where("name = ?").bind(name).where("type = ?").bind(type).where("user_id = ?").bind(userId));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<TrackList>>("select t_l from tracklist t_l").where("t_l.name = ?").bind(name).where("t_l.type = ?").bind(type).where("t_l.user_id = ?").bind(userId));
     }
 
     RangeResults<TrackListId> TrackList::find(Session& session, const FindParameters& params)
@@ -157,7 +157,7 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<TrackList>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<TrackList>>("select t_l from tracklist t_l").where("t_l.id = ?").bind(id));
     }
 
     bool TrackList::isEmpty() const

src/libs/database/impl/User.cpp

@@ -78,17 +78,17 @@ namespace lms::db
     {
         session.checkReadTransaction();
 
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<User>().where("type = ?").bind(UserType::DEMO));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<User>>("SELECT u from user u").where("u.type = ?").bind(UserType::DEMO));
     }
 
     User::pointer User::find(Session& session, UserId id)
     {
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<User>().where("id = ?").bind(id));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<User>>("SELECT u from user u").where("u.id = ?").bind(id));
     }
 
     User::pointer User::find(Session& session, std::string_view name)
     {
-        return utils::fetchQuerySingleResult(session.getDboSession()->find<User>().where("login_name = ?").bind(name));
+        return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<User>>("SELECT u from user u").where("u.login_name = ?").bind(name));
     }
 
     void User::setSubsonicDefaultTranscodingOutputBitrate(Bitrate bitrate)