Simplify compile time benchmark query result gathering

Author: Kobzol

site/src/comparison.rs

@@ -952,10 +952,14 @@ where
         } else {
             continue;
         };
-        let benchmark = *response.path.get::<Benchmark>().unwrap();
-        let profile = *response.path.get::<Profile>().unwrap();
-        let scenario = *response.path.get::<Scenario>().unwrap();
-        stats.insert((benchmark, profile, scenario), value);
+        stats.insert(
+            (
+                response.key.benchmark,
+                response.key.profile,
+                response.key.scenario,
+            ),
+            value,
+        );
     }
     stats
 }

site/src/request_handlers/graph.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use crate::api::graphs::GraphKind;
 use crate::api::{graph, graphs, ServerResult};
-use crate::db::{self, ArtifactId, Benchmark, Profile, Scenario};
+use crate::db::{self, ArtifactId, Profile, Scenario};
 use crate::interpolate::IsInterpolated;
 use crate::load::SiteCtxt;
 use crate::selector::{CompileBenchmarkQuery, Selector, SeriesResponse};
@@ -119,9 +119,9 @@ async fn create_graphs(
     }
 
     for response in interpolated_responses {
-        let benchmark = response.path.get::<Benchmark>()?.to_string();
-        let profile = *response.path.get::<Profile>()?;
-        let scenario = response.path.get::<Scenario>()?.to_string();
+        let benchmark = response.key.benchmark.to_string();
+        let profile = response.key.profile;
+        let scenario = response.key.scenario.to_string();
         let graph_series = graph_series(response.series.into_iter(), request.kind);
 
         benchmarks
@@ -188,9 +188,9 @@ fn create_summary(
                 let baseline_responses = interpolated_responses
                     .iter()
                     .filter(|sr| {
-                        let p = sr.path.get::<Profile>().unwrap();
-                        let s = sr.path.get::<Scenario>().unwrap();
-                        *p == profile && *s == Scenario::Empty
+                        let p = sr.key.profile;
+                        let s = sr.key.scenario;
+                        p == profile && s == Scenario::Empty
                     })
                     .map(|sr| sr.series.iter().cloned())
                     .collect();
@@ -205,9 +205,9 @@ fn create_summary(
         let summary_case_responses = interpolated_responses
             .iter()
             .filter(|sr| {
-                let p = sr.path.get::<Profile>().unwrap();
-                let s = sr.path.get::<Scenario>().unwrap();
-                *p == profile && *s == scenario
+                let p = sr.key.profile;
+                let s = sr.key.scenario;
+                p == profile && s == scenario
             })
             .map(|sr| sr.series.iter().cloned())
             .collect();

site/src/selector.rs

@@ -110,73 +110,6 @@ impl Iterator for ArtifactIdIter {
     }
 }
 
-#[derive(Copy, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Tag {
-    Benchmark,
-    Profile,
-    Scenario,
-    Metric,
-}
-
-pub trait GetValue {
-    fn value(component: &PathComponent) -> Option<&Self>;
-}
-
-impl GetValue for Benchmark {
-    fn value(component: &PathComponent) -> Option<&Self> {
-        match component {
-            PathComponent::Benchmark(v) => Some(v),
-            _ => None,
-        }
-    }
-}
-
-impl GetValue for Profile {
-    fn value(component: &PathComponent) -> Option<&Self> {
-        match component {
-            PathComponent::Profile(v) => Some(v),
-            _ => None,
-        }
-    }
-}
-
-impl GetValue for Scenario {
-    fn value(component: &PathComponent) -> Option<&Self> {
-        match component {
-            PathComponent::Scenario(v) => Some(v),
-            _ => None,
-        }
-    }
-}
-
-impl GetValue for database::Metric {
-    fn value(component: &PathComponent) -> Option<&Self> {
-        match component {
-            PathComponent::Metric(v) => Some(v),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub enum PathComponent {
-    Benchmark(Benchmark),
-    Profile(Profile),
-    Scenario(Scenario),
-    Metric(database::Metric),
-}
-
-impl PathComponent {
-    pub fn as_tag(&self) -> Tag {
-        match self {
-            PathComponent::Benchmark(_) => Tag::Benchmark,
-            PathComponent::Profile(_) => Tag::Profile,
-            PathComponent::Scenario(_) => Tag::Scenario,
-            PathComponent::Metric(_) => Tag::Metric,
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Selector<T> {
     All,
@@ -227,14 +160,14 @@ impl<T> Selector<T> {
 
 #[derive(Debug)]
 pub struct SeriesResponse<T> {
-    pub path: Path,
+    pub key: CompileBenchmarkKey,
     pub series: T,
 }
 
 impl<T> SeriesResponse<T> {
     pub fn map<U>(self, m: impl FnOnce(T) -> U) -> SeriesResponse<U> {
         SeriesResponse {
-            path: self.path,
+            key: self.key,
             series: m(self.series),
         }
     }
@@ -248,37 +181,6 @@ impl<T> SeriesResponse<T> {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Path {
-    path: Vec<PathComponent>,
-}
-
-impl Path {
-    pub fn new() -> Self {
-        Self { path: vec![] }
-    }
-
-    pub fn set(mut self, component: PathComponent) -> Self {
-        if let Some(idx) = self
-            .path
-            .iter()
-            .position(|c| c.as_tag() == component.as_tag())
-        {
-            self.path[idx] = component;
-        } else {
-            self.path.push(component);
-        }
-        self
-    }
-
-    pub fn get<V: 'static + GetValue>(&self) -> Result<&V, String> {
-        self.path
-            .iter()
-            .find_map(V::value)
-            .ok_or_else(|| format!("query must have {:?} selector", std::any::type_name::<V>()))
-    }
-}
-
 #[derive(Clone, Hash, Eq, PartialEq, Debug)]
 pub struct CompileBenchmarkQuery {
     benchmark: Selector<String>,
@@ -327,6 +229,13 @@ impl CompileBenchmarkQuery {
     }
 }
 
+#[derive(Debug)]
+pub struct CompileBenchmarkKey {
+    pub benchmark: Benchmark,
+    pub profile: Profile,
+    pub scenario: Scenario,
+}
+
 impl SiteCtxt {
     pub async fn compile_statistic_series(
         &self,
@@ -407,11 +316,11 @@ impl StatisticSeries {
                             points.into_iter()
                         },
                     },
-                    path: Path::new()
-                        .set(PathComponent::Benchmark(benchmark))
-                        .set(PathComponent::Profile(profile))
-                        .set(PathComponent::Scenario(scenario))
-                        .set(PathComponent::Metric(metric)),
+                    key: CompileBenchmarkKey {
+                        benchmark,
+                        profile,
+                        scenario,
+                    },
                 }
             })
             .collect::<Vec<_>>();