Enum BoundExpression 

pub enum BoundExpression {
    Literal(Value, DataType),
    Variable(String, DataType),
    Property {
        object: Box<BoundExpression>,
        property: String,
        value_type: DataType,
    },
    StructField {
        base: Box<BoundExpression>,
        field: String,
        return_type: DataType,
    },
    BinaryOp {
        left: Box<BoundExpression>,
        op: BinaryOperator,
        right: Box<BoundExpression>,
        return_type: DataType,
    },
    UnaryOp {
        op: UnaryOperator,
        operand: Box<BoundExpression>,
        return_type: DataType,
    },
    Function(BoundFunctionCall),
    Aggregate(BoundAggregateCall),
    ParameterRef(String, DataType),
    SessionVariable(String, DataType),
    Subquery {
        query: Box<BoundStatement>,
        original_body: Option<Box<SubqueryBody>>,
    },
    Cast {
        expr: Box<BoundExpression>,
        target_type: DataType,
    },
    List(Vec<BoundExpression>, DataType),
    Map(Vec<(String, BoundExpression)>, DataType),
    Case {
        expr: Option<Box<BoundExpression>>,
        when_then: Vec<(BoundExpression, BoundExpression)>,
        else_expr: Option<Box<BoundExpression>>,
        return_type: DataType,
    },
    Exists {
        query: Box<BoundStatement>,
        original_body: Option<Box<SubqueryBody>>,
    },
    Pattern(QueryGraph),
    Label(String),
    TagProperty {
        tag_name: String,
        property: String,
        value_type: DataType,
    },
    EdgeProperty {
        edge_name: String,
        property: String,
        value_type: DataType,
    },
    Predicate {
        func: String,
        args: Vec<BoundExpression>,
        return_type: DataType,
    },
    Subscript {
        collection: Box<BoundExpression>,
        index: Box<BoundExpression>,
        return_type: DataType,
    },
    WindowFunction {
        name: String,
        args: Vec<BoundExpression>,
        over_partition_by: Vec<BoundExpression>,
        over_order_by: Vec<BoundExpression>,
        over_order_desc: Vec<bool>,
        return_type: DataType,
    },
    In {
        expr: Box<BoundExpression>,
        subquery: Box<BoundStatement>,
        negated: bool,
        original_body: Option<Box<SubqueryBody>>,
    },
    CountSubquery {
        query: Box<BoundStatement>,
        original_body: Option<Box<SubqueryBody>>,
    },
    Lambda {
        params: Vec<String>,
        body: Box<BoundExpression>,
    },
    Path(Vec<BoundExpression>, DataType),
    ListComprehension {
        variable: String,
        source: Box<BoundExpression>,
        filter: Option<Box<BoundExpression>>,
        map: Option<Box<BoundExpression>>,
        return_type: DataType,
    },
    Reduce {
        accumulator: String,
        initial: Box<BoundExpression>,
        variable: String,
        source: Box<BoundExpression>,
        mapping: Box<BoundExpression>,
        return_type: DataType,
    },
    PathBuild(Vec<BoundExpression>, DataType),
    Vector(Vec<f32>),
}

A fully resolved expression with known types and catalog references.

Unlike the AST [Expression] which carries unresolved names, every variant here has been type-checked and catalog-resolved.

Variants

Literal(Value, DataType)

Literal value with resolved type

Variable(String, DataType)

Variable reference (no property access)

Property

Property access on an expression (e.g. n.name)

Fields

object: Box<BoundExpression>

property: String

value_type: DataType

StructField

STRUCT field access (e.g. addr.city)

Fields

base: Box<BoundExpression>

field: String

return_type: DataType

BinaryOp

Binary operation with resolved result type

Fields

left: Box<BoundExpression>

op: BinaryOperator

right: Box<BoundExpression>

return_type: DataType

UnaryOp

Unary operation

Fields

op: UnaryOperator

operand: Box<BoundExpression>

return_type: DataType

Function(BoundFunctionCall)

Function call with resolved return type

Aggregate(BoundAggregateCall)

Aggregate function call

ParameterRef(String, DataType)

Parameter reference (@param)

SessionVariable(String, DataType)

Session variable reference ($name), distinct from query parameters. Type is dynamic (resolved at execution time from session state).

Subquery

Subquery expression

Fields

query: Box<BoundStatement>

original_body: Option<Box<SubqueryBody>>

Cast

Cast expression

Fields

expr: Box<BoundExpression>

target_type: DataType

List(Vec<BoundExpression>, DataType)

List literal

Map(Vec<(String, BoundExpression)>, DataType)

Map literal

Case

Case/when expression

Fields

expr: Option<Box<BoundExpression>>

when_then: Vec<(BoundExpression, BoundExpression)>

else_expr: Option<Box<BoundExpression>>

return_type: DataType

Exists

Exists predicate

Fields

query: Box<BoundStatement>

original_body: Option<Box<SubqueryBody>>

Pattern(QueryGraph)

Pattern expression (path pattern in expression context)

Label(String)

Label expression

TagProperty

Tag property access

Fields

tag_name: String

property: String

value_type: DataType

EdgeProperty

Edge property access

Fields

edge_name: String

property: String

value_type: DataType

Predicate

Predicate expression (FILTER, ALL, ANY, etc.)

Fields

func: String

args: Vec<BoundExpression>

return_type: DataType

Subscript

Subscript access (collection[index])

Fields

collection: Box<BoundExpression>

index: Box<BoundExpression>

return_type: DataType

WindowFunction

Window function

Fields

name: String

args: Vec<BoundExpression>

over_partition_by: Vec<BoundExpression>

over_order_by: Vec<BoundExpression>

over_order_desc: Vec<bool>

return_type: DataType

In

IN subquery

Fields

expr: Box<BoundExpression>

subquery: Box<BoundStatement>

negated: bool

original_body: Option<Box<SubqueryBody>>

CountSubquery

COUNT subquery: evaluates to the number of rows returned by the subquery

Fields

query: Box<BoundStatement>

original_body: Option<Box<SubqueryBody>>

Lambda

Lambda expression: anonymous function used as callback for higher-order list functions

Fields

params: Vec<String>

body: Box<BoundExpression>

Path(Vec<BoundExpression>, DataType)

Path expression

ListComprehension

List comprehension

Fields

variable: String

source: Box<BoundExpression>

filter: Option<Box<BoundExpression>>

map: Option<Box<BoundExpression>>

return_type: DataType

Reduce

Reduce expression

Fields

accumulator: String

initial: Box<BoundExpression>

variable: String

source: Box<BoundExpression>

mapping: Box<BoundExpression>

return_type: DataType

PathBuild(Vec<BoundExpression>, DataType)

Path build

Vector(Vec<f32>)

Vector literal

Implementations

impl BoundExpression

pub fn return_type(&self) -> DataType

Return the concrete DataType of this expression.

pub fn value_type(&self) -> ValueType

Get the ValueType of this expression for downstream consumers.

Trait Implementations

impl Clone for BoundExpression

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 BoundExpression

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

Formats the value using the given formatter.