From c438f2c1764d6ae9de82ae4151dd3bfebc7f820b Mon Sep 17 00:00:00 2001 From: zzylol <50204836+zzylol@users.noreply.github.com> Date: Sat, 14 Nov 2026 20:35:44 +0000 Subject: [PATCH 1/2] fix(frontend): name every aggregate measure; validate names match measures The PromQL counter-ranking TopK (`topk by (region) (4, increase(m[5m]))`), the canonicalize ranking promotion, and the SQL asap_rate/asap_increase aggregate were built with no output names, so the executor refused the installed plan with "aggregate output names differ from measures". Each now carries one empty name per measure (the intent-keyed default), as the other builders do. NonASAPOp::validate_inputs checks that an Aggregate has one output name per measure, so the planner refuses a mismatch at resolve and at memo insertion instead of the executor at install time. Test fixtures that built nameless aggregates are updated. Part of #1303. --- crates/frontend-common/src/canonicalize.rs | 7 ++-- crates/frontend-common/src/resolve.rs | 6 ++-- crates/frontend-common/src/schema_resolver.rs | 2 +- crates/frontend-promql/src/promql.rs | 4 ++- .../frontend-promql/tests/promql_lowering.rs | 32 +++++++++++++++++++ crates/frontend-sql/src/sql/mod.rs | 3 +- crates/stage0-memo/src/lib.rs | 4 +-- .../src/candidates/mod.rs | 4 +-- crates/types/src/accuracy/target/tests.rs | 4 +-- crates/types/src/ir/operator/asap.rs | 4 +-- crates/types/src/ir/operator/non_asap.rs | 14 +++++--- .../stages/logical/memo/hash_consing/tests.rs | 2 +- crates/types/src/stages/logical/memo/tests.rs | 2 +- crates/types/tests/memo_aggregate_coverage.rs | 2 +- crates/types/tests/schema_rebuilding.rs | 2 +- crates/types/tests/structure_contract.rs | 20 ++++++++++++ 16 files changed, 85 insertions(+), 27 deletions(-) diff --git a/crates/frontend-common/src/canonicalize.rs b/crates/frontend-common/src/canonicalize.rs index 70bcf40f6..f85eefa51 100644 --- a/crates/frontend-common/src/canonicalize.rs +++ b/crates/frontend-common/src/canonicalize.rs @@ -280,7 +280,8 @@ fn try_promote_additive_top_ranking( OperatorNode::new_shared(asap_types::ir::Operator::NonASAP(NonASAPOp::Aggregate { reduction: Reduction::by(partition), measures: vec![AggIntent::TopK { k: *k }], - output_names: Vec::new(), + // One empty name per measure keeps the default `topk_{k}`. + output_names: vec![String::new()], filters: vec![], having: None, child: Rc::clone(agg_node), @@ -576,7 +577,7 @@ mod tests { node(NonASAPOp::Aggregate { reduction, measures: vec![agg], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child, @@ -685,7 +686,7 @@ mod tests { let filtered = node(NonASAPOp::Aggregate { reduction: Reduction::by(vec![1]), measures: vec![count()], - output_names: vec![], + output_names: vec![String::new()], filters: vec![Some(filter)], having: None, child: scan(), diff --git a/crates/frontend-common/src/resolve.rs b/crates/frontend-common/src/resolve.rs index 1904b798c..8d400c361 100644 --- a/crates/frontend-common/src/resolve.rs +++ b/crates/frontend-common/src/resolve.rs @@ -1252,7 +1252,7 @@ mod tests { let unresolved = UnresolvedOp::Aggregate { reduction: Reduction::by(vec![ColumnRef::Named("job".into())]), measures: vec![AggIntent::Sum { col: None }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: Rc::new(UnresolvedOp::BinaryOp { @@ -1413,7 +1413,7 @@ mod tests { let inner = UnresolvedOp::Aggregate { reduction: Reduction::by(vec![ColumnRef::Named("group".into())]), measures: vec![AggIntent::Sum { col: None }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: Rc::new(scan("m")), @@ -1421,7 +1421,7 @@ mod tests { let outer = UnresolvedOp::Aggregate { reduction: Reduction::by(vec![ColumnRef::Named("job".into())]), measures: vec![AggIntent::Sum { col: None }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: Rc::new(inner), diff --git a/crates/frontend-common/src/schema_resolver.rs b/crates/frontend-common/src/schema_resolver.rs index 96be18f6e..1280f7611 100644 --- a/crates/frontend-common/src/schema_resolver.rs +++ b/crates/frontend-common/src/schema_resolver.rs @@ -235,7 +235,7 @@ mod tests { left: ColumnRef::Named("x".into()), right: ColumnRef::Named("y".into()), }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: Rc::new(src("m")), diff --git a/crates/frontend-promql/src/promql.rs b/crates/frontend-promql/src/promql.rs index 731d3b0c3..198416282 100644 --- a/crates/frontend-promql/src/promql.rs +++ b/crates/frontend-promql/src/promql.rs @@ -1100,7 +1100,9 @@ impl PromqlLowerer<'_> { // whole input into one ordering, never per-entity). reduction: Reduction::Reduce(keys.into()), measures: vec![AggIntent::TopK { k: k as usize }], - output_names: vec![], + // One empty name per measure keeps the intent-keyed + // default (`topk_{k}`), as in `outer_aggregate`. + output_names: vec![String::new()], filters: vec![], having: None, child: Rc::new(base), diff --git a/crates/frontend-promql/tests/promql_lowering.rs b/crates/frontend-promql/tests/promql_lowering.rs index 0a92c4790..d5070254e 100644 --- a/crates/frontend-promql/tests/promql_lowering.rs +++ b/crates/frontend-promql/tests/promql_lowering.rs @@ -586,6 +586,38 @@ fn topk_over_count_is_heavy_hitter_topk() { assert!(matches!(child.expect_non_asap(), NonASAPOp::Scan { .. })); } +/// Issue #1303: a counter ranking keeps its `TopK` aggregate, and every +/// aggregate it lowers to names each measure (the executor rejects a +/// mismatch at install time). +#[test] +fn topk_over_counter_rate_names_every_aggregate_measure() { + for query in [ + "topk by (region) (4, increase(data_total[5m]))", + "topk by (region) (4, rate(data_total[20m]))", + ] { + let qe = lower(query); + let NonASAPOp::Aggregate { measures, .. } = qe.expect_non_asap() else { + panic!("expected Aggregate with TopK for {query:?}, got {qe:?}"); + }; + assert!(matches!(measures.as_slice(), [AggIntent::TopK { k: 4 }])); + let mut aggregates = 0; + let mut pending = vec![qe.clone()]; + while let Some(node) = pending.pop() { + if let Some(NonASAPOp::Aggregate { + measures, + output_names, + .. + }) = node.non_asap() + { + aggregates += 1; + assert_eq!(output_names.len(), measures.len(), "{query:?}: {node:?}"); + } + pending.extend(node.children().into_iter().cloned()); + } + assert!(aggregates >= 2, "{query:?}: TopK over the rate aggregate"); + } +} + #[test] fn topk_over_sum_is_value_weighted_heavy_hitter_topk() { let qe = lower(r#"topk by (service) (5, sum_over_time(requests{env="prod"}[1m]))"#); diff --git a/crates/frontend-sql/src/sql/mod.rs b/crates/frontend-sql/src/sql/mod.rs index 09edf5759..609662471 100644 --- a/crates/frontend-sql/src/sql/mod.rs +++ b/crates/frontend-sql/src/sql/mod.rs @@ -1013,7 +1013,8 @@ impl<'a> SqlLowerer<'a> { Ok(Unresolved::Aggregate { reduction: Reduction::PerEntity, measures: vec![intent], - output_names: vec![], + // One empty name per measure keeps the intent-keyed default. + output_names: vec![String::new()], filters: vec![], having: None, child: Rc::new(child), diff --git a/crates/stage0-memo/src/lib.rs b/crates/stage0-memo/src/lib.rs index 14cb42782..b72691b35 100644 --- a/crates/stage0-memo/src/lib.rs +++ b/crates/stage0-memo/src/lib.rs @@ -130,7 +130,7 @@ mod tests { node(NonASAPOp::Aggregate { reduction: Reduction::by(by), measures: vec![AggIntent::Quantile { col, q }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: scan(), @@ -256,7 +256,7 @@ mod tests { let sum_up = node(NonASAPOp::Aggregate { reduction: Reduction::by(vec![1]), measures: vec![AggIntent::Sum { col: Some(2) }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: scan(), diff --git a/crates/stage1-pass1-per-computation-candidates/src/candidates/mod.rs b/crates/stage1-pass1-per-computation-candidates/src/candidates/mod.rs index 8d95fe7d8..d6a7c2a5b 100644 --- a/crates/stage1-pass1-per-computation-candidates/src/candidates/mod.rs +++ b/crates/stage1-pass1-per-computation-candidates/src/candidates/mod.rs @@ -376,9 +376,7 @@ fn single_measure_part( child: input, reduction: reduction.clone(), measures: vec![measures[index].clone()], - output_names: output_names - .get(index) - .map_or_else(Vec::new, |name| vec![name.clone()]), + output_names: vec![output_names.get(index).cloned().unwrap_or_default()], filters: filters .get(index) .cloned() diff --git a/crates/types/src/accuracy/target/tests.rs b/crates/types/src/accuracy/target/tests.rs index 6590a0377..d5f690d39 100644 --- a/crates/types/src/accuracy/target/tests.rs +++ b/crates/types/src/accuracy/target/tests.rs @@ -25,8 +25,8 @@ fn aggregate(measures: Vec) -> QueryRoot { }); QueryRoot::Operator(node(NonASAPOp::Aggregate { reduction: Reduction::by(vec![]), + output_names: vec![String::new(); measures.len()], measures, - output_names: vec![], filters: vec![], having: None, child: scan, @@ -120,7 +120,7 @@ fn a_per_entity_count_states_its_value_column_not_its_last_column() { let count = node(NonASAPOp::Aggregate { reduction: Reduction::PerEntity, measures: vec![AggIntent::Count], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: scan, diff --git a/crates/types/src/ir/operator/asap.rs b/crates/types/src/ir/operator/asap.rs index 1b45b6fda..e53e1eee2 100644 --- a/crates/types/src/ir/operator/asap.rs +++ b/crates/types/src/ir/operator/asap.rs @@ -402,7 +402,7 @@ impl ASAPOp { child: source.clone(), reduction: Reduction::Reduce(keys), measures: vec![measure], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, } @@ -850,7 +850,7 @@ fn finalized_schema( child: source.clone(), reduction: reduction.clone(), measures: vec![measure], - output_names: vec![], + output_names: vec![String::new()], // A filtered SUM/MIN/MAX is NULL for a // group without a matching row. filters: vec![filter.clone()], diff --git a/crates/types/src/ir/operator/non_asap.rs b/crates/types/src/ir/operator/non_asap.rs index d2eafe2db..1569b79b7 100644 --- a/crates/types/src/ir/operator/non_asap.rs +++ b/crates/types/src/ir/operator/non_asap.rs @@ -1080,11 +1080,15 @@ impl NonASAPOp { child, filters, measures, + output_names, having, reduction, - .. } => { no_state(child, "Aggregate")?; + // One name per measure; an empty name keeps the default. + if output_names.len() != measures.len() { + return Err(invalid("aggregate output names differ from measures")); + } if let Reduction::Reduce(keys) = reduction { columns(keys.keys(), child.schema())?; } @@ -1427,7 +1431,7 @@ mod tests { NonASAPOp::Aggregate { reduction: Reduction::PerEntity, measures: vec![AggIntent::Rate], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: node(child), @@ -1651,7 +1655,7 @@ mod tests { let agg = NonASAPOp::Aggregate { reduction: Reduction::Reduce(GroupKeys::without(vec![2])), measures: vec![AggIntent::Sum { col: None }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: node(leaf), @@ -1693,7 +1697,7 @@ mod tests { let reduced = NonASAPOp::Aggregate { reduction: Reduction::PerEntity, measures: vec![measure], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: node(NonASAPOp::TimeRange { @@ -1723,7 +1727,7 @@ mod tests { let sum_by_job = NonASAPOp::Aggregate { reduction: Reduction::by(vec![2]), measures: vec![AggIntent::Sum { col: None }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: node(rate), diff --git a/crates/types/src/stages/logical/memo/hash_consing/tests.rs b/crates/types/src/stages/logical/memo/hash_consing/tests.rs index 07bfe87fd..5f03ab8ae 100644 --- a/crates/types/src/stages/logical/memo/hash_consing/tests.rs +++ b/crates/types/src/stages/logical/memo/hash_consing/tests.rs @@ -279,7 +279,7 @@ fn equal_keyless_expressions_that_return_the_same_rows_are_one_group() { Operator::NonASAP(NonASAPOp::Aggregate { reduction: Reduction::Reduce(GroupKeys::without(vec![0])), measures: vec![AggIntent::Count], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child, diff --git a/crates/types/src/stages/logical/memo/tests.rs b/crates/types/src/stages/logical/memo/tests.rs index cd39aa94a..6d66f4ef1 100644 --- a/crates/types/src/stages/logical/memo/tests.rs +++ b/crates/types/src/stages/logical/memo/tests.rs @@ -172,7 +172,7 @@ fn find_or_add_group_returns_an_error_for_an_expression_with_no_schema() { let out_of_range = Operator::NonASAP(NonASAPOp::Aggregate { reduction: Reduction::by(vec![9]), measures: vec![crate::ir::operator::agg_intent::AggIntent::Sum { col: Some(1) }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child: g1, diff --git a/crates/types/tests/memo_aggregate_coverage.rs b/crates/types/tests/memo_aggregate_coverage.rs index 5a2b74d2d..6effdb28c 100644 --- a/crates/types/tests/memo_aggregate_coverage.rs +++ b/crates/types/tests/memo_aggregate_coverage.rs @@ -557,7 +557,7 @@ fn an_exact_aggregate_has_coverage() { Operator::NonASAP(NonASAPOp::Aggregate { reduction: Reduction::by(vec![JOB]), measures: vec![AggIntent::Sum { col: Some(1) }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, child, diff --git a/crates/types/tests/schema_rebuilding.rs b/crates/types/tests/schema_rebuilding.rs index 5a61cb41b..e4f187d48 100644 --- a/crates/types/tests/schema_rebuilding.rs +++ b/crates/types/tests/schema_rebuilding.rs @@ -32,7 +32,7 @@ fn aggregate(child: Rc, asap: bool) -> Rc { child, reduction: Reduction::by(vec![0]), measures: vec![AggIntent::Sum { col: Some(1) }], - output_names: vec![], + output_names: vec![String::new()], filters: vec![], having: None, }) diff --git a/crates/types/tests/structure_contract.rs b/crates/types/tests/structure_contract.rs index a0e9200c3..facbc3ca0 100644 --- a/crates/types/tests/structure_contract.rs +++ b/crates/types/tests/structure_contract.rs @@ -38,6 +38,26 @@ fn retained_result_kind_is_checked() { node.result_kind = OperatorResultKind::RangeVector; assert!(Rc::new(node).validate_structure().is_err()); } +/// An aggregate names each measure (an empty name keeps the default), so a +/// plan whose names and measures differ is refused before installation +/// (issue #1303). +#[test] +fn aggregate_output_names_match_measures() { + use asap_types::ir::operator::{AggIntent, Reduction}; + use asap_types::test_support::forwarders::validate_non_asap_inputs; + let aggregate = |output_names: Vec| NonASAPOp::Aggregate { + reduction: Reduction::by(vec![]), + measures: vec![AggIntent::Sum { col: Some(0) }], + output_names, + filters: vec![], + having: None, + child: scan(), + }; + assert!(validate_non_asap_inputs(&aggregate(vec![String::new()])).is_ok()); + assert!(validate_non_asap_inputs(&aggregate(vec!["total".into()])).is_ok()); + assert!(validate_non_asap_inputs(&aggregate(vec![])).is_err()); + assert!(validate_non_asap_inputs(&aggregate(vec![String::new(), String::new()])).is_err()); +} /// Values validates arity and declared nullability without inventing columns. #[test] fn values_contract_is_checked() { From 47cb593b3c7f3d74b6bc3f32c63fc72394fc8c64 Mon Sep 17 00:00:00 2001 From: zzylol <50204836+zzylol@users.noreply.github.com> Date: Sat, 14 Nov 2026 21:03:59 +0000 Subject: [PATCH 2/2] fix(types): document one output name per measure; name both counts in the mismatch error The Aggregate.output_names doc now says exactly one entry per measure, with an empty string meaning the default name (serde default kept for old JSON). The validation error gives both counts, and the unit test accepts an aggregate with no measures and no names. Part of #1303. --- crates/types/src/ir/operator/non_asap.rs | 10 +++++++--- crates/types/tests/structure_contract.rs | 18 ++++++++++++------ 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/crates/types/src/ir/operator/non_asap.rs b/crates/types/src/ir/operator/non_asap.rs index 1569b79b7..2318fdd8c 100644 --- a/crates/types/src/ir/operator/non_asap.rs +++ b/crates/types/src/ir/operator/non_asap.rs @@ -80,8 +80,8 @@ pub enum NonASAPOp> { Aggregate { reduction: Reduction, measures: Vec, - /// Output column names parallel to `measures`; an empty entry falls - /// back to the intent's synthetic name. + /// Output column names, exactly one entry per measure; an empty + /// string means the default name (the intent's synthetic name). #[serde(default)] output_names: Vec, #[serde(default)] @@ -1087,7 +1087,11 @@ impl NonASAPOp { no_state(child, "Aggregate")?; // One name per measure; an empty name keeps the default. if output_names.len() != measures.len() { - return Err(invalid("aggregate output names differ from measures")); + return Err(SchemaDerivationError::InvalidScalarSignature(format!( + "aggregate output names differ from measures: {} output names for {} measures", + output_names.len(), + measures.len() + ))); } if let Reduction::Reduce(keys) = reduction { columns(keys.keys(), child.schema())?; diff --git a/crates/types/tests/structure_contract.rs b/crates/types/tests/structure_contract.rs index facbc3ca0..056ef94fd 100644 --- a/crates/types/tests/structure_contract.rs +++ b/crates/types/tests/structure_contract.rs @@ -45,18 +45,24 @@ fn retained_result_kind_is_checked() { fn aggregate_output_names_match_measures() { use asap_types::ir::operator::{AggIntent, Reduction}; use asap_types::test_support::forwarders::validate_non_asap_inputs; - let aggregate = |output_names: Vec| NonASAPOp::Aggregate { + let aggregate = |measures: Vec, output_names: Vec| NonASAPOp::Aggregate { reduction: Reduction::by(vec![]), - measures: vec![AggIntent::Sum { col: Some(0) }], + measures, output_names, filters: vec![], having: None, child: scan(), }; - assert!(validate_non_asap_inputs(&aggregate(vec![String::new()])).is_ok()); - assert!(validate_non_asap_inputs(&aggregate(vec!["total".into()])).is_ok()); - assert!(validate_non_asap_inputs(&aggregate(vec![])).is_err()); - assert!(validate_non_asap_inputs(&aggregate(vec![String::new(), String::new()])).is_err()); + let sum = || vec![AggIntent::Sum { col: Some(0) }]; + assert!(validate_non_asap_inputs(&aggregate(sum(), vec![String::new()])).is_ok()); + assert!(validate_non_asap_inputs(&aggregate(sum(), vec!["total".into()])).is_ok()); + // No measures and no names is consistent. + assert!(validate_non_asap_inputs(&aggregate(vec![], vec![])).is_ok()); + assert!(validate_non_asap_inputs(&aggregate(sum(), vec![])).is_err()); + let error = validate_non_asap_inputs(&aggregate(sum(), vec![String::new(), String::new()])) + .unwrap_err() + .to_string(); + assert!(error.contains("2 output names for 1 measures"), "{error}"); } /// Values validates arity and declared nullability without inventing columns. #[test]