Struct AdjacencyBatchAccessor 

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

Reusable-buffer batch accessor for adjacency reads.

Traversal and batch queries use the accessor with a caller-provided buffer so peak memory stays proportional to the batch size instead of the row degree. The buffer is valid only for the snapshot timestamp the accessor was created with and must not be held across snapshots. Visibility still goes through the version authority; no second decision source exists.

Implementations

impl<'a> AdjacencyBatchAccessor<'a>

pub fn new( table: &'a EdgeStore, outgoing: bool, ts: u64, ) -> AdjacencyBatchAccessor<'a>

pub fn fill_into(&self, src: u32, out: &mut Vec<Nbr>)

Fill a caller buffer with every visible neighbor of one row.

Clears the buffer first and never allocates internally beyond the buffer growth the caller owns. Missing legs fill nothing.

pub fn fill_limited(&self, src: u32, out: &mut Vec<Nbr>, limit: usize)

Fill a caller buffer with the first limit visible neighbors.

Stops the physical visit after limit hits so high-degree LIMIT queries never decode the full adjacency. Missing legs fill nothing.

pub fn visit_batched<F>( &self, src: u32, scratch: &mut Vec<Nbr>, batch_size: usize, f: F, )

where F: FnMut(&[Nbr]) -> bool,

Visit visible neighbors in fixed-size batches reusing one caller buffer. The callback receives each full batch slice and returns false to stop early. Peak memory stays proportional to batch_size. A zero batch_size selects the default adjacency batch.

pub fn lookup(&self, src: u32, dst: u32, rank: i64) -> Option<Nbr>

Point lookup through the shared merged row-location logic.

pub fn fill_many_into( &self, srcs: &[u32], out: &mut Vec<Nbr>, scratch: &mut Vec<Nbr>, )

Fill a caller buffer with the visible neighbors of many rows.

Multi-row fan-out sharing one staging buffer: each row stages into scratch (reused across rows, never reallocated per row) and the survivors append to out in row order. Missing legs contribute nothing. Topology only; properties still decode on demand.

pub fn fill_many_with_values_into( &self, srcs: &[u32], out: &mut Vec<(Nbr, Option<u64>)>, scratch: &mut Vec<(Nbr, Option<u64>)>, )

Fill a caller buffer with the visible neighbors of many rows paired with inline values (None for NULL slots and non-bundled forms).

Paired counterpart of Self::fill_many_into and the default batch read for bundled tables: one paired walk per row instead of a topology walk plus one value lookup per edge. Missing legs contribute nothing; visibility goes through the version authority alone.