Trait GraphStorage 

pub trait GraphStorage {
    // Required methods
    fn contains_node(&self, id: NodeId) -> bool;
    fn node(&self, id: NodeId) -> Option<NodeRecord>;
    fn all_node_ids(&self) -> Vec<NodeId> ;
    fn node_ids_by_label(&self, label: &str) -> Vec<NodeId> ;
    fn contains_relationship(&self, id: RelationshipId) -> bool;
    fn relationship(&self, id: RelationshipId) -> Option<RelationshipRecord>;
    fn all_rel_ids(&self) -> Vec<RelationshipId> ;
    fn rel_ids_by_type(&self, rel_type: &str) -> Vec<RelationshipId> ;
    fn relationship_endpoints(
        &self,
        id: RelationshipId,
    ) -> Option<(NodeId, NodeId)>;
    fn expand_ids(
        &self,
        node_id: NodeId,
        direction: Direction,
        types: &[String],
    ) -> Vec<(RelationshipId, NodeId)>;
    fn all_labels(&self) -> Vec<String>;
    fn all_relationship_types(&self) -> Vec<String>;

    // Provided methods
    fn try_for_each_expand_id<F, E>(
        &self,
        node_id: NodeId,
        direction: Direction,
        types: &[String],
        visit: F,
    ) -> Result<(), E>
       where F: FnMut(RelationshipId, NodeId) -> Result<(), E>,
             Self: Sized { ... }
    fn with_node<F, R>(&self, id: NodeId, f: F) -> Option<R>
       where F: FnOnce(&NodeRecord) -> R,
             Self: Sized { ... }
    fn with_relationship<F, R>(&self, id: RelationshipId, f: F) -> Option<R>
       where F: FnOnce(&RelationshipRecord) -> R,
             Self: Sized { ... }
    fn has_node(&self, id: NodeId) -> bool { ... }
    fn has_relationship(&self, id: RelationshipId) -> bool { ... }
    fn node_count(&self) -> usize { ... }
    fn relationship_count(&self) -> usize { ... }
    fn all_nodes(&self) -> Vec<NodeRecord> { ... }
    fn nodes_by_label(&self, label: &str) -> Vec<NodeRecord> { ... }
    fn all_relationships(&self) -> Vec<RelationshipRecord> { ... }
    fn relationships_by_type(&self, rel_type: &str) -> Vec<RelationshipRecord> { ... }
    fn relationship_ids_of(
        &self,
        node_id: NodeId,
        direction: Direction,
    ) -> Vec<RelationshipId>  { ... }
    fn outgoing_relationships(&self, node_id: NodeId) -> Vec<RelationshipRecord> { ... }
    fn incoming_relationships(&self, node_id: NodeId) -> Vec<RelationshipRecord> { ... }
    fn relationships_of(
        &self,
        node_id: NodeId,
        direction: Direction,
    ) -> Vec<RelationshipRecord> { ... }
    fn degree(&self, node_id: NodeId, direction: Direction) -> usize { ... }
    fn is_isolated(&self, node_id: NodeId) -> bool { ... }
    fn expand(
        &self,
        node_id: NodeId,
        direction: Direction,
        types: &[String],
    ) -> Vec<(RelationshipRecord, NodeRecord)> { ... }
    fn expand_detailed(
        &self,
        node_id: NodeId,
        direction: Direction,
        types: &[String],
    ) -> Vec<ExpandedRelationship> { ... }
    fn neighbors(
        &self,
        node_id: NodeId,
        direction: Direction,
        types: &[String],
    ) -> Vec<NodeRecord> { ... }
    fn node_has_label(&self, node_id: NodeId, label: &str) -> bool
       where Self: Sized { ... }
    fn node_labels(&self, node_id: NodeId) -> Option<Vec<String>>
       where Self: Sized { ... }
    fn node_properties(&self, node_id: NodeId) -> Option<Properties>
       where Self: Sized { ... }
    fn node_property(&self, node_id: NodeId, key: &str) -> Option<PropertyValue>
       where Self: Sized { ... }
    fn relationship_type(&self, rel_id: RelationshipId) -> Option<String>
       where Self: Sized { ... }
    fn relationship_properties(
        &self,
        rel_id: RelationshipId,
    ) -> Option<Properties>
       where Self: Sized { ... }
    fn relationship_property(
        &self,
        rel_id: RelationshipId,
        key: &str,
    ) -> Option<PropertyValue>
       where Self: Sized { ... }
    fn relationship_source(&self, rel_id: RelationshipId) -> Option<NodeId> { ... }
    fn relationship_target(&self, rel_id: RelationshipId) -> Option<NodeId> { ... }
    fn other_node(
        &self,
        rel_id: RelationshipId,
        node_id: NodeId,
    ) -> Option<NodeId> { ... }
    fn has_label_name(&self, label: &str) -> bool { ... }
    fn has_relationship_type_name(&self, rel_type: &str) -> bool { ... }
    fn all_node_property_keys(&self) -> Vec<String>
       where Self: Sized { ... }
    fn all_relationship_property_keys(&self) -> Vec<String>
       where Self: Sized { ... }
    fn all_property_keys(&self) -> Vec<String>
       where Self: Sized { ... }
    fn has_property_key(&self, key: &str) -> bool
       where Self: Sized { ... }
    fn label_property_keys(&self, label: &str) -> Vec<String>
       where Self: Sized { ... }
    fn rel_type_property_keys(&self, rel_type: &str) -> Vec<String>
       where Self: Sized { ... }
    fn label_has_property_key(&self, label: &str, key: &str) -> bool
       where Self: Sized { ... }
    fn rel_type_has_property_key(&self, rel_type: &str, key: &str) -> bool
       where Self: Sized { ... }
    fn find_nodes_by_property(
        &self,
        label: Option<&str>,
        key: &str,
        value: &PropertyValue,
    ) -> Vec<NodeRecord>
       where Self: Sized { ... }
    fn find_node_ids_by_property(
        &self,
        label: Option<&str>,
        key: &str,
        value: &PropertyValue,
    ) -> Vec<NodeId> 
       where Self: Sized { ... }
    fn find_relationships_by_property(
        &self,
        rel_type: Option<&str>,
        key: &str,
        value: &PropertyValue,
    ) -> Vec<RelationshipRecord>
       where Self: Sized { ... }
    fn find_relationship_ids_by_property(
        &self,
        rel_type: Option<&str>,
        key: &str,
        value: &PropertyValue,
    ) -> Vec<RelationshipId> 
       where Self: Sized { ... }
    fn node_exists_with_label_and_property(
        &self,
        label: &str,
        key: &str,
        value: &PropertyValue,
    ) -> bool
       where Self: Sized { ... }
    fn relationship_exists_with_type_and_property(
        &self,
        rel_type: &str,
        key: &str,
        value: &PropertyValue,
    ) -> bool
       where Self: Sized { ... }
    fn list_indexes(&self) -> Vec<IndexDefinition> { ... }
    fn get_index(&self, _name: &str) -> Option<IndexDefinition> { ... }
    fn fulltext_search(&self, _name: &str, _query: &str) -> Vec<(u64, f64)> { ... }
    fn vector_search(
        &self,
        _name: &str,
        _query: &LoraVector,
        _k: usize,
        _restrict_to: Option<&BTreeSet<u64>>,
    ) -> Vec<(u64, f64)> { ... }
    fn list_constraints(&self) -> Vec<ConstraintDefinition> { ... }
    fn get_constraint(&self, _name: &str) -> Option<ConstraintDefinition> { ... }
    fn check_node_create_against_constraints(
        &self,
        _labels: &[String],
        _properties: &Properties,
    ) -> Result<(), String> { ... }
    fn check_relationship_create_against_constraints(
        &self,
        _rel_type: &str,
        _properties: &Properties,
    ) -> Result<(), String> { ... }
    fn check_node_set_property_against_constraints(
        &self,
        _node_id: NodeId,
        _key: &str,
        _value: &PropertyValue,
    ) -> Result<(), String> { ... }
    fn check_node_remove_property_against_constraints(
        &self,
        _node_id: NodeId,
        _key: &str,
    ) -> Result<(), String> { ... }
    fn check_node_replace_properties_against_constraints(
        &self,
        _node_id: NodeId,
        _properties: &Properties,
    ) -> Result<(), String> { ... }
    fn check_relationship_set_property_against_constraints(
        &self,
        _rel_id: RelationshipId,
        _key: &str,
        _value: &PropertyValue,
    ) -> Result<(), String> { ... }
    fn check_relationship_remove_property_against_constraints(
        &self,
        _rel_id: RelationshipId,
        _key: &str,
    ) -> Result<(), String> { ... }
    fn check_relationship_replace_properties_against_constraints(
        &self,
        _rel_id: RelationshipId,
        _properties: &Properties,
    ) -> Result<(), String> { ... }
    fn check_node_add_label_against_constraints(
        &self,
        _node_id: NodeId,
        _label: &str,
    ) -> Result<(), String> { ... }
    fn graph_stats(&self) -> GraphStats { ... }
    fn node_text_candidates(
        &self,
        _label: &str,
        _property: &str,
        _query: &str,
    ) -> Option<Vec<NodeId>> { ... }
    fn node_range_candidates(
        &self,
        _label: &str,
        _property: &str,
        _lo: Option<&PropertyValue>,
        _hi: Option<&PropertyValue>,
    ) -> Option<Vec<NodeId>> { ... }
    fn node_point_within_bbox(
        &self,
        _label: &str,
        _property: &str,
        _ll: (f64, f64),
        _ur: (f64, f64),
    ) -> Option<Vec<NodeId>> { ... }
    fn node_point_within_distance(
        &self,
        _label: &str,
        _property: &str,
        _center: (f64, f64),
        _max_distance: f64,
    ) -> Option<Vec<NodeId>> { ... }
    fn relationship_text_candidates(
        &self,
        _rel_type: &str,
        _property: &str,
        _query: &str,
    ) -> Option<Vec<RelationshipId>> { ... }
    fn relationship_range_candidates(
        &self,
        _rel_type: &str,
        _property: &str,
        _lo: Option<&PropertyValue>,
        _hi: Option<&PropertyValue>,
    ) -> Option<Vec<RelationshipId>> { ... }
    fn relationship_point_within_bbox(
        &self,
        _rel_type: &str,
        _property: &str,
        _ll: (f64, f64),
        _ur: (f64, f64),
    ) -> Option<Vec<RelationshipId>> { ... }
    fn relationship_point_within_distance(
        &self,
        _rel_type: &str,
        _property: &str,
        _center: (f64, f64),
        _max_distance: f64,
    ) -> Option<Vec<RelationshipId>> { ... }
}

