Enum Expression 

pub enum Expression {
    Literal(Value),
    Variable(String),
    Property {
        object: Box<Expression>,
        property: String,
    },
    StructField {
        base: Box<Expression>,
        field: String,
    },
    Binary {
        left: Box<Expression>,
        op: BinaryOperator,
        right: Box<Expression>,
    },
    Unary {
        op: UnaryOperator,
        operand: Box<Expression>,
    },
    Function {
        name: String,
        args: Vec<FunctionArg>,
    },
    Aggregate {
        func: AggregateFunctionKind,
        args: Vec<Expression>,
        distinct: bool,
        filter: Option<Box<Expression>>,
    },
    List(Vec<Expression>),
    Map(Vec<(String, Expression)>),
    Case {
        test_expr: Option<Box<Expression>>,
        conditions: Vec<(Expression, Expression)>,
        default: Option<Box<Expression>>,
    },
    TypeCast {
        expression: Box<Expression>,
        target_type: DataType,
    },
    Subscript {
        collection: Box<Expression>,
        index: Box<Expression>,
    },
    Range {
        collection: Box<Expression>,
        start: Option<Box<Expression>>,
        end: Option<Box<Expression>>,
    },
    Path(Vec<Expression>),
    Label(String),
    ListComprehension {
        variable: String,
        source: Box<Expression>,
        filter: Option<Box<Expression>>,
        map: Option<Box<Expression>>,
    },
    LabelTagProperty {
        tag: Box<Expression>,
        property: String,
    },
    TagProperty {
        tag_name: String,
        property: String,
    },
    EdgeProperty {
        edge_name: String,
        property: String,
    },
    Predicate {
        func: String,
        args: Vec<Expression>,
    },
    Reduce {
        accumulator: String,
        initial: Box<Expression>,
        variable: String,
        source: Box<Expression>,
        mapping: Box<Expression>,
    },
    PathBuild(Vec<Expression>),
    Parameter(String),
    SessionVariable(String),
    Vector(Vec<f32>),
    WindowFunction {
        name: String,
        args: Vec<Expression>,
        over_partition_by: Vec<Expression>,
        over_order_by: Vec<Expression>,
        over_order_desc: Vec<bool>,
    },
    Exists {
        body: Box<SubqueryBody>,
    },
    In {
        expr: Box<Expression>,
        subquery: Box<SubqueryBody>,
        negated: bool,
    },
    CountSubquery {
        body: Box<SubqueryBody>,
    },
    ScalarSubquery {
        body: Box<SubqueryBody>,
    },
    Lambda {
        params: Vec<String>,
        body: Box<Expression>,
    },
}

Unified Expression Type

An enumeration of expressions containing location information (span fields) for:

• Parser layer: error localization and reporting
• Core Layer: Type Checking and Enforcement
• Serialization: storage and transmission

Variants

Literal(Value)

literal value

Variable(String)

variable reference

Property

Property Access

Fields

object: Box<Expression>

property: String

StructField

STRUCT field access

Accesses a named field of a STRUCT value, e.g. addr.city.

Fields

base: Box<Expression>

field: String

Binary

binary operation

Fields

left: Box<Expression>

op: BinaryOperator

right: Box<Expression>

Unary

one-dimensional operation

Fields

op: UnaryOperator

operand: Box<Expression>

Function

function call

Fields

name: String

args: Vec<FunctionArg>

Aggregate

aggregate function (math.)

Fields

func: AggregateFunctionKind

args: Vec<Expression>

distinct: bool

filter: Option<Box<Expression>>

List(Vec<Expression>)

list literal

Map(Vec<(String, Expression)>)

mapping literal

Case

conditional expression

Fields

test_expr: Option<Box<Expression>>

conditions: Vec<(Expression, Expression)>

default: Option<Box<Expression>>

TypeCast

type conversion

Fields

expression: Box<Expression>

target_type: DataType

Subscript

subscript access

Fields

collection: Box<Expression>

index: Box<Expression>

Range

range expression

