Enum Expression 

pub enum Expression {
    Literal(Value),
    QuantityLiteral {
        value: Decimal,
        unit: String,
    },
    TimeLiteral(String),
    IntervalLiteral {
        start: String,
        end: String,
    },
    Variable(String),
    GroupBy {
        variable: String,
        collection: Box<Expression>,
        filter: Option<Box<Expression>>,
        key: Box<Expression>,
        condition: Box<Expression>,
    },
    Binary {
        op: BinaryOp,
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expression>,
    },
    Cast {
        operand: Box<Expression>,
        target_type: String,
    },
    Quantifier {
        quantifier: Quantifier,
        variable: String,
        collection: Box<Expression>,
        condition: Box<Expression>,
    },
    MemberAccess {
        object: String,
        member: String,
    },
    Aggregation {
        function: AggregateFunction,
        collection: Box<Expression>,
        field: Option<String>,
        filter: Option<Box<Expression>>,
    },
    AggregationComprehension {
        function: AggregateFunction,
        variable: String,
        collection: Box<Expression>,
        window: Option<WindowSpec>,
        predicate: Box<Expression>,
        projection: Box<Expression>,
        target_unit: Option<String>,
    },
}

Variants

Literal(Value)

QuantityLiteral

Fields

value: Decimal

unit: String

TimeLiteral(String)

IntervalLiteral

Fields

start: String

end: String

Variable(String)

GroupBy

Fields

variable: String

collection: Box<Expression>

filter: Option<Box<Expression>>

key: Box<Expression>

condition: Box<Expression>

Binary

Fields

op: BinaryOp

left: Box<Expression>

right: Box<Expression>

Unary

Fields

op: UnaryOp

operand: Box<Expression>

Cast

Fields

operand: Box<Expression>

target_type: String

Quantifier

Fields

quantifier: Quantifier

variable: String

collection: Box<Expression>

condition: Box<Expression>

MemberAccess

Fields

object: String

member: String

Aggregation

Fields

function: AggregateFunction

collection: Box<Expression>

field: Option<String>

filter: Option<Box<Expression>>

AggregationComprehension

Fields

function: AggregateFunction

variable: String

collection: Box<Expression>

window: Option<WindowSpec>

predicate: Box<Expression>

projection: Box<Expression>

target_unit: Option<String>

Implementations

impl Expression

pub fn normalize(&self) -> NormalizedExpression

Returns a canonical normalized form of this expression.

The normalized form applies various simplification rules:

• Identity elimination (true AND x → x)
• Domination (false AND x → false)
• Idempotence (a AND a → a)
• Absorption (a OR (a AND b) → a)
• Double negation (NOT NOT x → x)
• Commutative sorting (operands sorted lexicographically)

pub fn is_equivalent(&self, other: &Expression) -> bool

Returns true if two expressions are semantically equivalent.

Two expressions are equivalent if their normalized forms are identical.

pub fn literal(value: impl Into<Value>) -> Self

pub fn variable(name: &str) -> Self

pub fn binary(op: BinaryOp, left: Expression, right: Expression) -> Self

pub fn unary(op: UnaryOp, operand: Expression) -> Self

pub fn quantifier( q: Quantifier, var: &str, collection: Expression, condition: Expression, ) -> Self

pub fn cast(operand: Expression, target_type: impl Into<String>) -> Self

pub fn comparison( var: &str, op: &str, value: impl Into<Value>, ) -> Result<Self, String>

pub fn aggregation( function: AggregateFunction, collection: Expression, field: Option<impl Into<String>>, filter: Option<Expression>, ) -> Self

pub fn member_access(object: &str, member: &str) -> Self

impl Expression

pub fn expand(&self, graph: &Graph) -> Result<Expression, String>

pub fn substitute(&self, var: &str, value: &Value) -> Result<Expression, String>

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expression

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

Formats the value using the given formatter.

impl From<&Expression> for Expression

fn from(e: &CoreExpression) -> Self

Converts to this type from the input type.

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> 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 Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expression