Struct Writer 

pub struct Writer {
    pub l0_manager: Arc<L0Manager>,
    pub storage: Arc<StorageManager>,
    pub schema_manager: Arc<SchemaManager>,
    pub allocator: Arc<IdAllocator>,
    pub config: UniConfig,
    pub xervo_runtime: Option<Arc<ModelRuntime>>,
    pub transaction_l0: Option<Arc<RwLock<L0Buffer>>>,
    pub property_manager: Option<Arc<PropertyManager>>,
    /* private fields */
}

Fields

l0_manager: Arc<L0Manager>

storage: Arc<StorageManager>

schema_manager: Arc<SchemaManager>

allocator: Arc<IdAllocator>

config: UniConfig

xervo_runtime: Option<Arc<ModelRuntime>>

transaction_l0: Option<Arc<RwLock<L0Buffer>>>

property_manager: Option<Arc<PropertyManager>>

Property manager for cache invalidation after flush

Implementations

impl Writer

pub async fn new( storage: Arc<StorageManager>, schema_manager: Arc<SchemaManager>, start_version: u64, ) -> Result<Self>

pub async fn new_with_config( storage: Arc<StorageManager>, schema_manager: Arc<SchemaManager>, start_version: u64, config: UniConfig, wal: Option<Arc<WriteAheadLog>>, allocator: Option<Arc<IdAllocator>>, ) -> Result<Self>

pub async fn replay_wal(&self, wal_high_water_mark: u64) -> Result<usize>

Replay WAL mutations into the current L0 buffer.

pub async fn next_vid(&self) -> Result<Vid>

Allocates the next VID (pure auto-increment).

pub async fn allocate_vids(&self, count: usize) -> Result<Vec<Vid>>

Allocates multiple VIDs at once for bulk operations. This is more efficient than calling next_vid() in a loop.

pub async fn next_eid(&self, _type_id: u32) -> Result<Eid>

Allocates the next EID (pure auto-increment).

pub fn set_xervo_runtime(&mut self, runtime: Arc<ModelRuntime>)

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

pub fn begin_transaction(&mut self) -> Result<()>

pub async fn commit_transaction(&mut self) -> Result<()>

pub async fn flush_wal(&self) -> Result<()>

Flush the WAL buffer to durable storage.

pub fn rollback_transaction(&mut self) -> Result<()>

pub fn force_rollback(&mut self)

Force-rollback any active transaction. Safe to call if no transaction active. Used by Transaction::Drop for cleanup.

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

Get vertex labels from all sources: current L0, pending L0s, and storage. This is the proper way to read vertex labels after a flush, as it checks both in-memory buffers and persisted storage.

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

Look up the edge type ID (u32) for an EID from the L0 buffer’s edge endpoints. Falls back to the transaction L0 if available.

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

Set the type name for an edge (used for schemaless edge types). This is called during CREATE for edge types not found in the schema.

pub async fn insert_vertex( &mut self, vid: Vid, properties: Properties, ) -> Result<()>

pub async fn insert_vertex_with_labels( &mut self, vid: Vid, properties: Properties, labels: &[String], ) -> Result<Properties>

pub async fn insert_vertices_batch( &mut self, vids: Vec<Vid>, properties_batch: Vec<Properties>, labels: Vec<String>, ) -> Result<Vec<Properties>>

Insert multiple vertices with batched operations.

This method uses batched operations to achieve O(N) complexity instead of O(N²) for bulk inserts with unique constraints.

Performance Improvements

• Batch VID allocation: 1 call instead of N calls
• Batch constraint validation: O(N) instead of O(N²)
• Batch embedding generation: 1 API call per config instead of N calls
• Transaction wrapping: Automatic flush deferral, atomicity

Arguments

• vids - Pre-allocated VIDs for the vertices
• properties_batch - Properties for each vertex
• labels - Labels for all vertices (assumes single label for simplicity)

Errors

Returns error if:

• VID/properties length mismatch
• Constraint violation detected
• Embedding generation fails
• Transaction commit fails

Atomicity

If this method fails, all changes are rolled back (if transaction was started here).

pub async fn delete_vertex( &mut self, vid: Vid, labels: Option<Vec<String>>, ) -> Result<()>

Delete a vertex by VID.

When labels is provided, uses them directly to populate L0 for correct tombstone flushing. Otherwise discovers labels from L0 buffers and storage (which can be slow for many vertices).

Errors

Returns an error if write pressure stalls, label lookup fails, or the L0 delete operation fails.

pub async 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 async fn delete_edge( &mut self, eid: Eid, src_vid: Vid, dst_vid: Vid, edge_type: u32, ) -> Result<()>

pub async fn check_flush(&mut self) -> Result<()>

Check if flush should be triggered based on mutation count or time elapsed. This method is called after each write operation and can also be called by a background task for time-based flushing.

pub async fn flush_to_l1(&mut self, name: Option<String>) -> Result<String>

Flushes the current in-memory L0 buffer to L1 storage.

Lock Ordering

To prevent deadlocks, locks must be acquired in the following order:

1. Writer lock (held by caller)
2. L0Manager lock (via begin_flush / get_current)
3. L0Buffer lock (individual buffer RWLocks)
4. Index / Storage locks (during actual flush)

pub fn set_property_manager(&mut self, pm: Arc<PropertyManager>)

Set the property manager for cache invalidation.