Fields

collection: Box<Expression>

start: Option<Box<Expression>>

end: Option<Box<Expression>>

Path(Vec<Expression>)

path expression

Label(String)

tag expression

ListComprehension

List Derivative Expressions

Fields

variable: String

source: Box<Expression>

filter: Option<Box<Expression>>

map: Option<Box<Expression>>

LabelTagProperty

Dynamic access to tag attributes

Used to access tag properties dynamically, e.g. tagName.propertyName where tagName is a variable or tag expression

Fields

tag: Box<Expression>

property: String

TagProperty

Tag Attribute Access

Used to access properties on the vertex tag, e.g. tagName.propertyName

Fields

tag_name: String

property: String

EdgeProperty

Edge Attribute Access

Used to access attributes on an edge type

Fields

edge_name: String

property: String

Predicate

predicate expression (math.)

Used to implement predicate functions such as FILTER, ALL, ANY, EXISTS, etc.

Fields

func: String

args: Vec<Expression>

Reduce

Reduce expression

Used to implement the REDUCE function

Fields

accumulator: String

initial: Box<Expression>

variable: String

source: Box<Expression>

mapping: Box<Expression>

PathBuild(Vec<Expression>)

path construction expression

Used for building paths, such as path(v1, e1, v2)

Parameter(String)

Query parameter expression

Used to represent query parameters, e.g. @param.

SessionVariable(String)

Session variable expression

Used to represent session-scoped variables, e.g. $name. Resolved from the session variable snapshot at execution time; distinct from Expression::Parameter so EXPLAIN, type inference and error reporting can tell the two apart.

Vector(Vec<f32>)

Vector literal expression

Represents vector literals like VECTOR[0.1, 0.2, 0.3] or [0.1, 0.2]::VECTOR

WindowFunction

Window function expression with OVER clause

Fields

name: String

Window function name (e.g. “row_number”, “rank”, “lead”)

args: Vec<Expression>

Arguments to the window function

over_partition_by: Vec<Expression>

PARTITION BY expressions

over_order_by: Vec<Expression>

ORDER BY expressions

over_order_desc: Vec<bool>

Whether each ORDER BY expression is descending

Exists

EXISTS subquery expression

Evaluates to true if the subquery pattern has at least one match. Syntax: EXISTS { pattern } or EXISTS(pattern)

Fields

body: Box<SubqueryBody>

The subquery body (WHERE clause condition or pattern reference)

In

IN subquery expression

Evaluates to true if expr is in the result set of the subquery. Syntax: expr IN { MATCH ... RETURN ... }

Fields

expr: Box<Expression>

The expression to test

subquery: Box<SubqueryBody>

The subquery body

negated: bool

Whether this is NOT IN

CountSubquery

COUNT subquery expression

Evaluates to the number of rows returned by the subquery. Syntax: COUNT { MATCH ... RETURN ... }

Fields

body: Box<SubqueryBody>

The subquery body

ScalarSubquery

Scalar subquery expression

Evaluates to the first column of the first row returned by the subquery, or NULL when the subquery returns no rows. Syntax: SUBQUERY { MATCH ... RETURN <single expr> }

Fields

body: Box<SubqueryBody>

The subquery body (must carry a single-column return_expr)

Lambda

Lambda expression

Represents an anonymous function, e.g. x -> x + 1 or (x, y) -> x + y. Used as callbacks for higher-order list functions like list_transform, list_filter.

Fields

params: Vec<String>

Parameter names

body: Box<Expression>

Lambda body expression

Implementations

impl Expression

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

Creating literal expressions

pub fn variable(name: impl Into<String>) -> Expression

Create a variable expression.

pub fn property(object: Expression, property: impl Into<String>) -> Expression

Create attribute access expressions

pub fn struct_field(base: Expression, field: impl Into<String>) -> Expression

Create a STRUCT field access expression.

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

Create a binary operation expression

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

Create a unary operation expression.

pub fn function(name: impl Into<String>, args: Vec<Expression>) -> Expression

