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_writer(self, writer: Arc<Writer>) -> Self

Attach the outer transaction’s writer handle so declared WRITE-mode procedures invoked through this context can run their Cypher bodies via the write-enabled inner-query host.

pub fn writer(&self) -> Option<&Arc<Writer>>

Borrow the outer transaction’s writer handle, if any.

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 with_plugin_registry(self, registry: Arc<PluginRegistry>) -> Self

Attach the plugin registry. Required by the M5h.2 native-label plugin-storage routing in columnar_scan_vertex_batch_static.

pub fn plugin_registry(&self) -> Option<&Arc<PluginRegistry>>

Reference to the plugin 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 deadline_for_host(&self) -> Option<Instant>

Wall-clock deadline for the surrounding query, if any.

Internal accessor used by crate::query::executor::procedure_host::QueryProcedureHost to snapshot the deadline so procedure plugins can implement check_timeout without holding a borrow on this context.

pub fn cancellation_token_for_host(&self) -> Option<CancellationToken>

Cancellation token clone for the surrounding query, if any.

Internal accessor for crate::query::executor::procedure_host::QueryProcedureHost; see Self::deadline_for_host.

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.

pub fn resolve_stored_edge_endpoints( &self, eid: Eid, traversal_src: Vid, traversal_dst: Vid, edge_type_ids: &[u32], ) -> (u64, u64)

Resolve an edge’s STORED (src, dst) orientation given a traversed hop.

A relationship in a path must report its stored (start -> end) direction even when the path traversed it backward (undirected -[r]- or incoming <-[r]-). This first consults the L0 visibility chain (exact for in-memory edges); if the edge has been flushed to durable storage and is no longer L0-resident, it recovers the orientation with a bounded directed-outgoing adjacency probe: the edge is stored (traversal_src -> traversal_dst) iff eid appears among traversal_src’s outgoing neighbours for one of edge_type_ids, otherwise it is the reverse. Falls back to the traversal order only when the probe is inconclusive (e.g. the type carries no CSR adjacency).

The probe costs at most the out-degree of one vertex per candidate edge type — never a full edge scan — and reads the adjacency manager directly, so it does not perturb the SSI read-set.

Examples

let (src, dst) =
    ctx.resolve_stored_edge_endpoints(eid, node_path[i], node_path[i + 1], &edge_type_ids);

Trait Implementations

impl Debug for GraphExecutionContext

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

Formats the value using the given formatter.