Struct ReaderSnapshot 

pub struct ReaderSnapshot {
    pub frozen: Arc<FrozenOverlay>,
    pub base: Option<Arc<MappedBase>>,
    pub deltas: Vec<Arc<CommitDelta>>,
    pub version: u64,
    /* private fields */
}

Lock-free reader snapshot: frozen overlay + optional V8 base + pending delta tail.

Obtained cheaply via crate::SharedDb::reader, which acquires the read lock only long enough to clone the Arc fields. Subsequent query operations run without any lock.

Memory bound: holds at most FOLD_EVERY_K − 1 CommitDelta Arcs in its delta tail; the fold that resets the tail runs synchronously on the write path.

Fields

frozen: Arc<FrozenOverlay>

Most-recent fold of the overlay state.

base: Option<Arc<MappedBase>>

Shared mmap base (zero-copy, Arc-ref-counted). None for legacy stores.

deltas: Vec<Arc<CommitDelta>>

Commits since the last fold, in arrival order. Length ≤ FOLD_EVERY_K − 1.

version: u64

The store’s commit_seq when this snapshot was taken — the version key for the shared role-mask memo. The effective state (frozen + deltas) is exactly the state the live handle had at this commit.

Implementations

impl ReaderSnapshot

pub fn mask_for_role(&self, role: &str) -> Result<NodeMask>

Resolve a role name to a node visibility mask.

Coherent with Self::query_masked: both read from the same effective state (frozen or cached materialization), so the mask is never stale relative to the query data.

Memoised per (role, version) in the cache shared with the originating GraphDb, so a scoped reader taking snapshot after snapshot between two writes resolves the role once.

pub fn mask_for_namespace(&self, namespace: &str) -> Result<NodeMask>

Every live node in namespace, as a visibility mask.

The snapshot-reader twin of GraphDb::mask_for_namespace: read off the effective state’s own ns column rather than a derived array, exactly as the namespace leg of Self::mask_for_role is. A name no node uses gives an empty mask — a namespace scope never widens.

pub fn resolve_key(&self, key: &str) -> Option<u32>

Resolve a node key to its dense id.

Checks the delta tail (via the cached materialization) so that nodes inserted since the last fold are visible.

pub fn query( &self, cypher: &str, params: &BTreeMap<String, Value>, ) -> Result<ResultSet>

Execute a read-only Cypher query over the epoch snapshot.

pub fn query_masked( &self, cypher: &str, params: &BTreeMap<String, Value>, mask: &NodeMask, ) -> Result<ResultSet>

Execute a read-only Cypher query with a node visibility mask.

Returns Err when cypher is a write statement (CREATE / MATCH…SET / DELETE).

pub fn node_info(&self, key: &str) -> Option<NodeInfo>

Live node info from the epoch snapshot. None if key is absent or tombstoned.

pub fn node_edges(&self, key: &str) -> Result<Vec<EdgeInfo>>

Every directed edge incident on key. derived is always false since the reader snapshot has no rule engine.

Unknown key → Err(GraphError::KeyNotFound).

pub fn neighborhood_masked( &self, key: &str, depth: u32, edge_types: Option<&[&str]>, dir: Dir, mask: &NodeMask, ) -> Option<ResultSet>

BFS neighborhood expansion restricted to mask-visible nodes.

Hidden nodes are neither returned nor used as traversal intermediaries (never-leak invariant). Returns None when key does not exist.