Enum Expr 

#[non_exhaustive]
pub enum Expr {
    Literal(Literal),
    Var(VarRef),
    Property(PropertyAccess),
    BinaryOp(BinaryOp),
    UnaryOp(UnaryOp),
    FunctionCall(FunctionCall),
    List(ListLiteral),
    Map(MapLiteral),
    Param(ParamRef),
    Case(CaseExpr),
    ListComprehension(ListComprehension),
    Quantifier(Quantifier),
    PatternComprehension(PatternComprehension),
    PatternPredicate(PatternPredicate),
    ExistentialSubquery(ExistentialSubquery),
    LabelPredicate(LabelPredicate),
    IsNull {
        expr: Box<Expr>,
        negated: bool,
        span: Span,
    },
    InList {
        expr: Box<Expr>,
        list: Box<Expr>,
        negated: bool,
        span: Span,
    },
    StringOp {
        expr: Box<Expr>,
        op: StringOpKind,
        pattern: Box<Expr>,
        span: Span,
    },
    RegexMatch {
        expr: Box<Expr>,
        pattern: Box<Expr>,
        span: Span,
    },
    Parenthesized {
        inner: Box<Expr>,
        span: Span,
    },
}

A Cypher expression.

Expr is recursive: Box<Expr> is used wherever a child expression is needed to keep the enum Sized.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Literal(Literal)

An integer, float, string, boolean, or null literal.

Var(VarRef)

A variable reference: n.

Property(PropertyAccess)

A property access: n.prop.

BinaryOp(BinaryOp)

A binary operation: left op right.

UnaryOp(UnaryOp)

A unary operation: op expr (e.g. NOT x, -x).

FunctionCall(FunctionCall)

A function call: name(args) or name(DISTINCT arg).

List(ListLiteral)

A list literal: [1, 2, 3].

Map(MapLiteral)

A map literal: {key: expr}.

Param(ParamRef)

A Cypher parameter: $name.

Case(CaseExpr)

A CASE expression.

ListComprehension(ListComprehension)

A list comprehension: [x IN list WHERE pred | expr].

Quantifier(Quantifier)

A quantifier predicate: all/any/none/single(x IN list WHERE pred).

PatternComprehension(PatternComprehension)

A pattern comprehension: [(n)-[r]->(m) | r.weight].

PatternPredicate(PatternPredicate)

A pattern predicate: (n)-[:KNOWS]->(m).

ExistentialSubquery(ExistentialSubquery)

A simple or full existential subquery: exists { (n)-->(m) } or exists { MATCH (n)-->(m) RETURN true }.

LabelPredicate(LabelPredicate)

A label predicate: n:Person.

IsNull

IS NULL / IS NOT NULL.

Fields

expr: Box<Expr>

negated: bool

span: Span

InList

x IN list / x NOT IN list.

Fields

expr: Box<Expr>

list: Box<Expr>

negated: bool

span: Span

StringOp

x STARTS WITH y / x ENDS WITH y / x CONTAINS y.

Fields

expr: Box<Expr>

op: StringOpKind

pattern: Box<Expr>

span: Span

RegexMatch

x =~ pattern — regular expression match.

Fields

expr: Box<Expr>

pattern: Box<Expr>

span: Span

Parenthesized

A subexpression wrapped in parentheses (preserved for span accuracy).

Fields

inner: Box<Expr>

span: Span

Implementations

impl Expr

pub fn span(&self) -> Span

Return the span of this expression.

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<'de> Deserialize<'de> for Expr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expr

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Expr

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 Expr