Struct Executor 

pub struct Executor { /* private fields */ }

Query executor: runs logical plans against a Uni storage backend.

Executor bridges the logical query plan produced by crate::query::planner::QueryPlanner with the underlying StorageManager. It handles both read-only sessions and write-enabled sessions (via Writer and L0Manager).

Cloning

Executor is cheaply cloneable — all expensive state is held behind Arcs. Clone it freely to share across tasks.

Note on Clone semantics: the derived Clone would alias the warnings Arc<Mutex<…>>, making warnings collected on the clone bleed into the original. A clone is intended to be a “fresh executor borrowing shared state,” so the manual impl below installs a fresh warnings accumulator. All other Arc-shared state is intentionally shared (caches, registries, runtimes).

Implementations

impl Executor

pub fn new(storage: Arc<StorageManager>) -> Self

Create a read-only executor backed by the given storage manager.

pub fn set_prop_manager(&mut self, pm: Arc<PropertyManager>)

Install a shared PropertyManager so the planner can reuse it instead of constructing a fresh one per query.

Reusing the caller’s Arc<PropertyManager> skips the LRU cache allocation cost (~80 µs/query in the InMemory backend).

pub fn set_df_session_template(&mut self, tmpl: Arc<SessionContext>)

Install a pre-built SessionContext template with Cypher UDFs already registered, so the planner can clone it (O(1)) instead of rebuilding.

When custom UDFs are also installed, the template is bypassed and a fresh SessionContext is built for that query (preserves UDF isolation across executors).

pub fn new_with_writer( storage: Arc<StorageManager>, writer: Arc<Writer>, ) -> Self

Create a write-enabled executor with an attached Writer.

pub fn set_procedure_registry(&mut self, registry: Arc<ProcedureRegistry>)

Attach an external procedure registry for user-defined procedures.

pub fn set_xervo_runtime(&mut self, runtime: Option<Arc<ModelRuntime>>)

Attach or detach the Uni-Xervo model runtime for vector auto-embedding.

pub fn set_file_sandbox(&mut self, sandbox: FileSandboxConfig)

Set the file sandbox configuration for BACKUP/COPY/EXPORT commands. MUST be called with sandboxed config in server mode.

pub fn set_config(&mut self, config: UniConfig)

Apply a runtime configuration to this executor.

pub fn set_writer(&mut self, writer: Arc<Writer>)

Attach a Writer after construction, enabling write operations.

pub fn take_warnings(&self) -> Vec<QueryWarning>

Take all collected warnings from the last execution, leaving the collector empty.

pub fn set_use_transaction(&mut self, use_transaction: bool)

Configure whether query execution should operate within a transaction context.

pub fn set_transaction_l0(&mut self, l0: Arc<RwLock<L0Buffer>>)

Set a private transaction L0 buffer for both read visibility (QueryContext) and mutation routing.

pub fn set_read_snapshot(&mut self, snapshot: Option<SnapshotView>)

Attach a pinned L0 snapshot for snapshot-isolated reads (Component C1).

When Some, get_context reads from the frozen view instead of the live L0. A None is a no-op (live reads), so threading it is always safe — callers that do not pin a snapshot leave it None.

pub fn set_id_reservoir(&mut self, r: Arc<TxIdReservoir>)

Attach a per-transaction VID/EID reservoir. When set, CREATE/MERGE paths in execute_create_pattern pull IDs from the reservoir’s pre-reserved cache, amortizing the global IdAllocator mutex.

pub fn set_custom_functions(&mut self, registry: Arc<CustomFunctionRegistry>)

Attach a custom scalar function registry for user-defined functions.

pub fn set_cancellation_token(&mut self, token: CancellationToken)

Set a cooperative cancellation token for in-flight query cancellation.

impl Executor

pub async fn profile( &self, plan: LogicalPlan, params: &HashMap<String, Value>, ) -> Result<(Vec<HashMap<String, Value>>, ProfileOutput)>

Profiles query execution and returns results with per-operator timing statistics extracted from the DataFusion physical plan tree.

impl Executor

pub async fn create_datafusion_planner( &self, prop_manager: &PropertyManager, params: &HashMap<String, Value>, ) -> Result<(Arc<SyncRwLock<SessionContext>>, HybridPhysicalPlanner, Arc<PropertyManager>)>

Create L0 context, session, and planner for DataFusion execution.

This is the shared setup for execute_datafusion and execute_merge_read_plan. Returns (session_ctx, planner, prop_manager_arc).

pub fn collect_batches( session_ctx: &Arc<SyncRwLock<SessionContext>>, execution_plan: Arc<dyn ExecutionPlan>, ) -> BoxFuture<'_, Result<Vec<RecordBatch>>>

Execute a DataFusion physical plan and collect all result batches.

pub async fn execute_datafusion( &self, plan: LogicalPlan, prop_manager: &PropertyManager, params: &HashMap<String, Value>, ) -> Result<Vec<RecordBatch>>

Executes a query using the DataFusion-based engine.

Uses HybridPhysicalPlanner which produces DataFusion ExecutionPlan trees with custom graph operators for graph-specific operations.

pub async fn execute_datafusion_with_plan( &self, plan: LogicalPlan, prop_manager: &PropertyManager, params: &HashMap<String, Value>, ) -> Result<(Vec<RecordBatch>, Arc<dyn ExecutionPlan>)>

Executes a query using the DataFusion-based engine, returning both result batches and the physical execution plan.

The returned Arc<dyn ExecutionPlan> can be walked to extract per-operator metrics (e.g., output_rows, elapsed_compute) that DataFusion’s BaselineMetrics recorded during execution.

pub fn execute<'a>( &'a self, plan: LogicalPlan, prop_manager: &'a PropertyManager, params: &'a HashMap<String, Value>, ) -> BoxFuture<'a, Result<Vec<HashMap<String, Value>>>>

pub fn execute_stream( self, plan: LogicalPlan, prop_manager: Arc<PropertyManager>, params: HashMap<String, Value>, ) -> BoxStream<'static, Result<Vec<HashMap<String, Value>>>>

Executes a query as a stream of result batches.

Routes DDL/Admin through the fallback executor and everything else through DataFusion.

Trait Implementations

impl Clone for Executor

fn clone(&self) -> Self

Clone an Executor, sharing all Arc-backed state but installing a fresh warnings accumulator. Warnings are query-scoped; aliasing the Mutex across clones would let one query’s warnings spill into another.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Executor

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

Formats the value using the given formatter.