Struct LpgStore 

pub struct LpgStore { /* private fields */ }

The core in-memory graph storage.

Everything lives here: nodes, edges, properties, adjacency indexes, and version chains for MVCC. Concurrent reads never block each other.

Most users should go through GrafeoDB (from the grafeo_engine crate) which adds transaction management and query execution. Use LpgStore directly when you need raw performance for algorithm implementations.

Example

use grafeo_core::graph::lpg::LpgStore;
use grafeo_core::graph::Direction;

let store = LpgStore::new().expect("arena allocation");

// Create a small social network
let alix = store.create_node(&["Person"]);
let gus = store.create_node(&["Person"]);
store.create_edge(alix, gus, "KNOWS");

// Traverse outgoing edges
for neighbor in store.neighbors(alix, Direction::Outgoing) {
    println!("Alix knows node {:?}", neighbor);
}

Lock Ordering

LpgStore contains multiple RwLock fields that must be acquired in a consistent order to prevent deadlocks. Always acquire locks in this order:

Level 1 - Entity Storage (mutually exclusive via feature flag)

1. nodes / node_versions
2. edges / edge_versions

Level 2 - Catalogs (acquire as pairs when writing)

3. label_to_id + id_to_label
4. edge_type_to_id + id_to_edge_type

Level 3 - Indexes

5. label_index
6. node_labels
7. property_indexes

Level 4 - Statistics

8. statistics

Level 5 - Nested Locks (internal to other structs)

9. PropertyStorage::columns (via node_properties/edge_properties)
10. ChunkedAdjacency::lists (via forward_adj/backward_adj)

Rules

• Catalog pairs must be acquired together when writing.
• Never hold entity locks while acquiring catalog locks in a different scope.
• Statistics lock is always last.
• Read locks are generally safe, but avoid read-to-write upgrades.

Implementations

impl LpgStore

pub fn create_edge(&self, src: NodeId, dst: NodeId, edge_type: &str) -> EdgeId

Creates a new edge.

pub fn create_edge_with_props( &self, src: NodeId, dst: NodeId, edge_type: &str, properties: impl IntoIterator<Item = (impl Into<PropertyKey>, impl Into<Value>)>, ) -> EdgeId

Creates a new edge with properties.

pub fn get_edge(&self, id: EdgeId) -> Option<Edge>

Gets an edge by ID (latest visible version).

pub fn get_edge_at_epoch(&self, id: EdgeId, epoch: EpochId) -> Option<Edge>

Gets an edge by ID at a specific epoch.

pub fn get_edge_history( &self, id: EdgeId, ) -> Vec<(EpochId, Option<EpochId>, Edge)>

Returns all versions of an edge with their creation/deletion epochs, newest first.

Each entry is (created_epoch, deleted_epoch, Edge). Note that properties reflect the current state (they are not versioned per-epoch).

pub fn delete_edge(&self, id: EdgeId) -> bool

Deletes an edge (using latest epoch).

pub fn edge_count(&self) -> usize

Returns the number of edges (non-deleted at current epoch).

pub fn batch_create_edges( &self, edges: &[(NodeId, NodeId, &str)], ) -> Vec<EdgeId>

Creates multiple edges in batch, significantly faster than calling create_edge() in a loop.

Each tuple is (src, dst, edge_type). Returns the assigned EdgeIds in the same order. Acquires the adjacency write lock once for all edges, rather than once per edge.

pub fn edge_type(&self, id: EdgeId) -> Option<ArcStr>

Gets the type of an edge by ID.

impl LpgStore

pub fn create_property_index(&self, property: &str)

Creates an index on a node property for O(1) lookups by value.

After creating an index, calls to Self::find_nodes_by_property will be O(1) instead of O(n) for this property. The index is automatically maintained when properties are set or removed.

Example

use grafeo_core::graph::lpg::LpgStore;
use grafeo_common::types::Value;

let store = LpgStore::new().expect("arena allocation");

// Create nodes with an 'id' property
let alix = store.create_node(&["Person"]);
store.set_node_property(alix, "id", Value::from("alice_123"));

