Made database ID manipulations safer

src/libs/database/impl/Artist.cpp

@@ -28,6 +28,7 @@
 #include "utils/Logger.hpp"
 #include "SqlQuery.hpp"
 #include "Utils.hpp"
+#include "Traits.hpp"
 
 namespace Database
 {
@@ -37,7 +38,6 @@ Artist::Artist(const std::string& name, const std::optional<UUID>& MBID)
 _sortName {_name},
 _MBID {MBID ? MBID->getAsString() : ""}
 {
-
 }
 
 std::vector<Artist::pointer>
@@ -45,7 +45,7 @@ Artist::getByName(Session& session, const std::string& name)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<Artist::pointer> res = session.getDboSession().find<Artist>()
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>()
 		.where("name = ?").bind(std::string {name, 0, _maxNameLength})
 		.orderBy("LENGTH(mbid) DESC"); // put mbid entries first
 
@@ -56,14 +56,14 @@ Artist::pointer
 Artist::getByMBID(Session& session, const UUID& mbid)
 {
 	session.checkSharedLocked();
-	return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string {mbid.getAsString()});
+	return session.getDboSession().find<Artist>().where("mbid = ?").bind(std::string {mbid.getAsString()}).resultValue();
 }
 
 Artist::pointer
-Artist::getById(Session& session, IdType id)
+Artist::getById(Session& session, ArtistId id)
 {
 	session.checkSharedLocked();
-	return session.getDboSession().find<Artist>().where("id = ?").bind(id);
+	return session.getDboSession().find<Artist>().where("id = ?").bind(id).resultValue();
 }
 
 Artist::pointer