Required Methods

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

Cheap existence check. Should not clone or materialize the record.

fn node(&self, id: NodeId) -> Option<NodeRecord>

Point lookup returning an owned record. Backends that can hand out borrows should also implement BorrowedGraphStorage::node_ref and override [with_node] to avoid clones on the hot path.

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

Enumerate every node id. Should be O(nodes) without cloning records.

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

Enumerate node ids carrying the given label. Implementations that keep a label index should override this.

fn contains_relationship(&self, id: RelationshipId) -> bool

fn relationship(&self, id: RelationshipId) -> Option<RelationshipRecord>

fn all_rel_ids(&self) -> Vec<RelationshipId>

fn rel_ids_by_type(&self, rel_type: &str) -> Vec<RelationshipId>

fn relationship_endpoints(&self, id: RelationshipId) -> Option<(NodeId, NodeId)>

Endpoint pair (src, dst) for a relationship. Required because traversal uses it on hot paths; a backend that stores endpoints alongside the id index can answer this without fetching properties.

fn expand_ids( &self, node_id: NodeId, direction: Direction, types: &[String], ) -> Vec<(RelationshipId, NodeId)>

Expand a node’s incident relationships filtered by direction and (optional) types. This is the single traversal primitive; variable- length paths, degree, and adjacency helpers are all derived from it.

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