// Create an index on the 'id' property
store.create_property_index("id");

// Now lookups by 'id' are O(1)
let found = store.find_nodes_by_property("id", &Value::from("alice_123"));
assert!(found.contains(&alix));

pub fn drop_property_index(&self, property: &str) -> bool

Drops an index on a node property.

Returns true if the index existed and was removed.

pub fn has_property_index(&self, property: &str) -> bool

Returns true if the property has an index.

impl LpgStore

pub fn create_node(&self, labels: &[&str]) -> NodeId

Creates a new node with the given labels.

Uses the system transaction for non-transactional operations.

pub fn create_node_with_props( &self, labels: &[&str], properties: impl IntoIterator<Item = (impl Into<PropertyKey>, impl Into<Value>)>, ) -> NodeId

Creates a new node with labels and properties.

pub fn create_node_with_props_versioned( &self, labels: &[&str], properties: impl IntoIterator<Item = (impl Into<PropertyKey>, impl Into<Value>)>, epoch: EpochId, tx_id: TxId, ) -> NodeId

Creates a new node with labels and properties within a transaction context.

pub fn get_node(&self, id: NodeId) -> Option<Node>

Gets a node by ID (latest visible version).

pub fn get_node_at_epoch(&self, id: NodeId, epoch: EpochId) -> Option<Node>

Gets a node by ID at a specific epoch.

pub fn get_node_history( &self, id: NodeId, ) -> Vec<(EpochId, Option<EpochId>, Node)>

Returns all versions of a node with their creation/deletion epochs, newest first.

Each entry is (created_epoch, deleted_epoch, Node). Note that labels and properties reflect the current state (they are not versioned per-epoch).

pub fn delete_node(&self, id: NodeId) -> bool

Deletes a node and all its edges (using latest epoch).

pub fn delete_node_edges(&self, node_id: NodeId)

Deletes all edges connected to a node (implements DETACH DELETE).

Call this before delete_node() if you want to remove a node that has edges. Grafeo doesn’t auto-delete edges - you have to be explicit.

pub fn node_count(&self) -> usize

Returns the number of nodes (non-deleted at current epoch).

pub fn node_ids(&self) -> Vec<NodeId>

Returns all node IDs in the store.

This returns a snapshot of current node IDs. The returned vector excludes deleted nodes. Results are sorted by NodeId for deterministic iteration order.

impl LpgStore

pub fn set_node_property(&self, id: NodeId, key: &str, value: Value)

Sets a property on a node.

pub fn set_edge_property(&self, id: EdgeId, key: &str, value: Value)

Sets a property on an edge.

pub fn remove_node_property(&self, id: NodeId, key: &str) -> Option<Value>

Removes a property from a node.

Returns the previous value if it existed, or None if the property didn’t exist.

pub fn remove_edge_property(&self, id: EdgeId, key: &str) -> Option<Value>

Removes a property from an edge.

Returns the previous value if it existed, or None if the property didn’t exist.

pub fn get_node_property(&self, id: NodeId, key: &PropertyKey) -> Option<Value>

Gets a single property from a node without loading all properties.

This is O(1) vs O(properties) for get_node().get_property(). Use this for filter predicates where you only need one property value.

Example

let store = LpgStore::new().expect("arena allocation");
let node_id = store.create_node(&["Person"]);
store.set_node_property(node_id, "age", Value::from(30i64));

// Fast: Direct single-property lookup
let age = store.get_node_property(node_id, &PropertyKey::new("age"));

// Slow: Loads all properties, then extracts one
let age = store.get_node(node_id).and_then(|n| n.get_property("age").cloned());

pub fn get_edge_property(&self, id: EdgeId, key: &PropertyKey) -> Option<Value>

Gets a single property from an edge without loading all properties.

This is O(1) vs O(properties) for get_edge().get_property().

pub fn get_node_property_batch( &self, ids: &[NodeId], key: &PropertyKey, ) -> Vec<Option<Value>>

Gets a property for multiple nodes in a single batch operation.