@@ -82,7 +82,7 @@ static
 Wt::Dbo::Query<T>
 createQuery(Session& session,
 		const std::string& queryStr,
-		const std::set<IdType>& clusterIds,
+		const std::vector<ClusterId>& clusterIds,
 		const std::vector<std::string_view>& keywords,
 		std::optional<TrackArtistLinkType> linkType)
 {
@@ -125,7 +125,7 @@ createQuery(Session& session,
 			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
 
 		WhereClause clusterClause;
-		for (const IdType clusterId : clusterIds)
+		for (const ClusterId clusterId : clusterIds)
 		{
 			clusterClause.Or(WhereClause("c.id = ?"));
 			query.bind(clusterId);
@@ -145,7 +145,7 @@ Artist::getAll(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().find<Artist>();
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session.getDboSession().find<Artist>();
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
@@ -167,7 +167,7 @@ Artist::getAll(Session& session, SortMethod sortMethod)
 			break;
 	}
 
-	Wt::Dbo::collection<pointer> res = query;
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = query;
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
@@ -177,7 +177,7 @@ Artist::getAll(Session& session, SortMethod sortMethod, std::optional<Range> ran
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Artist::pointer>(session, "SELECT a FROM Artist a", {}, {}, std::nullopt)};
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT a FROM Artist a", {}, {}, std::nullopt)};
 
 	switch (sortMethod)
 	{
@@ -191,11 +191,11 @@ Artist::getAll(Session& session, SortMethod sortMethod, std::optional<Range> ran
 			break;
 	}
 
-	Wt::Dbo::collection<Artist::pointer> collection = query
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
 		.offset(range ? static_cast<int>(range->offset) : -1);
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<Artist::pointer> res (collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -207,27 +207,27 @@ Artist::getAll(Session& session, SortMethod sortMethod, std::optional<Range> ran
 	return res;
 }
 
-std::vector<IdType>
+std::vector<ArtistId>
 Artist::getAllIds(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>("SELECT id FROM artist");
-	return std::vector<IdType>(res.begin(), res.end());
+	Wt::Dbo::collection<ArtistId> res = session.getDboSession().query<ArtistId>("SELECT id FROM artist");
+	return std::vector<ArtistId>(res.begin(), res.end());
 }
 
-std::vector<IdType>
-Artist::getAllIdsRandom(Session& session, const std::set<IdType>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size)
+std::vector<ArtistId>
+Artist::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<IdType>(session, "SELECT DISTINCT a.id from artist a", clusters, {}, linkType)};
+	auto query {createQuery<ArtistId>(session, "SELECT DISTINCT a.id from artist a", clusters, {}, linkType)};
 
-	Wt::Dbo::collection<IdType> res = query
+	Wt::Dbo::collection<ArtistId> res = query
 		.orderBy("RANDOM()")
 		.limit(size ? static_cast<int>(*size) : -1);
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<ArtistId>(res.begin(), res.end());
 
 }
 
@@ -240,22 +240,22 @@ Artist::getAllOrphans(Session& session)
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
-std::vector<IdType>
+std::vector<ArtistId>
 Artist::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>
+	Wt::Dbo::collection<ArtistId> res = session.getDboSession().query<ArtistId>
 		("SELECT DISTINCT a.id FROM artist a"
 			" INNER JOIN track t ON t.id = t_a_l.track_id INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
 			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
 		.limit(limit ? static_cast<int>(*limit) : -1);
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<ArtistId>(res.begin(), res.end());
 }
 
 std::vector<Artist::pointer>
-Artist::getByClusters(Session& session, const std::set<IdType>& clusters, SortMethod sortMethod)
+Artist::getByClusters(Session& session, const std::vector<ClusterId>& clusters, SortMethod sortMethod)
 {
 	assert(!clusters.empty());
 
@@ -266,7 +266,7 @@ Artist::getByClusters(Session& session, const std::set<IdType>& clusters, SortMe
 
 std::vector<Artist::pointer>
 Artist::getByFilter(Session& session,
-		const std::set<IdType>& clusters,
+		const std::vector<ClusterId>& clusters,
 		const std::vector<std::string_view>& keywords,
 		std::optional<TrackArtistLinkType> linkType,
 		SortMethod sortMethod,
@@ -275,7 +275,7 @@ Artist::getByFilter(Session& session,
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Artist::pointer>(session, "SELECT DISTINCT a from artist a", clusters, keywords, linkType)};
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, keywords, linkType)};
 	switch (sortMethod)
 	{
 		case Artist::SortMethod::None:
@@ -288,11 +288,11 @@ Artist::getByFilter(Session& session,
 			break;
 	}
 
-	Wt::Dbo::collection<Artist::pointer> collection = query
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
 		.offset(range ? static_cast<int>(range->offset) : -1);
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<pointer> res (collection.begin(), collection.end());
 
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
@@ -308,23 +308,23 @@ Artist::getByFilter(Session& session,
 std::vector<Artist::pointer>
 Artist::getLastWritten(Session& session,
 		std::optional<Wt::WDateTime> after,
-		const std::set<IdType>& clusters,
+		const std::vector<ClusterId>& clusters,
 		std::optional<TrackArtistLinkType> linkType,
 		std::optional<Range> range, bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Artist::pointer>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
 
 	if (after)
 		query.where("t.file_last_write > ?").bind(*after);
 
-	Wt::Dbo::collection<Artist::pointer> collection = query
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
 		.orderBy("t.file_last_write DESC")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
 		.offset(range ? static_cast<int>(range->offset) : -1);
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<pointer> res (collection.begin(), collection.end());
 
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
@@ -340,14 +340,14 @@ Artist::getLastWritten(Session& session,
 std::vector<Artist::pointer>
 Artist::getStarred(Session& session,
 		User::pointer user,
-		const std::set<IdType>& clusters,
+		const std::vector<ClusterId>& clusters,
 		std::optional<TrackArtistLinkType> linkType,
 		SortMethod sortMethod,
 		std::optional<Range> range, bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Artist::pointer>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
+	auto query {createQuery<Wt::Dbo::ptr<Artist>>(session, "SELECT DISTINCT a from artist a", clusters, {}, linkType)};
 
 	{
 		std::ostringstream oss;
@@ -355,7 +355,7 @@ Artist::getStarred(Session& session,
 			" INNER JOIN user_artist_starred uas ON uas.artist_id = a.id"
 			" INNER JOIN user u ON u.id = uas.user_id WHERE u.id = ?)";
 
-		query.bind(user.id());
+		query.bind(user->getId());
 		query.where(oss.str());
 	}
 
@@ -371,12 +371,12 @@ Artist::getStarred(Session& session,
 			break;
 	}
 
-	Wt::Dbo::collection<Artist::pointer> collection = query
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> collection = query
 		.groupBy("a.id")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
 		.offset(range ? static_cast<int>(range->offset) : -1);
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<pointer> res (collection.begin(), collection.end());
 
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
@@ -389,11 +389,9 @@ Artist::getStarred(Session& session,
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
-std::vector<Wt::Dbo::ptr<Release>>
-Artist::getReleases(const std::set<IdType>& clusterIds) const
+std::vector<Release::pointer>
+Artist::getReleases(const std::vector<ClusterId>& clusterIds) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	WhereClause where;
@@ -409,12 +407,12 @@ Artist::getReleases(const std::set<IdType>& clusterIds) const
 		WhereClause clusterClause;
 
 		for (auto id : clusterIds)
-			clusterClause.Or(WhereClause("c.id = ?")).bind(std::to_string(id));
+			clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString());
 
 		where.And(clusterClause);
 	}
 
-	where.And(WhereClause("a.id = ?")).bind(std::to_string(id()));
+	where.And(WhereClause("a.id = ?")).bind(getId().toString());
 
 	oss << " " << where.get();
 
@@ -423,56 +421,48 @@ Artist::getReleases(const std::set<IdType>& clusterIds) const
 
 	oss << " ORDER BY t.year DESC, r.name COLLATE NOCASE";
 
-	Wt::Dbo::Query<Release::pointer> query = session()->query<Release::pointer>( oss.str() );
+	auto query {session()->query<Wt::Dbo::ptr<Release>>(oss.str())};
 
 	for (const std::string& bindArg : where.getBindArgs())
 		query.bind(bindArg);
 
-	Wt::Dbo::collection<Wt::Dbo::ptr<Release>> res = query;
-
-	return std::vector<Wt::Dbo::ptr<Release>>(res.begin(), res.end());
+	auto res {query.resultList()};
+	return std::vector<Release::pointer>(res.begin(), res.end());
 }
 
 std::size_t
 Artist::getReleaseCount() const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	int res = session()->query<int>("SELECT COUNT(DISTINCT r.id) FROM release r INNER JOIN artist a ON a.id = t_a_l.artist_id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id INNER JOIN track t ON t.release_id = r.id")
-		.where("a.id = ?").bind(self()->id());
+		.where("a.id = ?").bind(getId());
 	return res;
 }
 
-std::vector<Wt::Dbo::ptr<Track>>
+std::vector<Track::pointer>
 Artist::getTracks(std::optional<TrackArtistLinkType> linkType) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	auto query {session()->query<Wt::Dbo::ptr<Track>>("SELECT DISTINCT t FROM track t INNER JOIN artist a ON a.id = t_a_l.artist_id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id")
-		.where("a.id = ?").bind(self()->id())
+		.where("a.id = ?").bind(getId())
 		.orderBy("t.year DESC,t.release_id,t.disc_number,t.track_number")};
 
 	if (linkType)
 		query.where("t_a_l.type = ?").bind(*linkType);
 
-	Wt::Dbo::collection<Wt::Dbo::ptr<Track>> tracks {query.resultList()};
-
-	return std::vector<Wt::Dbo::ptr<Track>>(tracks.begin(), tracks.end());
+	auto tracks {query.resultList()};
+	return std::vector<Track::pointer>(tracks.begin(), tracks.end());
 }
 
-std::vector<Wt::Dbo::ptr<Track>>
+std::vector<Track::pointer>
 Artist::getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	auto query {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t INNER JOIN artist a ON a.id = t_a_l.artist_id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id")
-		.where("a.id = ?").bind(self()->id())
+		.where("a.id = ?").bind(getId())
 		.where("t.release_id is NULL")
 		.orderBy("t.name")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
@@ -481,9 +471,8 @@ Artist::getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::op
 	if (linkType)
 		query.where("t_a_l.type = ?").bind(*linkType);
 
-	Wt::Dbo::collection<Track::pointer> tracks {query.resultList()};
-
-	auto res {std::vector<Track::pointer>(tracks.begin(), tracks.end())};
+	Wt::Dbo::collection<Wt::Dbo::ptr<Track>> tracks {query.resultList()};
+	std::vector<Track::pointer> res(tracks.begin(), tracks.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -499,37 +488,32 @@ bool
 Artist::hasNonReleaseTracks(std::optional<TrackArtistLinkType> linkType) const
 {
 	auto query {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t INNER JOIN artist a ON a.id = t_a_l.artist_id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id")
-		.where("a.id = ?").bind(self()->id())
+		.where("a.id = ?").bind(getId())
 		.where("t.release_id is NULL")
 		.orderBy("t.name")};
 
 	if (linkType)
 		query.where("t_a_l.type = ?").bind(*linkType);
 
-	Wt::Dbo::collection<Track::pointer> tracks {query.resultList()};
-	return !tracks.empty();
+	return !query.resultList().empty();
 }
 
-std::vector<Wt::Dbo::ptr<Track>>
+std::vector<Track::pointer>
 Artist::getRandomTracks(std::optional<std::size_t> count) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	Wt::Dbo::collection<Wt::Dbo::ptr<Track>> tracks {session()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t INNER JOIN artist a ON a.id = t_a_l.artist_id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id")
-		.where("a.id = ?").bind(self()->id())
+		.where("a.id = ?").bind(getId())
 		.orderBy("RANDOM()")
 		.limit(count ? static_cast<int>(*count) : -1)};
 
-	return std::vector<Wt::Dbo::ptr<Track>>(tracks.begin(), tracks.end());
+	return std::vector<Track::pointer>(tracks.begin(), tracks.end());
 }
 
-std::vector<Wt::Dbo::ptr<Artist>>
+std::vector<Artist::pointer>
 Artist::getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, std::optional<Range> range) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	std::ostringstream oss;
@@ -563,9 +547,9 @@ Artist::getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, std::opt
 		oss << ")";
 	}
 
-	Wt::Dbo::Query<pointer> query {session()->query<pointer>(oss.str())
-		.bind(self()->id())
-		.bind(self()->id())
+	Wt::Dbo::Query<Wt::Dbo::ptr<Artist>> query {session()->query<Wt::Dbo::ptr<Artist>>(oss.str())
+		.bind(getId())
+		.bind(getId())
 		.groupBy("a.id")
 		.orderBy("COUNT(*) DESC, RANDOM()")
 		.limit(range ? static_cast<int>(range->limit) : -1)
@@ -574,15 +558,13 @@ Artist::getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes, std::opt
 	for (TrackArtistLinkType type : artistLinkTypes)
 		query.bind(type);
 
-	Wt::Dbo::collection<pointer> res = query;
+	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res {query.resultList()};
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
-std::vector<std::vector<Wt::Dbo::ptr<Cluster>>>
+std::vector<std::vector<Cluster::pointer>>
 Artist::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	WhereClause where;
@@ -590,34 +572,34 @@ Artist::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::si
 	std::ostringstream oss;
 	oss << "SELECT c FROM cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id INNER JOIN artist a ON t_a_l.artist_id = a.id INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id";
 
-	where.And(WhereClause("a.id = ?")).bind(std::to_string(self()->id()));
+	where.And(WhereClause("a.id = ?")).bind(getId().toString());
 	{
 		WhereClause clusterClause;
 		for (auto clusterType : clusterTypes)
-			clusterClause.Or(WhereClause("c_type.id = ?")).bind(std::to_string(clusterType.id()));
+			clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
 
 		where.And(clusterClause);
 	}
 	oss << " " << where.get();
 	oss << "GROUP BY c.id ORDER BY COUNT(DISTINCT c.id) DESC";
 
-	Wt::Dbo::Query<Cluster::pointer> query = session()->query<Cluster::pointer>( oss.str() );
+	Wt::Dbo::Query<Wt::Dbo::ptr<Cluster>> query = session()->query<Wt::Dbo::ptr<Cluster>>( oss.str() );
 
 	for (const std::string& bindArg : where.getBindArgs())
 		query.bind(bindArg);
 
-	Wt::Dbo::collection<Cluster::pointer> queryRes = query;
+	Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> queryRes = query;
 
-	std::map<IdType, std::vector<Cluster::pointer>> clusters;
-	for (auto cluster : queryRes)
+	std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
+	for (const Cluster::pointer& cluster : queryRes)
 	{
-		if (clusters[cluster->getType().id()].size() < size)
-			clusters[cluster->getType().id()].push_back(cluster);
+		if (clustersByType[cluster->getType()->getId()].size() < size)
+			clustersByType[cluster->getType()->getId()].push_back(cluster);
 	}
 
 	std::vector<std::vector<Cluster::pointer>> res;
-	for (auto cluster_list : clusters)
-		res.push_back(cluster_list.second);
+	for (const auto& [clusterTypeId, clusters] : clustersByType)
+		res.push_back(clusters);
 
 	return res;
 }

src/libs/database/impl/Cluster.cpp

@@ -25,21 +25,18 @@
 #include "database/Session.hpp"
 #include "database/Track.hpp"
 #include "SqlQuery.hpp"
+#include "Traits.hpp"
 
 namespace Database {
 
-Cluster::Cluster()
-{
-}
-
-Cluster::Cluster(Wt::Dbo::ptr<ClusterType> type, std::string_view name)
-	: _name(std::string {name, 0, _maxNameLength}),
-	_clusterType {type}
+Cluster::Cluster(ObjectPtr<ClusterType> type, std::string_view name)
+	: _name {std::string {name, 0, _maxNameLength}},
+	_clusterType {getDboPtr(type)}
 {
 }
 
 Cluster::pointer
-Cluster::create(Session& session, Wt::Dbo::ptr<ClusterType> type, std::string_view name)
+Cluster::create(Session& session, ObjectPtr<ClusterType> type, std::string_view name)
 {
 	session.checkUniqueLocked();
 
@@ -54,8 +51,7 @@ Cluster::getAll(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<Cluster::pointer> res {session.getDboSession().find<Cluster>()};
-
+	Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> res {session.getDboSession().find<Cluster>()};
 	return std::vector<Cluster::pointer>(res.begin(), res.end());
 }
 
@@ -63,67 +59,61 @@ std::vector<Cluster::pointer>
 Cluster::getAllOrphans(Session& session)
 {
 	session.checkSharedLocked();
-	Wt::Dbo::collection<Cluster::pointer> res {session.getDboSession().query<Cluster::pointer>("SELECT DISTINCT c FROM cluster c WHERE NOT EXISTS(SELECT 1 FROM track_cluster t_c WHERE t_c.cluster_id = c.id)")};
-
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Cluster>>("SELECT DISTINCT c FROM cluster c WHERE NOT EXISTS(SELECT 1 FROM track_cluster t_c WHERE t_c.cluster_id = c.id)").resultList()};
 	return std::vector<Cluster::pointer>(res.begin(), res.end());
 }
 
 Cluster::pointer
-Cluster::getById(Session& session, IdType id)
+Cluster::getById(Session& session, ClusterId id)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<Cluster>().where("id = ?").bind(id);
+	return session.getDboSession().find<Cluster>().where("id = ?").bind(id).resultValue();
 }
 
 void
-Cluster::addTrack(Wt::Dbo::ptr<Track> track)
+Cluster::addTrack(ObjectPtr<Track> track)
 {
-	_tracks.insert(track);
+	_tracks.insert(getDboPtr(track));
 }
 
-std::vector<Wt::Dbo::ptr<Track>>
+std::vector<Track::pointer>
 Cluster::getTracks(std::optional<std::size_t> offset, std::optional<std::size_t> limit) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<Track::pointer> res
-		{session()->query<Track::pointer>("SELECT t FROM track t INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
-			.where("c.id = ?").bind(self()->id())
+	auto res {session()->query<Wt::Dbo::ptr<Track>>("SELECT t FROM track t INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
+			.where("c.id = ?").bind(getId())
 			.offset(offset ? static_cast<int>(*offset) : -1)
-			.limit(limit ? static_cast<int>(*limit) : -1)};
+			.limit(limit ? static_cast<int>(*limit) : -1)
+			.resultList()};
 
-	return std::vector<Wt::Dbo::ptr<Track>>(res.begin(), res.end());
+	return std::vector<Track::pointer>(res.begin(), res.end());
 }
 
-std::set<IdType>
+std::vector<TrackId>
 Cluster::getTrackIds() const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<IdType> res = session()->query<IdType>("SELECT t_c.track_id FROM track_cluster t_c INNER JOIN cluster c ON c.id = t_c.cluster_id")
-		.where("c.id = ?").bind(self()->id());
-
-	return std::set<IdType>(res.begin(), res.end());
+	Wt::Dbo::collection<TrackId> res = session()->query<TrackId>("SELECT t_c.track_id FROM track_cluster t_c INNER JOIN cluster c ON c.id = t_c.cluster_id")
+		.where("c.id = ?").bind(getId());
 
+	return std::vector<TrackId>(res.begin(), res.end());
 }
 
 std::size_t
 Cluster::getReleasesCount() const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
 	return session()->query<int>("SELECT COUNT(DISTINCT r.id) FROM release r INNER JOIN track t on t.release_id = r.id INNER JOIN cluster c ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
-		.where("c.id = ?").bind(self()->id());
-
+		.where("c.id = ?").bind(getId());
 }
 
 
-ClusterType::ClusterType(std::string name)
-	: _name(name)
+ClusterType::ClusterType(std::string_view name)
+	: _name {name}
 {
 }
 
@@ -132,7 +122,7 @@ ClusterType::getAllOrphans(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
+	Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
 			"SELECT c_t from cluster_type c_t"
 			" LEFT OUTER JOIN cluster c ON c_t.id = c.cluster_type_id")
 		.where("c.id IS NULL");
@@ -145,7 +135,7 @@ ClusterType::getAllUsed(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
+	Wt::Dbo::collection<Wt::Dbo::ptr<ClusterType>> res = session.getDboSession().query<Wt::Dbo::ptr<ClusterType>>(
 			"SELECT DISTINCT c_t from cluster_type c_t")
 		.join("cluster c ON c_t.id = c.cluster_type_id");
 
@@ -157,15 +147,15 @@ ClusterType::getByName(Session& session, const std::string& name)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<ClusterType>().where("name = ?").bind(name);
+	return session.getDboSession().find<ClusterType>().where("name = ?").bind(name).resultValue();
 }
 
 ClusterType::pointer
-ClusterType::getById(Session& session, IdType id)
+ClusterType::getById(Session& session, ClusterTypeId id)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<ClusterType>().where("id= ?").bind(id);
+	return session.getDboSession().find<ClusterType>().where("id = ?").bind(id).resultValue();
 }
 
 std::vector<ClusterType::pointer>
@@ -173,8 +163,7 @@ ClusterType::getAll(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().find<ClusterType>();
-
+	auto res {session.getDboSession().find<ClusterType>().resultList()};
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
@@ -193,24 +182,23 @@ Cluster::pointer
 ClusterType::getCluster(const std::string& name) const
 {
 	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	return session()->find<Cluster>()
 		.where("name = ?").bind(name)
-		.where("cluster_type_id = ?").bind(self()->id());
+		.where("cluster_type_id = ?").bind(getId()).resultValue();
 }
 
 std::vector<Cluster::pointer>
 ClusterType::getClusters() const
 {
 	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
-	Wt::Dbo::collection<Cluster::pointer> res = session()->find<Cluster>()
-						.where("cluster_type_id = ?").bind(self()->id())
-						.orderBy("name");
+	auto res = session()->find<Cluster>()
+						.where("cluster_type_id = ?").bind(getId())
+						.orderBy("name")
+						.resultList();
 
 	return std::vector<Cluster::pointer>(res.begin(), res.end());
 }

src/libs/database/impl/Release.cpp

@@ -28,6 +28,7 @@
 #include "database/User.hpp"
 #include "utils/Logger.hpp"
 #include "SqlQuery.hpp"
+#include "Traits.hpp"
 #include "Utils.hpp"
 
 namespace Database
@@ -38,7 +39,7 @@ static
 Wt::Dbo::Query<T>
 createQuery(Session& session,
 			const std::string& queryStr,
-			const std::set<IdType>& clusterIds,
+			const std::vector<ClusterId>& clusterIds,
 			const std::vector<std::string_view>& keywords)
 {
 
@@ -57,7 +58,7 @@ createQuery(Session& session,
 			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
 
 		WhereClause clusterClause;
-		for (const IdType clusterId : clusterIds)
+		for (const ClusterId clusterId : clusterIds)
 		{
 			clusterClause.Or(WhereClause("c.id = ?"));
 			query.bind(clusterId);
@@ -76,7 +77,6 @@ Release::Release(const std::string& name, const std::optional<UUID>& MBID)
 : _name {std::string(name, 0 , _maxNameLength)},
 _MBID {MBID ? MBID->getAsString() : ""}
 {
-
 }
 
 std::vector<Release::pointer>
@@ -84,7 +84,11 @@ Release::getByName(Session& session, const std::string& name)
 {
 	session.checkUniqueLocked();
 
-	Wt::Dbo::collection<Release::pointer> res = session.getDboSession().find<Release>().where("name = ?").bind( std::string(name, 0, _maxNameLength) );
+	auto res {session.getDboSession()
+						.find<Release>()
+						.where("name = ?").bind( std::string(name, 0, _maxNameLength) )
+						.resultList()};
+
 	return std::vector<Release::pointer>(res.begin(), res.end());
 }
 
@@ -93,15 +97,21 @@ Release::getByMBID(Session& session, const UUID& mbid)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<Release>().where("mbid = ?").bind(std::string {mbid.getAsString()});
+	return session.getDboSession()
+					.find<Release>()
+					.where("mbid = ?").bind(std::string {mbid.getAsString()})
+					.resultValue();;
 }
 
 Release::pointer
-Release::getById(Session& session, IdType id)
+Release::getById(Session& session, ReleaseId id)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<Release>().where("id = ?").bind(id);
+	return session.getDboSession()
+					.find<Release>()
+					.where("id = ?").bind(id)
+					.resultValue();
 }
 
 Release::pointer
@@ -120,8 +130,7 @@ Release::getCount(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> releases {session.getDboSession().find<Release>()};
-	return releases.size();
+	return session.getDboSession().find<Release>().resultList().size();
 }
 
 std::vector<Release::pointer>
@@ -129,21 +138,22 @@ Release::getAll(Session& session, std::optional<Range> range)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().find<Release>()
+	auto res {session.getDboSession().find<Release>()
 		.offset(range ? static_cast<int>(range->offset) : -1)
 		.limit(range ? static_cast<int>(range->limit) : -1)
-		.orderBy("name COLLATE NOCASE");
+		.orderBy("name COLLATE NOCASE")
+		.resultList()};
 
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
-std::vector<IdType>
+std::vector<ReleaseId>
 Release::getAllIds(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>("SELECT id FROM release");
-	return std::vector<IdType>(res.begin(), res.end());
+	Wt::Dbo::collection<ReleaseId> res = session.getDboSession().query<ReleaseId>("SELECT id FROM release");
+	return std::vector<ReleaseId>(res.begin(), res.end());
 }
 
 std::vector<Release::pointer>
@@ -151,44 +161,45 @@ Release::getAllOrderedByArtist(Session& session, std::optional<std::size_t> offs
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().query<Wt::Dbo::ptr<Release>>(
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>(
 			"SELECT DISTINCT r FROM release r"
 			" INNER JOIN track t ON r.id = t.release_id"
 			" INNER JOIN track_artist_link t_a_l ON t_a_l.track_id = t.id"
 			" INNER JOIN artist a ON t_a_l.artist_id = a.id")
 		 .offset(offset ? static_cast<int>(*offset) : -1)
 		 .limit(size ? static_cast<int>(*size) : -1)
-		 .orderBy("a.name COLLATE NOCASE, r.name COLLATE NOCASE");
+		 .orderBy("a.name COLLATE NOCASE, r.name COLLATE NOCASE")
+		 .resultList()};
 
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
 std::vector<Release::pointer>
-Release::getAllRandom(Session& session, const std::set<IdType>& clusterIds, std::optional<std::size_t> size)
+Release::getAllRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> size)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Release::pointer>(session, "SELECT DISTINCT r from release r", clusterIds,{})};
-
-	Wt::Dbo::collection<pointer> res = query
+	auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT DISTINCT r from release r", clusterIds, {})};
+	auto res {query
 		.orderBy("RANDOM()")
-		.limit(size ? static_cast<int>(*size) : -1);
+		.limit(size ? static_cast<int>(*size) : -1)
+		.resultList()};
 
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
-std::vector<IdType>
-Release::getAllIdsRandom(Session& session, const std::set<IdType>& clusterIds, std::optional<std::size_t> size)
+std::vector<ReleaseId>
+Release::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> size)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<IdType>(session, "SELECT DISTINCT r.id from release r", clusterIds,{})};
+	auto query {createQuery<ReleaseId>(session, "SELECT DISTINCT r.id from release r", clusterIds, {})};
 
-	Wt::Dbo::collection<IdType> res = query
+	Wt::Dbo::collection<ReleaseId> res = query
 		.orderBy("RANDOM()")
 		.limit(size ? static_cast<int>(*size) : -1);
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<ReleaseId>(res.begin(), res.end());
 }
 
 
@@ -197,31 +208,31 @@ Release::getAllOrphans(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<Release::pointer> res = session.getDboSession().query<Wt::Dbo::ptr<Release>>("select r from release r LEFT OUTER JOIN Track t ON r.id = t.release_id WHERE t.id IS NULL");
-
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>("select r from release r LEFT OUTER JOIN Track t ON r.id = t.release_id WHERE t.id IS NULL").resultList()};
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
 std::vector<Release::pointer>
 Release::getLastWritten(Session& session,
 		std::optional<Wt::WDateTime> after,
-		const std::set<IdType>& clusterIds,
+		const std::vector<ClusterId>& clusterIds,
 		std::optional<Range> range,
 		bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Release::pointer>(session, "SELECT r from release r", clusterIds, {})};
+	auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, {})};
 	if (after)
 		query.where("t.file_last_write > ?").bind(after);
 
-	Wt::Dbo::collection<Release::pointer> collection = query
+	auto collection {query
 		.orderBy("t.file_last_write DESC")
 		.groupBy("r.id")
 		.offset(range ? static_cast<int>(range->offset) : -1)
-		.limit(range ? static_cast<int>(range->limit) + 1: -1);
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -236,13 +247,14 @@ Release::getLastWritten(Session& session,
 std::vector<Release::pointer>
 Release::getByYear(Session& session, int yearFrom, int yearTo, std::optional<Range> range)
 {
-	Wt::Dbo::collection<Release::pointer> res = session.getDboSession().query<Release::pointer>
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Release>>
 		("SELECT DISTINCT r from release r INNER JOIN track t ON r.id = t.release_id")
 		.where("t.year >= ?").bind(yearFrom)
 		.where("t.year <= ?").bind(yearTo)
 		.orderBy("t.year, r.name COLLATE NOCASE")
 		.offset(range ? static_cast<int>(range->offset) : -1)
-		.limit(range ? static_cast<int>(range->limit) : -1);
+		.limit(range ? static_cast<int>(range->limit) : -1)
+		.resultList()};
 
 	return std::vector<pointer>(res.begin(), res.end());
 }
@@ -250,30 +262,31 @@ Release::getByYear(Session& session, int yearFrom, int yearTo, std::optional<Ran
 std::vector<Release::pointer>
 Release::getStarred(Session& session,
 		User::pointer user,
-		const std::set<IdType>& clusterIds,
+		const std::vector<ClusterId>& clusterIds,
 		std::optional<Range> range,
 		bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Release::pointer>(session, "SELECT r from release r", clusterIds, {})};
+	auto query {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, {})};
 	{
 		std::ostringstream oss;
 		oss << "r.id IN (SELECT DISTINCT r.id FROM release r"
 			" INNER JOIN user_release_starred urs ON urs.release_id = r.id"
 			" INNER JOIN user u ON u.id = urs.user_id WHERE u.id = ?)";
 
-		query.bind(user.id());
+		query.bind(user->getId());
 		query.where(oss.str());
 	}
 
-	Wt::Dbo::collection<Release::pointer> collection = query
+	auto collection {query
 		.groupBy("r.id")
 		.orderBy("r.name COLLATE NOCASE")
 		.offset(range ? static_cast<int>(range->offset) : -1)
-		.limit(range ? static_cast<int>(range->limit) + 1: -1);
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -288,7 +301,7 @@ Release::getStarred(Session& session,
 }
 
 std::vector<Release::pointer>
-Release::getByClusters(Session& session, const std::set<IdType>& clusters)
+Release::getByClusters(Session& session, const std::vector<ClusterId>& clusters)
 {
 	assert(!clusters.empty());
 
@@ -300,21 +313,21 @@ Release::getByClusters(Session& session, const std::set<IdType>& clusters)
 
 std::vector<Release::pointer>
 Release::getByFilter(Session& session,
-		const std::set<IdType>& clusterIds,
+		const std::vector<ClusterId>& clusterIds,
 		const std::vector<std::string_view>& keywords,
 		std::optional<Range> range,
 		bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> collection = createQuery<Release::pointer>(session, "SELECT r from release r", clusterIds, keywords)
+	auto collection {createQuery<Wt::Dbo::ptr<Release>>(session, "SELECT r from release r", clusterIds, keywords)
 		.groupBy("r.id")
 		.orderBy("r.name COLLATE NOCASE")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
-
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
+	std::vector<pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -326,18 +339,18 @@ Release::getByFilter(Session& session,
 	return res;
 }
 
-std::vector<IdType>
+std::vector<ReleaseId>
 Release::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>
+	Wt::Dbo::collection<ReleaseId> res = session.getDboSession().query<ReleaseId>
 		("SELECT DISTINCT r.id FROM release r"
 		 	" INNER JOIN track t ON t.release_id = r.id"
 		 	" INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
 		.limit(limit ? static_cast<int>(*limit) : -1);
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<ReleaseId>(res.begin(), res.end());
 }
 
 
@@ -345,11 +358,10 @@ std::optional<std::size_t>
 Release::getTotalTrack(void) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
 	int res = session()->query<int>("SELECT COALESCE(MAX(total_track),0) FROM track t INNER JOIN release r ON r.id = t.release_id")
 		.where("r.id = ?")
-		.bind(this->id());
+		.bind(getId());
 
 	return (res > 0) ? std::make_optional<std::size_t>(res) : std::nullopt;
 }
@@ -358,11 +370,10 @@ std::optional<std::size_t>
 Release::getTotalDisc(void) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
 	int res = session()->query<int>("SELECT COALESCE(MAX(total_disc),0) FROM track t INNER JOIN release r ON r.id = t.release_id")
 		.where("r.id = ?")
-		.bind(this->id());
+		.bind(getId());
 
 	return (res > 0) ? std::make_optional<std::size_t>(res) : std::nullopt;
 }
@@ -372,13 +383,13 @@ Release::getReleaseYear(bool original) const
 {
 	assert(session());
 
-	const std::string field {original ? "original_year" : "year"};
+	const char* field {original ? "original_year" : "year"};
 
 	Wt::Dbo::collection<int> dates = session()->query<int>(
 			std::string {"SELECT "} + "t." + field + " FROM track t INNER JOIN release r ON r.id = t.release_id")
 		.where("r.id = ?")
 		.groupBy(field)
-		.bind(this->id());
+		.bind(getId());
 
 	// various dates => no date
 	if (dates.empty() || dates.size() > 1)
@@ -388,8 +399,8 @@ Release::getReleaseYear(bool original) const
 
 	if (date > 0)
 		return date;
-	else
-		return std::nullopt;
+
+	return std::nullopt;
 }
 
 std::optional<std::string>
@@ -401,7 +412,7 @@ Release::getCopyright() const
 		("SELECT copyright FROM track t INNER JOIN release r ON r.id = t.release_id")
 		.where("r.id = ?")
 		.groupBy("copyright")
-		.bind(this->id());
+		.bind(getId());
 
 	std::vector<std::string> values(copyrights.begin(), copyrights.end());
 
@@ -421,7 +432,7 @@ Release::getCopyrightURL() const
 		("SELECT copyright_url FROM track t INNER JOIN release r ON r.id = t.release_id")
 		.where("r.id = ?")
 		.groupBy("copyright_url")
-		.bind(this->id());
+		.bind(getId());
 
 	std::vector<std::string> values(copyrights.begin(), copyrights.end());
 
@@ -432,32 +443,29 @@ Release::getCopyrightURL() const
 	return values.front();
 }
 
-std::vector<Wt::Dbo::ptr<Artist>>
+std::vector<Artist::pointer>
 Release::getArtists(TrackArtistLinkType linkType) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
-	Wt::Dbo::collection<Wt::Dbo::ptr<Artist>> res = session()->query<Wt::Dbo::ptr<Artist>>(
+	auto res {session()->query<Wt::Dbo::ptr<Artist>>(
 			"SELECT DISTINCT a FROM artist a"
 			" INNER JOIN track_artist_link t_a_l ON t_a_l.artist_id = a.id"
 			" INNER JOIN track t ON t.id = t_a_l.track_id"
 			" INNER JOIN release r ON r.id = t.release_id")
-		.where("r.id = ?").bind(self()->id())
-		.where("t_a_l.type = ?").bind(linkType);
+		.where("r.id = ?").bind(getId())
+		.where("t_a_l.type = ?").bind(linkType)
+		.resultList()};
 
-	return std::vector<Wt::Dbo::ptr<Artist>>(res.begin(), res.end());
+	return std::vector<Artist::pointer>(res.begin(), res.end());
 }
 
 std::vector<Release::pointer>
 Release::getSimilarReleases(std::optional<std::size_t> offset, std::optional<std::size_t> count) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
-	Wt::Dbo::Query<pointer> query {session()->query<pointer>(
+	auto res {session()->query<Wt::Dbo::ptr<Release>>(
 			"SELECT r FROM release r"
 			" INNER JOIN track t ON t.release_id = r.id"
 			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
@@ -465,14 +473,14 @@ Release::getSimilarReleases(std::optional<std::size_t> offset, std::optional<std
 					" t_c.cluster_id IN (SELECT c.id from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN release r ON r.id = t.release_id WHERE r.id = ?)"
 					" AND r.id <> ?"
 				)
-		.bind(self()->id())
-		.bind(self()->id())
+		.bind(getId())
+		.bind(getId())
 		.groupBy("r.id")
 		.orderBy("COUNT(*) DESC, RANDOM()")
 		.limit(count ? static_cast<int>(*count) : -1)
-		.offset(offset ? static_cast<int>(*offset) : -1)};
+		.offset(offset ? static_cast<int>(*offset) : -1)
+		.resultList()};
 
-	Wt::Dbo::collection<pointer> res = query;
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
@@ -483,11 +491,9 @@ Release::hasVariousArtists() const
 	return getArtists().size() > 1;
 }
 
-std::vector<Wt::Dbo::ptr<Track>>
-Release::getTracks(const std::set<IdType>& clusterIds) const
+std::vector<Track::pointer>
+Release::getTracks(const std::vector<ClusterId>& clusterIds) const
 {
-	assert(self());
-	assert(self()->id() != Wt::Dbo::dbo_traits<Release>::invalidId() );
 	assert(session());
 
 	WhereClause where;
@@ -502,12 +508,12 @@ Release::getTracks(const std::set<IdType>& clusterIds) const
 		WhereClause clusterClause;
 
 		for (auto id : clusterIds)
-			clusterClause.Or(WhereClause("c.id = ?")).bind(std::to_string(id));
+			clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString());
 
 		where.And(clusterClause);
 	}
 
-	where.And(WhereClause("r.id = ?")).bind(std::to_string(id()));
+	where.And(WhereClause("r.id = ?")).bind(getId().toString());
 
 	oss << " " << where.get();
 
@@ -516,16 +522,12 @@ Release::getTracks(const std::set<IdType>& clusterIds) const
 
 	oss << " ORDER BY t.disc_number,t.track_number";
 
-	Wt::Dbo::Query<Track::pointer> query = session()->query<Track::pointer>( oss.str() );
-
+	auto query {session()->query<Wt::Dbo::ptr<Track>>(oss.str())};
 	for (const std::string& bindArg : where.getBindArgs())
-	{
 		query.bind(bindArg);
-	}
 
-	Wt::Dbo::collection< Wt::Dbo::ptr<Track> > res = query;
-
-	return std::vector< Wt::Dbo::ptr<Track> > (res.begin(), res.end());
+	auto res {query.resultList()};
+	return std::vector<Track::pointer> (res.begin(), res.end());
 }
 
 std::size_t
@@ -534,31 +536,28 @@ Release::getTracksCount() const
 	return _tracks.size();
 }
 
-Wt::Dbo::ptr<Track>
+Track::pointer
 Release::getFirstTrack() const
 {
-	assert(self());
-	assert(self()->id() != Wt::Dbo::dbo_traits<Artist>::invalidId());
 	assert(session());
 
-	return session()->query<Track::pointer>("SELECT t from track t")
+	return session()->query<Wt::Dbo::ptr<Track>>("SELECT t from track t")
 		.join("release r ON t.release_id = r.id")
-		.where("r.id = ?").bind(self()->id())
+		.where("r.id = ?").bind(getId())
 		.orderBy("t.disc_number,t.track_number")
-		.limit(1);
+		.limit(1)
+		.resultValue();
 }
 
 std::chrono::milliseconds
 Release::getDuration() const
 {
-	assert(self());
-	assert(self()->id() != Wt::Dbo::dbo_traits<Artist>::invalidId());
 	assert(session());
 
 	using milli = std::chrono::duration<int, std::milli>;
 
 	Wt::Dbo::Query<milli> query {session()->query<milli>("SELECT COALESCE(SUM(duration), 0) FROM track t INNER JOIN release r ON t.release_id = r.id")
-			.where("r.id = ?").bind(self()->id())};
+			.where("r.id = ?").bind(getId())};
 
 	return query.resultValue();
 }
