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