db: Combine playlist repo methods into one

crates/media-file/src/util/mod.rs

@@ -193,8 +193,8 @@ pub fn push_next_actor<'a>(
                 }
                 // Warn about ambiguous sorting actors
                 log::warn!(
-                    "Ignoring {role:?} actor \"{name}\" because \"{actor_name}\" is already \
-                    used for sorting",
+                    "Ignoring {role:?} actor \"{name}\" because \"{actor_name}\" is already used \
+                     for sorting",
                     actor_name = actor.name
                 );
                 return false;

crates/repo-sqlite/src/repo/playlist/mod.rs

@@ -12,8 +12,9 @@ use aoide_core::{
 };
 use aoide_core_api::playlist::EntityWithEntriesSummary;
 use aoide_repo::{
-    collection::RecordId as CollectionId, playlist::*, track::EntityRepo as _,
-    track::RecordId as TrackId,
+    collection::RecordId as CollectionId,
+    playlist::*,
+    track::{EntityRepo as _, RecordId as TrackId},
 };
 use diesel::dsl::{count_distinct, count_star};
 
@@ -333,25 +334,22 @@ impl<'db> EntryRepo for crate::Connection<'db> {
             .map_err(repo_error)
     }
 
-    fn count_playlist_track_entries(&mut self, id: RecordId) -> RepoResult<usize> {
+    fn load_playlist_tracks_summary(&mut self, id: RecordId) -> RepoResult<TracksSummary> {
         use playlist_entry_db::schema::*;
         playlist_entry::table
             .filter(playlist_entry::playlist_id.eq(RowId::from(id)))
-            .select(count_star())
+            .select((count_star(), count_distinct(playlist_entry::track_id)))
             .filter(playlist_entry::track_id.is_not_null())
-            .first::<i64>(self.as_mut())
-            .map(|count| count as usize)
-            .map_err(repo_error)
-    }
-
-    fn count_playlist_distinct_track_entries(&mut self, id: RecordId) -> RepoResult<usize> {
-        use playlist_entry_db::schema::*;
-        playlist_entry::table
-            .filter(playlist_entry::playlist_id.eq(RowId::from(id)))
-            .select(count_distinct(playlist_entry::track_id))
-            .filter(playlist_entry::track_id.is_not_null())
-            .first::<i64>(self.as_mut())
-            .map(|count| count as usize)
+            .first::<(i64, i64)>(self.as_mut())
+            .map(|(total_count, distinct_count)| {
+                debug_assert!(total_count >= 0);
+                debug_assert!(distinct_count >= 0);
+                debug_assert!(distinct_count <= total_count);
+                TracksSummary {
+                    total_count: total_count as usize,
+                    distinct_count: distinct_count as usize,
+                }
+            })
             .map_err(repo_error)
     }
 
@@ -373,10 +371,9 @@ impl<'db> EntryRepo for crate::Connection<'db> {
     fn load_playlist_entries_summary(&mut self, id: RecordId) -> RepoResult<EntriesSummary> {
         use playlist_entry_db::schema::*;
         let entries_count = self.count_playlist_entries(id)?;
-        let total_tracks_count = self.count_playlist_track_entries(id)?;
-        debug_assert!(total_tracks_count <= entries_count);
-        let distinct_tracks_count = self.count_playlist_distinct_track_entries(id)?;
-        debug_assert!(distinct_tracks_count <= total_tracks_count);
+        let tracks_summary = self.load_playlist_tracks_summary(id)?;
+        debug_assert!(tracks_summary.total_count <= entries_count);
+        debug_assert!(tracks_summary.distinct_count <= tracks_summary.total_count);
         let added_at_minmax = if entries_count > 0 {
             let added_at_min = playlist_entry::table
                 .filter(playlist_entry::playlist_id.eq(RowId::from(id)))
@@ -406,10 +403,7 @@ impl<'db> EntryRepo for crate::Connection<'db> {
         Ok(EntriesSummary {
             total_count: entries_count,
             added_at_minmax,
-            tracks: TracksSummary {
-                total_count: total_tracks_count,
-                distinct_count: distinct_tracks_count,
-            },
+            tracks: tracks_summary,
         })
     }
 

crates/repo-sqlite/src/repo/playlist/tests.rs

@@ -152,7 +152,7 @@ fn new_separator_entry_with_title(title: String) -> Entry {
 }
 
 #[test]
-fn count_entries() -> anyhow::Result<()> {
+fn load_tracks_summary_and_count_entries() -> anyhow::Result<()> {
     let mut db = establish_connection()?;
     let mut db = crate::Connection::new(&mut db);
     let fixture = Fixture::new(&mut db)?;
@@ -184,11 +184,9 @@ fn count_entries() -> anyhow::Result<()> {
     let last_track_id = db.resolve_track_id(last_track_uid)?;
 
     assert_eq!(track_count, db.count_playlist_entries(playlist_id)?);
-    assert_eq!(track_count, db.count_playlist_track_entries(playlist_id)?);
-    assert_eq!(
-        track_count,
-        db.count_playlist_distinct_track_entries(playlist_id)?
-    );
+    let tracks_summary = db.load_playlist_tracks_summary(playlist_id)?;
+    assert_eq!(track_count, tracks_summary.total_count);
+    assert_eq!(track_count, tracks_summary.distinct_count);
     assert_eq!(
         1,
         db.count_playlist_single_track_entries(playlist_id, first_track_id)?
@@ -206,14 +204,9 @@ fn count_entries() -> anyhow::Result<()> {
     db.prepend_playlist_entries(playlist_id, &[first_separator.clone()])?;
 
     assert_eq!(track_count + 2, db.count_playlist_entries(playlist_id)?);
-    assert_eq!(
-        track_count + 1,
-        db.count_playlist_track_entries(playlist_id)?
-    );
-    assert_eq!(
-        track_count,
-        db.count_playlist_distinct_track_entries(playlist_id)?
-    );
+    let tracks_summary = db.load_playlist_tracks_summary(playlist_id)?;
+    assert_eq!(track_count + 1, tracks_summary.total_count);
+    assert_eq!(track_count, tracks_summary.distinct_count);
     assert_eq!(
         2,
         db.count_playlist_single_track_entries(playlist_id, first_track_id)?

crates/repo/src/playlist/mod.rs

@@ -4,7 +4,9 @@
 use std::{borrow::Cow, ops::Range};
 
 use aoide_core::{
-    playlist::{Entity, EntityHeader, EntityUid, EntityWithEntries, EntriesSummary, Entry},
+    playlist::{
+        Entity, EntityHeader, EntityUid, EntityWithEntries, EntriesSummary, Entry, TracksSummary,
+    },
     util::{clock::DateTime, random::adhoc_rng},
 };
 use aoide_core_api::playlist::EntityWithEntriesSummary;
@@ -198,9 +200,7 @@ pub trait EntryRepo {
 
     fn count_playlist_entries(&mut self, id: RecordId) -> RepoResult<usize>;
 
-    fn count_playlist_track_entries(&mut self, id: RecordId) -> RepoResult<usize>;
-
-    fn count_playlist_distinct_track_entries(&mut self, id: RecordId) -> RepoResult<usize>;
+    fn load_playlist_tracks_summary(&mut self, id: RecordId) -> RepoResult<TracksSummary>;
 
     fn count_playlist_single_track_entries(
         &mut self,