More efficient than calling Self::get_node_property in a loop because it reduces lock overhead and enables better cache utilization.

Example

use grafeo_core::graph::lpg::LpgStore;
use grafeo_common::types::{NodeId, PropertyKey, Value};

let store = LpgStore::new().expect("arena allocation");
let n1 = store.create_node(&["Person"]);
let n2 = store.create_node(&["Person"]);
store.set_node_property(n1, "age", Value::from(25i64));
store.set_node_property(n2, "age", Value::from(30i64));

let ages = store.get_node_property_batch(&[n1, n2], &PropertyKey::new("age"));
assert_eq!(ages, vec![Some(Value::from(25i64)), Some(Value::from(30i64))]);

pub fn get_nodes_properties_batch( &self, ids: &[NodeId], ) -> Vec<FxHashMap<PropertyKey, Value>>

Gets all properties for multiple nodes in a single batch operation.

Returns a vector of property maps, one per node ID (empty map if no properties). More efficient than calling Self::get_node in a loop.

pub fn get_nodes_properties_selective_batch( &self, ids: &[NodeId], keys: &[PropertyKey], ) -> Vec<FxHashMap<PropertyKey, Value>>

Gets selected properties for multiple nodes (projection pushdown).

This is more efficient than Self::get_nodes_properties_batch when you only need a subset of properties. It only iterates the requested columns instead of all columns.

Use this for: Queries with explicit projections like RETURN n.name, n.age instead of RETURN n (which requires all properties).

Example

use grafeo_core::graph::lpg::LpgStore;
use grafeo_common::types::{PropertyKey, Value};

let store = LpgStore::new().expect("arena allocation");
let n1 = store.create_node(&["Person"]);
store.set_node_property(n1, "name", Value::from("Alix"));
store.set_node_property(n1, "age", Value::from(30i64));
store.set_node_property(n1, "email", Value::from("alix@example.com"));

// Only fetch name and age (faster than get_nodes_properties_batch)
let keys = vec![PropertyKey::new("name"), PropertyKey::new("age")];
let props = store.get_nodes_properties_selective_batch(&[n1], &keys);

assert_eq!(props[0].len(), 2); // Only name and age, not email

pub fn get_edges_properties_selective_batch( &self, ids: &[EdgeId], keys: &[PropertyKey], ) -> Vec<FxHashMap<PropertyKey, Value>>

Gets selected properties for multiple edges (projection pushdown).

Edge-property version of Self::get_nodes_properties_selective_batch.

impl LpgStore

pub fn add_label(&self, node_id: NodeId, label: &str) -> bool

Adds a label to a node.

Returns true if the label was added, false if the node doesn’t exist or already has the label.

pub fn remove_label(&self, node_id: NodeId, label: &str) -> bool

Removes a label from a node.

Returns true if the label was removed, false if the node doesn’t exist or doesn’t have the label.

pub fn nodes_by_label(&self, label: &str) -> Vec<NodeId>

Returns all nodes with a specific label.

Uses the label index for O(1) lookup per label. Returns a snapshot - concurrent modifications won’t affect the returned vector. Results are sorted by NodeId for deterministic iteration order.

pub fn label_count(&self) -> usize

Returns the number of distinct labels in the store.

pub fn property_key_count(&self) -> usize

Returns the number of distinct property keys in the store.

This counts unique property keys across both nodes and edges.

pub fn edge_type_count(&self) -> usize

Returns the number of distinct edge types in the store.

pub fn all_labels(&self) -> Vec<String>

Returns all label names in the database.

pub fn all_edge_types(&self) -> Vec<String>

Returns all edge type names in the database.

pub fn all_property_keys(&self) -> Vec<String>

Returns all property keys used in the database.

impl LpgStore

pub fn find_nodes_in_range( &self, property: &str, min: Option<&Value>, max: Option<&Value>, min_inclusive: bool, max_inclusive: bool, ) -> Vec<NodeId>

Finds all nodes whose property value falls within a range.