fn all_relationship_types(&self) -> Vec<String>

Provided Methods

fn try_for_each_expand_id<F, E>( &self, node_id: NodeId, direction: Direction, types: &[String], visit: F, ) -> Result<(), E>

where F: FnMut(RelationshipId, NodeId) -> Result<(), E>, Self: Sized,

Visit expanded (relationship_id, other_node_id) pairs without forcing backends to allocate an intermediate Vec. The default keeps the trait easy to implement; hot backends can override it.

fn with_node<F, R>(&self, id: NodeId, f: F) -> Option<R>

where F: FnOnce(&NodeRecord) -> R, Self: Sized,

fn with_relationship<F, R>(&self, id: RelationshipId, f: F) -> Option<R>

where F: FnOnce(&RelationshipRecord) -> R, Self: Sized,

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

fn has_relationship(&self, id: RelationshipId) -> bool

fn node_count(&self) -> usize

fn relationship_count(&self) -> usize

fn all_nodes(&self) -> Vec<NodeRecord>

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

fn all_relationships(&self) -> Vec<RelationshipRecord>

fn relationships_by_type(&self, rel_type: &str) -> Vec<RelationshipRecord>

fn relationship_ids_of( &self, node_id: NodeId, direction: Direction, ) -> Vec<RelationshipId>

