From a98c21e880ebb6bbdb0785adff4ba046c6f18114 Mon Sep 17 00:00:00 2001 From: Dennis Zhuang Date: Sun, 18 Oct 2026 00:20:41 +0800 Subject: [PATCH] fix(promql): check smoothing factors at the first non-empty window Signed-off-by: Dennis Zhuang --- src/promql/src/range_eval.rs | 23 +++++++++++++++-------- src/promql/src/range_eval/tests.rs | 17 +++++++++++++---- 2 files changed, 28 insertions(+), 12 deletions(-) diff --git a/src/promql/src/range_eval.rs b/src/promql/src/range_eval.rs index 1081e08ff5d..b9a254151ad 100644 --- a/src/promql/src/range_eval.rs +++ b/src/promql/src/range_eval.rs @@ -71,6 +71,8 @@ pub struct RangeEvaluator { fields: Vec, row: Vec>, drops_metric_name: bool, + /// Raised by the first non-empty window, where Prometheus validates function arguments. + window_error: Option, } /// Prometheus `schema.IsMetadataLabel`: the labels removed with the metric name. @@ -100,15 +102,15 @@ impl RangeEvaluator { window: RangeWindow, function: RangeFunction, ) -> Result { + let mut window_error = None; if let RangeFunction::DoubleExponentialSmoothing { smoothing, trend } = function { - for (name, factor) in [("smoothing", smoothing), ("trend", trend)] { - // Prometheus rejects factors outside (0, 1); NaN passes its check. - if factor <= 0.0 || factor >= 1.0 { - return Err(DataFusionError::Plan(format!( - "invalid {name} factor. Expected: 0 < factor < 1, got: {factor}" - ))); - } - } + // Prometheus rejects factors outside (0, 1); NaN passes its check. + window_error = [("smoothing", smoothing), ("trend", trend)] + .into_iter() + .find(|(_, factor)| *factor <= 0.0 || *factor >= 1.0) + .map(|(name, factor)| { + format!("invalid {name} factor. Expected: 0 < factor < 1, got: {factor}") + }); } if let RangeFunction::PredictLinear(_) = function { let spec = grid.spec(); @@ -126,6 +128,7 @@ impl RangeEvaluator { let mut evaluator = Self::with_kernel(input, grid, window, function.kernel(window.offset_ms))?; evaluator.drops_metric_name = function.drops_metric_name(); + evaluator.window_error = window_error; Ok(evaluator) } @@ -164,6 +167,7 @@ impl RangeEvaluator { .collect(), row: Vec::with_capacity(input.fields.len()), drops_metric_name: false, + window_error: None, }) } @@ -334,6 +338,9 @@ impl RangeEvaluator { state.cursor = usize::try_from(steps).map_or(grid.len(), |i| i.min(grid.len())); continue; } + if let Some(error) = &self.window_error { + return Err(DataFusionError::Execution(error.clone())); + } self.row.clear(); for field in &self.fields { diff --git a/src/promql/src/range_eval/tests.rs b/src/promql/src/range_eval/tests.rs index deac9d87945..31a00199ee9 100644 --- a/src/promql/src/range_eval/tests.rs +++ b/src/promql/src/range_eval/tests.rs @@ -717,14 +717,23 @@ fn rejects_double_exponential_smoothing_factors_outside_the_unit_interval() { offset_ms: 0, }; for (smoothing, trend) in [(0.0, 0.5), (1.0, 0.5), (0.5, 0.0), (0.5, 1.5)] { - assert!(matches!( + let evaluator = || { RangeEvaluator::try_new( &raw_schema(1), grid(0, 10, 4), window, - RangeFunction::DoubleExponentialSmoothing { smoothing, trend } - ), - Err(DataFusionError::Plan(_)) + RangeFunction::DoubleExponentialSmoothing { smoothing, trend }, + ) + .unwrap() + }; + // Like Prometheus, only a window holding a sample checks the factors. + let outside = chunk(&[(100, vec![Some(1.0)])], 1, 0, true); + assert!(evaluator().push(&outside).unwrap().is_none()); + evaluator().finish().unwrap(); + let inside = chunk(&[(5, vec![Some(1.0)])], 1, 0, true); + assert!(matches!( + evaluator().push(&inside), + Err(DataFusionError::Execution(_)) )); } }