Struct L0Buffer 

pub struct L0Buffer {

    pub graph: SimpleGraph,
    pub tombstones: HashMap<Eid, TombstoneEntry>,
    pub vertex_tombstones: HashSet<Vid>,
    pub edge_versions: HashMap<Eid, u64>,
    pub vertex_versions: HashMap<Vid, u64>,
    pub edge_properties: HashMap<Eid, Properties>,
    pub vertex_properties: HashMap<Vid, Properties>,
    pub edge_endpoints: HashMap<Eid, (Vid, Vid, u32)>,
    pub vertex_labels: HashMap<Vid, Vec<String>>,
    pub edge_types: HashMap<Eid, String>,
    pub current_version: u64,
    pub mutation_count: usize,
    pub wal: Option<Arc<WriteAheadLog>>,
    pub wal_lsn_at_flush: u64,
    pub vertex_created_at: HashMap<Vid, i64>,
    pub vertex_updated_at: HashMap<Vid, i64>,
    pub edge_created_at: HashMap<Eid, i64>,
    pub edge_updated_at: HashMap<Eid, i64>,
    pub estimated_size: usize,
    pub constraint_index: HashMap<Vec<u8>, Vid>,
}

Fields

graph: SimpleGraph

Graph topology using simple adjacency lists

tombstones: HashMap<Eid, TombstoneEntry>

Soft-deleted edges (tombstones for LSM-style merging)

vertex_tombstones: HashSet<Vid>

Soft-deleted vertices

edge_versions: HashMap<Eid, u64>

Edge version tracking for MVCC

vertex_versions: HashMap<Vid, u64>

Vertex version tracking for MVCC

edge_properties: HashMap<Eid, Properties>

Edge properties (stored separately from topology)

vertex_properties: HashMap<Vid, Properties>

Vertex properties (stored separately from topology)

edge_endpoints: HashMap<Eid, (Vid, Vid, u32)>

Edge endpoint lookup: eid -> (src, dst, type)

vertex_labels: HashMap<Vid, Vec<String>>

Vertex labels (VID -> list of label names) New in storage design: vertices can have multiple labels

edge_types: HashMap<Eid, String>

Edge types (EID -> type name)

current_version: u64

Current version counter

mutation_count: usize

Mutation count for flush decisions

wal: Option<Arc<WriteAheadLog>>

Write-ahead log for durability

wal_lsn_at_flush: u64

WAL LSN at the time this L0 was rotated for flush. Used to ensure WAL truncation doesn’t remove entries needed by pending flushes.

vertex_created_at: HashMap<Vid, i64>

Vertex creation timestamps (nanoseconds since epoch)

vertex_updated_at: HashMap<Vid, i64>

Vertex update timestamps (nanoseconds since epoch)

edge_created_at: HashMap<Eid, i64>

Edge creation timestamps (nanoseconds since epoch)

edge_updated_at: HashMap<Eid, i64>

Edge update timestamps (nanoseconds since epoch)

estimated_size: usize

Estimated size in bytes for memory limit enforcement. Incremented O(1) on each mutation to avoid O(V+E) size_bytes() calls.

constraint_index: HashMap<Vec<u8>, Vid>

Per-constraint index for O(1) unique key checks. Key: constraint composite key (label + sorted property values serialized). Value: Vid that owns this key.

Implementations

impl L0Buffer

pub fn size_bytes(&self) -> usize

Returns an estimate of the buffer size in bytes. Includes all fields for accurate memory accounting.

pub fn new(start_version: u64, wal: Option<Arc<WriteAheadLog>>) -> Self

pub fn insert_vertex(&mut self, vid: Vid, properties: Properties)

pub fn insert_vertex_with_labels( &mut self, vid: Vid, properties: Properties, labels: &[String], )

Insert a vertex with associated labels.

pub fn add_vertex_labels(&mut self, vid: Vid, labels: &[String])

Add labels to an existing vertex.

pub fn remove_vertex_label(&mut self, vid: Vid, label: &str) -> bool

Remove a label from an existing vertex. Returns true if the label was found and removed, false otherwise.

pub fn set_edge_type(&mut self, eid: Eid, edge_type: String)

Set the type for an edge.

pub fn delete_vertex(&mut self, vid: Vid) -> Result<()>

pub fn insert_edge( &mut self, src_vid: Vid, dst_vid: Vid, edge_type: u32, eid: Eid, properties: Properties, edge_type_name: Option<String>, ) -> Result<()>

pub fn delete_edge( &mut self, eid: Eid, src_vid: Vid, dst_vid: Vid, edge_type: u32, ) -> Result<()>

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

Returns neighbors in the specified direction. O(degree) complexity - iterates only edges connected to the vertex.

pub fn is_tombstoned(&self, eid: Eid) -> bool

pub fn vids_for_label(&self, label_name: &str) -> Vec<Vid>

Returns all VIDs in vertex_labels that match the given label name. Used for L0 overlay during vertex scanning.

pub fn all_vertex_vids(&self) -> Vec<Vid>

Returns all vertex VIDs in the L0 buffer.

Used for schemaless scanning (MATCH (n) without label).

pub fn vids_for_labels(&self, label_names: &[&str]) -> Vec<Vid>

Returns all VIDs in vertex_labels that match any of the given label names. Used for L0 overlay during multi-label vertex scanning.

pub fn vids_with_all_labels(&self, label_names: &[&str]) -> Vec<Vid>

Returns all VIDs that have ALL specified labels.

pub fn get_vertex_labels(&self, vid: Vid) -> Option<&[String]>

Gets the labels for a VID.

pub fn get_edge_type(&self, eid: Eid) -> Option<&str>

Gets the edge type for an EID.

pub fn eids_for_type(&self, type_name: &str) -> Vec<Eid>

Returns all EIDs in edge_types that match the given type name. Used for L0 overlay during schemaless edge scanning.

pub fn all_edge_eids(&self) -> Vec<Eid>

Returns all edge EIDs in the L0 buffer (non-tombstoned).

Used for schemaless scanning (MATCH ()-[r]->()) without type.

pub fn get_edge_endpoints(&self, eid: Eid) -> Option<(Vid, Vid)>

Returns edge endpoint data (src_vid, dst_vid) for an EID.

pub fn get_edge_endpoint_full(&self, eid: Eid) -> Option<(Vid, Vid, u32)>

Returns full edge endpoint data (src_vid, dst_vid, edge_type_id) for an EID.

pub fn insert_constraint_key(&mut self, key: Vec<u8>, vid: Vid)

Insert a constraint key into the index for O(1) duplicate detection.

pub fn has_constraint_key(&self, key: &[u8], exclude_vid: Vid) -> bool

Check if a constraint key exists in the index, excluding a specific VID. Returns true if the key exists and is owned by a different vertex.

pub fn merge(&mut self, other: &L0Buffer) -> Result<()>

pub fn replay_mutations(&mut self, mutations: Vec<Mutation>) -> Result<()>

Replay mutations from WAL without re-logging them. Used during startup recovery to restore L0 state from persisted WAL. Uses CRDT merge semantics to ensure recovered state matches pre-crash state.

Trait Implementations

impl Debug for L0Buffer

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

Formats the value using the given formatter.