fn outgoing_relationships(&self, node_id: NodeId) -> Vec<RelationshipRecord>

fn incoming_relationships(&self, node_id: NodeId) -> Vec<RelationshipRecord>

fn relationships_of( &self, node_id: NodeId, direction: Direction, ) -> Vec<RelationshipRecord>

fn degree(&self, node_id: NodeId, direction: Direction) -> usize

fn is_isolated(&self, node_id: NodeId) -> bool

fn expand( &self, node_id: NodeId, direction: Direction, types: &[String], ) -> Vec<(RelationshipRecord, NodeRecord)>

fn expand_detailed( &self, node_id: NodeId, direction: Direction, types: &[String], ) -> Vec<ExpandedRelationship>

fn neighbors( &self, node_id: NodeId, direction: Direction, types: &[String], ) -> Vec<NodeRecord>

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

where Self: Sized,

fn node_labels(&self, node_id: NodeId) -> Option<Vec<String>>

where Self: Sized,

fn node_properties(&self, node_id: NodeId) -> Option<Properties>

where Self: Sized,

fn node_property(&self, node_id: NodeId, key: &str) -> Option<PropertyValue>

where Self: Sized,

fn relationship_type(&self, rel_id: RelationshipId) -> Option<String>

where Self: Sized,

fn relationship_properties(&self, rel_id: RelationshipId) -> Option<Properties>

where Self: Sized,

fn relationship_property( &self, rel_id: RelationshipId, key: &str, ) -> Option<PropertyValue>

where Self: Sized,

fn relationship_source(&self, rel_id: RelationshipId) -> Option<NodeId>

fn relationship_target(&self, rel_id: RelationshipId) -> Option<NodeId>

fn other_node(&self, rel_id: RelationshipId, node_id: NodeId) -> Option<NodeId>

fn has_label_name(&self, label: &str) -> bool

fn has_relationship_type_name(&self, rel_type: &str) -> bool

fn all_node_property_keys(&self) -> Vec<String>

where Self: Sized,

fn all_relationship_property_keys(&self) -> Vec<String>

where Self: Sized,

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

