Enum Expr 

pub enum Expr {
    Aggregate(AggregateExpr),
    Unary(UnaryExpr),
    Binary(BinaryExpr),
    Paren(ParenExpr),
    Subquery(SubqueryExpr),
    NumberLiteral(NumberLiteral),
    StringLiteral(StringLiteral),
    VectorSelector(VectorSelector),
    MatrixSelector(MatrixSelector),
    Call(Call),
    Extension(Extension),
}

Variants

Aggregate(AggregateExpr)

Aggregate represents an aggregation operation on a Vector.

Unary(UnaryExpr)

Unary represents a unary operation on another expression. Currently unary operations are only supported for Scalars.

Binary(BinaryExpr)

Binary represents a binary expression between two child expressions.

Paren(ParenExpr)

Paren wraps an expression so it cannot be disassembled as a consequence of operator precedence.

Subquery(SubqueryExpr)

SubqueryExpr represents a subquery.

NumberLiteral(NumberLiteral)

NumberLiteral represents a number.

StringLiteral(StringLiteral)

StringLiteral represents a string.

VectorSelector(VectorSelector)

VectorSelector represents a Vector selection.

MatrixSelector(MatrixSelector)

MatrixSelector represents a Matrix selection.

Call(Call)

Call represents a function call.

Extension(Extension)

Extension represents an extension expression. It is for user to attach additional information to the AST. This parser won’t generate Extension node.

Implementations

impl Expr

pub fn value_type(&self) -> ValueType

pub fn prettify(&self) -> String

Examples found in repository

examples/parser.rs (line 27)

fn main() {
    let promql = r#"
        http_requests_total{
            environment=~"staging|testing|development",
            method!="GET"
        } offset 5m
    "#;

    match parser::parse(promql) {
        Ok(expr) => {
            println!("Prettify:\n{}\n", expr.prettify());
            println!("AST:\n{expr:?}");
        }
        Err(info) => println!("Err: {info:?}"),
    }
}

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&str> for Expr

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<String> for Expr

fn from(val: String) -> Self

Converts to this type from the input type.

impl From<VectorSelector> for Expr

directly create an Expr::VectorSelector from instant vector

Examples

Basic usage:

use promql_parser::label::Matchers;
use promql_parser::parser::{Expr, VectorSelector};

let name = String::from("foo");
let vs = VectorSelector::new(Some(name), Matchers::empty());

assert_eq!(Expr::VectorSelector(vs), Expr::from(VectorSelector::from("foo")));

fn from(vs: VectorSelector) -> Self

Converts to this type from the input type.

impl From<f64> for Expr

fn from(val: f64) -> Self

Converts to this type from the input type.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Prettier for Expr

fn pretty(&self, level: usize, max: usize) -> String

max param is short for max_characters_per_line.

fn format(&self, level: usize, _max: usize) -> String

override format if expr needs to be split into multiple lines

fn needs_split(&self, max: usize) -> bool

override needs_split to return false, in order not to split multiple lines

impl TryFrom<Expr> for AtModifier

type Error = String

The type returned in the event of a conversion error.

fn try_from(ex: Expr) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Expr