Struct BorrowedRowContext 

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

A light-weight expression context that borrows the row data instead of cloning it. Use this in hot paths (e.g. Filter) where the expression only reads from the row and does not take ownership.

Individual values returned by get_variable are still cloned (that is inherent in the ExpressionContext trait), but the Vec<Value> wrapper itself is not — saving one allocation per row.

Implementations

impl<'a> BorrowedRowContext<'a>

pub fn new(row: &'a [Value], layout: Arc<SlotLayout>) -> Self

pub fn with_parameters( row: &'a [Value], layout: Arc<SlotLayout>, parameters: Arc<HashMap<String, Value>>, ) -> Self

Create with parameter values for @name resolution.

pub fn with_env( row: &'a [Value], layout: Arc<SlotLayout>, env: &EvalEnv, ) -> Self

Create from a full evaluation environment (parameters + subquery executor).

pub fn set_row(&mut self, row: &'a [Value])

Update the row reference and clear per-row variables.

Call this in a hot loop to reuse the same context across many rows, avoiding repeated Arc::clone on the slot layout.

Trait Implementations

impl ExpressionContext for BorrowedRowContext<'_>

fn get_variable(&self, name: &str) -> Option<Value>

Obtain the value of the variable

fn get_variable_by_slot(&self, slot: SlotId) -> Option<Value>

Obtain the value of a variable by slot ID (fast path). Default implementation falls back to name-based lookup.

fn set_variable(&mut self, name: String, value: Value)

Setting variable values

fn get_parameter(&self, name: &str) -> Option<Value>

Obtain the value of a query parameter (@name). Default implementation returns None — contexts without parameter support simply ignore parameter references.

fn get_session_variable(&self, name: &str) -> Result<Value, ExpressionError>

Obtain the value of a session variable ($name).

fn get_sequence_manager(&self) -> Option<Arc<SequenceManager>>

Obtain the sequence catalog manager for curr_val / next_val. Default implementation returns None — contexts without sequence support report the functions’ missing-context error.

fn execute_exists( &mut self, body: &SubqueryBody, ) -> Result<bool, ExpressionError>

EXISTS semantics: whether the subquery produces at least one row.

fn execute_scalar_subquery( &mut self, body: &SubqueryBody, ) -> Result<Value, ExpressionError>

Scalar-subquery semantics: the first result value, or NULL when the subquery returns no rows. Streaming contexts override this to dispatch through the hosting operator’s subquery executor.

fn contains_subquery( &mut self, body: &SubqueryBody, value: &Value, ) -> Result<Value, ExpressionError>

IN semantics: whether value occurs in the subquery result.

fn get_function(&self, name: &str) -> Option<OwnedFunctionRef>

Obtain a function reference

fn get_graph_storage(&self) -> Option<GraphStorageRef>

Obtain the graph storage accessor for graph algorithm functions

fn supports_cache(&self) -> bool

Check whether the context supports caching.

fn get_cache(&mut self) -> Option<&mut ()>

Obtain the cache manager (if available).

fn execute_subquery( &mut self, body: &SubqueryBody, ) -> Result<Vec<Value>, ExpressionError>

Execute a subquery body and return the result values.

fn evaluate_label(&self, label: &str) -> Result<Value, ExpressionError>

Evaluate a :Label expression against the current row binding.

fn evaluate_list_comprehension( &mut self, variable: &str, source: &Expression, filter: Option<&Expression>, map: Option<&Expression>, ) -> Result<Value, ExpressionError>

where Self: Sized,

Evaluate a list comprehension [variable IN source WHERE filter | map].

fn evaluate_label_tag_property( &mut self, tag: &Expression, property: &str, ) -> Result<Value, ExpressionError>

where Self: Sized,

Evaluate a dynamic tag-property access tag.property where tag is itself an expression.

fn evaluate_predicate( &mut self, func: &str, args: &[Expression], ) -> Result<Value, ExpressionError>

where Self: Sized,

Evaluate a predicate expression func(variable IN list WHERE predicate) with func in {ALL, ANY, SINGLE, NONE}.

fn evaluate_reduce( &mut self, accumulator: &str, initial: &Expression, variable: &str, source: &Expression, mapping: &Expression, ) -> Result<Value, ExpressionError>

where Self: Sized,

Evaluate a REDUCE expression reduce(acc = initial, variable IN source | mapping).

fn evaluate_path_build( &mut self, items: &[Expression], ) -> Result<Value, ExpressionError>

where Self: Sized,

Evaluate a path construction expression path(v1, e1, v2, e2, v3).