Uses zone maps to skip the scan entirely when no values could possibly match. This is the primary building block for range predicates in query execution.

Arguments

• property - The property key to check
• min - Optional lower bound
• max - Optional upper bound
• min_inclusive - Whether the lower bound is inclusive
• max_inclusive - Whether the upper bound is inclusive

Example

use grafeo_core::graph::lpg::LpgStore;
use grafeo_common::types::Value;

let store = LpgStore::new().expect("arena allocation");
let n1 = store.create_node(&["Person"]);
let n2 = store.create_node(&["Person"]);
store.set_node_property(n1, "age", Value::from(25i64));
store.set_node_property(n2, "age", Value::from(35i64));

// Find nodes where age > 30
let result = store.find_nodes_in_range(
    "age",
    Some(&Value::from(30i64)),
    None,
    false, // exclusive lower bound
    true,  // inclusive upper bound (doesn't matter since None)
);
assert_eq!(result.len(), 1); // Only n2 matches

pub fn find_nodes_by_properties( &self, conditions: &[(&str, Value)], ) -> Vec<NodeId>

Finds nodes matching multiple property equality conditions.

This is more efficient than intersecting multiple single-property lookups because it can use indexes when available and short-circuits on the first miss.

Example

use grafeo_core::graph::lpg::LpgStore;
use grafeo_common::types::Value;

let store = LpgStore::new().expect("arena allocation");
let alix = store.create_node(&["Person"]);
store.set_node_property(alix, "name", Value::from("Alix"));
store.set_node_property(alix, "city", Value::from("NYC"));

// Find nodes where name = "Alix" AND city = "NYC"
let matches = store.find_nodes_by_properties(&[
    ("name", Value::from("Alix")),
    ("city", Value::from("NYC")),
]);
assert!(matches.contains(&alix));

pub fn find_nodes_by_property( &self, property: &str, value: &Value, ) -> Vec<NodeId>

Finds all nodes that have a specific property value.

If the property is indexed, this is O(1). Otherwise, it scans all nodes which is O(n). Use Self::create_property_index for frequently queried properties.

Example

use grafeo_core::graph::lpg::LpgStore;
use grafeo_common::types::Value;

let store = LpgStore::new().expect("arena allocation");
store.create_property_index("city"); // Optional but makes lookups fast

let alix = store.create_node(&["Person"]);
let gus = store.create_node(&["Person"]);
store.set_node_property(alix, "city", Value::from("NYC"));
store.set_node_property(gus, "city", Value::from("NYC"));

let nyc_people = store.find_nodes_by_property("city", &Value::from("NYC"));
assert_eq!(nyc_people.len(), 2);

pub fn find_nodes_matching_filter( &self, property: &str, filter_value: &Value, ) -> Vec<NodeId>

Finds nodes whose property matches an operator filter.

The filter_value is either a scalar (equality) or a Value::Map with $-prefixed operator keys like $gt, $lt, $gte, $lte, $in, $nin, $ne, $contains.

pub fn node_property_might_match( &self, property: &PropertyKey, op: CompareOp, value: &Value, ) -> bool

Checks if a node property predicate might match any nodes.

Uses zone maps for early filtering. Returns true if there might be matching nodes, false if there definitely aren’t.

pub fn edge_property_might_match( &self, property: &PropertyKey, op: CompareOp, value: &Value, ) -> bool

Checks if an edge property predicate might match any edges.

pub fn node_property_zone_map( &self, property: &PropertyKey, ) -> Option<ZoneMapEntry>

Gets the zone map for a node property.

pub fn edge_property_zone_map( &self, property: &PropertyKey, ) -> Option<ZoneMapEntry>

Gets the zone map for an edge property.

impl LpgStore

pub fn statistics(&self) -> Arc<Statistics>

Returns the current statistics (cheap Arc clone, no deep copy).

pub fn estimate_label_cardinality(&self, label: &str) -> f64

Estimates cardinality for a label scan.

pub fn estimate_avg_degree(&self, edge_type: &str, outgoing: bool) -> f64

Estimates average degree for an edge type.

