vortex-data
diff --git a/‎benchmarks-website/server/src/api.rs‎
Lines changed: 103 additions & 5 deletions b/‎benchmarks-website/server/src/api.rs‎
Lines changed: 103 additions & 5 deletions
@@ -34,6 +34,39 @@ pub const DEFAULT_COMMIT_WINDOW: u32 = 100;
 /// Hard server-side ceiling on `?n=NNN`.
 pub const MAX_COMMIT_WINDOW: u32 = 1000;
 
+/// Canonical group ordering, ported from the v2 site's hard-coded list at
+/// `origin/ct/vfvb:benchmarks-website/index.html`. Group names not in this
+/// list sort after every listed name in alphabetical order. The order is
+/// significant for the landing page render — the first group is opened by
+/// default and the rest are collapsed.
+pub const GROUP_ORDER: &[&str] = &[
+    "Random Access",
+    "Compression",
+    "Compression Size",
+    "Clickbench",
+    "TPC-H (NVMe) (SF=1)",
+    "TPC-H (S3) (SF=1)",
+    "TPC-H (NVMe) (SF=10)",
+    "TPC-H (S3) (SF=10)",
+    "TPC-H (NVMe) (SF=100)",
+    "TPC-H (S3) (SF=100)",
+    "TPC-H (NVMe) (SF=1000)",
+    "TPC-H (S3) (SF=1000)",
+    "TPC-DS (NVMe) (SF=1)",
+    "TPC-DS (NVMe) (SF=10)",
+];
+
+/// Sort key for a group name against [`GROUP_ORDER`]. Names in the list sort
+/// by position (0..GROUP_ORDER.len()); names not in the list sort after, by
+/// the same primary index plus an alphabetical tiebreaker.
+pub fn group_sort_key(name: &str) -> (usize, &str) {
+    let pos = GROUP_ORDER
+        .iter()
+        .position(|&n| n == name)
+        .unwrap_or(GROUP_ORDER.len());
+    (pos, name)
+}
+
 /// Server-side cap on how many of the most recent commits a chart includes.
 ///
 /// `Last(n)` keeps the most recent `n` commits by `commits.timestamp`; `All`
@@ -107,10 +140,19 @@ impl CommitWindow {
 }
 
 /// Query string for `/api/chart/{slug}` and `/chart/{slug}`.