@@ -566,21 +565,17 @@ Release::getDuration() const
 Wt::WDateTime
 Release::getLastWritten() const
 {
-	assert(self());
-	assert(self()->id() != Wt::Dbo::dbo_traits<Artist>::invalidId());
 	assert(session());
 
 	Wt::Dbo::Query<Wt::WDateTime> query {session()->query<Wt::WDateTime>("SELECT COALESCE(MAX(file_last_write), '1970-01-01T00:00:00') FROM track t INNER JOIN release r ON t.release_id = r.id")
-			.where("r.id = ?").bind(self()->id())};
+			.where("r.id = ?").bind(getId())};
 
 	return query.resultValue();
 }
 
-std::vector<std::vector<Wt::Dbo::ptr<Cluster>>>
-Release::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const
+std::vector<std::vector<Cluster::pointer>>
+Release::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
 {
-	assert(self());
-	assert(self()->id() != Wt::Dbo::dbo_traits<Artist>::invalidId() );
 	assert(session());
 
 	WhereClause where;
@@ -589,33 +584,32 @@ Release::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::s
 
 	oss << "SELECT c from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id INNER JOIN release r ON t.release_id = r.id ";
 
-	where.And(WhereClause("r.id = ?")).bind(std::to_string(self()->id()));
+	where.And(WhereClause("r.id = ?")).bind(getId().toString());
 	{
 		WhereClause clusterClause;
 		for (auto clusterType : clusterTypes)
-			clusterClause.Or(WhereClause("c_type.id = ?")).bind(std::to_string(clusterType.id()));
+			clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
 		where.And(clusterClause);
 	}
 	oss << " " << where.get();
 	oss << " GROUP BY c.id ORDER BY COUNT(c.id) DESC";
 
-	Wt::Dbo::Query<Cluster::pointer> query = session()->query<Cluster::pointer>( oss.str() );
-
+	auto query {session()->query<Wt::Dbo::ptr<Cluster>>(oss.str())};
 	for (const std::string& bindArg : where.getBindArgs())
 		query.bind(bindArg);
 
-	Wt::Dbo::collection<Cluster::pointer> queryRes = query;
+	auto queryRes {query.resultList()};
 
-	std::map<IdType, std::vector<Cluster::pointer>> clusters;
-	for (auto cluster : queryRes)
+	std::map<ClusterTypeId, std::vector<Cluster::pointer>> clustersByType;
+	for (const Wt::Dbo::ptr<Cluster>& cluster : queryRes)
 	{
-		if (clusters[cluster->getType().id()].size() < size)
-			clusters[cluster->getType().id()].push_back(cluster);
+		if (clustersByType[cluster->getType()->getId()].size() < size)
+			clustersByType[cluster->getType()->getId()].push_back(cluster);
 	}
 
 	std::vector<std::vector<Cluster::pointer>> res;
-	for (auto cluster_list : clusters)
-		res.push_back(cluster_list.second);
+	for (const auto& [clusterTypeId, clusters] : clustersByType)
+		res.push_back(clusters);
 
 	return res;
 }

src/libs/database/impl/ScanSettings.cpp

@@ -60,14 +60,14 @@ ScanSettings::get(Session& session)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<ScanSettings>();
+	return session.getDboSession().find<ScanSettings>().resultValue();
 }
 
-std::unordered_set<std::filesystem::path>
+std::vector<std::filesystem::path>
 ScanSettings::getAudioFileExtensions() const
 {
-	auto extensions = StringUtils::splitString(_audioFileExtensions, " ");
-	return std::unordered_set<std::filesystem::path>(std::cbegin(extensions), std::cend(extensions));
+	const auto extensions {StringUtils::splitString(_audioFileExtensions, " ")};
+	return std::vector<std::filesystem::path>(std::cbegin(extensions), std::cend(extensions));
 }
 
 void
@@ -111,19 +111,19 @@ ScanSettings::setClusterTypes(Session& session, const std::set<std::string>& clu
 	// Create any missing cluster type
 	for (const std::string& clusterTypeName : clusterTypeNames)
 	{
-		auto clusterType {ClusterType::getByName(session, clusterTypeName)};
+		ClusterType::pointer clusterType {ClusterType::getByName(session, clusterTypeName)};
 		if (!clusterType)
 		{
 			LMS_LOG(DB, INFO) << "Creating cluster type " << clusterTypeName;
 			clusterType = ClusterType::create(session, clusterTypeName);
-			_clusterTypes.insert(clusterType);
+			_clusterTypes.insert(getDboPtr(clusterType));
 
 			needRescan = true;
 		}
 	}
 
 	// Delete no longer existing cluster types
-	for (ClusterType::pointer& clusterType : _clusterTypes)
+	for (Wt::Dbo::ptr<ClusterType> clusterType : _clusterTypes)
 	{
 		if (std::none_of(clusterTypeNames.begin(), clusterTypeNames.end(),
 			[clusterType](const std::string& name) { return name == clusterType->getName(); }))

src/libs/database/impl/Track.cpp

@@ -27,10 +27,12 @@
 #include "database/TrackArtistLink.hpp"
 #include "database/TrackFeatures.hpp"
 #include "database/Session.hpp"
+#include "database/User.hpp"
 #include "utils/Logger.hpp"
 
 #include "SqlQuery.hpp"
 #include "StringViewTraits.hpp"
+#include "Traits.hpp"
 #include "Utils.hpp"
 
 namespace Database {
@@ -40,7 +42,7 @@ static
 Wt::Dbo::Query<T>
 createQuery(Session& session,
 		const std::string& queryStr,
-		const std::set<IdType>& clusterIds,
+		const std::vector<ClusterId>& clusterIds,
 		const std::vector<std::string_view>& keywords)
 {
 	session.checkSharedLocked();
@@ -58,7 +60,7 @@ createQuery(Session& session,
 			" INNER JOIN cluster c ON c.id = t_c.cluster_id";
 
 		WhereClause clusterClause;
-		for (const IdType clusterId : clusterIds)
+		for (const ClusterId clusterId : clusterIds)
 		{
 			clusterClause.Or(WhereClause("c.id = ?"));
 			query.bind(clusterId);
@@ -91,48 +93,49 @@ Track::getAll(Session& session, std::optional<std::size_t> limit)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<Track::pointer> res {session.getDboSession().find<Track>()
-		.limit(limit ? static_cast<int>(*limit) : -1)};
+	auto res {session.getDboSession().find<Track>()
+		.limit(limit ? static_cast<int>(*limit) : -1)
+		.resultList()};
 
 	return std::vector<Track::pointer>(std::cbegin(res), std::cend(res));
 }
 
 std::vector<Track::pointer>
-Track::getAllRandom(Session& session, const std::set<IdType>& clusterIds, std::optional<std::size_t> limit)
+Track::getAllRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> limit)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Track::pointer>(session, "SELECT t from track t", clusterIds, {})};
-
-	Wt::Dbo::collection<Track::pointer> collection = query
+	auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
+	auto collection {query
 		.orderBy("RANDOM()")
-		.limit(limit ? static_cast<int>(*limit) + 1: -1);
+		.limit(limit ? static_cast<int>(*limit) + 1: -1)
+		.resultList()};
 
 	return std::vector<pointer>(collection.begin(), collection.end());
 }
 
-std::vector<Database::IdType>
-Track::getAllIdsRandom(Session& session, const std::set<IdType>& clusterIds, std::optional<std::size_t> limit)
+std::vector<TrackId>
+Track::getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusterIds, std::optional<std::size_t> limit)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<IdType>(session, "SELECT t.id from track t", clusterIds, {})};
+	auto query {createQuery<TrackId>(session, "SELECT t.id from track t", clusterIds, {})};
 
-	Wt::Dbo::collection<IdType> collection = query
+	Wt::Dbo::collection<TrackId> collection = query
 		.orderBy("RANDOM()")
 		.limit(limit ? static_cast<int>(*limit) + 1: -1);
 
-	return std::vector<IdType>(collection.begin(), collection.end());
+	return std::vector<TrackId>(collection.begin(), collection.end());
 }
 
 
-std::vector<IdType>
+std::vector<TrackId>
 Track::getAllIds(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>("SELECT id FROM track");
-	return std::vector<IdType>(res.begin(), res.end());
+	Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>("SELECT id FROM track");
+	return std::vector<TrackId>(res.begin(), res.end());
 }
 
 Track::pointer
@@ -140,16 +143,17 @@ Track::getByPath(Session& session, const std::filesystem::path& p)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<Track>().where("file_path = ?").bind(p.string());
+	return session.getDboSession().find<Track>().where("file_path = ?").bind(p.string()).resultValue();
 }
 
 Track::pointer
-Track::getById(Session& session, IdType id)
+Track::getById(Session& session, TrackId id)
 {
 	session.checkSharedLocked();
 
 	return session.getDboSession().find<Track>()
-		.where("id = ?").bind(id);
+		.where("id = ?").bind(id)
+		.resultValue();
 }
 
 std::vector<Track::pointer>
@@ -157,8 +161,9 @@ Track::getByRecordingMBID(Session& session, const UUID& mbid)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<Track::pointer> res = session.getDboSession().find<Track>()
-		.where("recording_mbid = ?").bind(std::string {mbid.getAsString()});
+	auto res {session.getDboSession().find<Track>()
+		.where("recording_mbid = ?").bind(std::string {mbid.getAsString()})
+		.resultList()};
 
 	return std::vector<Track::pointer>(res.begin(), res.end());
 }
@@ -174,17 +179,17 @@ Track::create(Session& session, const std::filesystem::path& p)
 	return res;
 }
 
-std::vector<std::pair<IdType, std::filesystem::path>>
+std::vector<std::pair<TrackId, std::filesystem::path>>
 Track::getAllPaths(Session& session, std::optional<std::size_t> offset, std::optional<std::size_t> size)
 {
-	using QueryResultType = std::tuple<IdType, std::string>;
+	using QueryResultType = std::tuple<TrackId, std::string>;
 	session.checkSharedLocked();
 
 	Wt::Dbo::collection<QueryResultType> queryRes = session.getDboSession().query<QueryResultType>("SELECT id,file_path FROM track")
 		.limit(size ? static_cast<int>(*size) + 1 : -1)
 		.offset(offset ? static_cast<int>(*offset) : -1);
 
-	std::vector<std::pair<IdType, std::filesystem::path>> result;
+	std::vector<std::pair<TrackId, std::filesystem::path>> result;
 	result.reserve(queryRes.size());
 
 	std::transform(std::begin(queryRes), std::end(queryRes), std::back_inserter(result),
@@ -201,26 +206,29 @@ Track::getMBIDDuplicates(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().query<pointer>( "SELECT track FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)").orderBy("track.release_id,track.disc_number,track.track_number,track.mbid");
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>( "SELECT track FROM track WHERE mbid in (SELECT mbid FROM track WHERE mbid <> '' GROUP BY mbid HAVING COUNT (*) > 1)")
+		.orderBy("track.release_id,track.disc_number,track.track_number,track.mbid")
+		.resultList()};
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
 std::vector<Track::pointer>
-Track::getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults)
+Track::getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Track::pointer>(session, "SELECT t from track t", clusterIds, {})};
+	auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
 	if (after)
 		query.where("t.file_last_write > ?").bind(after);
 
-	Wt::Dbo::collection<Track::pointer> collection = query
+	auto collection {query
 		.orderBy("t.file_last_write DESC")
 		.groupBy("t.id")
 		.offset(range ? static_cast<int>(range->offset) : -1)
-		.limit(range ? static_cast<int>(range->limit) + 1: -1);
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -237,63 +245,65 @@ Track::getAllWithRecordingMBIDAndMissingFeatures(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().query<pointer>
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>
 		("SELECT t FROM track t")
 		.where("LENGTH(t.recording_mbid) > 0")
-		.where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)");
+		.where("NOT EXISTS (SELECT * FROM track_features t_f WHERE t_f.track_id = t.id)")
+		.resultList()};
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
-std::vector<IdType>
+std::vector<TrackId>
 Track::getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>
+	Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>
 		("SELECT t.id FROM track t")
 		.where("EXISTS (SELECT * from track_features t_f WHERE t_f.track_id = t.id)")
 		.limit(limit ? static_cast<int>(*limit) : -1);
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<TrackId>(res.begin(), res.end());
 }
 
