Struct GraphExecutionContext 

pub struct GraphExecutionContext { /* private fields */ }

Shared context for graph operators.

Provides access to graph-specific resources needed during query execution:

• CSR adjacency cache for fast neighbor lookups
• L0 buffers for MVCC visibility of uncommitted changes
• Property manager for lazy-loading vertex/edge properties
• Storage manager for schema and dataset access

Example

let ctx = GraphExecutionContext::new(
    storage_manager,
    l0_buffer,
    property_manager,
);

// Get neighbors with L0 overlay
let neighbors = ctx.get_neighbors(vid, edge_type_id, Direction::Outgoing);

Implementations

impl GraphExecutionContext

pub fn new( storage: Arc<StorageManager>, l0: Arc<RwLock<L0Buffer>>, property_manager: Arc<PropertyManager>, ) -> Self

Create a new graph execution context.

Arguments

• storage - Storage manager for schema and dataset access
• l0 - Current L0 buffer for MVCC visibility
• property_manager - Manager for lazy property loading

pub fn with_l0_context( storage: Arc<StorageManager>, l0_context: L0Context, property_manager: Arc<PropertyManager>, ) -> Self

Create context with full L0 visibility.

Arguments

• storage - Storage manager for schema and dataset access
• l0_context - L0 visibility context with all buffers
• property_manager - Manager for lazy property loading

pub fn from_query_context( storage: Arc<StorageManager>, query_ctx: &QueryContext, property_manager: Arc<PropertyManager>, ) -> Self

Create context from a query context.

pub fn with_deadline(self, deadline: Instant) -> Self

Set query timeout deadline.

pub fn with_algo_registry(self, registry: Arc<AlgorithmRegistry>) -> Self

Set the algorithm registry for uni.algo.* procedure dispatch.

pub fn algo_registry(&self) -> Option<&Arc<AlgorithmRegistry>>

Get a reference to the algorithm registry, if set.

pub fn with_procedure_registry(self, registry: Arc<ProcedureRegistry>) -> Self

Set the external procedure registry for test/user-defined procedures.

pub fn with_xervo_runtime(self, runtime: Arc<ModelRuntime>) -> Self

Set Uni-Xervo runtime for query-time auto-embedding.

pub fn procedure_registry(&self) -> Option<&Arc<ProcedureRegistry>>

Get a reference to the procedure registry, if set.

pub fn xervo_runtime(&self) -> Option<&Arc<ModelRuntime>>

pub fn push_warning(&self, warning: QueryWarning)

Record a runtime warning.

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

Take all collected warnings, leaving the collector empty.

pub fn check_timeout(&self) -> Result<()>

Check if the query has timed out.

Errors

Returns an error if the deadline has passed.

pub fn storage(&self) -> &Arc<StorageManager>

Get a reference to the storage manager.

pub fn adjacency_manager(&self) -> Arc<AdjacencyManager>

Get a reference to the adjacency manager.

pub fn property_manager(&self) -> &Arc<PropertyManager>

Get a reference to the property manager.

pub fn l0_context(&self) -> &L0Context

Get a reference to the L0 context.

pub fn query_context(&self) -> QueryContext

Create a query context for property manager calls.

If there is no current L0 buffer (e.g., for snapshot queries), creates an empty one.

pub async fn ensure_adjacency_warmed( &self, edge_type_ids: &[u32], direction: Direction, ) -> Result<()>

Ensure adjacency CSRs are warmed for the given edge types and direction.

This loads any missing CSR data from storage into the adjacency manager so that subsequent get_neighbors calls return complete results. Skips warming if the adjacency manager already has data (Main CSR or active overlay) for the edge type, avoiding duplicate entries.

pub fn warming_future( self: &Arc<Self>, edge_type_ids: Vec<u32>, direction: Direction, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>>

Create a boxed warming future for use in DataFusion stream state machines.

Wraps ensure_adjacency_warmed into a Pin<Box<dyn Future<Output = DFResult<()>> + Send>> suitable for polling in stream poll_next implementations.

pub fn get_neighbors( &self, vid: Vid, edge_type: u32, direction: Direction, ) -> Vec<(Vid, Eid)>

Get neighbors for a vertex, merging CSR and all L0 buffers.

This implements the MVCC visibility rules:

1. Load from CSR (L2 + L1 merged, auto-warms on cache miss)
2. Overlay pending flush L0s (oldest to newest)
3. Overlay current L0
4. Overlay transaction L0 (if present)
5. Filter tombstones (handled by overlay)

Arguments

• vid - Source vertex ID
• edge_type - Edge type ID to traverse
• direction - Traversal direction (Outgoing, Incoming, or Both)

Returns

Vector of (neighbor VID, edge ID) pairs.

pub fn get_neighbors_batch( &self, vids: &[Vid], edge_type: u32, direction: Direction, ) -> Vec<(Vid, Vid, Eid)>

Get neighbors for multiple vertices in batch.

More efficient than calling get_neighbors repeatedly as it amortizes lock acquisition for L0 buffers.

Arguments

• vids - Source vertex IDs
• edge_type - Edge type ID to traverse
• direction - Traversal direction

Returns

Vector of (source VID, neighbor VID, edge ID) triples.

Trait Implementations

impl Debug for GraphExecutionContext

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

Formats the value using the given formatter.