Various fixes

server-rs/src/routes/hexagons.rs

@@ -9,7 +9,7 @@ use serde_json::{Map, Value};
 use tracing::{info, warn};
 
 use crate::consts::{H3_PRECOMPUTE_MAX, H3_REQUEST_MAX, H3_REQUEST_MIN};
-use crate::parsing::{parse_bounds, parse_filters, row_passes_filters};
+use crate::parsing::{bounds_intersect, h3_cell_bounds, parse_bounds, parse_filters, row_passes_filters};
 use crate::state::AppState;
 
 #[derive(Serialize)]
@@ -92,21 +92,29 @@ impl CellAgg {
     }
 }
 
-/// Build feature maps from aggregated cell data.
+/// Build feature maps from aggregated cell data, filtering to only cells that intersect the query bounds.
 fn build_feature_maps(
     groups: &FxHashMap<u64, CellAgg>,
     min_keys: &[String],
     max_keys: &[String],
     num_features: usize,
     indices: Option<&[usize]>,
+    query_bounds: (f64, f64, f64, f64), // (south, west, north, east)
 ) -> Vec<Map<String, Value>> {
     let mut features = Vec::with_capacity(groups.len());
+    let (q_south, q_west, q_north, q_east) = query_bounds;
 
     for (&cell_id, aggregation) in groups {
         let Some(cell) = h3o::CellIndex::try_from(cell_id).ok() else {
             continue;
         };
 
+        // Filter out cells that don't intersect the query bounds
+        let (c_south, c_west, c_north, c_east) = h3_cell_bounds(cell, 0.0);
+        if !bounds_intersect(c_south, c_west, c_north, c_east, q_south, q_west, q_north, q_east) {
+            continue;
+        }
+
         let mut map = Map::new();
         map.insert("h3".into(), Value::String(cell.to_string()));
         map.insert("count".into(), Value::Number(aggregation.count.into()));
@@ -166,7 +174,7 @@ pub async fn get_hexagons(
     let filters_str = params.filters.clone();
     let (parsed_filters, parsed_enum_filters) = parse_filters(
         params.filters.as_deref(),
-        &state.data.feature_names,
+        &state.feature_name_to_index,
         &state.data.enum_values,
     );
     let num_filters = parsed_filters.len() + parsed_enum_filters.len();
@@ -185,11 +193,7 @@ pub async fn get_hexagons(
                 if name.is_empty() {
                     return None;
                 }
-                state
-                    .data
-                    .feature_names
-                    .iter()
-                    .position(|feat| feat == name)
+                state.feature_name_to_index.get(name).copied()
             })
             .collect()
     });
@@ -209,20 +213,6 @@ pub async fn get_hexagons(
 
         let mut groups: FxHashMap<u64, CellAgg> = FxHashMap::default();
 
-        let has_selective = field_indices.is_some();
-        let sel_indices = field_indices.as_deref().unwrap_or(&[]);
-
-        let aggregate_row = |groups: &mut FxHashMap<u64, CellAgg>, cell_id: u64, row: usize| {
-            let aggregation = groups
-                .entry(cell_id)
-                .or_insert_with(|| CellAgg::new(num_features));
-            if has_selective {
-                aggregation.add_row_selective(feature_data, row, num_features, sel_indices);
-            } else {
-                aggregation.add_row(feature_data, row, num_features);
-            }
-        };
-
         let cell_for_row = |row: usize| -> u64 {
             let max_cell = precomputed[row];
             if !need_parent || max_cell == 0 {
@@ -235,21 +225,48 @@ pub async fn get_hexagons(
                 .unwrap_or(0)
         };
 
-        state
-            .grid
-            .for_each_in_bounds(south, west, north, east, |row_idx| {
-                let row = row_idx as usize;
-                if !row_passes_filters(
-                    row,
-                    &parsed_filters,
-                    &parsed_enum_filters,
-                    feature_data,
-                    num_features,
-                ) {
-                    return;
-                }
-                aggregate_row(&mut groups, cell_for_row(row), row);
-            });
+        // Hoist has_selective branch outside the hot loop to avoid per-row branching
+        if let Some(sel_indices) = field_indices.as_deref() {
+            state
+                .grid
+                .for_each_in_bounds(south, west, north, east, |row_idx| {
+                    let row = row_idx as usize;
+                    if !row_passes_filters(
+                        row,
+                        &parsed_filters,
+                        &parsed_enum_filters,
+                        feature_data,
+                        num_features,
+                    ) {
+                        return;
+                    }
+                    let cell_id = cell_for_row(row);
+                    let aggregation = groups
+                        .entry(cell_id)
+                        .or_insert_with(|| CellAgg::new(num_features));
+                    aggregation.add_row_selective(feature_data, row, num_features, sel_indices);
+                });
+        } else {
+            state
+                .grid
+                .for_each_in_bounds(south, west, north, east, |row_idx| {
+                    let row = row_idx as usize;
+                    if !row_passes_filters(
+                        row,
+                        &parsed_filters,
+                        &parsed_enum_filters,
+                        feature_data,
+                        num_features,
+                    ) {
+                        return;
+                    }
+                    let cell_id = cell_for_row(row);
+                    let aggregation = groups
+                        .entry(cell_id)
+                        .or_insert_with(|| CellAgg::new(num_features));
+                    aggregation.add_row(feature_data, row, num_features);
+                });
+        }
 
         let t_agg = t0.elapsed();
 
@@ -259,6 +276,7 @@ pub async fn get_hexagons(
             max_keys,
             num_features,
             field_indices.as_deref(),
+            (south, west, north, east),
         );
 
         let t_total = t0.elapsed();