Avoid unnecessary allocations

src/controllers/krate/metadata.rs

@@ -65,12 +65,12 @@ pub async fn show(app: AppState, Path(name): Path<String>, req: Parts) -> AppRes
             let versions = versions_and_publishers
                 .iter()
                 .map(|(v, _)| v)
-                .cloned()
                 .collect::<Vec<_>>();
+            let actions = VersionOwnerAction::for_versions(conn, &versions)?;
             Some(
                 versions_and_publishers
                     .into_iter()
-                    .zip(VersionOwnerAction::for_versions(conn, &versions)?)
+                    .zip(actions)
                     .map(|((v, pb), aas)| (v, pb, aas))
                     .collect::<Vec<_>>(),
             )
@@ -267,12 +267,12 @@ pub async fn reverse_dependencies(
             .load(conn)?;
         let versions = versions_and_publishers
             .iter()
-            .map(|(v, _, _)| v)
-            .cloned()
+            .map(|(v, ..)| v)
             .collect::<Vec<_>>();
+        let actions = VersionOwnerAction::for_versions(conn, &versions)?;
         let versions = versions_and_publishers
             .into_iter()
-            .zip(VersionOwnerAction::for_versions(conn, &versions)?)
+            .zip(actions)
             .map(|((version, krate_name, published_by), actions)| {
                 EncodableVersion::from(version, &krate_name, published_by, actions)
             })

src/controllers/krate/search.rs

@@ -214,15 +214,7 @@ pub async fn search(app: AppState, req: Parts) -> AppResult<Json<Value>> {
             )
         };
 
-        let perfect_matches = data.iter().map(|&(_, b, _, _, _)| b).collect::<Vec<_>>();
-        let downloads = data
-            .iter()
-            .map(|&(_, _, total, recent, _)| (total, recent.unwrap_or(0)))
-            .collect::<Vec<_>>();
-        let crates = data
-            .into_iter()
-            .map(|(c, _, _, _, _)| c)
-            .collect::<Vec<_>>();
+        let crates = data.iter().map(|(c, ..)| c).collect::<Vec<_>>();
 
         let versions: Vec<Version> = info_span!("db.query", message = "SELECT ... FROM versions")
             .in_scope(|| crates.versions().load(conn))?;
@@ -232,17 +224,15 @@ pub async fn search(app: AppState, req: Parts) -> AppResult<Json<Value>> {
             .map(TopVersions::from_versions);
 
         let crates = versions
-            .zip(crates)
-            .zip(perfect_matches)
-            .zip(downloads)
-            .map(|(((max_version, krate), perfect_match), (total, recent))| {
+            .zip(data)
+            .map(|(max_version, (krate, perfect_match, total, recent, _))| {
                 EncodableCrate::from_minimal(
                     krate,
                     Some(&max_version),
                     Some(vec![]),
                     perfect_match,
                     total,
-                    Some(recent),
+                    Some(recent.unwrap_or(0)),
                 )
             })
             .collect::<Vec<_>>();

src/controllers/krate/versions.rs

@@ -68,12 +68,12 @@ pub async fn versions(
             .data
             .iter()
             .map(|(v, _)| v)
-            .cloned()
             .collect::<Vec<_>>();
+        let actions = VersionOwnerAction::for_versions(conn, &versions)?;
         let versions = versions_and_publishers
             .data
             .into_iter()
-            .zip(VersionOwnerAction::for_versions(conn, &versions)?)
+            .zip(actions)
             .map(|((v, pb), aas)| EncodableVersion::from(v, &crate_name, pb, aas))
             .collect::<Vec<_>>();
 

src/controllers/summary.rs

@@ -27,21 +27,14 @@ pub async fn summary(state: AppState) -> AppResult<Json<Value>> {
             conn: &mut impl Conn,
             data: Vec<(Crate, i64, Option<i64>)>,
         ) -> AppResult<Vec<EncodableCrate>> {
-            let downloads = data
-                .iter()
-                .map(|&(_, total, recent)| (total, recent))
-                .collect::<Vec<_>>();
-
-            let krates = data.into_iter().map(|(c, _, _)| c).collect::<Vec<_>>();
-
+            let krates = data.iter().map(|(c, ..)| c).collect::<Vec<_>>();
             let versions: Vec<Version> = krates.versions().load(conn)?;
             versions
                 .grouped_by(&krates)
                 .into_iter()
                 .map(TopVersions::from_versions)
-                .zip(krates)
-                .zip(downloads)
-                .map(|((top_versions, krate), (total, recent))| {
+                .zip(data)
+                .map(|(top_versions, (krate, total, recent))| {
                     Ok(EncodableCrate::from_minimal(
                         krate,
                         Some(&top_versions),

src/controllers/user/me.rs

@@ -85,10 +85,11 @@ pub async fn updates(app: AppState, req: Parts) -> AppResult<Json<Value>> {
             .pages_pagination(PaginationOptions::builder().gather(&req)?);
         let data: Paginated<(Version, String, Option<User>)> = query.load(conn)?;
         let more = data.next_page_params().is_some();
-        let versions = data.iter().map(|(v, _, _)| v).cloned().collect::<Vec<_>>();
+        let versions = data.iter().map(|(v, ..)| v).collect::<Vec<_>>();
+        let actions = VersionOwnerAction::for_versions(conn, &versions)?;
         let data = data
             .into_iter()
-            .zip(VersionOwnerAction::for_versions(conn, &versions)?)
+            .zip(actions)
             .map(|((v, cn, pb), voas)| (v, cn, pb, voas));
 
         let versions = data

src/models/action.rs

@@ -65,7 +65,7 @@ impl VersionOwnerAction {
 
     pub fn for_versions(
         conn: &mut impl Conn,
-        versions: &[Version],
+        versions: &[&Version],
     ) -> QueryResult<Vec<Vec<(Self, User)>>> {
         Ok(Self::belonging_to(versions)
             .inner_join(users::table)

src/models/krate.rs

@@ -494,6 +494,12 @@ impl CrateVersions for [Crate] {
     }
 }
 
+impl CrateVersions for [&Crate] {
+    fn all_versions(&self) -> versions::BoxedQuery<'_, Pg> {
+        Version::belonging_to(self).into_boxed()
+    }
+}
+
 #[derive(Debug, Eq, PartialEq, thiserror::Error)]
 pub enum InvalidFeature {
     #[error("feature cannot be empty")]