+///
+/// `y` (linear|log) and `mode` (abs|rel) are accepted but ignored by the SQL —
+/// the JSON response is identical regardless. They exist on the API surface so
+/// the client can drive deep links and refetches with a single URL shape; the
+/// rendering hints are applied client-side in `chart-init.js`.
 #[derive(Debug, Default, Deserialize)]
 pub struct ChartQuery {
     /// Commit window: `25`, `50`, `100`, `250`, `all`, etc.
     pub n: Option<String>,
+    /// Y-axis hint (linear|log). Echoed for client-side rendering only.
+    pub y: Option<String>,
+    /// Display mode hint (abs|rel). Echoed for client-side rendering only.
+    pub mode: Option<String>,
 }
 
 impl ChartQuery {
@@ -208,7 +250,7 @@ pub async fn chart(
         .map_err(|e| ApiError::BadRequest(format!("invalid slug: {e}")))?;
     let window = q.window();
     let response =
-        db::run_blocking(&state.db, move |conn| collect_chart(conn, &key, &window)).await?;
+        db::run_blocking(&state.db, move |conn| chart_payload(conn, &key, &window)).await?;
     let response =
         response.ok_or_else(|| ApiError::NotFound(format!("no data for slug {slug:?}")))?;
     Ok(Json(response))
@@ -289,6 +331,11 @@ pub(crate) fn collect_groups(conn: &Connection) -> Result<Vec<Group>> {
     let vsr_groups = collect_vector_search_groups(conn)?;
     groups.extend(vsr_groups);
 
+    // Apply canonical ordering. `sort_by_key` is stable, so groups whose
+    // names map to the same key (the `GROUP_ORDER.len()` bucket — i.e. not in
+    // the canonical list) keep the order the discovery passes produced.
+    groups.sort_by(|a, b| group_sort_key(&a.name).cmp(&group_sort_key(&b.name)));
+
     Ok(groups)
 }
 
@@ -358,12 +405,44 @@ fn collect_query_groups(conn: &Connection) -> Result<Vec<Group>> {
     Ok(groups)
 }
 
+/// Render a query group name in the same shape v2 used (per the hard-coded
+/// list in `origin/ct/vfvb:benchmarks-website/index.html`):
+///
+/// - `tpch` + storage + scale_factor → `TPC-H (NVMe) (SF=1)`
+/// - `tpcds` + storage + scale_factor → `TPC-DS (NVMe) (SF=1)`
+/// - `clickbench` → `Clickbench`
+/// - anything else → fall back to the legacy `dataset[/variant] sf=N [storage]`
+///   shape so unknown datasets still get a deterministic name.
+///
+/// Variant disambiguation: for tpch/tpcds, if `dataset_variant` is set we
+/// append ` / variant`, since v2's list flattened variants but v3 ingests
+/// them. Without this, two ingestion variants would collide.
 fn group_name_query(
     dataset: &str,
     dataset_variant: &Option<String>,
     scale_factor: &Option<String>,
     storage: &str,
 ) -> String {
+    let storage_label = match storage {
+        "nvme" => Some("NVMe"),
+        "s3" => Some("S3"),
+        _ => None,
+    };
+    let base = match (dataset, storage_label, scale_factor.as_deref()) {
+        ("tpch", Some(s), Some(sf)) => Some(format!("TPC-H ({s}) (SF={sf})")),
+        ("tpcds", Some(s), Some(sf)) => Some(format!("TPC-DS ({s}) (SF={sf})")),
+        ("clickbench", ..) => Some("Clickbench".to_string()),
+        _ => None,
+    };
+    if let Some(mut name) = base {
+        if let Some(v) = dataset_variant {
+            name.push_str(" / ");
+            name.push_str(v);
+        }
+        return name;
+    }
+    // Legacy fallback for unknown datasets — keeps the page rendering rather
+    // than silently dropping data.
     let mut name = dataset.to_string();
     if let Some(v) = dataset_variant {
         name.push('/');
@@ -548,9 +627,14 @@ fn collect_vector_search_groups(conn: &Connection) -> Result<Vec<Group>> {
     Ok(groups)
 }
 
-/// Collect the data for one chart by key. Used by both `GET /api/chart/:slug`
-/// and the HTML chart page. `window` caps the number of recent commits.
-pub(crate) fn collect_chart(
+/// Build the JSON payload for one chart by key. This is the shared
+/// implementation behind `GET /api/chart/{slug}`, the inline `<script>` JSON
+/// rendered into the HTML pages, and `collect_group_charts`.
+///
+/// `window` caps the number of recent commits returned. `y` / `mode` are not
+/// inputs here — they're rendering hints applied client-side, so the SQL is
+/// unaffected and the cached payload is identical across hint values.
+pub(crate) fn chart_payload(
     conn: &Connection,
     key: &ChartKey,
     window: &CommitWindow,
@@ -588,8 +672,22 @@ pub(crate) fn collect_chart(
     }
 }
 
+/// Thin wrapper around [`chart_payload`] kept for callers that prefer the old
+/// name. New code should prefer [`chart_payload`].
+pub(crate) fn collect_chart(
+    conn: &Connection,
+    key: &ChartKey,
+    window: &CommitWindow,
+) -> Result<Option<ChartResponse>> {
+    chart_payload(conn, key, window)
+}
+
 /// Collect every chart inside one group. Returns `None` if the group has no
 /// data at all (callers should render a 404).
+// TODO: this currently re-runs the entire `collect_groups` discovery pass
+// (api.rs) per call before fetching each chart, which makes the landing page
+// O(groups * charts_per_group) DB queries plus the discovery scan. Fine for
+// the current dataset; revisit when chart counts grow.
 pub(crate) fn collect_group_charts(
     conn: &Connection,
     key: &GroupKey,
@@ -604,7 +702,7 @@ pub(crate) fn collect_group_charts(
     for link in group.charts {
         let chart_key = ChartKey::from_slug(&link.slug)
             .with_context(|| format!("invalid chart slug in group: {}", link.slug))?;
-        let Some(chart) = collect_chart(conn, &chart_key, window)? else {
+        let Some(chart) = chart_payload(conn, &chart_key, window)? else {
             continue;
         };
         charts.push(NamedChartResponse {