Enum ExprKind 

#[non_exhaustive]
pub enum ExprKind {
    Literal(Literal),
    Variable(Name),
    Parameter(Parameter),
    Wildcard,
    List(Vec<Expr>),
    Map(Vec<MapEntry>),
    MapProjection(MapProjection),
    Unary {
        operator: Node<UnaryOperator>,
        operand: Box<Expr>,
    },
    Binary {
        left: Box<Expr>,
        operator: Node<BinaryOperator>,
        right: Box<Expr>,
    },
    Is {
        expression: Box<Expr>,
        negated: bool,
        predicate: IsPredicate,
    },
    Property {
        expression: Box<Expr>,
        key: Name,
    },
    DynamicProperty {
        expression: Box<Expr>,
        key: Box<Expr>,
    },
    Index {
        expression: Box<Expr>,
        index: Box<Expr>,
    },
    Slice {
        expression: Box<Expr>,
        lower: Option<Box<Expr>>,
        upper: Option<Box<Expr>>,
    },
    Function(FunctionInvocation),
    Case(CaseExpression),
    ListComprehension(ListComprehension),
    PatternComprehension(PatternComprehension),
    Reduce(ReduceExpression),
    QuantifiedPredicate(QuantifiedPredicate),
    Subquery(SubqueryExpression),
    Pattern(Pattern),
    Parenthesized(Box<Expr>),
    Error(ErrorNode),
}

Any expression in openCypher 2024.3.

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)

Variable(Name)

Parameter(Parameter)

Wildcard

List(Vec<Expr>)

Map(Vec<MapEntry>)

MapProjection(MapProjection)

Unary

Fields

operator: Node<UnaryOperator>

operand: Box<Expr>

Binary

Fields

left: Box<Expr>

operator: Node<BinaryOperator>

right: Box<Expr>

Is

Fields

expression: Box<Expr>

negated: bool

predicate: IsPredicate

Property

Fields

expression: Box<Expr>

key: Name

DynamicProperty

Fields

expression: Box<Expr>

key: Box<Expr>

Index

Fields

expression: Box<Expr>

index: Box<Expr>

Slice

Fields

expression: Box<Expr>

lower: Option<Box<Expr>>

upper: Option<Box<Expr>>

Function(FunctionInvocation)

Case(CaseExpression)

ListComprehension(ListComprehension)

PatternComprehension(PatternComprehension)

Reduce(ReduceExpression)

QuantifiedPredicate(QuantifiedPredicate)

Subquery(SubqueryExpression)

Pattern(Pattern)

Parenthesized(Box<Expr>)

Error(ErrorNode)

A missing operand inserted by recovery, with an empty source span.

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ExprKind

impl Hash for ExprKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ExprKind

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ExprKind

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 ExprKind