impl LpgStore

pub fn neighbors( &self, node: NodeId, direction: Direction, ) -> impl Iterator<Item = NodeId> + '_

Iterates over neighbors of a node in the specified direction.

This is the fast path for graph traversal - goes straight to the adjacency index without loading full node data.

pub fn edges_from( &self, node: NodeId, direction: Direction, ) -> impl Iterator<Item = (NodeId, EdgeId)> + '_

Returns edges from a node with their targets.

Returns an iterator of (target_node, edge_id) pairs.

pub fn edges_to(&self, node: NodeId) -> Vec<(NodeId, EdgeId)>

Returns edges to a node (where the node is the destination).

Returns (source_node, edge_id) pairs for all edges pointing TO this node. Uses the backward adjacency index for O(degree) lookup.

Example

let store = LpgStore::new().expect("arena allocation");
let a = store.create_node(&["Node"]);
let b = store.create_node(&["Node"]);
let c = store.create_node(&["Node"]);
let _e1 = store.create_edge(a, b, "LINKS");
let _e2 = store.create_edge(c, b, "LINKS");

// For edges: A->B, C->B
let incoming = store.edges_to(b);
assert_eq!(incoming.len(), 2);

pub fn out_degree(&self, node: NodeId) -> usize

Returns the out-degree of a node (number of outgoing edges).

Uses the forward adjacency index for O(1) lookup.

pub fn in_degree(&self, node: NodeId) -> usize

Returns the in-degree of a node (number of incoming edges).

Uses the backward adjacency index for O(1) lookup if available, otherwise falls back to scanning edges.

pub fn all_nodes(&self) -> impl Iterator<Item = Node> + '_

Returns an iterator over all nodes in the database.

This creates a snapshot of all visible nodes at the current epoch. Useful for dump/export operations.

pub fn all_edges(&self) -> impl Iterator<Item = Edge> + '_

Returns an iterator over all edges in the database.

This creates a snapshot of all visible edges at the current epoch. Useful for dump/export operations.

pub fn nodes_with_label<'a>( &'a self, label: &str, ) -> impl Iterator<Item = Node> + 'a

Returns an iterator over nodes with a specific label.

pub fn edges_with_type<'a>( &'a self, edge_type: &str, ) -> impl Iterator<Item = Edge> + 'a

Returns an iterator over edges with a specific type.

impl LpgStore

pub fn new() -> Result<Self, AllocError>

Creates a new LPG store with default configuration.

Errors

Returns AllocError if the arena allocator cannot be initialized (only possible with the tiered-storage feature).

pub fn with_config(config: LpgStoreConfig) -> Result<Self, AllocError>

Creates a new LPG store with custom configuration.

Errors

Returns AllocError if the arena allocator cannot be initialized (only possible with the tiered-storage feature).

pub fn current_epoch(&self) -> EpochId

Returns the current epoch.

pub fn clear(&self)

Removes all data from the store, resetting it to an empty state.

Acquires locks in the documented ordering to prevent deadlocks. After clearing, the store behaves as if freshly constructed.

pub fn has_backward_adjacency(&self) -> bool

Returns whether backward adjacency (incoming edge index) is available.

When backward adjacency is enabled (the default), bidirectional search algorithms can traverse from the target toward the source.

pub fn graph(&self, name: &str) -> Option<Arc<LpgStore>>

Returns a named graph by name, or None if it does not exist.

pub fn graph_or_create(&self, name: &str) -> Result<Arc<LpgStore>, AllocError>

Returns a named graph, creating it if it does not exist.

Errors

Returns AllocError if a new store cannot be allocated.

pub fn create_graph(&self, name: &str) -> Result<bool, AllocError>

Creates a named graph. Returns true on success, false if it already exists.

Errors

Returns AllocError if the new store cannot be allocated.

pub fn drop_graph(&self, name: &str) -> bool

Drops a named graph. Returns false if it did not exist.

pub fn graph_names(&self) -> Vec<String>

Returns all named graph names.

pub fn graph_count(&self) -> usize

