Enum CompiledExpr 

pub enum CompiledExpr {
    Const(Value),
    Slot(SlotId),
    CompoundSlot(SlotId),
    Unary {
        op: UnaryOperator,
        operand: Box<CompiledExpr>,
    },
    Binary {
        op: BinaryOperator,
        left: Box<CompiledExpr>,
        right: Box<CompiledExpr>,
    },
    Case {
        test: Option<Box<CompiledExpr>>,
        conditions: Vec<(CompiledExpr, CompiledExpr)>,
        default: Option<Box<CompiledExpr>>,
    },
    Function {
        name: String,
        func: Option<OwnedFunctionRef>,
        args: Vec<CompiledExpr>,
    },
    TypeCast {
        expr: Box<CompiledExpr>,
        target_type: DataType,
    },
    List(Vec<CompiledExpr>),
    Map(Vec<(String, CompiledExpr)>),
    Subscript {
        collection: Box<CompiledExpr>,
        index: Box<CompiledExpr>,
    },
    Range {
        collection: Box<CompiledExpr>,
        start: Option<Box<CompiledExpr>>,
        end: Option<Box<CompiledExpr>>,
    },
    Path(Vec<CompiledExpr>),
    Parameter(String),
    SessionVariable(String),
    Fallback(Expression),
}

Compiled closure-tree node.

Mirrors the hot subset of Expression with slot-resolved variables and pre-resolved function references; anything else is kept verbatim in CompiledExpr::Fallback and evaluated through the scalar interpreter.

Variants

Const(Value)

Compile-time folded constant.

Slot(SlotId)

A variable resolved to its slot at compile time.

CompoundSlot(SlotId)

A var.prop property access resolved to its compound slot at compile time (flat column layout).

Unary

Unary operation over a compiled operand.

Fields

op: UnaryOperator

operand: Box<CompiledExpr>

Binary

Binary operation over two compiled operands.

Fields

op: BinaryOperator

left: Box<CompiledExpr>

right: Box<CompiledExpr>

Case

CASE expression with short-circuit evaluation.

Fields

test: Option<Box<CompiledExpr>>

conditions: Vec<(CompiledExpr, CompiledExpr)>

default: Option<Box<CompiledExpr>>

Function

Function call with compile-time resolved function reference.

Fields

name: String

func: Option<OwnedFunctionRef>

args: Vec<CompiledExpr>

TypeCast

Type cast over a compiled operand.

Fields

expr: Box<CompiledExpr>

target_type: DataType

List(Vec<CompiledExpr>)

List literal.

Map(Vec<(String, CompiledExpr)>)

Map literal.

Subscript

Subscript access.

Fields

collection: Box<CompiledExpr>

index: Box<CompiledExpr>

Range

Range access.

Fields

collection: Box<CompiledExpr>

start: Option<Box<CompiledExpr>>

end: Option<Box<CompiledExpr>>

Path(Vec<CompiledExpr>)

Path expression (evaluates to a list).

Parameter(String)

Query parameter reference, resolved from the environment at runtime.

SessionVariable(String)

Session variable reference, resolved from the environment at runtime.

Fallback(Expression)

Everything that requires the full runtime context — evaluated per row through the original interpreter with a BorrowedRowContext.

Implementations

impl CompiledExpr

pub fn compile(expression: &Expression, layout: &SlotLayout) -> Self

Compile an expression tree against a slot layout.

Variable references resolve to slot IDs, var.prop accesses to their compound slots, function references to the global registry, and constant subtrees are folded inline. Any node that needs the runtime context stays as CompiledExpr::Fallback.

pub fn evaluate( &self, row: &[Value], layout: Arc<SlotLayout>, env: Option<&EvalEnv>, ) -> Result<Value, ExpressionError>

Evaluate the compiled expression against a single row.

layout and env are only used by fallback nodes that delegate to the scalar interpreter; the compiled nodes read the row slice directly.

pub fn evaluate_batch( &self, rows: &[Vec<Value>], layout: Arc<SlotLayout>, env: Option<&EvalEnv>, typed_columns: Option<&[TypedColumn]>, ) -> Result<ColumnarValue, ExpressionError>

Batch-evaluate the compiled expression over every row of a chunk.

The columnar entry point: constants are never materialized into columns, binary/unary operators run elementwise over the produced columns, and fallback nodes delegate per row to the scalar interpreter.

typed_columns is an optional zero-clone read path for slot leaves: when present, Slot/CompoundSlot nodes materialize their column from the typed layout instead of cloning per-row values out of rows. Non-slot subtrees still evaluate over rows, so mixed expressions keep exact semantics while their slot leaves skip the per-row clone.

Trait Implementations

impl Clone for CompiledExpr

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 CompiledExpr

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

Formats the value using the given formatter.