Struct CompiledEvaluator 

pub struct CompiledEvaluator<'a> { /* private fields */ }

Compiled expression evaluator using the Expression VM.

Deprecated

This type is deprecated. Use the new, more efficient alternatives:

• ExpressionEval - For single expression evaluation (most common case)
• RowFilter - For closure-based filtering (Send+Sync safe)
• JoinFilter - For join condition evaluation
• MultiExpressionEval - For SELECT projections (multiple expressions)

The new APIs pre-compile expressions eagerly rather than lazily, avoiding cache invalidation issues and providing better performance.

Migration Guide

Before (CompiledEvaluator):

let mut eval = CompiledEvaluator::new(&registry);
eval.init_columns(&columns);
for row in rows {
    eval.set_row_array(&row);
    let value = eval.evaluate(&expr)?;
}

After (ExpressionEval):

let mut eval = ExpressionEval::compile(&expr, &columns)?;
for row in rows {
    let value = eval.eval(&row)?;
}

When to use CompiledEvaluator vs new APIs

Use the new APIs (recommended for most cases):

• ExpressionEval - Single expression with static schema
• RowFilter - WHERE clause filtering (thread-safe)
• MultiExpressionEval - SELECT projections (multiple expressions)

Use CompiledEvaluator when:

• Expressions change per-row (e.g., after process_correlated_expression)
• You need dynamic/lazy expression compilation
• Complex scenarios with correlated subqueries

Implementations

impl<'a> CompiledEvaluator<'a>

pub fn new(function_registry: &'a FunctionRegistry) -> Self

Create a new compiled evaluator with a function registry reference

pub fn with_defaults() -> CompiledEvaluator<'static>

Create an evaluator using the global function registry.

pub fn clear(&mut self)

Clear all state for reuse.

pub fn set_transaction_id(&mut self, txn_id: u64)

Set the current transaction ID

pub fn with_params(self, params: ParamVec) -> Self

Set query parameters (positional) - fluent API

pub fn with_named_params(self, named_params: FxHashMap<String, Value>) -> Self

Set named query parameters - fluent API

pub fn with_context(self, ctx: &ExecutionContext) -> Self

Set parameters from execution context - fluent API

PERF: Both params and named_params share the Arc - zero cloning.

pub fn with_row(self, row: Row, columns: &[String]) -> Self

Bind an owned row and its column names for fluent evaluation.

pub fn init_columns(&mut self, columns: &[String])

Initialize the column index mapping (call once before set_row_array)

Repeated semantic schemas avoid cloning; pointer identity is never used because allocator reuse is not a schema identity.

pub fn init_columns_arc(&mut self, columns: CompactArc<Vec<String>>)

Initialize columns from an Arc (zero-copy when schema already has Arc)

This is the preferred method when the caller already has a CompactArc<Vec<String>>, such as from Schema::column_names_arc(). It avoids all string cloning.

pub fn add_aggregate_aliases(&mut self, aliases: &[(String, usize)])

Add aggregate expression aliases for HAVING clause evaluation

pub fn add_expression_aliases(&mut self, aliases: &[(String, usize)])

Add expression aliases for HAVING clause with GROUP BY expressions

pub fn set_row_array(&mut self, row: &Row)

Set the row using array-based access (optimized - no map rebuilding) Call init_columns() once before using this method.

pub fn set_outer_row( &mut self, outer_row: Option<&FxHashMap<CompactArc<str>, Value>>, )

Set the outer row context for correlated subqueries Accepts CompactArc<str> keys directly to avoid conversion overhead.

pub fn set_outer_row_owned( &mut self, outer_row: FxHashMap<CompactArc<str>, Value>, )

Set the outer row context by taking ownership Accepts CompactArc<str> keys directly to avoid conversion overhead.

pub fn take_outer_row(&mut self) -> FxHashMap<CompactArc<str>, Value>

Take ownership of the outer row back (for reuse) Returns CompactArc<str> keys directly to avoid conversion overhead.

pub fn clear_outer_row(&mut self)

Clear the outer row context

pub fn evaluate(&mut self, expr: &Expression) -> Result<Value>

Evaluate an expression to a Value

pub fn evaluate_bool(&mut self, expr: &Expression) -> Result<bool>

Evaluate an expression as a boolean (for WHERE/HAVING clauses)

Returns false for NULL results (SQL three-valued logic).

Trait Implementations

impl Default for CompiledEvaluator<'static>

fn default() -> Self

Returns the “default value” for a type.