Returns the number of named graphs.

pub fn clear_graph(&self, name: Option<&str>)

Clears a specific graph, or the default graph if name is None.

pub fn copy_graph( &self, source: Option<&str>, dest: Option<&str>, ) -> Result<(), AllocError>

Copies all data from the source graph to the destination graph. Creates the destination graph if it does not exist.

Errors

Returns AllocError if the destination store cannot be allocated.

Trait Implementations

impl Default for LpgStore

fn default() -> Self

Returns the “default value” for a type.

impl GraphStore for LpgStore

fn get_node(&self, id: NodeId) -> Option<Node>

Returns a node by ID (latest visible version at current epoch).

fn get_edge(&self, id: EdgeId) -> Option<Edge>

Returns an edge by ID (latest visible version at current epoch).

fn get_node_versioned( &self, id: NodeId, epoch: EpochId, tx_id: TxId, ) -> Option<Node>

Returns a node visible to a specific transaction.

fn get_edge_versioned( &self, id: EdgeId, epoch: EpochId, tx_id: TxId, ) -> Option<Edge>

Returns an edge visible to a specific transaction.

fn get_node_at_epoch(&self, id: NodeId, epoch: EpochId) -> Option<Node>

Returns a node using pure epoch-based visibility (no transaction context).

fn get_edge_at_epoch(&self, id: EdgeId, epoch: EpochId) -> Option<Edge>

Returns an edge using pure epoch-based visibility (no transaction context).

fn get_node_property(&self, id: NodeId, key: &PropertyKey) -> Option<Value>

Gets a single property from a node without loading all properties.

fn get_edge_property(&self, id: EdgeId, key: &PropertyKey) -> Option<Value>

Gets a single property from an edge without loading all properties.

fn get_node_property_batch( &self, ids: &[NodeId], key: &PropertyKey, ) -> Vec<Option<Value>>

Gets a property for multiple nodes in a single batch operation.

fn get_nodes_properties_batch( &self, ids: &[NodeId], ) -> Vec<FxHashMap<PropertyKey, Value>>

Gets all properties for multiple nodes in a single batch operation.

fn get_nodes_properties_selective_batch( &self, ids: &[NodeId], keys: &[PropertyKey], ) -> Vec<FxHashMap<PropertyKey, Value>>

Gets selected properties for multiple nodes (projection pushdown).

fn get_edges_properties_selective_batch( &self, ids: &[EdgeId], keys: &[PropertyKey], ) -> Vec<FxHashMap<PropertyKey, Value>>

Gets selected properties for multiple edges (projection pushdown).

fn neighbors(&self, node: NodeId, direction: Direction) -> Vec<NodeId>

Returns neighbor node IDs in the specified direction.

fn edges_from( &self, node: NodeId, direction: Direction, ) -> Vec<(NodeId, EdgeId)>

Returns (target_node, edge_id) pairs for edges from a node.

fn out_degree(&self, node: NodeId) -> usize

Returns the out-degree of a node (number of outgoing edges).

fn in_degree(&self, node: NodeId) -> usize

Returns the in-degree of a node (number of incoming edges).

fn has_backward_adjacency(&self) -> bool

Whether backward adjacency is available for incoming edge queries.

fn node_ids(&self) -> Vec<NodeId>

Returns all non-deleted node IDs, sorted by ID.

fn nodes_by_label(&self, label: &str) -> Vec<NodeId>

Returns node IDs with a specific label.

fn node_count(&self) -> usize

Returns the total number of non-deleted nodes.

fn edge_count(&self) -> usize

Returns the total number of non-deleted edges.

fn edge_type(&self, id: EdgeId) -> Option<ArcStr>

Returns the type string of an edge.

fn has_property_index(&self, property: &str) -> bool

Returns true if a property index exists for the given property.

fn find_nodes_by_property(&self, property: &str, value: &Value) -> Vec<NodeId>

Finds all nodes with a specific property value. Uses indexes when available.

fn find_nodes_by_properties(&self, conditions: &[(&str, Value)]) -> Vec<NodeId>