-std::vector<IdType>
+std::vector<TrackId>
 Track::getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>
+	Wt::Dbo::collection<TrackId> res = session.getDboSession().query<TrackId>
 		("SELECT DISTINCT t.id FROM track t"
 		 	" INNER JOIN track_cluster t_c ON t_c.track_id = t.id")
 		.limit(limit ? static_cast<int>(*limit) : -1);
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<TrackId>(res.begin(), res.end());
 }
 
 std::vector<Track::pointer>
 Track::getStarred(Session& session,
-		Wt::Dbo::ptr<User> user,
-		const std::set<IdType>& clusterIds,
+		ObjectPtr<User> user,
+		const std::vector<ClusterId>& clusterIds,
 		std::optional<Range> range, bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	auto query {createQuery<Track::pointer>(session, "SELECT t from track t", clusterIds, {})};
+	auto query {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, {})};
 	{
 		std::ostringstream oss;
 		oss << "t.id IN (SELECT DISTINCT t.id FROM track t"
 			" INNER JOIN user_track_starred uts ON uts.track_id = t.id"
 			" INNER JOIN user u ON u.id = uts.user_id WHERE u.id = ?)";
 
-		query.bind(user.id());
+		query.bind(user->getId().toString());
 		query.where(oss.str());
 	}
 
-	Wt::Dbo::collection<Track::pointer> collection = query
+	auto collection {query
 		.offset(range ? static_cast<int>(range->offset) : -1)
-		.limit(range ? static_cast<int>(range->limit) + 1: -1);
+		.limit(range ? static_cast<int>(range->limit) + 1: -1)
+		.resultList()};
 
-	auto res {std::vector<pointer>(collection.begin(), collection.end())};
+	std::vector<pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -308,43 +318,41 @@ Track::getStarred(Session& session,
 std::vector<Cluster::pointer>
 Track::getClusters() const
 {
-	std::vector< Cluster::pointer > clusters;
-	std::copy(_clusters.begin(), _clusters.end(), std::back_inserter(clusters));
-	return clusters;
+	return std::vector<Cluster::pointer>(_clusters.begin(), _clusters.end());
 }
 
-std::vector<IdType>
+std::vector<ClusterId>
 Track::getClusterIds() const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
-	Wt::Dbo::collection<IdType> res = session()->query<IdType>
+	auto res {session()->query<ClusterId>
 		("SELECT DISTINCT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id INNER JOIN track t ON t.id = t_c.track_id")
-		.where("t.id = ?").bind(self()->id());
+		.where("t.id = ?").bind(getId())
+		.resultList()};
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<ClusterId>(res.begin(), res.end());
 }
 
 bool
 Track::hasTrackFeatures() const
 {
-	return (_trackFeatures.lock() != Database::TrackFeatures::pointer());
+	return (_trackFeatures.lock() != Wt::Dbo::ptr<Database::TrackFeatures> {});
 }
 
 std::vector<Track::pointer>
 Track::getByFilter(Session& session,
-		const std::set<IdType>& clusterIds,
+		const std::vector<ClusterId>& clusterIds,
 		const std::vector<std::string_view>& keywords,
 		std::optional<Range> range,
 		bool& moreResults)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> collection = createQuery<Track::pointer>(session, "SELECT t from track t", clusterIds, keywords)