where Self: Sized,

fn has_property_key(&self, key: &str) -> bool

where Self: Sized,

fn label_property_keys(&self, label: &str) -> Vec<String>

where Self: Sized,

fn rel_type_property_keys(&self, rel_type: &str) -> Vec<String>

where Self: Sized,

fn label_has_property_key(&self, label: &str, key: &str) -> bool

where Self: Sized,

fn rel_type_has_property_key(&self, rel_type: &str, key: &str) -> bool

where Self: Sized,

fn find_nodes_by_property( &self, label: Option<&str>, key: &str, value: &PropertyValue, ) -> Vec<NodeRecord>

where Self: Sized,

fn find_node_ids_by_property( &self, label: Option<&str>, key: &str, value: &PropertyValue, ) -> Vec<NodeId>

where Self: Sized,

fn find_relationships_by_property( &self, rel_type: Option<&str>, key: &str, value: &PropertyValue, ) -> Vec<RelationshipRecord>

where Self: Sized,

fn find_relationship_ids_by_property( &self, rel_type: Option<&str>, key: &str, value: &PropertyValue, ) -> Vec<RelationshipId>

where Self: Sized,

fn node_exists_with_label_and_property( &self, label: &str, key: &str, value: &PropertyValue, ) -> bool

where Self: Sized,

fn relationship_exists_with_type_and_property( &self, rel_type: &str, key: &str, value: &PropertyValue, ) -> bool

where Self: Sized,

fn list_indexes(&self) -> Vec<IndexDefinition>

fn get_index(&self, _name: &str) -> Option<IndexDefinition>

fn fulltext_search(&self, _name: &str, _query: &str) -> Vec<(u64, f64)>

Run a FULLTEXT index query against the named index. Returns (entity_id, score) pairs sorted descending by score. Backends without fulltext support return an empty vector; the caller is expected to have validated that the index exists via the catalog first.

fn vector_search( &self, _name: &str, _query: &LoraVector, _k: usize, _restrict_to: Option<&BTreeSet<u64>>, ) -> Vec<(u64, f64)>

Run a VECTOR index query against the named index. Returns unsorted (entity_id, score) pairs; the caller sorts by score descending and truncates to top-k. Backends without vector support return an empty vector. The caller has already validated that the index exists via the catalog and that the query vector matches the configured dimensions.

k is a hint: future ANN backends can use it to prune work; the flat backend ignores it because exhaustive scoring is the cheapest correctness contract.

restrict_to, when Some, hard-filters the result set to those entity ids. The backend may still traverse other entities internally (HNSW uses them as routing hops), but returned tuples are guaranteed to live in the set.

fn list_constraints(&self) -> Vec<ConstraintDefinition>

List explicitly-declared constraints. Backends without a constraint catalog return the empty vector.

fn get_constraint(&self, _name: &str) -> Option<ConstraintDefinition>

fn check_node_create_against_constraints( &self, _labels: &[String], _properties: &Properties, ) -> Result<(), String>

Mutation-time pre-check: would creating a node with these labels and properties violate any registered constraint? Default returns Ok(()) so backends without a constraint catalog pay nothing. The in-memory backend overrides this and the call is virtually free when the catalog is empty.

fn check_relationship_create_against_constraints( &self, _rel_type: &str, _properties: &Properties, ) -> Result<(), String>

Mutation-time pre-check for CREATE ()-[r:TYPE { ... }]->().

fn check_node_set_property_against_constraints( &self, _node_id: NodeId, _key: &str, _value: &PropertyValue, ) -> Result<(), String>

Mutation-time pre-check: would setting key = value on this node violate any registered constraint? Default Ok(()).

fn check_node_remove_property_against_constraints( &self, _node_id: NodeId, _key: &str, ) -> Result<(), String>

Mutation-time pre-check: would removing key on this node violate an existence / key constraint? Default Ok(()).

