diff --git a/src/query/src/promql/native_compile.rs b/src/query/src/promql/native_compile.rs index 56ea7445b76..f731c571427 100644 --- a/src/query/src/promql/native_compile.rs +++ b/src/query/src/promql/native_compile.rs @@ -23,11 +23,14 @@ //! ([]) e.g. rate(x[5m]) //! (, []) e.g. quantile_over_time(0.9, x[5m]) //! ([, ]*) e.g. abs(rate(x[5m])), clamp_min(x, 0) +//! ([, ]*) e.g. sort_desc(x), sort_by_label(x, "job") +//! absent() e.g. absent(x{job="a"}) //! ``` //! //! which become `Input` (raw samples) → `Instant` (the last sample within the statement's lookback), //! `Input` (raw samples) → `Window` (the range function over the statement's grid) and -//! `` → `Map` (a pointwise math function over what its argument evaluates to). A +//! `` → `Map` (a pointwise math function over what its argument evaluates to), and +//! `` → `Select` (a sort or `absent`, which read the whole vector). A //! selector may carry `offset` in either selection shape and, in the window shape, an `@` anchor. //! Everything else is a [`DataFusionError::NotImplemented`] that names what was found and quotes the //! shapes above, because rejecting a query the compiler does not understand is the only honest @@ -53,19 +56,22 @@ use std::sync::Arc; use std::time::Duration; use datafusion::error::{DataFusionError, Result}; -use datatypes::series::SeriesOrdering; use datatypes::series::samples::SeriesSchema; use datatypes::series::time::{EvalGrid, GridSpec}; +use datatypes::series::{MetricName, SeriesOrdering}; use promql::map::{ArithmeticOp, MathOp}; use promql::native::plan::{ - BoundInput, BoundInstant, BoundMap, BoundWindow, NativeExpr, NativeNode, NativeTree, NativeType, + BoundInput, BoundInstant, BoundMap, BoundSelect, BoundWindow, NativeExpr, NativeNode, + NativeTree, NativeType, }; use promql::range_eval::{RangeFunction, RangeWindow}; +use promql::select::{LabelMatcher, MatchOp, SortOrder, absent_labels}; +use promql_parser::label::MatchOp as ParserMatchOp; use promql_parser::parser::token::TokenType; use promql_parser::parser::value::ValueType; use promql_parser::parser::{ AtModifier, Call, EvalStmt, Expr as PromExpr, MatrixSelector, NumberLiteral, Offset, - VectorSelector, token, + StringLiteral, VectorSelector, token, }; use crate::promql::label_values::signed_millis_since_epoch; @@ -73,9 +79,10 @@ use crate::promql::label_values::signed_millis_since_epoch; /// The shapes this compiler accepts, quoted in every rejection. const SUPPORTED: &str = "a selector, a range function over a range selector — \ `([])`, with its constants in front of \ - the selector as in `quantile_over_time(0.9, x[5m])` — or a math function \ - over any of them, as in `abs(rate(x[5m]))`: for example `x`, \ - `rate(x[5m])`, `quantile_over_time(0.9, x[5m])` or `abs(rate(x[5m]))`"; + the selector as in `quantile_over_time(0.9, x[5m])` — or a math function, \ + a sort or `absent` over any of them, as in `abs(rate(x[5m]))`: for \ + example `x`, `rate(x[5m])`, `quantile_over_time(0.9, x[5m])` or \ + `abs(rate(x[5m]))`"; /// Compiles `stmt` into a tree that reads `input` and evaluates the statement's expression over it. /// @@ -167,6 +174,9 @@ fn compile_call(context: &Context, call: &Call) -> Result { if let Some(signature) = range_signature(func.name) { return window_call(context, func.name, signature, &args.args); } + if let Some((op, vector)) = select_op(func.name, &args.args)? { + return select_call(context, func.name, op, vector); + } // The name is looked up before the call's arguments are read, so a name this compiler has no // kernel for is refused as such whichever arguments it was given: `pi()` and `time()` have no // vector to map, and the rejection names the name rather than describing a vector they never @@ -247,6 +257,125 @@ fn map_call(context: &Context, name: &str, op: MathOp, vector: &PromExpr) -> Res }) } +/// Wraps the selection `op` over the value of `vector`, which keeps its type as a map does. +fn select_call( + context: &Context, + name: &str, + op: BoundSelect, + vector: &PromExpr, +) -> Result { + if vector.value_type() != ValueType::Vector { + return Err(not_implemented(&format!( + "a call to `{name}` whose first argument is `{vector}`, which is a {}, where the \ + function takes a vector", + vector.value_type() + ))); + } + let input = compile_expr(context, vector)?; + let output = input.output.clone(); + Ok(NativeNode { + expr: NativeExpr::Select { + input: Box::new(input), + op, + }, + output, + }) +} + +/// The selection a sort or `absent` binds, and the vector it reads, or `None` when `name` is +/// neither. +fn select_op<'a>( + name: &str, + arguments: &'a [Box], +) -> Result> { + let order = match name { + "sort" => Some(SortOrder::Asc), + "sort_desc" => Some(SortOrder::Desc), + "sort_by_label" | "sort_by_label_desc" => None, + "absent" => { + let [vector] = arguments else { + return Err(not_implemented(&format!( + "a call to `absent` with {} argument(s)", + arguments.len() + ))); + }; + let labels = absent_labels_of(vector)?; + return Ok(Some((BoundSelect::Absent { labels }, vector))); + } + _ => return Ok(None), + }; + let Some((vector, strings)) = arguments.split_first() else { + return Err(not_implemented(&format!( + "a call to `{name}` with no argument" + ))); + }; + let order = match order { + Some(order) if strings.is_empty() => order, + Some(_) => { + return Err(not_implemented(&format!( + "a call to `{name}` with {} argument(s)", + arguments.len() + ))); + } + None => { + let labels = strings + .iter() + .map(|argument| match unparen(argument) { + PromExpr::StringLiteral(StringLiteral { val }) => Ok(Arc::from(val.as_str())), + other => Err(not_implemented(&format!( + "a call to `{name}` whose argument `{other}` is not a string literal" + ))), + }) + .collect::>>()?; + if name == "sort_by_label" { + SortOrder::ByLabel(labels) + } else { + SortOrder::ByLabelDesc(labels) + } + } + }; + Ok(Some((BoundSelect::Sort(order), vector))) +} + +/// The labels `absent(expr)` answers with, as Prometheus `createLabelsForAbsentFunction` derives +/// them: from the matchers of a vector selector, and none for any other expression. +/// +/// `__field__`, `__schema__` and `__database__` choose what is read rather than match a label, so +/// they are not labels of the answer, as in the existing planner. +fn absent_labels_of(expr: &PromExpr) -> Result { + let PromExpr::VectorSelector(selector) = unparen(expr) else { + return absent_labels(&[]); + }; + if !selector.matchers.or_matchers.is_empty() { + return Err(not_implemented(&format!( + "`absent` over `{selector}`, whose matchers are alternatives" + ))); + } + let matchers = selector + .matchers + .matchers + .iter() + .filter(|matcher| { + !matches!( + matcher.name.as_str(), + "__field__" | "__schema__" | "__database__" + ) + }) + .map(|matcher| LabelMatcher { + name: Arc::from(matcher.name.as_str()), + op: match matcher.op { + ParserMatchOp::Equal => MatchOp::Equal, + ParserMatchOp::NotEqual => MatchOp::NotEqual, + ParserMatchOp::Re(_) => MatchOp::Regex, + ParserMatchOp::NotRe(_) => MatchOp::NotRegex, + }, + value: Arc::from(matcher.value.as_str()), + matches_empty: matcher.is_match(""), + }) + .collect::>(); + absent_labels(&matchers) +} + /// Binds `function` over the range selector `vs[range]` into a window over the raw input. /// /// Both shapes reach this: the range, the offset, the anchor, the grid and the output are the same diff --git a/src/query/src/promql/native_compile/tests.rs b/src/query/src/promql/native_compile/tests.rs index f16bb74b072..f4d4b990d58 100644 --- a/src/query/src/promql/native_compile/tests.rs +++ b/src/query/src/promql/native_compile/tests.rs @@ -826,8 +826,8 @@ fn an_unsupported_shape_is_rejected_and_names_what_it_found() { "a call to `predict_linear`, which has no native kernel", ), ( - "absent(x)", - "a call to `absent`, which has no native kernel", + "scalar(x)", + "a call to `scalar`, which has no native kernel", ), // The two functions PromQL calls with no arguments at all: neither has a kernel, and the // rejection names the name rather than describing a vector they were never given. @@ -1159,3 +1159,39 @@ fn a_math_function_over_a_non_vector_argument_is_refused_and_names_it() { ); } } + +/// The sorts and `absent` bind a selection over the vector they are given. `absent` derives its +/// labels from the selector's matchers as Prometheus does: the first equality of a name sets the +/// label and any other matcher of it removes it, the matchers that accept a missing label read +/// last; `__name__` and the table-choosing matchers are not labels, and any expression other than +/// a selector answers without labels. +#[test] +fn sorts_and_absent_bind_a_selection() { + let cases = [ + ("sort(x)", "sort"), + ("sort_desc(rate(x[5m]))", "sort_desc"), + ( + r#"sort_by_label(x, "job", "le")"#, + "sort_by_label [job, le]", + ), + ( + r#"sort_by_label_desc(x, "job")"#, + "sort_by_label_desc [job]", + ), + ( + r#"absent(x{job="a", env=~"p.*", instance!="", __field__="v"})"#, + r#"absent {job="a"}"#, + ), + // `job!="b"` accepts a missing `job`, so it reads after `job="a"` and removes it. + (r#"absent(x{job!="b", job="a"})"#, "absent {}"), + (r#"absent({__name__="x", job="a"})"#, r#"absent {job="a"}"#), + ("absent(rate(x[5m]))", "absent {}"), + ]; + for (query, op) in cases { + let tree = compile(&eval_stmt(query), raw_schema(), SeriesOrdering::KeyThenTime) + .unwrap_or_else(|error| panic!("`{query}` was refused: {error}")); + let display = tree.to_string(); + let root = display.lines().nth(1).expect("a compiled tree has a root"); + assert_eq!(root, format!(" root Select {op}"), "`{query}`"); + } +}