Use a single query to fetch self profile results

This avoids numerous roundtrips to the database, saving a lot of time
(especially with the postgres backend).

Author: Mark-Simulacrum

database/src/pool.rs

@@ -49,6 +49,13 @@ pub trait Connection: Send + Sync {
         series: &[u32],
         cid: &[Option<ArtifactIdNumber>],
     ) -> Vec<Vec<Option<f64>>>;
+    async fn get_self_profile(
+        &self,
+        cid: ArtifactIdNumber,
+        crate_: &str,
+        profile: &str,
+        cache: &str,
+    ) -> HashMap<crate::QueryLabel, QueryDatum>;
     async fn get_self_profile_query(
         &self,
         series: u32,

database/src/pool/postgres.rs

@@ -232,6 +232,7 @@ pub struct CachedStatements {
     get_pstat: Statement,
     insert_pstat: Statement,
     get_self_profile_query: Statement,
+    get_self_profile: Statement,
     insert_self_profile_query: Statement,
     select_self_query_series: Statement,
     insert_self_query_series: Statement,
@@ -333,6 +334,17 @@ impl PostgresConnection {
                     )
                     .await
                     .unwrap(),
+                get_self_profile: conn.prepare("
+                    select
+                        query, self_time, blocked_time, incremental_load_time, number_of_cache_hits, invocation_count
+                    from self_profile_query_series
+                    join self_profile_query on self_profile_query_series.id = self_profile_query.series
+                    where
+                        crate = $1
+                        and profile = $2
+                        and cache = $3
+                        and aid = $4
+                ").await.unwrap(),
                 insert_self_profile_query: conn
                     .prepare(
                         "insert into self_profile_query(
@@ -563,6 +575,40 @@ where
             invocation_count: row.get::<_, i32>(4) as u32,
         })
     }
+    async fn get_self_profile(
+        &self,
+        cid: ArtifactIdNumber,
+        crate_: &str,
+        profile: &str,
+        cache: &str,
+    ) -> HashMap<crate::QueryLabel, crate::QueryDatum> {
+        let rows = self
+            .conn()
+            .query(
+                &self.statements().get_self_profile,
+                &[&crate_, &profile, &cache, &(cid.0 as i16)],
+            )
+            .await
+            .unwrap();
+
+        rows.into_iter()
+            .map(|r| {
+                let self_time: i64 = r.get(1);
+                let blocked_time: i64 = r.get(2);
+                let incremental_load_time: i64 = r.get(3);
+                (
+                    r.get::<_, &str>(0).into(),
+                    crate::QueryDatum {
+                        self_time: Duration::from_nanos(self_time as u64),
+                        blocked_time: Duration::from_nanos(blocked_time as u64),
+                        incremental_load_time: Duration::from_nanos(incremental_load_time as u64),
+                        number_of_cache_hits: r.get::<_, i32>(4) as u32,
+                        invocation_count: r.get::<_, i32>(5) as u32,
+                    },
+                )
+            })
+            .collect()
+    }
     async fn get_error(&self, cid: crate::ArtifactIdNumber) -> HashMap<String, Option<String>> {
         let rows = self
             .conn()

database/src/pool/sqlite.rs

@@ -397,6 +397,45 @@ impl Connection for SqliteConnection {
             .optional()
             .unwrap()
     }
+    async fn get_self_profile(
+        &self,
+        cid: ArtifactIdNumber,
+        crate_: &str,
+        profile: &str,
+        cache: &str,
+    ) -> HashMap<crate::QueryLabel, crate::QueryDatum> {
+        self.raw_ref()
+            .prepare_cached("
+                select
+                    query, self_time, blocked_time, incremental_load_time, number_of_cache_hits, invocation_count
+                from self_profile_query_series
+                join self_profile_query on self_profile_query_series.id = self_profile_query.series
+                where
+                    crate = ?
+                    and profile = ?
+                    and cache = ?
+                    and aid = ?
+                ")
+            .unwrap()
+            .query_map(params![&crate_, &profile, &cache, &cid.0], |r| {
+                let self_time: i64 = r.get(1)?;
+                let blocked_time: i64 = r.get(2)?;
+                let incremental_load_time: i64 = r.get(3)?;
+                Ok((
+                    r.get::<_, String>(0)?.as_str().into(),
+                    crate::QueryDatum {
+                        self_time: Duration::from_nanos(self_time as u64),
+                        blocked_time: Duration::from_nanos(blocked_time as u64),
+                        incremental_load_time: Duration::from_nanos(incremental_load_time as u64),
+                        number_of_cache_hits: r.get::<_, i32>(4)? as u32,
+                        invocation_count: r.get::<_, i32>(5)? as u32,
+                    },
+                ))
+            })
+            .unwrap()
+            .collect::<Result<_, _>>()
+            .unwrap()
+    }
     async fn get_error(&self, cid: crate::ArtifactIdNumber) -> HashMap<String, Option<String>> {
         self.raw_ref()
             .prepare_cached(

site/src/selector.rs

@@ -673,32 +673,23 @@ impl SelfProfile {
                 res.push(None);
                 continue;
             };
-            for label in labels.iter() {
-                let query = crate::db::DbLabel::SelfProfileQuery {
-                    krate,
-                    profile,
-                    cache,
-                    query: *label,
-                };
-                let qid = if let Some(qid) = query.lookup(&idx) {
-                    qid
-                } else {
-                    continue;
-                };
-                if let Some(qd) = conn.get_self_profile_query(qid, cid_id).await {
-                    queries.push(QueryData {
-                        label: *label,
-                        self_time: qd.self_time.as_nanos().try_into().unwrap(),
-                        number_of_cache_hits: qd.number_of_cache_hits,
-                        invocation_count: qd.invocation_count,
-                        blocked_time: qd.blocked_time.as_nanos().try_into().unwrap(),
-                        incremental_load_time: qd
-                            .incremental_load_time
-                            .as_nanos()
-                            .try_into()
-                            .unwrap(),
-                    });
-                }
+            let cid_data = conn
+                .get_self_profile(
+                    cid_id,
+                    krate.as_str(),
+                    &profile.to_string(),
+                    &cache.to_string(),
+                )
+                .await;
+            for (label, qd) in cid_data {
+                queries.push(QueryData {
+                    label,
+                    self_time: qd.self_time.as_nanos().try_into().unwrap(),
+                    number_of_cache_hits: qd.number_of_cache_hits,
+                    invocation_count: qd.invocation_count,
+                    blocked_time: qd.blocked_time.as_nanos().try_into().unwrap(),
+                    incremental_load_time: qd.incremental_load_time.as_nanos().try_into().unwrap(),
+                });
             }
             if queries.is_empty() {
                 res.push(None);