fn check_node_replace_properties_against_constraints( &self, _node_id: NodeId, _properties: &Properties, ) -> Result<(), String>

Mutation-time pre-check: would replacing all properties on this node leave it in violation of any registered constraint? Default Ok(()).

fn check_relationship_set_property_against_constraints( &self, _rel_id: RelationshipId, _key: &str, _value: &PropertyValue, ) -> Result<(), String>

Mutation-time pre-check: equivalent for relationship property writes.

fn check_relationship_remove_property_against_constraints( &self, _rel_id: RelationshipId, _key: &str, ) -> Result<(), String>

fn check_relationship_replace_properties_against_constraints( &self, _rel_id: RelationshipId, _properties: &Properties, ) -> Result<(), String>

Mutation-time pre-check: would replacing all properties on this relationship leave it in violation of any registered constraint? Default Ok(()).

fn check_node_add_label_against_constraints( &self, _node_id: NodeId, _label: &str, ) -> Result<(), String>

Mutation-time pre-check: would adding label to this node activate a constraint the node currently violates?

fn graph_stats(&self) -> GraphStats

Cardinality snapshot used by the cost model. Backends without per-label / per-type indexes return GraphStats::default(), which the planner treats as “no information available”.

fn node_text_candidates( &self, _label: &str, _property: &str, _query: &str, ) -> Option<Vec<NodeId>>

Trigram-index candidates for query on label.property.

Semantics:

• Some(ids) → these node ids might match (refilter required).
• None → no trigram scope for (label, property); caller must fall back to a full scan.

Backends without text-index support always return None.

fn node_range_candidates( &self, _label: &str, _property: &str, _lo: Option<&PropertyValue>, _hi: Option<&PropertyValue>, ) -> Option<Vec<NodeId>>

Sorted-index candidates for a [lo, hi] range on label.property. Both bounds are inclusive at this layer; the caller refilters with the precise predicate inclusivity (> vs >=, < vs <=).

Returns None when no scope exists — caller falls back to scan.

fn node_point_within_bbox( &self, _label: &str, _property: &str, _ll: (f64, f64), _ur: (f64, f64), ) -> Option<Vec<NodeId>>

Spatial-index candidates inside the closed [ll, ur] 2D bounding box. The executor refilters every id with the precise predicate, including the z-coordinate when the indexed point is 3D.

fn node_point_within_distance( &self, _label: &str, _property: &str, _center: (f64, f64), _max_distance: f64, ) -> Option<Vec<NodeId>>

Spatial-index candidates within max_distance of (x, y). The candidate set is conservative — the actual great-circle / cartesian distance check is the executor’s responsibility.

fn relationship_text_candidates( &self, _rel_type: &str, _property: &str, _query: &str, ) -> Option<Vec<RelationshipId>>

Trigram-index candidates for relationships of rel_type whose property value matches query (substring/prefix/suffix). Mirror of Self::node_text_candidates for relationship-target indexes.

fn relationship_range_candidates( &self, _rel_type: &str, _property: &str, _lo: Option<&PropertyValue>, _hi: Option<&PropertyValue>, ) -> Option<Vec<RelationshipId>>

Sorted-index candidates for relationships of rel_type on the closed [lo, hi] range. Mirror of Self::node_range_candidates.

fn relationship_point_within_bbox( &self, _rel_type: &str, _property: &str, _ll: (f64, f64), _ur: (f64, f64), ) -> Option<Vec<RelationshipId>>

Spatial-index candidates inside the closed [ll, ur] 2D bounding box, scoped to relationships of rel_type. Mirror of Self::node_point_within_bbox.

fn relationship_point_within_distance( &self, _rel_type: &str, _property: &str, _center: (f64, f64), _max_distance: f64, ) -> Option<Vec<RelationshipId>>

Spatial-index candidates within max_distance of (x, y), scoped to relationships of rel_type. Mirror of Self::node_point_within_distance.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl GraphStorage for InMemoryGraph