Create a function call expression with positional arguments.

pub fn function_with_args( name: impl Into<String>, args: Vec<FunctionArg>, ) -> Expression

Create a function call expression with mixed positional and named arguments.

pub fn aggregate( func: AggregateFunctionKind, arg: Expression, distinct: bool, ) -> Expression

Create an aggregate function expression.

pub fn aggregate_with_filter( func: AggregateFunctionKind, arg: Expression, distinct: bool, filter: Expression, ) -> Expression

Create an aggregate function expression with a FILTER clause.

pub fn aggregate_multi( func: AggregateFunctionKind, args: Vec<Expression>, distinct: bool, ) -> Expression

Create a multi-argument aggregate function expression (e.g. CORR, COVAR).

pub fn list(items: Vec<Expression>) -> Expression

Create a list expression.

pub fn map(pairs: Vec<(impl Into<String>, Expression)>) -> Expression

Create a mapping expression

pub fn case( test_expr: Option<Expression>, conditions: Vec<(Expression, Expression)>, default: Option<Expression>, ) -> Expression

Create a conditional expression

pub fn cast(expression: Expression, target_type: DataType) -> Expression

Create a type conversion expression.

pub fn subscript(collection: Expression, index: Expression) -> Expression

Create an subscript access expression.

pub fn range( collection: Expression, start: Option<Expression>, end: Option<Expression>, ) -> Expression

Create a range expression

pub fn path(items: Vec<Expression>) -> Expression

Create a path expression

pub fn label(name: impl Into<String>) -> Expression

Create a tag expression

pub fn list_comprehension( variable: impl Into<String>, source: Expression, filter: Option<Expression>, map: Option<Expression>, ) -> Expression

Create a list comprehension expression.

pub fn label_tag_property( tag: Expression, property: impl Into<String>, ) -> Expression

Create dynamic access expressions for tag attributes

pub fn tag_property( tag_name: impl Into<String>, property: impl Into<String>, ) -> Expression

Create tag attribute access expressions

pub fn edge_property( edge_name: impl Into<String>, property: impl Into<String>, ) -> Expression

Create an edge attribute access expression.

pub fn predicate(func: impl Into<String>, args: Vec<Expression>) -> Expression

Create a predicate expression.

pub fn reduce( accumulator: impl Into<String>, initial: Expression, variable: impl Into<String>, source: Expression, mapping: Expression, ) -> Expression

Create a Reduce expression.

pub fn path_build(items: Vec<Expression>) -> Expression

Create a path construction expression

pub fn parameter(name: impl Into<String>) -> Expression

Create a parameter expression

pub fn session_variable(name: impl Into<String>) -> Expression

Create a session variable expression

pub fn vector(data: Vec<f32>) -> Expression

Create a vector literal expression

pub fn exists(body: SubqueryBody) -> Expression

Create an EXISTS subquery expression

pub fn in_subquery( expr: Expression, subquery: SubqueryBody, negated: bool, ) -> Expression

Create an IN subquery expression

pub fn count_subquery(body: SubqueryBody) -> Expression

Create a COUNT subquery expression

pub fn scalar_subquery(body: SubqueryBody) -> Expression

Create a scalar subquery expression

pub fn lambda(params: Vec<String>, body: Expression) -> Expression

Create a Lambda expression

pub fn bool(value: bool) -> Expression

Creating a boolean literal

pub fn int(value: i32) -> Expression

Creating integer literal values (i32)

pub fn bigint(value: i64) -> Expression

Creating bigint literal values (i64)

pub fn float(value: f32) -> Expression

Creating a floating-point numeric literal (f32)

pub fn double(value: f64) -> Expression

Creating a double-precision numeric literal (f64)

pub fn string(value: impl AsRef<str>) -> Expression

Creating a string literal

pub fn null() -> Expression

Create an empty literal value.

pub fn modulo(left: Expression, right: Expression) -> Expression

Create a modulus expression

pub fn eq(left: Expression, right: Expression) -> Expression