+	auto collection {createQuery<Wt::Dbo::ptr<Track>>(session, "SELECT t from track t", clusterIds, keywords)
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
 	std::vector<pointer> res(collection.begin(), collection.end());
 	if (range && (res.size() == static_cast<std::size_t>(range->limit) + 1))
@@ -362,17 +370,18 @@ std::vector<Track::pointer>
 Track::getByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName)
 {
 	session.checkSharedLocked();
-	Wt::Dbo::collection<pointer> collection = session.getDboSession().query<Track::pointer>("SELECT t from track t")
+
+	auto res {session.getDboSession().query<Wt::Dbo::ptr<Track>>("SELECT t from track t")
 		.join("release r ON t.release_id = r.id")
 		.where("t.name = ?").bind(trackName)
-		.where("r.name = ?").bind(releaseName);
-
-	return std::vector<pointer>(collection.begin(), collection.end());
+		.where("r.name = ?").bind(releaseName)
+		.resultList()};
+	return std::vector<pointer>(res.begin(), res.end());
 }
 
 std::vector<Track::pointer>
 Track::getSimilarTracks(Session& session,
-				const std::unordered_set<IdType>& tracks,
+				const std::vector<TrackId>& tracks,
 				std::optional<std::size_t> offset,
 				std::optional<std::size_t> size)
 {
@@ -387,7 +396,7 @@ Track::getSimilarTracks(Session& session,
 		oss << "?";
 	}
 
-	Wt::Dbo::Query<pointer> query {session.getDboSession().query<pointer>(
+	auto query {session.getDboSession().query<Wt::Dbo::ptr<Track>>(
 			"SELECT t FROM track t"
 			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
 					" AND t_c.cluster_id IN (SELECT c.id FROM cluster c INNER JOIN track_cluster t_c ON t_c.cluster_id = c.id WHERE t_c.track_id IN (" + oss.str() + "))"
@@ -397,19 +406,18 @@ Track::getSimilarTracks(Session& session,
 		.limit(size ? static_cast<int>(*size) : -1)
 		.offset(offset ? static_cast<int>(*offset) : -1)};
 
-	for (IdType trackId : tracks)
-		query.bind(trackId );
+	for (TrackId trackId : tracks)
+		query.bind(trackId);
 
-	for (IdType trackId : tracks)
-		query.bind(trackId );
+	for (TrackId trackId : tracks)
+		query.bind(trackId);
 
-	Wt::Dbo::collection<pointer> res = query;
+	auto res {query.resultList()};
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
 std::vector<Track::pointer>
-Track::getByClusters(Session& session,
-			const std::set<IdType>& clusters)
+Track::getByClusters(Session& session, const std::vector<ClusterId>& clusters)
 {
 	assert(!clusters.empty());
 	session.checkSharedLocked();
@@ -429,23 +437,23 @@ Track::clearArtistLinks()
 }
 
 void
-Track::addArtistLink(const Wt::Dbo::ptr<TrackArtistLink>& artistLink)
+Track::addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink)
 {
-	_trackArtistLinks.insert(artistLink);
+	_trackArtistLinks.insert(getDboPtr(artistLink));
 }
 
 void
-Track::setClusters(const std::vector<Wt::Dbo::ptr<Cluster>>& clusters)
+Track::setClusters(const std::vector<ObjectPtr<Cluster>>& clusters)
 {
 	_clusters.clear();
-	for (const Wt::Dbo::ptr<Cluster>& cluster : clusters)
-		_clusters.insert(cluster);
+	for (const ObjectPtr<Cluster>& cluster : clusters)
+		_clusters.insert(getDboPtr(cluster));
 }
 
 void
-Track::setFeatures(const Wt::Dbo::ptr<TrackFeatures>& features)
+Track::setFeatures(const ObjectPtr<TrackFeatures>& features)
 {
-	_trackFeatures = features;
+	_trackFeatures = getDboPtr(features);
 }
 
 std::optional<std::size_t>
@@ -496,11 +504,9 @@ Track::getCopyrightURL() const
 	return _copyrightURL != "" ? std::make_optional<std::string>(_copyrightURL) : std::nullopt;
 }
 
-std::vector<Wt::Dbo::ptr<Artist>>
+std::vector<Artist::pointer>
 Track::getArtists(EnumSet<TrackArtistLinkType> linkTypes) const
 {
-	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	std::ostringstream oss;
@@ -525,22 +531,20 @@ Track::getArtists(EnumSet<TrackArtistLinkType> linkTypes) const
 		oss << ")";
 	}
 
-	Wt::Dbo::Query<Artist::pointer> query {session()->query<Artist::pointer>(oss.str())};
-
+	auto query {session()->query<Wt::Dbo::ptr<Artist>>(oss.str())};
 	for (TrackArtistLinkType type : linkTypes)
 		query.bind(type);
 
-	query.where("t.id = ?").bind(self()->id());
+	query.where("t.id = ?").bind(getId());
 
-	Wt::Dbo::collection<Artist::pointer> res = query;
+	auto res {query.resultList()};
 	return std::vector<Artist::pointer>(std::begin(res), std::end(res));
 }
 
-std::vector<IdType>
+std::vector<ArtistId>
 Track::getArtistIds(EnumSet<TrackArtistLinkType> linkTypes) const
 {
 	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	std::ostringstream oss;
@@ -565,33 +569,32 @@ Track::getArtistIds(EnumSet<TrackArtistLinkType> linkTypes) const
 		oss << ")";
 	}
 
-	Wt::Dbo::Query<IdType> query {session()->query<IdType>(oss.str())
-		.where("t.id = ?").bind(self()->id())};
+	Wt::Dbo::Query<ArtistId> query {session()->query<ArtistId>(oss.str())
+		.where("t.id = ?").bind(getId())};
 
 	for (TrackArtistLinkType type : linkTypes)
 		query.bind(type);
 
-	Wt::Dbo::collection<IdType> res = query;
-	return std::vector<IdType>(std::begin(res), std::end(res));
+	Wt::Dbo::collection<ArtistId> res = query;
+	return std::vector<ArtistId>(std::begin(res), std::end(res));
 }
 
-std::vector<Wt::Dbo::ptr<TrackArtistLink>>
+std::vector<TrackArtistLink::pointer>
 Track::getArtistLinks() const
 {
-	return std::vector<Wt::Dbo::ptr<TrackArtistLink>>(_trackArtistLinks.begin(), _trackArtistLinks.end());
+	return std::vector<TrackArtistLink::pointer>(_trackArtistLinks.begin(), _trackArtistLinks.end());
 }
 
-Wt::Dbo::ptr<TrackFeatures>
+ObjectPtr<TrackFeatures>
 Track::getTrackFeatures() const
 {
 	return _trackFeatures.lock();
 }
 
 std::vector<std::vector<Cluster::pointer>>
-Track::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::size_t size) const
+Track::getClusterGroups(const std::vector<ClusterType::pointer>& clusterTypes, std::size_t size) const
 {
 	assert(self());
-	assert(IdIsValid(self()->id()));
 	assert(session());
 
 	WhereClause where;
@@ -600,28 +603,27 @@ Track::getClusterGroups(std::vector<ClusterType::pointer> clusterTypes, std::siz
 
 	oss << "SELECT c from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN cluster_type c_type ON c.cluster_type_id = c_type.id";
 
-	where.And(WhereClause("t.id = ?")).bind(std::to_string(self()->id()));
+	where.And(WhereClause("t.id = ?")).bind(getId().toString());
 	{
 		WhereClause clusterClause;
 		for (auto clusterType : clusterTypes)
-			clusterClause.Or(WhereClause("c_type.id = ?")).bind(std::to_string(clusterType.id()));
+			clusterClause.Or(WhereClause("c_type.id = ?")).bind(clusterType->getId().toString());
 		where.And(clusterClause);
 	}
 	oss << " " << where.get();
 	oss << " GROUP BY c.id ORDER BY COUNT(c.id) DESC";
 
-	Wt::Dbo::Query<Cluster::pointer> query = session()->query<Cluster::pointer>( oss.str() );
-
+	auto query {session()->query<Wt::Dbo::ptr<Cluster>>(oss.str())};
 	for (const std::string& bindArg : where.getBindArgs())
 		query.bind(bindArg);
 
-	Wt::Dbo::collection<Cluster::pointer> queryRes = query;
+	auto queryRes {query.resultList()};
 
-	std::map<IdType, std::vector<Cluster::pointer>> clusters;
-	for (auto cluster : queryRes)
+	std::map<ClusterTypeId, std::vector<Cluster::pointer>> clusters;
+	for (const Wt::Dbo::ptr<Cluster>& cluster : queryRes)
 	{
-		if (clusters[cluster->getType().id()].size() < size)
-			clusters[cluster->getType().id()].push_back(cluster);
+		if (clusters[cluster->getType()->getId()].size() < size)
+			clusters[cluster->getType()->getId()].push_back(cluster);
 	}
 
 	std::vector<std::vector<Cluster::pointer>> res;

src/libs/database/impl/TrackArtistLink.cpp

@@ -23,17 +23,19 @@
 #include "database/Session.hpp"
 #include "database/Track.hpp"
 
+#include "Traits.hpp"
+
 namespace Database {
 
-TrackArtistLink::TrackArtistLink(Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<Artist> artist, TrackArtistLinkType type)
+TrackArtistLink::TrackArtistLink(ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type)
 : _type {type},
-_track {track},
-_artist {artist}
+_track {getDboPtr(track)},
+_artist {getDboPtr(artist)}
 {
 }
 
 TrackArtistLink::pointer
-TrackArtistLink::create(Session& session, Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<Artist> artist, TrackArtistLinkType type)
+TrackArtistLink::create(Session& session, ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type)
 {
 	session.checkUniqueLocked();
 
@@ -48,9 +50,9 @@ TrackArtistLink::getUsedTypes(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<TrackArtistLinkType> collection = session.getDboSession().query<TrackArtistLinkType>("SELECT DISTINCT type from track_artist_link");
+	auto res {session.getDboSession().query<TrackArtistLinkType>("SELECT DISTINCT type from track_artist_link").resultList()};
 
-	return EnumSet<TrackArtistLinkType>(std::begin(collection), std::end(collection));
+	return EnumSet<TrackArtistLinkType>(std::begin(res), std::end(res));
 }
 
 }

src/libs/database/impl/TrackBookmark.cpp

@@ -22,18 +22,18 @@
 #include "database/Session.hpp"
 #include "database/Track.hpp"
 #include "database/User.hpp"
+#include "Traits.hpp"
 
 namespace Database {
 
-TrackBookmark::TrackBookmark(Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track)
-: _user {user},
-_track {track}
+TrackBookmark::TrackBookmark(ObjectPtr<User> user, ObjectPtr<Track> track)
+: _user {getDboPtr(user)},
+_track {getDboPtr(track)}
 {
 }
 
-
 TrackBookmark::pointer
-TrackBookmark::create(Session& session, Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track)
+TrackBookmark::create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track)
 {
 	session.checkUniqueLocked();
 
@@ -48,42 +48,41 @@ TrackBookmark::getAll(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<TrackBookmark::pointer> res {session.getDboSession().find<TrackBookmark>()};
-
+	auto res {session.getDboSession().find<TrackBookmark>().resultList()};
 	return std::vector<TrackBookmark::pointer>(std::cbegin(res), std::cend(res));
 }
 
 std::vector<TrackBookmark::pointer>
-TrackBookmark::getByUser(Session& session, Wt::Dbo::ptr<User> user)
+TrackBookmark::getByUser(Session& session, User::pointer user)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<TrackBookmark::pointer> res
-	{
-		session.getDboSession().find<TrackBookmark>()
-		.where("user_id = ?").bind(user.id())
-	};
+	auto res {session.getDboSession().find<TrackBookmark>()
+				.where("user_id = ?").bind(user->getId())
+				.resultList()};
 
 	return std::vector<TrackBookmark::pointer>(std::cbegin(res), std::cend(res));
 }
 
 TrackBookmark::pointer
-TrackBookmark::getByUser(Session& session, Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track)
+TrackBookmark::getByUser(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track)
 {
 	session.checkSharedLocked();
 
 	return session.getDboSession().find<TrackBookmark>()
-		.where("user_id = ?").bind(user.id())
-		.where("track_id = ?").bind(track.id());
+		.where("user_id = ?").bind(user->getId())
+		.where("track_id = ?").bind(track->getId())
+		.resultValue();
 }
 
 TrackBookmark::pointer
-TrackBookmark::getById(Session& session, IdType id)
+TrackBookmark::getById(Session& session, TrackBookmarkId id)
 {
 	session.checkSharedLocked();
 
 	return session.getDboSession().find<TrackBookmark>()
-		.where("id = ?").bind(id);
+		.where("id = ?").bind(id)
+		.resultValue();
 }
 
 

src/libs/database/impl/TrackFeatures.cpp

@@ -28,14 +28,14 @@
 
 namespace Database {
 
-TrackFeatures::TrackFeatures(Wt::Dbo::ptr<Track> track, const std::string& jsonEncodedFeatures)
-: _data(jsonEncodedFeatures),
-_track(track)
+TrackFeatures::TrackFeatures(ObjectPtr<Track> track, const std::string& jsonEncodedFeatures)
+: _data {jsonEncodedFeatures},
+_track {getDboPtr(track)}
 {
 }
 
 TrackFeatures::pointer
-TrackFeatures::create(Session& session, Wt::Dbo::ptr<Track> track, const std::string& jsonEncodedFeatures)
+TrackFeatures::create(Session& session, ObjectPtr<Track> track, const std::string& jsonEncodedFeatures)
 {
 	session.checkUniqueLocked();
 	return session.getDboSession().add(std::make_unique<TrackFeatures>(track, jsonEncodedFeatures));

src/libs/database/impl/TrackList.cpp

@@ -30,32 +30,33 @@
 #include "database/Track.hpp"
 #include "SqlQuery.hpp"
 #include "StringViewTraits.hpp"
+#include "Traits.hpp"
 
 namespace Database {
 
-TrackList::TrackList(std::string_view name, Type type, bool isPublic, Wt::Dbo::ptr<User> user)
+TrackList::TrackList(std::string_view name, Type type, bool isPublic, ObjectPtr<User> user)
 : _name {name},
  _type {type},
  _isPublic {isPublic},
- _user {user}
+ _user {getDboPtr(user)}
 {
 
 }
 
 TrackList::pointer
-TrackList::create(Session& session, std::string_view name, Type type, bool isPublic, Wt::Dbo::ptr<User> user)
+TrackList::create(Session& session, std::string_view name, Type type, bool isPublic, ObjectPtr<User> user)
 {
 	session.checkUniqueLocked();
 	assert(user);
 
-	auto res = session.getDboSession().add( std::make_unique<TrackList>(name, type, isPublic, user) );
+	TrackList::pointer res {session.getDboSession().add( std::make_unique<TrackList>(name, type, isPublic, user) )};
 	session.getDboSession().flush();
 
 	return res;
 }
 
 TrackList::pointer
-TrackList::get(Session& session, std::string_view name, Type type, Wt::Dbo::ptr<User> user)
+TrackList::get(Session& session, std::string_view name, Type type, ObjectPtr<User> user)
 {
 	session.checkSharedLocked();
 	assert(user);
@@ -63,49 +64,51 @@ TrackList::get(Session& session, std::string_view name, Type type, Wt::Dbo::ptr<
 	return session.getDboSession().find<TrackList>()
 		.where("name = ?").bind(name)
 		.where("type = ?").bind(type)
-		.where("user_id = ?").bind(user.id());
+		.where("user_id = ?").bind(user->getId()).resultValue();
 }
 
 std::vector<TrackList::pointer>
 TrackList::getAll(Session& session)
 {
 	session.checkSharedLocked();
-	Wt::Dbo::collection<TrackList::pointer> res = session.getDboSession().find<TrackList>();
+
+	auto res = session.getDboSession().find<TrackList>().resultList();
+	return std::vector<TrackList::pointer>(res.begin(), res.end());
+}
+
+std::vector<TrackList::pointer>
+TrackList::getAll(Session& session, ObjectPtr<User> user)
+{
+	session.checkSharedLocked();
+
+	auto res {session.getDboSession().find<TrackList>()
+		.where("user_id = ?").bind(user->getId())
+		.orderBy("name COLLATE NOCASE")
+		.resultList()};
 
 	return std::vector<TrackList::pointer>(res.begin(), res.end());
 }
 
 std::vector<TrackList::pointer>
-TrackList::getAll(Session& session, Wt::Dbo::ptr<User> user)
+TrackList::getAll(Session& session, ObjectPtr<User> user, Type type)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<TrackList::pointer> res = session.getDboSession().find<TrackList>()
-		.where("user_id = ?").bind(user.id())
-		.orderBy("name COLLATE NOCASE");
-
-	return std::vector<TrackList::pointer>(res.begin(), res.end());
-}
-
-std::vector<TrackList::pointer>
-TrackList::getAll(Session& session, Wt::Dbo::ptr<User> user, Type type)
-{
-	session.checkSharedLocked();
-
-	Wt::Dbo::collection<TrackList::pointer> res = session.getDboSession().find<TrackList>()
-		.where("user_id = ?").bind(user.id())
+	auto res {session.getDboSession().find<TrackList>()
+		.where("user_id = ?").bind(user->getId())
 		.where("type = ?").bind(type)
-		.orderBy("name COLLATE NOCASE");
+		.orderBy("name COLLATE NOCASE")
+		.resultList()};
 
 	return std::vector<TrackList::pointer>(res.begin(), res.end());
 }
 
 TrackList::pointer
-TrackList::getById(Session& session, IdType id)
+TrackList::getById(Session& session, TrackListId id)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<TrackList>().where("id = ?").bind(id);
+	return session.getDboSession().find<TrackList>().where("id = ?").bind(id).resultValue();
 }
 
 bool
@@ -120,10 +123,10 @@ TrackList::getCount() const
 	return _entries.size();
 }
 
-Wt::Dbo::ptr<TrackListEntry>
+TrackListEntry::pointer
 TrackList::getEntry(std::size_t pos) const
 {
-	Wt::Dbo::ptr<TrackListEntry> res;
+	TrackListEntry::pointer res;
 
 	auto entries = getEntries(pos, 1);
 	if (!entries.empty())
@@ -132,39 +135,39 @@ TrackList::getEntry(std::size_t pos) const
 	return res;
 }
 
-std::vector<Wt::Dbo::ptr<TrackListEntry>>
+std::vector<TrackListEntry::pointer>
 TrackList::getEntries(std::optional<std::size_t> offset, std::optional<std::size_t> size) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<Wt::Dbo::ptr<TrackListEntry>> entries =
+	auto entries {
 		session()->find<TrackListEntry>()
-		.where("tracklist_id = ?").bind(self().id())
+		.where("tracklist_id = ?").bind(getId())
 		.orderBy("id")
 		.limit(size ? static_cast<int>(*size) : -1)
-		.offset(offset ? static_cast<int>(*offset) : -1);
+		.offset(offset ? static_cast<int>(*offset) : -1)
+		.resultList()};
 
-	return std::vector<Wt::Dbo::ptr<TrackListEntry>>(entries.begin(), entries.end());
+	return std::vector<TrackListEntry::pointer>(entries.begin(), entries.end());
 }
 
-Wt::Dbo::ptr<TrackListEntry>
-TrackList::getEntryByTrackAndDateTime(Wt::Dbo::ptr<Track> track, const Wt::WDateTime& dateTime) const
+TrackListEntry::pointer
+TrackList::getEntryByTrackAndDateTime(ObjectPtr<Track> track, const Wt::WDateTime& dateTime) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
 	return session()->find<TrackListEntry>()
-			.where("tracklist_id = ?").bind(self().id())
-			.where("track_id = ?").bind(track.id())
-			.where("date_time = ?").bind(Wt::WDateTime::fromTime_t(dateTime.toTime_t()));
+			.where("tracklist_id = ?").bind(getId())
+			.where("track_id = ?").bind(track->getId())
+			.where("date_time = ?").bind(Wt::WDateTime::fromTime_t(dateTime.toTime_t()))
+			.resultValue();
 }
 
 static
-Wt::Dbo::Query<Artist::pointer>
-createArtistsQuery(Wt::Dbo::Session& session, const std::string& queryStr, IdType tracklistId, const std::set<IdType>& clusterIds, std::optional<TrackArtistLinkType> linkType)
+Wt::Dbo::Query<Wt::Dbo::ptr<Artist>>
+createArtistsQuery(Wt::Dbo::Session& session, const std::string& queryStr, TrackListId tracklistId, const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType)
 {
-	auto query {session.query<Artist::pointer>(queryStr)};
+	auto query {session.query<Wt::Dbo::ptr<Artist>>(queryStr)};
 	query.join("track t ON t.id = t_a_l.track_id");
 	query.join("track_artist_link t_a_l ON t_a_l.artist_id = a.id");
 	query.join("tracklist_entry p_e ON p_e.track_id = t.id");
@@ -201,10 +204,10 @@ createArtistsQuery(Wt::Dbo::Session& session, const std::string& queryStr, IdTyp
 }
 
 static
-Wt::Dbo::Query<Release::pointer>
-createReleasesQuery(Wt::Dbo::Session& session, const std::string& queryStr, IdType tracklistId, const std::set<IdType>& clusterIds)
+Wt::Dbo::Query<Wt::Dbo::ptr<Release>>
+createReleasesQuery(Wt::Dbo::Session& session, const std::string& queryStr, TrackListId tracklistId, const std::vector<ClusterId>& clusterIds)
 {
-	auto query {session.query<Release::pointer>(queryStr)};
+	auto query {session.query<Wt::Dbo::ptr<Release>>(queryStr)};
 	query.join("track t ON t.release_id = r.id");
 	query.join("tracklist_entry p_e ON p_e.track_id = t.id");
 	query.join("tracklist p ON p.id = p_e.tracklist_id");
@@ -220,7 +223,7 @@ createReleasesQuery(Wt::Dbo::Session& session, const std::string& queryStr, IdTy
 				" INNER JOIN track_cluster t_c ON t_c.track_id = t.id";
 
 		WhereClause clusterClause;
-		for (auto id : clusterIds)
+		for (ClusterId id : clusterIds)
 		{
 			clusterClause.Or(WhereClause("c.id = ?"));
 			query.bind(id);
@@ -236,10 +239,10 @@ createReleasesQuery(Wt::Dbo::Session& session, const std::string& queryStr, IdTy
 }
 
 static
-Wt::Dbo::Query<Track::pointer>
-createTracksQuery(Wt::Dbo::Session& session, IdType tracklistId, const std::set<IdType>& clusterIds)
+Wt::Dbo::Query<Wt::Dbo::ptr<Track>>
+createTracksQuery(Wt::Dbo::Session& session, TrackListId tracklistId, const std::vector<ClusterId>& clusterIds)
 {
-	auto query {session.query<Track::pointer>("SELECT t from track t INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id")};
+	auto query {session.query<Wt::Dbo::ptr<Track>>("SELECT t from track t INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id")};
 
 	query.where("p.id = ?").bind(tracklistId);
 
@@ -253,7 +256,7 @@ createTracksQuery(Wt::Dbo::Session& session, IdType tracklistId, const std::set<
 		WhereClause clusterClause;
 		for (auto id : clusterIds)
 		{
-			clusterClause.Or(WhereClause("c.id = ?")).bind(std::to_string(id));
+			clusterClause.Or(WhereClause("c.id = ?")).bind(id.toString());
 			query.bind(id);
 		}
 
@@ -267,16 +270,16 @@ createTracksQuery(Wt::Dbo::Session& session, IdType tracklistId, const std::set<
 }
 
 std::vector<Artist::pointer>
-TrackList::getArtistsReverse(const std::set<IdType>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
+TrackList::getArtistsReverse(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<Artist::pointer> collection = createArtistsQuery(*session(), "SELECT a from artist a", self()->id(), clusterIds, linkType)
+	auto collection {createArtistsQuery(*session(), "SELECT a from artist a", getId(), clusterIds, linkType)
 		.groupBy("a.id").having("p_e.date_time = MAX(p_e.date_time)")
 		.orderBy("p_e.date_time DESC")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
 	auto res {std::vector<Artist::pointer>(collection.begin(), collection.end())};
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
@@ -291,18 +294,18 @@ TrackList::getArtistsReverse(const std::set<IdType>& clusterIds, std::optional<T
 }
 
 std::vector<Release::pointer>
-TrackList::getReleasesReverse(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const
+TrackList::getReleasesReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<Release::pointer> collection = createReleasesQuery(*session(), "SELECT r from release r", self()->id(), clusterIds)
+	auto collection {createReleasesQuery(*session(), "SELECT r from release r", getId(), clusterIds)
 		.groupBy("r.id").having("p_e.date_time = MAX(p_e.date_time)")
 		.orderBy("p_e.date_time DESC")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
-	auto res {std::vector<Release::pointer>(collection.begin(), collection.end())};
+	std::vector<Release::pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -315,18 +318,18 @@ TrackList::getReleasesReverse(const std::set<IdType>& clusterIds, std::optional<
 }
 
 std::vector<Track::pointer>
-TrackList::getTracksReverse(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const
+TrackList::getTracksReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<Track::pointer> collection = createTracksQuery(*session(), self()->id(), clusterIds)
+	auto collection {createTracksQuery(*session(), getId(), clusterIds)
 		.groupBy("t.id").having("p_e.date_time = MAX(p_e.date_time)")
 		.orderBy("p_e.date_time DESC")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
-	auto res {std::vector<Track::pointer>(collection.begin(), collection.end())};
+	std::vector<Track::pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -338,29 +341,28 @@ TrackList::getTracksReverse(const std::set<IdType>& clusterIds, std::optional<Ra
 	return res;
 }
 
-std::vector<Wt::Dbo::ptr<Cluster>>
+std::vector<Cluster::pointer>
 TrackList::getClusters() const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<Cluster::pointer> res = session()->query<Cluster::pointer>("SELECT c from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id")
-		.where("p.id = ?").bind(self()->id())
+	auto res {session()->query<Wt::Dbo::ptr<Cluster>>("SELECT c from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id")
+		.where("p.id = ?").bind(getId())
 		.groupBy("c.id")
-		.orderBy("COUNT(c.id) DESC");
+		.orderBy("COUNT(c.id) DESC")
+		.resultList()};
 
-	return std::vector<Wt::Dbo::ptr<Cluster>>(res.begin(), res.end());
+	return std::vector<Cluster::pointer>(res.begin(), res.end());
 }
 
 bool
-TrackList::hasTrack(IdType trackId) const
+TrackList::hasTrack(TrackId trackId) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
 	Wt::Dbo::collection<TrackListEntry::pointer> res = session()->query<TrackListEntry::pointer>("SELECT p_e from tracklist_entry p_e INNER JOIN tracklist p ON p_e.tracklist_id = p.id")
 		.where("p_e.track_id = ?").bind(trackId)
-		.where("p.id = ?").bind(self()->id());
+		.where("p.id = ?").bind(getId());
 
 	return res.size() > 0;
 }
@@ -369,67 +371,64 @@ std::vector<Track::pointer>
 TrackList::getSimilarTracks(std::optional<std::size_t> offset, std::optional<std::size_t> size) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::Query<Track::pointer> query {session()->query<Track::pointer>(
+	auto res {session()->query<Wt::Dbo::ptr<Track>>(
 			"SELECT t FROM track t"
 			" INNER JOIN track_cluster t_c ON t_c.track_id = t.id"
 				" WHERE "
 					" (t_c.cluster_id IN (SELECT c.id from cluster c INNER JOIN track t ON c.id = t_c.cluster_id INNER JOIN track_cluster t_c ON t_c.track_id = t.id INNER JOIN tracklist_entry p_e ON p_e.track_id = t.id INNER JOIN tracklist p ON p.id = p_e.tracklist_id WHERE p.id = ?)"
 					" AND t.id NOT IN (SELECT tracklist_t.id FROM track tracklist_t INNER JOIN tracklist_entry t_e ON t_e.track_id = tracklist_t.id WHERE t_e.tracklist_id = ?))"
 				)
-		.bind(self()->id())
-		.bind(self()->id())
+		.bind(getId())
+		.bind(getId())
 		.groupBy("t.id")
 		.orderBy("COUNT(*) DESC, RANDOM()")
 		.limit(size ? static_cast<int>(*size) : -1)
-		.offset(offset ? static_cast<int>(*offset) : -1)};
+		.offset(offset ? static_cast<int>(*offset) : -1)
+		.resultList()};
 
-	Wt::Dbo::collection<Track::pointer> tracks = query;
-	return std::vector<Track::pointer>(tracks.begin(), tracks.end());
+	return std::vector<Track::pointer>(res.begin(), res.end());
 }
 
-std::vector<IdType>
+std::vector<TrackId>
 TrackList::getTrackIds() const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	Wt::Dbo::collection<IdType> res = session()->query<IdType>("SELECT p_e.track_id from tracklist_entry p_e INNER JOIN tracklist p ON p_e.tracklist_id = p.id")
-		.where("p.id = ?").bind(self()->id());
+	Wt::Dbo::collection<TrackId> res = session()->query<TrackId>("SELECT p_e.track_id from tracklist_entry p_e INNER JOIN tracklist p ON p_e.tracklist_id = p.id")
+		.where("p.id = ?").bind(getId());
 
-	return std::vector<IdType>(res.begin(), res.end());
+	return std::vector<TrackId>(res.begin(), res.end());
 }
 
 std::chrono::milliseconds
 TrackList::getDuration() const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
 	using milli = std::chrono::duration<int, std::milli>;
 
 	Wt::Dbo::Query<milli> query {session()->query<milli>("SELECT COALESCE(SUM(duration), 0) FROM track t INNER JOIN tracklist_entry p_e ON t.id = p_e.track_id")
-			.where("p_e.tracklist_id = ?").bind(self()->id())};
+			.where("p_e.tracklist_id = ?").bind(getId())};
 
 	return query.resultValue();
 }
 
 std::vector<Artist::pointer>
-TrackList::getTopArtists(const std::set<IdType>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
+TrackList::getTopArtists(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	auto query {createArtistsQuery(*session(), "SELECT a from artist a", self()->id(), clusterIds, linkType)};
+	auto query {createArtistsQuery(*session(), "SELECT a from artist a", getId(), clusterIds, linkType)};
 
-	Wt::Dbo::collection<Artist::pointer> collection = query
+	auto collection {query
 		.orderBy("COUNT(a.id) DESC")
 		.groupBy("a.id")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
-	auto res {std::vector<Artist::pointer>(collection.begin(), collection.end())};
+	std::vector<Artist::pointer> res(collection.begin(), collection.end());
 
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
@@ -439,26 +438,23 @@ TrackList::getTopArtists(const std::set<IdType>& clusterIds, std::optional<Track
 	else
 		moreResults = false;
 
-
 	return res;
 }
 
 std::vector<Release::pointer>
-TrackList::getTopReleases(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const
+TrackList::getTopReleases(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	auto query {createReleasesQuery(*session(), "SELECT r from release r", self()->id(), clusterIds)};
-
-	Wt::Dbo::collection<Release::pointer> collection = query
+	auto query {createReleasesQuery(*session(), "SELECT r from release r", getId(), clusterIds)};
+	auto collection {query
 		.orderBy("COUNT(r.id) DESC")
 		.groupBy("r.id")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
-
-	auto res {std::vector<Release::pointer>(collection.begin(), collection.end())};
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
+	std::vector<Release::pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -471,21 +467,19 @@ TrackList::getTopReleases(const std::set<IdType>& clusterIds, std::optional<Rang
 }
 
 std::vector<Track::pointer>
-TrackList::getTopTracks(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const
+TrackList::getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const
 {
 	assert(session());
-	assert(IdIsValid(self()->id()));
 
-	auto query {createTracksQuery(*session(), self()->id(), clusterIds)};
-
-	Wt::Dbo::collection<Track::pointer> collection = query
+	auto query {createTracksQuery(*session(), getId(), clusterIds)};
+	auto collection {query
 		.orderBy("COUNT(t.id) DESC")
 		.groupBy("t.id")
 		.limit(range ? static_cast<int>(range->limit) + 1 : -1)
-		.offset(range ? static_cast<int>(range->offset) : -1);
-
-	auto res {std::vector<Track::pointer>(collection.begin(), collection.end())};
+		.offset(range ? static_cast<int>(range->offset) : -1)
+		.resultList()};
 
+	std::vector<Track::pointer> res(collection.begin(), collection.end());
 	if (range && res.size() == static_cast<std::size_t>(range->limit) + 1)
 	{
 		moreResults = true;
@@ -497,16 +491,16 @@ TrackList::getTopTracks(const std::set<IdType>& clusterIds, std::optional<Range>
 	return res;
 }
 
-TrackListEntry::TrackListEntry(Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<TrackList> tracklist, const Wt::WDateTime& dateTime)
+TrackListEntry::TrackListEntry(ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime)
 : _dateTime {Wt::WDateTime::fromTime_t(dateTime.toTime_t())} // force second resolution
-, _track {track}
-, _tracklist {tracklist}
+, _track {getDboPtr(track)}
+, _tracklist {getDboPtr(tracklist)}
 {
 	assert(_dateTime.isValid());
 }
 
 TrackListEntry::pointer
-TrackListEntry::create(Session& session, Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<TrackList> tracklist, const Wt::WDateTime& dateTime)
+TrackListEntry::create(Session& session, ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime)
 {
 	session.checkUniqueLocked();
 	assert(track);
@@ -519,11 +513,11 @@ TrackListEntry::create(Session& session, Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr
 }
 
 TrackListEntry::pointer
-TrackListEntry::getById(Session& session, IdType id)
+TrackListEntry::getById(Session& session, TrackListEntryId id)
 {
 	session.checkSharedLocked();
 
-	return session.getDboSession().find<TrackListEntry>().where("id = ?").bind(id);
+	return session.getDboSession().find<TrackListEntry>().where("id = ?").bind(id).resultValue();
 }
 
 } // namespace Database

src/libs/database/impl/Traits.hpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2021 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 <type_traits>
+#include <Wt/Dbo/StdSqlTraits.h>
+
+#include "database/Types.hpp"
+
+namespace Wt::Dbo
+{
+
+	template<typename T>
+	struct sql_value_traits<T, typename std::enable_if<std::is_base_of<Database::IdType, T>::value>::type>
+	{
+		static_assert(!std::is_same_v<Database::IdType, T>, "Cannot use IdType, use derived types");
+		static const bool specialized = true;
+
+		static std::string type(SqlConnection *conn, int size)
+		{
+			return sql_value_traits<typename T::ValueType, void>::type(conn, size);
+		}
+
+		static void bind(const T& v, SqlStatement *statement, int column, int size)
+		{
+			sql_value_traits<typename T::ValueType>::bind(v.getValue(), statement, column, size);
+		}
+
+		static bool read(T& v, SqlStatement *statement, int column, int size)
+		{
+			typename T::ValueType value;
+			if (sql_value_traits<typename T::ValueType>::read(value, statement, column, size))
+			{
+				v = value;
+				return true;
+			}
+
+			v = {};
+			return false;
+		}
+	};
+}
+

src/libs/database/impl/User.cpp

@@ -26,25 +26,25 @@
 #include "database/TrackList.hpp"
 #include "utils/Logger.hpp"
 #include "StringViewTraits.hpp"
+#include "Traits.hpp"
 
 namespace Database {
 
 
-AuthToken::AuthToken(const std::string& value, const Wt::WDateTime& expiry, Wt::Dbo::ptr<User> user)
+AuthToken::AuthToken(const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
 : _value {value}
 , _expiry {expiry}
-, _user {user}
+, _user {getDboPtr(user)}
 {
 
 }
 
 AuthToken::pointer
-AuthToken::create(Session& session, const std::string& value, const Wt::WDateTime& expiry, Wt::Dbo::ptr<User> user)
+AuthToken::create(Session& session, const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user)
 {
 	session.checkUniqueLocked();
 
-	auto res {session.getDboSession().add(std::make_unique<AuthToken>(value, expiry, user))};
-
+	AuthToken::pointer res {session.getDboSession().add(std::make_unique<AuthToken>(value, expiry, user))};
 	session.getDboSession().flush();
 
 	return res;
@@ -65,7 +65,8 @@ AuthToken::getByValue(Session& session, const std::string& value)
 	session.checkSharedLocked();
 
 	return session.getDboSession().find<AuthToken>()
-		.where("value = ?").bind(value);
+		.where("value = ?").bind(value)
+		.resultValue();
 }
 
 static const std::string queuedListName {"__queued_tracks__"};
@@ -80,17 +81,17 @@ User::getAll(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<pointer> res = session.getDboSession().find<User>();
+	auto res {session.getDboSession().find<User>().resultList()};
 	return std::vector<pointer>(res.begin(), res.end());
 }
 
-std::vector<IdType>
+std::vector<UserId>
 User::getAllIds(Session& session)
 {
 	session.checkSharedLocked();
 
-	Wt::Dbo::collection<IdType> res = session.getDboSession().query<IdType>("SELECT id FROM user");
-	return std::vector<IdType>(res.begin(), res.end());
+	auto res {session.getDboSession().query<UserId>("SELECT id FROM user").resultList()};
+	return std::vector<UserId>(res.begin(), res.end());
 }
 
 User::pointer
@@ -98,8 +99,7 @@ User::getDemo(Session& session)
 {
 	session.checkSharedLocked();
 
-	pointer res = session.getDboSession().find<User>().where("type = ?").bind(UserType::DEMO);
-	return res;
+	return session.getDboSession().find<User>().where("type = ?").bind(UserType::DEMO).resultValue();
 }
 
 std::size_t
@@ -125,16 +125,17 @@ User::create(Session& session, std::string_view loginName)
 }
 
 User::pointer
-User::getById(Session& session, IdType id)
+User::getById(Session& session, UserId id)
 {
-	return session.getDboSession().find<User>().where("id = ?").bind( id );
+	return session.getDboSession().find<User>().where("id = ?").bind(id).resultValue();
 }
 
 User::pointer
 User::getByLoginName(Session& session, std::string_view name)
 {
 	return session.getDboSession().find<User>()
-		.where("login_name = ?").bind(name);
+		.where("login_name = ?").bind(name)
+		.resultValue();
 }
 
 void
@@ -150,7 +151,7 @@ User::clearAuthTokens()
 	_authTokens.clear();
 }
 
-Wt::Dbo::ptr<TrackList>
+TrackList::pointer
 User::getQueuedTrackList(Session& session) const
 {
 	assert(self());
@@ -160,63 +161,63 @@ User::getQueuedTrackList(Session& session) const
 }
 
 void
-User::starArtist(Wt::Dbo::ptr<Artist> artist)
+User::starArtist(ObjectPtr<Artist> artist)
 {
-	if (_starredArtists.count(artist) == 0)
-		_starredArtists.insert(artist);
+	if (_starredArtists.count(getDboPtr(artist)) == 0)
+		_starredArtists.insert(getDboPtr(artist));
 }
 
 void
-User::unstarArtist(Wt::Dbo::ptr<Artist> artist)
+User::unstarArtist(ObjectPtr<Artist> artist)
 {
-	if (_starredArtists.count(artist) != 0)
-		_starredArtists.erase(artist);
+	if (_starredArtists.count(getDboPtr(artist)) != 0)
+		_starredArtists.erase(getDboPtr(artist));
 }
 
 bool
-User::hasStarredArtist(Wt::Dbo::ptr<Artist> artist) const
+User::hasStarredArtist(ObjectPtr<Artist> artist) const
 {
-	return _starredArtists.count(artist) != 0;
+	return _starredArtists.count(getDboPtr(artist)) != 0;
 }
 
 void
-User::starRelease(Wt::Dbo::ptr<Release> release)
+User::starRelease(ObjectPtr<Release> release)
 {
-	if (_starredReleases.count(release) == 0)
-		_starredReleases.insert(release);
+	if (_starredReleases.count(getDboPtr(release)) == 0)
+		_starredReleases.insert(getDboPtr(release));
 }
 
 void
-User::unstarRelease(Wt::Dbo::ptr<Release> release)
+User::unstarRelease(ObjectPtr<Release> release)
 {
-	if (_starredReleases.count(release) != 0)
-		_starredReleases.erase(release);
+	if (_starredReleases.count(getDboPtr(release)) != 0)
+		_starredReleases.erase(getDboPtr(release));
 }
 
 bool
-User::hasStarredRelease(Wt::Dbo::ptr<Release> release) const
+User::hasStarredRelease(ObjectPtr<Release> release) const
 {
-	return _starredReleases.count(release) != 0;
+	return _starredReleases.count(getDboPtr(release)) != 0;
 }
 
 void
-User::starTrack(Wt::Dbo::ptr<Track> track)
+User::starTrack(ObjectPtr<Track> track)
 {
-	if (_starredTracks.count(track) == 0)
-		_starredTracks.insert(track);
+	if (_starredTracks.count(getDboPtr(track)) == 0)
+		_starredTracks.insert(getDboPtr(track));
 }
 
 void
-User::unstarTrack(Wt::Dbo::ptr<Track> track)
+User::unstarTrack(ObjectPtr<Track> track)
 {
-	if (_starredTracks.count(track) != 0)
-		_starredTracks.erase(track);
+	if (_starredTracks.count(getDboPtr(track)) != 0)
+		_starredTracks.erase(getDboPtr(track));
 }
 
 bool
-User::hasStarredTrack(Wt::Dbo::ptr<Track> track) const
+User::hasStarredTrack(ObjectPtr<Track> track) const
 {
-	return _starredTracks.count(track) != 0;
+	return _starredTracks.count(getDboPtr(track)) != 0;
 }
 
 } // namespace Database

src/libs/database/include/database/Artist.hpp

@@ -22,17 +22,15 @@
 #include <optional>
 #include <string>
 #include <string_view>
-#include <unordered_set>
 #include <vector>
 
 #include <Wt/WDateTime.h>
 #include <Wt/Dbo/Dbo.h>
 
+#include "database/Types.hpp"
 #include "utils/EnumSet.hpp"
 #include "utils/UUID.hpp"
 
-#include "Types.hpp"
-
 namespace Database
 {
 
@@ -44,10 +42,9 @@ class Track;
 class TrackArtistLink;
 class User;
 
-class Artist : public Wt::Dbo::Dbo<Artist>
+class Artist : public Object<Artist, ArtistId>
 {
 	public:
-
 		enum class SortMethod
 		{
 			None,
@@ -55,43 +52,41 @@ class Artist : public Wt::Dbo::Dbo<Artist>
 			BySortName,
 		};
 
-		using pointer = Wt::Dbo::ptr<Artist>;
-
-		Artist() {}
+		Artist() = default;
 		Artist(const std::string& name, const std::optional<UUID>& MBID = {});
 
 		// Accessors
 		static pointer			getByMBID(Session& session, const UUID& MBID);
-		static pointer			getById(Session& session, IdType id);
+		static pointer			getById(Session& session, ArtistId id);
 		static std::vector<pointer>	getByName(Session& session, const std::string& name);		// exact match on name field
 		static std::vector<pointer> 	getByClusters(Session& session,
-								const std::set<IdType>& clusters,		// at least one track that belongs to  these clusters
+								const std::vector<ClusterId>& clusters,		// at least one track that belongs to  these clusters
 								SortMethod sortMethod
 								);
 		static std::vector<pointer> 	getByFilter(Session& session,
-								const std::set<IdType>& clusters,		// if non empty, at least one artist that belongs to these clusters
+								const std::vector<ClusterId>& clusters,			// if non empty, at least one artist that belongs to these clusters
 								const std::vector<std::string_view>& keywords,	// if non empty, name must match all of these keywords (name + sort name fields)
 								std::optional<TrackArtistLinkType> linkType, 	// if set, only artists that have produced at least one track with this link type
 								SortMethod sortMethod,
 								std::optional<Range> range,
 								bool& moreExpected);
 
-		static std::vector<pointer>	getAll(Session& session);
-		static std::vector<pointer>	getAll(Session& session, SortMethod sortMethod);
-		static std::vector<pointer>	getAll(Session& session, SortMethod sortMethod, std::optional<Range> range, bool& moreResults);
-		static std::vector<IdType>	getAllIds(Session& session);
-		static std::vector<IdType>	getAllIdsRandom(Session& session, const std::set<IdType>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size = {});
-		static std::vector<pointer>	getAllOrphans(Session& session); // No track related
-		static std::vector<pointer>	getLastWritten(Session& session,
+		static std::vector<pointer>		getAll(Session& session);
+		static std::vector<pointer>		getAll(Session& session, SortMethod sortMethod);
+		static std::vector<pointer>		getAll(Session& session, SortMethod sortMethod, std::optional<Range> range, bool& moreResults);
+		static std::vector<ArtistId>	getAllIds(Session& session);
+		static std::vector<ArtistId>	getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<TrackArtistLinkType> linkType, std::optional<std::size_t> size = {});
+		static std::vector<pointer>		getAllOrphans(Session& session); // No track related
+		static std::vector<pointer>		getLastWritten(Session& session,
 								std::optional<Wt::WDateTime> after,
-								const std::set<IdType>& clusters,
+								const std::vector<ClusterId>& clusters,
 								std::optional<TrackArtistLinkType> linkType, 	// if set, only artists that have produced at least one track with this link type
 								std::optional<Range>,
 								bool& moreResults);
-		static std::vector<IdType>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<ArtistId>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
 		static std::vector<pointer>	getStarred(Session& session,
-								Wt::Dbo::ptr<User> user,
-								const std::set<IdType>& clusters,
+								ObjectPtr<User> user,
+								const std::vector<ClusterId>& clusters,
 								std::optional<TrackArtistLinkType> linkType, 	// if set, only artists that have produced at least one track with this link type
 								SortMethod sortMethod,
 								std::optional<Range>, bool& moreResults);
@@ -101,12 +96,12 @@ class Artist : public Wt::Dbo::Dbo<Artist>
 		const std::string&	getSortName() const { return _sortName; }
 		std::optional<UUID>	getMBID() const { return UUID::fromString(_MBID); }
 
-		std::vector<Wt::Dbo::ptr<Release>>	getReleases(const std::set<IdType>& clusterIds = {}) const; // if non empty, get the releases that match all these clusters
-		std::size_t				getReleaseCount() const;
-		std::vector<Wt::Dbo::ptr<Track>>	getTracks(std::optional<TrackArtistLinkType> linkType = {}) const;
+		std::vector<ObjectPtr<Release>>	getReleases(const std::vector<ClusterId>& clusterIds = {}) const; // if non empty, get the releases that match all these clusters
+		std::size_t							getReleaseCount() const;
+		std::vector<ObjectPtr<Track>>		getTracks(std::optional<TrackArtistLinkType> linkType = {}) const;
 		bool								hasNonReleaseTracks(std::optional<TrackArtistLinkType> linkType = std::nullopt) const;
-		std::vector<Wt::Dbo::ptr<Track>>	getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
-		std::vector<Wt::Dbo::ptr<Track>>	getRandomTracks(std::optional<std::size_t> count) const;
+		std::vector<ObjectPtr<Track>>		getNonReleaseTracks(std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Track>>		getRandomTracks(std::optional<std::size_t> count) const;
 
 		// No artistLinkTypes means get them all
 		std::vector<pointer>				getSimilarArtists(EnumSet<TrackArtistLinkType> artistLinkTypes = {}, std::optional<Range> range = std::nullopt) const;
@@ -114,14 +109,14 @@ class Artist : public Wt::Dbo::Dbo<Artist>
 		// Get the cluster of the tracks made by this artist
 		// Each clusters are grouped by cluster type, sorted by the number of occurence
 		// size is the max number of cluster per cluster type
-		std::vector<std::vector<Wt::Dbo::ptr<Cluster>>> getClusterGroups(std::vector<Wt::Dbo::ptr<ClusterType>> clusterTypes, std::size_t size) const;
+		std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(std::vector<ObjectPtr<ClusterType>> clusterTypes, std::size_t size) const;
 
 		void setName(std::string_view name)		{ _name  = name; }
 		void setMBID(const std::optional<UUID>& mbid)	{ _MBID = mbid ? mbid->getAsString() : ""; }
 		void setSortName(const std::string& sortName);
 
 		// Create
-		static pointer create(Session& session, const std::string& name, const std::optional<UUID>& UUID = {});
+		static pointer	create(Session& session, const std::string& name, const std::optional<UUID>& UUID = {});
 
 		template<class Action>
 			void persist(Action& a)

src/libs/database/include/database/Cluster.hpp

@@ -24,10 +24,9 @@
 #include <vector>
 
 #include <Wt/Dbo/Dbo.h>
-
 #include <Wt/WDateTime.h>
 
-#include "Types.hpp"
+#include "database/Types.hpp"
 
 namespace Database {
 
@@ -36,31 +35,29 @@ class ClusterType;
 class ScanSettings;
 class Session;
 
-class Cluster : public Wt::Dbo::Dbo<Cluster>
+class Cluster : public Object<Cluster, ClusterId>
 {
 	public:
-		using pointer = Wt::Dbo::ptr<Cluster>;
-
-		Cluster();
-		Cluster(Wt::Dbo::ptr<ClusterType> type, std::string_view name);
+		Cluster() = default;
+		Cluster(ObjectPtr<ClusterType> type, std::string_view name);
 
 		// Find utility
 		static std::vector<pointer> getAll(Session& session);
 		static std::vector<pointer> getAllOrphans(Session& session);
-		static pointer getById(Session& session, IdType id);
+		static pointer getById(Session& session, ClusterId id);
 
 		// Create utility
-		static pointer create(Session& session, Wt::Dbo::ptr<ClusterType> type, std::string_view name);
+		static pointer create(Session& session, ObjectPtr<ClusterType> type, std::string_view name);
 
 		// Accessors
 		const std::string& getName() const		{ return _name; }
-		Wt::Dbo::ptr<ClusterType> getType() const	{ return _clusterType; }
+		ObjectPtr<ClusterType> getType() const	{ return _clusterType; }
 		std::size_t getTracksCount() const		{ return _tracks.size(); }
-		std::vector<Wt::Dbo::ptr<Track>> getTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> limit = {}) const;
-		std::set<IdType> getTrackIds() const;
+		std::vector<ObjectPtr<Track>> getTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> limit = {}) const;
+		std::vector<TrackId> getTrackIds() const;
 		std::size_t getReleasesCount() const;
 
-		void addTrack(Wt::Dbo::ptr<Track> track);
+		void addTrack(ObjectPtr<Track> track);
 
 		template<class Action>
 		void persist(Action& a)
@@ -72,7 +69,6 @@ class Cluster : public Wt::Dbo::Dbo<Cluster>
 		}
 
 	private:
-
 		static const std::size_t _maxNameLength = 128;
 
 		std::string	_name;
@@ -82,19 +78,17 @@ class Cluster : public Wt::Dbo::Dbo<Cluster>
 };
 
 
-class ClusterType : public Wt::Dbo::Dbo<ClusterType>
+class ClusterType : public Object<ClusterType, ClusterTypeId>
 {
 	public:
+		ClusterType() = default;
+		ClusterType(std::string_view name);
 
-		using pointer = Wt::Dbo::ptr<ClusterType>;
-
-		ClusterType() {}
-		ClusterType(std::string name);
-
+		// Getters
 		static std::vector<pointer> getAllOrphans(Session& session);
 		static std::vector<pointer> getAllUsed(Session& session);
 		static pointer getByName(Session& session, const std::string& name);
-		static pointer getById(Session& session, IdType id);
+		static pointer getById(Session& session, ClusterTypeId id);
 		static std::vector<pointer> getAll(Session& session);
 
 		static pointer create(Session& session, const std::string& name);

src/libs/database/include/database/Release.hpp

@@ -20,13 +20,13 @@
 #pragma once
 
 #include <optional>
-#include <set>
+#include <vector>
 
 #include <Wt/WDateTime.h>
 #include <Wt/Dbo/Dbo.h>
 
+#include "database/Types.hpp"
 #include "utils/UUID.hpp"
-#include "Types.hpp"
 
 namespace Database
 {
@@ -39,49 +39,46 @@ class Session;
 class Track;
 class User;
 
-class Release : public Wt::Dbo::Dbo<Release>
+class Release : public Object<Release, ReleaseId>
 {
 	public:
-
-		using pointer = Wt::Dbo::ptr<Release>;
-
-		Release() {}
+		Release() = default;
 		Release(const std::string& name, const std::optional<UUID>& MBID = {});
 
 		// Accessors
 		static std::size_t		getCount(Session& session);
 		static pointer			getByMBID(Session& session, const UUID& MBID);
 		static std::vector<pointer>	getByName(Session& session, const std::string& name);
-		static pointer			getById(Session& session, IdType id);
+		static pointer			getById(Session& session, ReleaseId id);
 		static std::vector<pointer>	getAllOrphans(Session& session); // no track related
 		static std::vector<pointer>	getAll(Session& session, std::optional<Range> range = std::nullopt);
-		static std::vector<IdType>	getAllIds(Session& session);
+		static std::vector<ReleaseId>	getAllIds(Session& session);
 		static std::vector<pointer>	getAllOrderedByArtist(Session& session, std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {});
-		static std::vector<pointer>	getAllRandom(Session& session, const std::set<IdType>& clusters, std::optional<std::size_t> size = {});
-		static std::vector<IdType>	getAllIdsRandom(Session& session, const std::set<IdType>& clusters, std::optional<std::size_t> size = {});
-		static std::vector<pointer>	getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::set<IdType>& clusters, std::optional<Range> range, bool& moreResults);
+		static std::vector<pointer>	getAllRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> size = {});
+		static std::vector<ReleaseId>	getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> size = {});
+		static std::vector<pointer>	getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
 		static std::vector<pointer>	getByYear(Session& session, int yearFrom, int yearTo, std::optional<Range> range = std::nullopt);
-		static std::vector<pointer> getStarred(Session& session, Wt::Dbo::ptr<User> user, const std::set<IdType>& clusters, std::optional<Range> range, bool& moreResults);
+		static std::vector<pointer> getStarred(Session& session, ObjectPtr<User> user, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
 
-		static std::vector<pointer>	getByClusters(Session& session, const std::set<IdType>& clusters);
+		static std::vector<pointer>	getByClusters(Session& session, const std::vector<ClusterId>& clusters);
 		static std::vector<pointer>	getByFilter(Session& session,
-							const std::set<IdType>& clusters,		// if non empty, at least one release that belongs to these clusters
+							const std::vector<ClusterId>& clusters,		// if non empty, at least one release that belongs to these clusters
 							const std::vector<std::string_view>& keywords,	// if non empty, name must match all of these keywords
 							std::optional<Range> range,
 							bool& moreExpected);
-		static std::vector<IdType>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<ReleaseId>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
 
-		std::vector<Wt::Dbo::ptr<Track>> getTracks(const std::set<IdType>& clusters = std::set<IdType>()) const;
-		std::size_t			getTracksCount() const;
-		Wt::Dbo::ptr<Track>			getFirstTrack() const;
+		std::vector<ObjectPtr<Track>> getTracks(const std::vector<ClusterId>& clusters = {}) const;
+		std::size_t					getTracksCount() const;
+		ObjectPtr<Track>			getFirstTrack() const;
 
 		// Get the cluster of the tracks that belong to this release
 		// Each clusters are grouped by cluster type, sorted by the number of occurence (max to min)
 		// size is the max number of cluster per cluster type
-		std::vector<std::vector<Wt::Dbo::ptr<Cluster>>> getClusterGroups(std::vector<Wt::Dbo::ptr<ClusterType>> clusterTypes, std::size_t size) const;
+		std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(const std::vector<ObjectPtr<ClusterType>>& clusterTypes, std::size_t size) const;
 
 		// Create
-		static pointer create(Session& session, const std::string& name, const std::optional<UUID>& MBID = {});
+		static pointer	create(Session& session, const std::string& name, const std::optional<UUID>& MBID = {});
 
 		// Utility functions
 		std::optional<int> getReleaseYear(bool originalDate = false) const; // 0 if unknown or various
@@ -97,8 +94,8 @@ class Release : public Wt::Dbo::Dbo<Release>
 		Wt::WDateTime				getLastWritten() const;
 
 		// Get the artists of this release
-		std::vector<Wt::Dbo::ptr<Artist> > getArtists(TrackArtistLinkType type = TrackArtistLinkType::Artist) const;
-		std::vector<Wt::Dbo::ptr<Artist> > getReleaseArtists() const { return getArtists(TrackArtistLinkType::ReleaseArtist); }
+		std::vector<ObjectPtr<Artist> > getArtists(TrackArtistLinkType type = TrackArtistLinkType::Artist) const;
+		std::vector<ObjectPtr<Artist> > getReleaseArtists() const { return getArtists(TrackArtistLinkType::ReleaseArtist); }
 		bool hasVariousArtists() const;
 		std::vector<pointer>		getSimilarReleases(std::optional<std::size_t> offset = {}, std::optional<std::size_t> count = {}) const;
 

src/libs/database/include/database/ScanSettings.hpp

@@ -19,23 +19,22 @@
 
 #pragma once
 
-#include <unordered_set>
+#include <filesystem>
+#include <vector>
 
 #include <Wt/Dbo/Dbo.h>
 #include <Wt/WTime.h>
 
-#include "utils/Path.hpp"
+#include "database/Types.hpp"
 
 namespace Database {
 
 class ClusterType;
 class Session;
 
-class ScanSettings : public Wt::Dbo::Dbo<ScanSettings>
+class ScanSettings : public Object<ScanSettings, ScanSettingsId>
 {
 	public:
-		using pointer = Wt::Dbo::ptr<ScanSettings>;
-
 		// Do not modify values (just add)
 		enum class UpdatePeriod {
 			Never = 0,
@@ -61,8 +60,8 @@ class ScanSettings : public Wt::Dbo::Dbo<ScanSettings>
 		std::filesystem::path	getMediaDirectory() const { return _mediaDirectory; }
 		Wt::WTime				getUpdateStartTime() const { return _startTime; }
 		UpdatePeriod			getUpdatePeriod() const { return _updatePeriod; }
-		std::vector<Wt::Dbo::ptr<ClusterType>> getClusterTypes() const;
-		std::unordered_set<std::filesystem::path> getAudioFileExtensions() const;
+		std::vector<ObjectPtr<ClusterType>> getClusterTypes() const;
+		std::vector<std::filesystem::path> getAudioFileExtensions() const;
 		RecommendationEngineType	getRecommendationEngineType() const { return _recommendationEngineType; }
 
 		// Setters

src/libs/database/include/database/Track.hpp

@@ -34,7 +34,7 @@
 #include "utils/EnumSet.hpp"
 #include "utils/UUID.hpp"
 
-#include "Types.hpp"
+#include "database/Types.hpp"
 
 namespace Database {
 
@@ -49,46 +49,43 @@ class TrackListEntry;
 class TrackStats;
 class User;
 
-class Track : public Wt::Dbo::Dbo<Track>
+class Track : public Object<Track, TrackId>
 {
 	public:
-
-		using pointer = Wt::Dbo::ptr<Track>;
-
-		Track() {}
+		Track() = default;
 		Track(const std::filesystem::path& p);
 
 		// Find utility functions
 		static std::size_t getCount(Session& session);
 		static pointer getByPath(Session& session, const std::filesystem::path& p);
-		static pointer getById(Session& session, IdType id);
+		static pointer getById(Session& session, TrackId id);
 		static std::vector<pointer> getByRecordingMBID(Session& session, const UUID& MBID);
 		static std::vector<pointer>	getSimilarTracks(Session& session,
-							const std::unordered_set<IdType>& trackIds,
+							const std::vector<TrackId>& trackIds,
 							std::optional<std::size_t> offset = {},
 							std::optional<std::size_t> size = {});
 		static std::vector<pointer>	getByClusters(Session& session,
-							const std::set<IdType>& clusters);           // tracks that belong to these clusters
+							const std::vector<ClusterId>& clusters);           // tracks that belong to these clusters
 		static std::vector<pointer>	getByFilter(Session& session,
-							const std::set<IdType>& clusters,            // if non empty, tracks that belong to these clusters
+							const std::vector<ClusterId>& clusters,            // if non empty, tracks that belong to these clusters
 							const std::vector<std::string_view>& keywords,    // if non empty, name must match all of these keywords
 							std::optional<Range> range,
 							bool& moreExpected);
 		static std::vector<pointer> getByNameAndReleaseName(Session& session, std::string_view trackName, std::string_view releaseName);
 
 		static std::vector<pointer>	getAll(Session& session, std::optional<std::size_t> limit = std::nullopt);
-		static std::vector<pointer>	getAllRandom(Session& session, const std::set<IdType>& clusters, std::optional<std::size_t> limit = std::nullopt);
-		static std::vector<IdType>	getAllIdsRandom(Session& session, const std::set<IdType>& clusters, std::optional<std::size_t> limit = std::nullopt);
-		static std::vector<IdType>	getAllIds(Session& session);
-		static std::vector<std::pair<IdType, std::filesystem::path>> getAllPaths(Session& session, std::optional<std::size_t> offset = std::nullopt, std::optional<std::size_t> size = std::nullopt);
+		static std::vector<pointer>	getAllRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> limit = std::nullopt);
+		static std::vector<TrackId>	getAllIdsRandom(Session& session, const std::vector<ClusterId>& clusters, std::optional<std::size_t> limit = std::nullopt);
+		static std::vector<TrackId>	getAllIds(Session& session);
+		static std::vector<std::pair<TrackId, std::filesystem::path>> getAllPaths(Session& session, std::optional<std::size_t> offset = std::nullopt, std::optional<std::size_t> size = std::nullopt);
 		static std::vector<pointer>	getMBIDDuplicates(Session& session);
-		static std::vector<pointer>	getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::set<IdType>& clusters, std::optional<Range> range, bool& moreResults);
+		static std::vector<pointer>	getLastWritten(Session& session, std::optional<Wt::WDateTime> after, const std::vector<ClusterId>& clusters, std::optional<Range> range, bool& moreResults);
 		static std::vector<pointer>	getAllWithRecordingMBIDAndMissingFeatures(Session& session);
-		static std::vector<IdType>	getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit = {});
-		static std::vector<IdType>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<TrackId>	getAllIdsWithFeatures(Session& session, std::optional<std::size_t> limit = {});
+		static std::vector<TrackId>	getAllIdsWithClusters(Session& session, std::optional<std::size_t> limit = {});
 		static std::vector<pointer>	getStarred(Session& session,
-							Wt::Dbo::ptr<User> user,
-							const std::set<IdType>& clusters,
+							ObjectPtr<User> user,
+							const std::vector<ClusterId>& clusters,
 							std::optional<Range> range, bool& hasMore);
 
 		// Create utility
@@ -115,10 +112,10 @@ class Track : public Wt::Dbo::Dbo<Track>
 		void setTrackReplayGain(float replayGain)			{ _trackReplayGain = replayGain; }
 		void setReleaseReplayGain(float replayGain)			{ _releaseReplayGain = replayGain; }
 		void clearArtistLinks();
-		void addArtistLink(const Wt::Dbo::ptr<TrackArtistLink>& artistLink);
-		void setRelease(Wt::Dbo::ptr<Release> release)			{ _release = release; }
-		void setClusters(const std::vector<Wt::Dbo::ptr<Cluster>>& clusters );
-		void setFeatures(const Wt::Dbo::ptr<TrackFeatures>& features);
+		void addArtistLink(const ObjectPtr<TrackArtistLink>& artistLink);
+		void setRelease(ObjectPtr<Release> release)			{ _release = getDboPtr(release); }
+		void setClusters(const std::vector<ObjectPtr<Cluster>>& clusters );
+		void setFeatures(const ObjectPtr<TrackFeatures>& features);
 
 		std::size_t 				getScanVersion() const		{ return _scanVersion; }
 		std::optional<std::size_t>		getTrackNumber() const;
@@ -143,16 +140,16 @@ class Track : public Wt::Dbo::Dbo<Track>
 		std::optional<float>			getReleaseReplayGain() const	{ return _releaseReplayGain; }
 
 		// no artistLinkTypes means get all
-		std::vector<Wt::Dbo::ptr<Artist>>	getArtists(EnumSet<TrackArtistLinkType> artistLinkTypes) const;
-		std::vector<IdType>					getArtistIds(EnumSet<TrackArtistLinkType> artistLinkTypes) const;
-		std::vector<Wt::Dbo::ptr<TrackArtistLink>>	getArtistLinks() const;
-		Wt::Dbo::ptr<Release>			getRelease() const		{ return _release; }
-		std::vector<Wt::Dbo::ptr<Cluster>>	getClusters() const;
-		std::vector<IdType>			getClusterIds() const;
-		bool					hasTrackFeatures() const;
-		Wt::Dbo::ptr<TrackFeatures>		getTrackFeatures() const;
+		std::vector<ObjectPtr<Artist>>	getArtists(EnumSet<TrackArtistLinkType> artistLinkTypes) const;
+		std::vector<ArtistId>				getArtistIds(EnumSet<TrackArtistLinkType> artistLinkTypes) const;
+		std::vector<ObjectPtr<TrackArtistLink>>	getArtistLinks() const;
+		ObjectPtr<Release>				getRelease() const		{ return _release; }
+		std::vector<ObjectPtr<Cluster>>	getClusters() const;
+		std::vector<ClusterId>				getClusterIds() const;
+		bool								hasTrackFeatures() const;
+		ObjectPtr<TrackFeatures>			getTrackFeatures() const;
 
-		std::vector<std::vector<Wt::Dbo::ptr<Cluster>>> getClusterGroups(std::vector<Wt::Dbo::ptr<ClusterType>> clusterTypes, std::size_t size) const;
+		std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(const std::vector<ObjectPtr<ClusterType>>& clusterTypes, std::size_t size) const;
 
 		template<class Action>
 			void persist(Action& a)

src/libs/database/include/database/TrackArtistLink.hpp

@@ -23,7 +23,7 @@
 
 #include <Wt/Dbo/Dbo.h>
 
-#include "Types.hpp"
+#include "database/Types.hpp"
 #include "utils/EnumSet.hpp"
 
 namespace Database
@@ -33,20 +33,18 @@ namespace Database
 	class Session;
 	class Track;
 
-	class TrackArtistLink
+	class TrackArtistLink : public Object<TrackArtistLink, TrackArtistLinkId>
 	{
 		public:
-			using pointer = Wt::Dbo::ptr<TrackArtistLink>;
-
 			TrackArtistLink() = default;
-			TrackArtistLink(Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<Artist> artist, TrackArtistLinkType type);
+			TrackArtistLink(ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type);
 
-			static pointer create(Session& session, Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<Artist> artist, TrackArtistLinkType type);
+			static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<Artist> artist, TrackArtistLinkType type);
 
 			static EnumSet<TrackArtistLinkType> getUsedTypes(Session& session);
 
-			Wt::Dbo::ptr<Track>		getTrack() const { return _track; }
-			Wt::Dbo::ptr<Artist>	getArtist() const { return _artist; }
+			ObjectPtr<Track>		getTrack() const { return _track; }
+			ObjectPtr<Artist>	getArtist() const { return _artist; }
 			TrackArtistLinkType		getType() const { return _type; }
 
 			template<class Action>

src/libs/database/include/database/TrackBookmark.hpp

@@ -23,7 +23,7 @@
 
 #include <Wt/Dbo/Dbo.h>
 
-#include "Types.hpp"
+#include "database/Types.hpp"
 
 namespace Database {
 
@@ -31,22 +31,20 @@ class Session;
 class Track;
 class User;
 
-class TrackBookmark : public Wt::Dbo::Dbo<TrackBookmark>
+class TrackBookmark : public Object<TrackBookmark, TrackBookmarkId>
 {
 	public:
-		using pointer = Wt::Dbo::ptr<TrackBookmark>;
-
 		TrackBookmark () = default;
-		TrackBookmark(Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track);
+		TrackBookmark(ObjectPtr<User> user, ObjectPtr<Track> track);
 
 		// utility
-		static pointer create(Session& session, Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track);
+		static pointer create(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track);
 
 		// Find utility functions
 		static std::vector<pointer>	getAll(Session& session);
-		static std::vector<pointer>	getByUser(Session& session, Wt::Dbo::ptr<User> user);
-		static pointer			getByUser(Session& session, Wt::Dbo::ptr<User> user, Wt::Dbo::ptr<Track> track);
-		static pointer			getById(Session& session, IdType id);
+		static std::vector<pointer>	getByUser(Session& session, ObjectPtr<User> user);
+		static pointer			getByUser(Session& session, ObjectPtr<User> user, ObjectPtr<Track> track);
+		static pointer			getById(Session& session, TrackBookmarkId id);
 
 		// Setters
 		void setOffset(std::chrono::milliseconds offset)	{ _offset = offset; }
@@ -55,8 +53,8 @@ class TrackBookmark : public Wt::Dbo::Dbo<TrackBookmark>
 		// Getters
 		std::chrono::milliseconds	getOffset() const	{ return _offset; }
 		std::string_view		getComment() const	{ return _comment; }
-		Wt::Dbo::ptr<Track>		getTrack() const	{ return _track; }
-		Wt::Dbo::ptr<User>		getUser() const		{ return _user; }
+		ObjectPtr<Track>		getTrack() const	{ return _track; }
+		ObjectPtr<User>		getUser() const		{ return _user; }
 
 		template<class Action>
 			void persist(Action& a)

src/libs/database/include/database/TrackFeatures.hpp

@@ -26,7 +26,7 @@
 
 #include <Wt/Dbo/Dbo.h>
 
-#include "Types.hpp"
+#include "database/Types.hpp"
 
 namespace Database {
 
@@ -37,17 +37,14 @@ using FeatureName = std::string;
 using FeatureValues  = std::vector<double>;
 using FeatureValuesMap = std::unordered_map<FeatureName, FeatureValues>;
 
-class TrackFeatures : public Wt::Dbo::Dbo<TrackFeatures>
+class TrackFeatures : public Object<TrackFeatures, TrackFeaturesId>
 {
 	public:
-
-		using pointer = Wt::Dbo::ptr<TrackFeatures>;
-
 		TrackFeatures() = default;
-		TrackFeatures(Wt::Dbo::ptr<Track> track, const std::string& jsonEncodedFeatures);
+		TrackFeatures(ObjectPtr<Track> track, const std::string& jsonEncodedFeatures);
 
 		// Create utility
-		static pointer create(Session& session, Wt::Dbo::ptr<Track> track, const std::string& jsonEncodedFeatures);
+		static pointer create(Session& session, ObjectPtr<Track> track, const std::string& jsonEncodedFeatures);
 
 		FeatureValues		getFeatureValues(const FeatureName& feature) const;
 		FeatureValuesMap	getFeatureValuesMap(const std::unordered_set<FeatureName>& featureNames) const;

src/libs/database/include/database/TrackList.hpp

@@ -27,7 +27,7 @@
 #include <Wt/Dbo/Dbo.h>
 #include <Wt/WDateTime.h>
 
-#include "Types.hpp"
+#include "database/Types.hpp"
 
 namespace Database {
 
@@ -39,11 +39,9 @@ class Track;
 class TrackListEntry;
 class User;
 
-class TrackList : public Wt::Dbo::Dbo<TrackList>
+class TrackList : public Object<TrackList, TrackListId>
 {
 	public:
-		using pointer = Wt::Dbo::ptr<TrackList>;
-
 		enum class Type
 		{
 			Playlist,  // user controlled playlists
@@ -51,28 +49,28 @@ class TrackList : public Wt::Dbo::Dbo<TrackList>
 		};
 
 		TrackList() = default;
-		TrackList(std::string_view name, Type type, bool isPublic, Wt::Dbo::ptr<User> user);
+		TrackList(std::string_view name, Type type, bool isPublic, ObjectPtr<User> user);
 
 		// Stats utility
-		std::vector<Wt::Dbo::ptr<Artist>> getTopArtists(const std::set<IdType>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
-		std::vector<Wt::Dbo::ptr<Release>> getTopReleases(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const;
-		std::vector<Wt::Dbo::ptr<Track>> getTopTracks(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Artist>> getTopArtists(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Release>> getTopReleases(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Track>> getTopTracks(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
 
 		// Search utility
-		static pointer	get(Session& session, std::string_view name, Type type, Wt::Dbo::ptr<User> user);
-		static pointer	getById(Session& session, IdType tracklistId);
+		static pointer	get(Session& session, std::string_view name, Type type, ObjectPtr<User> user);
+		static pointer	getById(Session& session, TrackListId tracklistId);
 		static std::vector<pointer> getAll(Session& session);
-		static std::vector<pointer> getAll(Session& session, Wt::Dbo::ptr<User> user);
-		static std::vector<pointer> getAll(Session& session, Wt::Dbo::ptr<User> user, Type type);
+		static std::vector<pointer> getAll(Session& session, ObjectPtr<User> user);
+		static std::vector<pointer> getAll(Session& session, ObjectPtr<User> user, Type type);
 
 		// Create utility
-		static pointer	create(Session& session, std::string_view name, Type type, bool isPublic, Wt::Dbo::ptr<User> user);
+		static pointer	create(Session& session, std::string_view name, Type type, bool isPublic, ObjectPtr<User> user);
 
 		// Accessors
 		std::string	getName() const { return _name; }
 		bool		isPublic() const { return _isPublic; }
 		Type		getType() const { return _type; }
-		Wt::Dbo::ptr<User> getUser() const { return _user; }
+		ObjectPtr<User> getUser() const { return _user; }
 
 		// Modifiers
 		void		setName(const std::string& name) { _name = name; }
@@ -80,29 +78,29 @@ class TrackList : public Wt::Dbo::Dbo<TrackList>
 		void		clear() { _entries.clear(); }
 
 		// Get tracks, ordered by position
-		bool isEmpty() const;
-		std::size_t getCount() const;
-		Wt::Dbo::ptr<TrackListEntry> getEntry(std::size_t pos) const;
-		std::vector<Wt::Dbo::ptr<TrackListEntry>> getEntries(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
-		Wt::Dbo::ptr<TrackListEntry> getEntryByTrackAndDateTime(Wt::Dbo::ptr<Track> track, const Wt::WDateTime& dateTime) const;
+		bool										isEmpty() const;
+		std::size_t									getCount() const;
+		ObjectPtr<TrackListEntry>					getEntry(std::size_t pos) const;
+		std::vector<ObjectPtr<TrackListEntry>>	getEntries(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
+		ObjectPtr<TrackListEntry>					getEntryByTrackAndDateTime(ObjectPtr<Track> track, const Wt::WDateTime& dateTime) const;
 
 		// Get track bya
 
-		std::vector<Wt::Dbo::ptr<Artist>> getArtistsReverse(const std::set<IdType>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
-		std::vector<Wt::Dbo::ptr<Release>> getReleasesReverse(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const;
-		std::vector<Wt::Dbo::ptr<Track>> getTracksReverse(const std::set<IdType>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Artist>>	getArtistsReverse(const std::vector<ClusterId>& clusterIds, std::optional<TrackArtistLinkType> linkType, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Release>>	getReleasesReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
+		std::vector<ObjectPtr<Track>>		getTracksReverse(const std::vector<ClusterId>& clusterIds, std::optional<Range> range, bool& moreResults) const;
 
-		std::vector<IdType> getTrackIds() const;
+		std::vector<TrackId> getTrackIds() const;
 
 		std::chrono::milliseconds getDuration() const;
 
 		// Get clusters, order by occurence
-		std::vector<Wt::Dbo::ptr<Cluster>> getClusters() const;
+		std::vector<ObjectPtr<Cluster>> getClusters() const;
 
-		bool hasTrack(IdType trackId) const;
+		bool hasTrack(TrackId trackId) const;
 
 		// Ordered from most clusters in common
-		std::vector<Wt::Dbo::ptr<Track>> getSimilarTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
+		std::vector<ObjectPtr<Track>> getSimilarTracks(std::optional<std::size_t> offset = {}, std::optional<std::size_t> size = {}) const;
 
 		template<class Action>
 		void persist(Action& a)
@@ -122,27 +120,24 @@ class TrackList : public Wt::Dbo::Dbo<TrackList>
 		bool			_isPublic {false};
 
 		Wt::Dbo::ptr<User>	_user;
-		Wt::Dbo::collection< Wt::Dbo::ptr<TrackListEntry> > _entries;
+		Wt::Dbo::collection<Wt::Dbo::ptr<TrackListEntry>> _entries;
 
 };
 
-class TrackListEntry : public Wt::Dbo::Dbo<TrackListEntry>
+class TrackListEntry : public Object<TrackListEntry, TrackListEntryId>
 {
 	public:
-
-		using pointer = Wt::Dbo::ptr<TrackListEntry>;
-
 		TrackListEntry() = default;
-		TrackListEntry(Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<TrackList> tracklist, const Wt::WDateTime& dateTime);
+		TrackListEntry(ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime);
 
 		// find utility
-		static pointer getById(Session& session, IdType id);
+		static pointer getById(Session& session, TrackListEntryId id);
 
 		// Create utility
-		static pointer create(Session& session, Wt::Dbo::ptr<Track> track, Wt::Dbo::ptr<TrackList> tracklist, const Wt::WDateTime& dateTime = Wt::WDateTime::currentDateTime());
+		static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<TrackList> tracklist, const Wt::WDateTime& dateTime = Wt::WDateTime::currentDateTime());
 
 		// Accessors
-		Wt::Dbo::ptr<Track>	getTrack() const { return _track; }
+		ObjectPtr<Track>	getTrack() const { return _track; }
 		const Wt::WDateTime& getDateTime() const { return _dateTime; }
 
 		template<class Action>

src/libs/database/include/database/Types.hpp

@@ -20,16 +20,32 @@
 #pragma once
 
 #include <cstdint>
+#include <cassert>
+#include <functional>
 #include <Wt/Dbo/ptr.h>
 
 namespace Database
 {
-	using IdType = Wt::Dbo::dbo_default_traits::IdType;
-
-	static inline bool IdIsValid(IdType id)
+	class IdType
 	{
-		return id != Wt::Dbo::dbo_default_traits::invalidId();
-	}
+		public:
+			using ValueType = Wt::Dbo::dbo_default_traits::IdType;
+
+			IdType() = default;
+			IdType(ValueType id) : _id {id} { assert(isValid()); }
+
+			bool isValid() const { return _id != Wt::Dbo::dbo_default_traits::invalidId(); }
+			std::string toString() const { assert(isValid()); return std::to_string(_id); }
+
+			ValueType getValue() const { return _id; }
+
+			bool operator==(IdType other) const { return other._id == _id; }
+			bool operator!=(IdType other) const { return !(*this == other); }
+			bool operator<(IdType other) const { return other._id < _id; }
+
+		private:
+			Wt::Dbo::dbo_default_traits::IdType _id {Wt::Dbo::dbo_default_traits::invalidId()};
+	};
 
 	struct Range
 	{
@@ -78,5 +94,83 @@ namespace Database
 		ADMIN	= 1,
 		DEMO	= 2,
 	};
+
+	template <typename T>
+	class ObjectPtr
+	{
+		public:
+			ObjectPtr() = default;
+			ObjectPtr(Wt::Dbo::ptr<T> obj) : _obj {obj} {}
+
+			const T* operator->() const { return _obj.get(); }
+			operator bool() const { return _obj.get(); }
+			bool operator!() const { return !_obj.get(); }
+
+			auto modify() { return _obj.modify(); }
+			void remove() { _obj.remove(); }
+
+		private:
+			template <typename, typename> friend class Object;
+			Wt::Dbo::ptr<T> _obj;
+	};
+
+	template <typename T, typename ObjectIdType>
+	class Object : public Wt::Dbo::Dbo<T>
+	{
+		static_assert(std::is_base_of_v<Database::IdType, ObjectIdType>);
+		static_assert(!std::is_same_v<Database::IdType, ObjectIdType>);
+
+		public:
+			using pointer = ObjectPtr<T>;
+			using IdType = ObjectIdType;
+
+			IdType getId() const { return Wt::Dbo::Dbo<T>::self()->Wt::Dbo::Dbo<T>::id(); }
+
+			// catch some misuses
+			typename Wt::Dbo::dbo_traits<T>::IdType id() const = delete;
+
+		protected:
+			// Can get raw dbo ptr only from Objects
+			template <typename SomeObject>
+			static
+			Wt::Dbo::ptr<SomeObject> getDboPtr(ObjectPtr<SomeObject> ptr) { return ptr._obj; }
+	};
 }
 
+// TODO factorize hash with std::enable_if
+#define LMS_DECLARE_IDTYPE(name) \
+namespace Database { \
+	class name : public IdType \
+	{ \
+		public: \
+			using IdType::IdType; \
+	};\
+} \
+namespace std \
+{ \
+	template<> \
+	class hash<Database::name> \
+	{ \
+		public: \
+			size_t operator()(Database::name id) const \
+			{ \
+				return std::hash<Database::name::ValueType>()(id.getValue()); \
+			} \
+	}; \
+} // ns std
+
+LMS_DECLARE_IDTYPE(ArtistId)
+LMS_DECLARE_IDTYPE(AuthTokenId)
+LMS_DECLARE_IDTYPE(ClusterId)
+LMS_DECLARE_IDTYPE(ClusterTypeId)
+LMS_DECLARE_IDTYPE(ReleaseId)
+LMS_DECLARE_IDTYPE(ScanSettingsId)
+LMS_DECLARE_IDTYPE(TrackArtistLinkId)
+LMS_DECLARE_IDTYPE(TrackBookmarkId)
+LMS_DECLARE_IDTYPE(TrackFeaturesId)
+LMS_DECLARE_IDTYPE(TrackId)
+LMS_DECLARE_IDTYPE(TrackListId)
+LMS_DECLARE_IDTYPE(TrackListEntryId)
+LMS_DECLARE_IDTYPE(UserId)
+
+

src/libs/database/include/database/User.hpp

@@ -26,8 +26,8 @@
 #include <Wt/Dbo/Dbo.h>
 #include <Wt/WDateTime.h>
 
+#include "database/Types.hpp"
 #include "utils/UUID.hpp"
-#include "Types.hpp"
 
 namespace Database {
 
@@ -39,24 +39,21 @@ class TrackList;
 class Track;
 
 class User;
-class AuthToken
+class AuthToken : public Object<AuthToken, AuthTokenId>
 {
 	public:
-
-		using pointer = Wt::Dbo::ptr<AuthToken>;
-
 		AuthToken() = default;
-		AuthToken(const std::string& value, const Wt::WDateTime& expiry, Wt::Dbo::ptr<User> user);
+		AuthToken(const std::string& value, const Wt::WDateTime& expiry, ObjectPtr<User> user);
 
 		// Utility
-		static pointer create(Session& session, const std::string& value, const Wt::WDateTime&expiry, Wt::Dbo::ptr<User> user);
+		static pointer create(Session& session, const std::string& value, const Wt::WDateTime&expiry, ObjectPtr<User> user);
 		static void removeExpiredTokens(Session& session, const Wt::WDateTime& now);
 		static pointer getByValue(Session& session, const std::string& value);
-		static pointer getById(Session& session, IdType tokenId);
+		static pointer getById(Session& session, AuthTokenId tokenId);
 
 		// Accessors
 		const Wt::WDateTime&	getExpiry() const { return _expiry; }
-		Wt::Dbo::ptr<User>	getUser() const { return _user; }
+		ObjectPtr<User>	getUser() const { return _user; }
 		const std::string&	getValue() const { return _value; }
 
 		template<class Action>
@@ -75,11 +72,9 @@ class AuthToken
 		Wt::Dbo::ptr<User>	_user;
 };
 
-class User : public Wt::Dbo::Dbo<User>
+class User : public Object<User, UserId>
 {
 	public:
-		using pointer = Wt::Dbo::ptr<User>;
-
 		struct PasswordHash
 		{
 			std::string salt;
@@ -120,17 +115,16 @@ class User : public Wt::Dbo::Dbo<User>
 		static inline const SubsonicArtistListMode defaultSubsonicArtistListMode {SubsonicArtistListMode::AllArtists};
 		static inline const Scrobbler	defaultScrobbler {Scrobbler::Internal};
 
-
 		User() = default;
 		User(std::string_view loginName);
 
 		// utility
 		static pointer create(Session& session, std::string_view loginName);
 
-		static pointer			getById(Session& session, IdType id);
+		static pointer			getById(Session& session, UserId id);
 		static pointer			getByLoginName(Session& session, std::string_view loginName);
 		static std::vector<pointer>	getAll(Session& session);
-		static std::vector<IdType>	getAllIds(Session& session);
+		static std::vector<UserId>	getAllIds(Session& session);
 		static pointer			getDemo(Session& session);
 		static std::size_t		getCount(Session& session);
 
@@ -171,20 +165,20 @@ class User : public Wt::Dbo::Dbo<User>
 		Scrobbler				getScrobbler() const { return _scrobbler; }
 		std::optional<UUID>		getListenBrainzToken() const	{ return UUID::fromString(_listenbrainzToken); }
 
-		Wt::Dbo::ptr<TrackList>	getQueuedTrackList(Session& session) const;
+		ObjectPtr<TrackList>	getQueuedTrackList(Session& session) const;
 
-		void			starArtist(Wt::Dbo::ptr<Artist> artist);
-		void			unstarArtist(Wt::Dbo::ptr<Artist> artist);
-		bool			hasStarredArtist(Wt::Dbo::ptr<Artist> artist) const;
+		void			starArtist(ObjectPtr<Artist> artist);
+		void			unstarArtist(ObjectPtr<Artist> artist);
+		bool			hasStarredArtist(ObjectPtr<Artist> artist) const;
 
-		void			starRelease(Wt::Dbo::ptr<Release> release);
-		void			unstarRelease(Wt::Dbo::ptr<Release> release);
-		bool			hasStarredRelease(Wt::Dbo::ptr<Release> release) const;
+		void			starRelease(ObjectPtr<Release> release);
+		void			unstarRelease(ObjectPtr<Release> release);
+		bool			hasStarredRelease(ObjectPtr<Release> release) const;
 
 		// Stars
-		void			starTrack(Wt::Dbo::ptr<Track> track);
-		void			unstarTrack(Wt::Dbo::ptr<Track> track);
-		bool			hasStarredTrack(Wt::Dbo::ptr<Track> track) const;
+		void			starTrack(ObjectPtr<Track> track);
+		void			unstarTrack(ObjectPtr<Track> track);
+		bool			hasStarredTrack(ObjectPtr<Track> track) const;
 
 		template<class Action>
 		void persist(Action& a)