Finds nodes matching multiple property equality conditions.

fn find_nodes_in_range( &self, property: &str, min: Option<&Value>, max: Option<&Value>, min_inclusive: bool, max_inclusive: bool, ) -> Vec<NodeId>

Finds nodes whose property value falls within a range.

fn node_property_might_match( &self, property: &PropertyKey, op: CompareOp, value: &Value, ) -> bool

Returns true if a node property predicate might match any nodes. Uses zone maps for early filtering.

fn edge_property_might_match( &self, property: &PropertyKey, op: CompareOp, value: &Value, ) -> bool

Returns true if an edge property predicate might match any edges.

fn statistics(&self) -> Arc<Statistics>

Returns the current statistics snapshot (cheap Arc clone).

fn estimate_label_cardinality(&self, label: &str) -> f64

Estimates cardinality for a label scan.

fn estimate_avg_degree(&self, edge_type: &str, outgoing: bool) -> f64

Estimates average degree for an edge type.

fn current_epoch(&self) -> EpochId

Returns the current MVCC epoch.

fn get_node_history(&self, id: NodeId) -> Vec<(EpochId, Option<EpochId>, Node)>

Returns all versions of a node with their creation/deletion epochs, newest first.

fn get_edge_history(&self, id: EdgeId) -> Vec<(EpochId, Option<EpochId>, Edge)>

Returns all versions of an edge with their creation/deletion epochs, newest first.

impl GraphStoreMut for LpgStore

fn create_node(&self, labels: &[&str]) -> NodeId

Creates a new node with the given labels.

fn create_node_versioned( &self, labels: &[&str], epoch: EpochId, tx_id: TxId, ) -> NodeId

Creates a new node within a transaction context.

fn create_edge(&self, src: NodeId, dst: NodeId, edge_type: &str) -> EdgeId

Creates a new edge between two nodes.

fn create_edge_versioned( &self, src: NodeId, dst: NodeId, edge_type: &str, epoch: EpochId, tx_id: TxId, ) -> EdgeId

Creates a new edge within a transaction context.

fn batch_create_edges(&self, edges: &[(NodeId, NodeId, &str)]) -> Vec<EdgeId>

Creates multiple edges in batch (single lock acquisition).

fn delete_node(&self, id: NodeId) -> bool

Deletes a node. Returns true if the node existed.

fn delete_node_versioned( &self, id: NodeId, epoch: EpochId, _tx_id: TxId, ) -> bool

Deletes a node within a transaction context. Returns true if the node existed.

fn delete_node_edges(&self, node_id: NodeId)

Deletes all edges connected to a node (DETACH DELETE).

fn delete_edge(&self, id: EdgeId) -> bool

Deletes an edge. Returns true if the edge existed.

fn delete_edge_versioned( &self, id: EdgeId, epoch: EpochId, _tx_id: TxId, ) -> bool

Deletes an edge within a transaction context. Returns true if the edge existed.

fn set_node_property(&self, id: NodeId, key: &str, value: Value)

Sets a property on a node.

fn set_edge_property(&self, id: EdgeId, key: &str, value: Value)

Sets a property on an edge.

fn remove_node_property(&self, id: NodeId, key: &str) -> Option<Value>

Removes a property from a node. Returns the previous value if it existed.

fn remove_edge_property(&self, id: EdgeId, key: &str) -> Option<Value>

Removes a property from an edge. Returns the previous value if it existed.

fn add_label(&self, node_id: NodeId, label: &str) -> bool

Adds a label to a node. Returns true if the label was new.

fn remove_label(&self, node_id: NodeId, label: &str) -> bool

Removes a label from a node. Returns true if the label existed.

fn create_node_with_props( &self, labels: &[&str], properties: &[(PropertyKey, Value)], ) -> NodeId

Creates a new node with labels and properties in one call.

fn create_edge_with_props( &self, src: NodeId, dst: NodeId, edge_type: &str, properties: &[(PropertyKey, Value)], ) -> EdgeId

Creates a new edge with properties in one call.