Creating an expression that equals a certain value…

pub fn ne(left: Expression, right: Expression) -> Expression

Creating something does not equal expressing it in words.

pub fn lt(left: Expression, right: Expression) -> Expression

Create an expression that is smaller than the given one.

pub fn le(left: Expression, right: Expression) -> Expression

Create an expression that is less than or equal to…

pub fn gt(left: Expression, right: Expression) -> Expression

Create something that is greater than the expression…

pub fn ge(left: Expression, right: Expression) -> Expression

Create an expression that is greater than or equal to…

pub fn and(left: Expression, right: Expression) -> Expression

Creating logic and expressions

pub fn or(left: Expression, right: Expression) -> Expression

Create a logical statement or expression.

pub fn is_null(operand: Expression) -> Expression

Creating an IS NULL expression

pub fn is_not_null(operand: Expression) -> Expression

Creating an IS NOT NULL expression

impl Expression

pub fn to_expression_string(&self) -> String

Convert the expression into a string representation.

Generate an expression string similar to SQL/Cypher.

impl Expression

pub fn is_constant(&self) -> bool

Checking if an expression is a constant

Constant expressions can be determined at compile time and do not require run-time evaluation.

pub fn contains_aggregate(&self) -> bool

Check if the expression contains an aggregate function

Used to identify expressions that need to be evaluated in a GROUP BY context.

pub fn get_variables(&self) -> Vec<String>

Get the names of all variables in the expression

Returns a list of de-duplicated variable names.

pub fn is_literal(&self) -> bool

Checks if it is a literal expression

pub fn as_literal(&self) -> Option<&Value>

Get the literal value (if it is a literal)

pub fn is_variable(&self) -> bool

Checking for variable expressions

pub fn as_variable(&self) -> Option<&str>

Get variable name (if variable)

pub fn is_aggregate(&self) -> bool

Checking for Aggregate Expressions

pub fn is_property(&self) -> bool

Checks if it is an attribute access expression

pub fn is_function(&self) -> bool

Check if it is a function call expression

pub fn is_binary(&self) -> bool

Checking for binary arithmetic expressions

pub fn is_unary(&self) -> bool

Checking for unary arithmetic expressions

pub fn is_list(&self) -> bool

Checks if it is a list expression

pub fn is_map(&self) -> bool

Checks if it is a mapping expression

pub fn is_path(&self) -> bool

Checks if it is a path expression

pub fn is_label(&self) -> bool

Checks if it’s a tag expression

pub fn is_parameter(&self) -> bool

Checks if it is a parameter expression

pub fn is_session_variable(&self) -> bool

Checks if it is a session variable expression

pub fn as_parameter(&self) -> Option<&str>

Get the parameter name (if it is a parameter)

pub fn is_case(&self) -> bool

Checking for Conditional Expressions

pub fn is_cast(&self) -> bool

Checking for type conversion expressions

pub fn is_subscript(&self) -> bool

Checking for subscript access expressions

pub fn is_range(&self) -> bool

Checks if it is a range expression

pub fn function_name(&self) -> Option<&str>

Get the function name (if it’s a function call)

pub fn aggregate_function_name(&self) -> Option<&str>

Get the name of the aggregate function (if it is an aggregate expression)

pub fn is_path_build(&self) -> bool

Checks if it is a path building expression

pub fn is_type_cast(&self) -> bool

Check whether it is a type conversion expression

pub fn is_list_comprehension(&self) -> bool

Checking for List Derivation Expressions

pub fn is_reduce(&self) -> bool

Checks for a Reduce expression

pub fn is_count_subquery(&self) -> bool

Checks for a COUNT subquery expression

pub fn is_scalar_subquery(&self) -> bool

Checks for a scalar subquery expression

pub fn is_lambda(&self) -> bool

Checks for a Lambda expression

pub fn as_function_name(&self) -> Option<String>

Gets the function name (if it is a function call)

pub fn as_property_name(&self) -> Option<String>

Get the attribute name (in case of attribute access)

