fix(sql-parser): accept global aggregates without GROUP BY (#826)

* fix(sql-parser): accept global aggregates without group by

* fix(query-engine): execute global SQL aggregates

* fix(query-engine): stub benchmark binary in Docker build

* fix(query-engine): reject partitioned scalar fallbacks

Author: milindsrivastava1997

asap-common/dependencies/rs/asap_types/src/capability_matching.rs

@@ -157,6 +157,15 @@ pub fn labels_compatible(config_labels: &KeyByLabelNames, req_labels: &KeyByLabe
     config_labels == req_labels
 }
 
+fn scalar_requirement_compatible(
+    config: &AggregationConfig,
+    requirements: &QueryRequirements,
+) -> bool {
+    !requirements.grouping_labels.labels.is_empty()
+        || requirements.statistics.contains(&Statistic::Topk)
+        || config.aggregated_labels.labels.is_empty()
+}
+
 /// Spatial filter compatibility.
 /// - Both empty → compatible.
 /// - Config non-empty and matches query → compatible.
@@ -290,6 +299,7 @@ pub fn find_compatible_aggregation(
                     && sub_type.is_none_or(|st| c.aggregation_sub_type.eq_ignore_ascii_case(st))
                     && window_compatible(c, requirements.data_range_ms)
                     && labels_compatible(&c.grouping_labels, &requirements.grouping_labels)
+                    && scalar_requirement_compatible(c, requirements)
                     && spatial_filter_compatible(
                         &c.spatial_filter_normalized,
                         &requirements.spatial_filter_normalized,
@@ -552,6 +562,20 @@ mod tests {
         assert_eq!(result.unwrap().aggregation_id_for_value, 1);
     }
 
+    #[test]
+    fn scalar_sum_does_not_match_an_internally_partitioned_config() {
+        let mut value = make_config(1, "cpu", "MultipleSum", "sum", 300_000, "tumbling", &[], "");
+        value.aggregated_labels = KeyByLabelNames::new(vec!["host".to_string()]);
+        let key = make_config(2, "cpu", "SetAggregator", "", 300_000, "tumbling", &[], "");
+        let configs = HashMap::from([(1, value), (2, key)]);
+
+        assert!(
+            find_compatible_aggregation(&configs, &req("cpu", &[Statistic::Sum], 300_000, &[], ""))
+                .is_none(),
+            "a scalar query cannot be served by an internally partitioned aggregation"
+        );
+    }
+
     #[test]
     fn plain_cms_matching_respects_sum_and_count_subtypes() {
         let mut configs = HashMap::new();

asap-common/dependencies/rs/sql_utilities/src/ast_matching/sqlparser_test.rs

@@ -82,6 +82,37 @@ mod tests {
         assert!(query.labels.contains("L1"));
     }
 
+    #[test]
+    fn test_global_aggregate_parses_with_empty_grouping_labels() {
+        let query = parse_sql_query(
+            "SELECT SUM(value) FROM cpu_usage WHERE time BETWEEN DATEADD(s, -1, NOW()) AND NOW()",
+        )
+        .expect("global aggregate parses");
+
+        assert!(query.labels.is_empty());
+    }
+
+    #[test]
+    fn test_nested_global_aggregates_parse_with_empty_grouping_labels() {
+        let query = parse_sql_query(
+            "SELECT SUM(total) FROM (SELECT SUM(value) AS total FROM cpu_usage WHERE time BETWEEN DATEADD(s, -1, NOW()) AND NOW())",
+        )
+        .expect("nested global aggregates parse");
+
+        // Matching and execution may reject nested queries, but parsing retains both layers.
+        assert!(query.labels.is_empty());
+        assert!(query.subquery.expect("inner query").labels.is_empty());
+    }
+
+    #[test]
+    fn test_nested_global_aggregates_remain_unsupported_by_matcher() {
+        check_query(
+            "SELECT SUM(total) FROM (SELECT SUM(value) AS total FROM cpu_usage WHERE time BETWEEN DATEADD(s, -1, NOW()) AND NOW())",
+            vec![],
+            Some(QueryError::NestedQueryUnsupported),
+        );
+    }
+
     #[test]
     fn test_pattern_matching() {
         let schema = create_test_schema();

asap-common/dependencies/rs/sql_utilities/src/ast_matching/sqlpattern_parser.rs

@@ -847,11 +847,7 @@ impl SQLPatternParser {
                     }
                 }
 
-                if group_bys.is_empty() {
-                    None
-                } else {
-                    Some(group_bys)
-                }
+                Some(group_bys)
             }
             _ => None,
         }

asap-query-engine/src/engines/simple_engine/mod.rs

@@ -3141,11 +3141,9 @@ impl SimpleEngine {
                         Some(&query_bounds),
                     )
                     .into_iter()
-                    // A fully unlabeled result (fallback_key was None and
-                    // the value accumulator has no self-keys) has no
-                    // RangeVectorElement representation -- matches today's
-                    // behavior of producing no sample for this combination.
-                    .filter_map(|(key, value)| key.map(|key| (key, value)))
+                    // A missing store key denotes the single scalar row of
+                    // a global aggregate; represent it with empty labels.
+                    .map(|(key, value)| (key.unwrap_or_else(KeyByLabelValues::new), value))
                     .collect();
 
                 // Rank and truncate to k within this group only -- a

asap-query-engine/src/tests/native_range_query_tests.rs

@@ -2202,7 +2202,11 @@ mod tests {
     fn create_range_engine_self_keyed(
         metric: &str,
         aggregated_label: &str,
-        data: Vec<(u64, CountMinSketchWithHeapAccumulator)>,
+        data: Vec<(
+            u64,
+            Option<KeyByLabelValues>,
+            CountMinSketchWithHeapAccumulator,
+        )>,
         promql_query: &str,
     ) -> SimpleEngine {
         let mut aggregation_configs = HashMap::new();
@@ -2239,8 +2243,8 @@ mod tests {
             CleanupPolicy::NoCleanup,
         ));
 
-        for (timestamp, acc) in data {
-            let output = PrecomputedOutput::new(timestamp - WINDOW_MS, timestamp, None, 1);
+        for (timestamp, key, acc) in data {
+            let output = PrecomputedOutput::new(timestamp - WINDOW_MS, timestamp, key, 1);
             store
                 .insert_precomputed_output(output, Box::new(acc))
                 .unwrap();
@@ -2287,8 +2291,12 @@ mod tests {
         sketch.inner.update("host-c", 10.0);
 
         let query = "topk(5, transfer_events)";
-        let engine =
-            create_range_engine_self_keyed("transfer_events", "srcip", vec![(1000, sketch)], query);
+        let engine = create_range_engine_self_keyed(
+            "transfer_events",
+            "srcip",
+            vec![(1000, None, sketch)],
+            query,
+        );
 
         let result = engine
             .handle_range_query_promql(query.to_string(), 1.0, 1.5, 1.0)
@@ -2333,6 +2341,61 @@ mod tests {
         );
     }
 
+    #[tokio::test(flavor = "multi_thread")]
+    async fn range_query_empty_self_keyed_topk_does_not_emit_outer_key() {
+        let query = "topk(5, transfer_events)";
+        let engine = create_range_engine_self_keyed(
+            "transfer_events",
+            "srcip",
+            vec![(
+                1000,
+                Some(KeyByLabelValues::new()),
+                CountMinSketchWithHeapAccumulator::new(3, 1024, 32),
+            )],
+            query,
+        );
+
+        let result = engine
+            .handle_range_query_promql(query.to_string(), 1.0, 1.5, 1.0)
+            .expect("native query execution should not fail");
+        let (_, query_result) = result.expect("range query failed");
+
+        assert!(
+            matrix_values(query_result).is_empty(),
+            "an empty self-keyed heap must not become an unlabeled result"
+        );
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn range_query_global_sum_returns_one_unlabeled_series() {
+        let query = "sum(requests)";
+        let engine = create_engine_multi_timestamp_with_window(
+            "requests",
+            AggregationType::Sum,
+            vec![],
+            vec![(
+                1000,
+                None,
+                Box::new(SumAccumulator::with_sum(42.0)) as Box<dyn AggregateCore>,
+            )],
+            query,
+            1000,
+            1000,
+            WindowType::Tumbling,
+        );
+
+        let result = engine
+            .handle_range_query_promql(query.to_string(), 1.0, 1.5, 1.0)
+            .expect("native query execution should not fail");
+        let (_, query_result) = result.expect("range query failed");
+        let elements = matrix_values(query_result);
+
+        assert_eq!(elements.len(), 1);
+        assert_eq!(elements[0].labels, KeyByLabelValues::new());
+        assert_eq!(elements[0].samples.len(), 1);
+        assert_eq!(elements[0].samples[0].value, 42.0);
+    }
+
     #[tokio::test(flavor = "multi_thread")]
     async fn range_query_set_aggregator_merges_multiple_buckets_within_one_window() {
         // Every other SetAggregator test uses window_size_ms == bucket