pub fn as_label_name(&self) -> Option<String>

Get the tag name (if it’s a tag expression)

pub fn as_parameter_name(&self) -> Option<String>

Get the parameter name (if it is a parameter expression)

pub fn as_session_variable_name(&self) -> Option<String>

Get the session variable name (if it is a session variable expression)

impl Expression

pub fn estimate_memory_iterative(&self) -> usize

Estimate memory using iterative approach to avoid stack overflow This is useful for deeply nested expressions

pub fn is_simple(&self) -> bool

Check if this is a simple expression (leaf node)

pub fn node_count(&self) -> usize

Get approximate node count for complexity estimation

impl Expression

pub fn children(&self) -> Vec<&Expression>

Obtain all the subexpressions of the expression.

Return a vector that contains all the direct subexpressions.

pub fn children_mut(&mut self) -> Vec<&mut Expression>

Obtaining the variable subexpression

Return a vector containing all the directly mutable subexpressions.

pub fn traverse_preorder<F>(&self, callback: &mut F)

where F: FnMut(&Expression),

Traversing the expression tree (pre-order traversal)

Perform a pre-order traversal of the expression tree, and call the callback function for each node.

pub fn traverse_postorder<F>(&self, callback: &mut F)

where F: FnMut(&Expression),

Traversing the expression tree (post-order traversal)

Perform a post-order traversal of the expression tree, and call the callback function for each node.

pub fn find<F>(&self, predicate: &F) -> Option<&Expression>

where F: Fn(&Expression) -> bool,

Find the expression that meets the conditions.

Find the first expression in the expression tree that meets the specified condition.

pub fn find_all<'a, F>( &'a self, predicate: &F, results: &mut Vec<&'a Expression>, )

where F: Fn(&Expression) -> bool,

Find all expressions that meet the specified conditions.

Find all expressions in the expression tree that meet the specified conditions.

pub fn transform<F>(&self, transformer: &F) -> Expression

where F: Fn(&Expression) -> Option<Expression>,

Transform the expression tree

Transform the expression tree and return the new expression tree.

impl Expression

pub fn deduce_type(&self) -> DataType

Deriving the data type of an expression

Derive the return type of an expression from its structure and operators. Returns DataType::Unknown if the type cannot be determined without schema/binding information (the binder completes these paths), and DataType::Empty only for the explicit Value::Empty.

Trait Implementations

impl Add for Expression

type Output = Expression

The resulting type after applying the + operator.

fn add(self, rhs: Expression) -> <Expression as Add>::Output

Performs the + operation.

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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Expression, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expression

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

Formats the value using the given formatter.

impl Div for Expression

type Output = Expression

The resulting type after applying the / operator.

fn div(self, rhs: Expression) -> <Expression as Div>::Output

Performs the / operation.

impl From<Arc<ExpressionMeta>> for Expression

Extract the core expressions from Arc ExpressionMeta.

fn from(meta: Arc<ExpressionMeta>) -> Expression

Converts to this type from the input type.

impl From<ExpressionMeta> for Expression

Extract the core expressions from ExpressionMeta.

fn from(meta: ExpressionMeta) -> Expression

Converts to this type from the input type.

impl MemoryEstimatable for Expression

fn estimate_memory(&self) -> usize

impl Mul for Expression

type Output = Expression

The resulting type after applying the * operator.

fn mul(self, rhs: Expression) -> <Expression as Mul>::Output

Performs the * operation.

impl Neg for Expression

type Output = Expression

The resulting type after applying the - operator.

fn neg(self) -> <Expression as Neg>::Output

Performs the unary - operation.

impl Not for Expression

type Output = Expression

The resulting type after applying the ! operator.

fn not(self) -> <Expression as Not>::Output

Performs the unary ! operation.

impl PartialEq for Expression

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Expression

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expression

impl Sub for Expression

type Output = Expression

The resulting type after applying the - operator.

fn sub(self, rhs: Expression) -> <Expression as Sub>::Output

Performs the - operation.