Struct Mutator 

pub struct Mutator<'tx, 'g> { /* private fields */ }

Borrowed mutation builder for one write transaction.

Implementations

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn create_node_type( &mut self, name: DbString, key_labels: LabelSet, properties: Vec<PropertyTypeDef>, validation_mode: ValidationMode, ) -> GraphResult<()>

Add a node type to the transaction-local closed graph type.

Errors

Returns GraphError::Inconsistent when the graph is open, the type already exists, or the resulting graph type is structurally invalid.

pub fn create_edge_type( &mut self, name: DbString, label: DbString, source_node_type: EdgeEndpointDef, target_node_type: EdgeEndpointDef, properties: Vec<PropertyTypeDef>, validation_mode: ValidationMode, ) -> GraphResult<()>

Add an edge type to the transaction-local closed graph type.

Errors

Returns GraphError::Inconsistent when the graph is open, the type already exists, an endpoint index is invalid, or the resulting graph type is structurally invalid.

pub fn drop_node_type( &mut self, name: DbString, behavior: DropBehavior, ) -> GraphResult<()>

Drop a node type from the transaction-local closed graph type.

behavior selects the surviving-instance / inbound-dependency policy (deletion-reclamation audit Item 3, Seam B):

• DropBehavior::Restrict (the default) rejects the drop with GraphError::Inconsistent when any instance still carries name as its key label, or when an edge type still references the node type (dangling-endpoint guard). Nothing is removed — no Change is recorded and the bound graph type is left intact (no partial state).
• DropBehavior::Cascade (IM_DROP_CASCADE) truncates every instance first via Mutator::truncate_node_type (which also removes incident edges, so no dangling endpoints remain), then drops the type. Both the truncate change(s) and the SchemaChange::NodeTypeDropped land in the same transaction, so commit and WAL replay are atomic.

Errors

Returns GraphError::Inconsistent when the graph is open, the type does not exist, Restrict finds surviving instances or an inbound edge dependency, or any edge endpoint would require positional endpoint reindexing.

pub fn drop_edge_type( &mut self, name: DbString, behavior: DropBehavior, ) -> GraphResult<()>

Drop an edge type from the transaction-local closed graph type.

behavior selects the surviving-instance policy (deletion-reclamation audit Item 3, Seam B). Edge types have no inbound type dependency, so only the instance check applies:

• DropBehavior::Restrict (the default) rejects with GraphError::Inconsistent when any edge still carries name; nothing is removed and no Change is recorded.
• DropBehavior::Cascade (IM_DROP_CASCADE) truncates every edge of the type first via Mutator::truncate_edge_type, then drops the type, atomically in one transaction.

Errors

Returns GraphError::Inconsistent when the graph is open, the type does not exist, Restrict finds surviving instances, or the resulting graph type is structurally invalid.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn create_composite_property_index_named( &mut self, label: DbString, properties: SmallVec<[DbString; 4]>, kinds: SmallVec<[TypedIndexKind; 4]>, name: Option<DbString>, ) -> GraphResult<()>

Register a durable node composite-property index with optional catalog name.

Errors

Returns GraphError::CompositePropertyIndexAlreadyExists if the canonical property set already exists.

pub fn drop_composite_property_index( &mut self, label: DbString, properties: SmallVec<[DbString; 4]>, ) -> GraphResult<()>

Drop a durable node composite-property index from the active write transaction.

The operation is idempotent. Dropping an absent index succeeds and emits no WAL change.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn delete_node(&mut self, id: NodeId) -> GraphResult<()>

Delete an alive node and cascade delete incident edges.

pub fn delete_edge(&mut self, id: EdgeId) -> GraphResult<()>

Delete an alive edge.

pub fn truncate_node_type(&mut self, label: DbString) -> GraphResult<()>

Remove every node carrying label and all of their incident edges in one declarative truncate.

Observationally identical to MATCH (n:L) DETACH DELETE n: every matched node and every incident edge (of any edge type, derived from both adjacency directions) is removed via the same change-free in-memory path delete_node/delete_edge_inner use, so the resulting graph state is byte-identical. The difference is the changeset: exactly one declarative Change::NodesOfTypeTruncated is recorded regardless of the number of rows removed (O(1) WAL write, deletion-reclamation audit Item 11), while the per-row NodeDeleted/EdgeDeleted tombstones are staged for provider/subscriber fan-out so derived state (e.g. extension providers) is reclaimed without leaks. An absent label is a clean no-op (no change is recorded), matching DETACH DELETE of zero matches; a second truncate of the same label is therefore idempotent.

All logic lives in the mutator (the single write funnel, hard rule 11) so future DROP NODE TYPE CASCADE and DROP GRAPH factory-reset paths can reuse it without an N+1 change storm.

pub fn truncate_edge_type(&mut self, label: DbString) -> GraphResult<()>

Remove every edge carrying label in one declarative truncate.

Observationally identical to MATCH ()-[e:L]->() DELETE e: each matched edge is removed via the same change-free path delete_edge uses, leaving the graph dangling-free. Records exactly one declarative Change::EdgesOfTypeTruncated (O(1) WAL) and stages per-row EdgeDeleted tombstones for fan-out. Absent label is a clean idempotent no-op.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn delete_elements( &mut self, nodes: BTreeSet<NodeId>, edges: BTreeSet<EdgeId>, ) -> GraphResult<()>

Delete a set of node and edge references.

Nodes are deleted first through Self::delete_node, so incident edges keep the same cascade behavior and change ordering as a direct node delete. Explicit edges already removed by a node cascade are skipped during the edge pass. IDs that are mapped but already invalidated are clean no-ops, matching set-oriented query deletion where duplicate rows may reference the same graph element more than once. IDs that were never allocated still return the same not-found errors as single-element delete calls. The full set is validated before the first row is removed, so a mixed set cannot partially mutate the transaction before surfacing a missing-id error.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn factory_reset(&mut self) -> GraphResult<()>

Factory-reset the entire graph: wipe every node and edge and reset the schema to open, recording exactly one declarative Change::GraphReset (deletion-reclamation audit Item 10, BRIEF-152).

This is the DROP GRAPH primitive. Under D1 single-graph it targets the one bound graph. Behaviour and invariants:

• Wipes ALL rows, including untyped ones. Live rows are enumerated from the two alive roaring::RoaringBitmaps (crate::SeleneGraph::live_nodes / crate::SeleneGraph::live_edges), never per label — so nodes/edges whose labels are not declared types (legal in an open GG01 graph) are removed too. A per-type truncate would silently miss them.
• Resets the schema to open. meta.bound_type is set to None, making a previously closed (GG02) graph open (GG01) again. There are no standalone type defs outside bound_type, so clearing it is the complete schema reset. As a side effect, the commit-time closed-graph validation loop (write_txn) is skipped entirely once bound_type is None, which is correct — nothing is left to validate.
• O(1) WAL. Exactly one Change::GraphReset is pushed regardless of the number of rows removed. The per-row NodeDeleted/EdgeDeleted tombstones are staged into the fan-out buffer (truncate_expansions) only, never into the persisted changeset, so derived state (e.g. the label/property indexes) is reclaimed without leaks while the WAL stays constant-size.
• Idempotent. On an already-empty + open graph the row enumeration is empty and bound_type is already None; a GraphReset is still pushed with an empty staged expansion (which the fan-out expander drops), so a second DROP GRAPH is a clean observable no-op, never an error.

The MANIFEST epoch and WAL archive lineage are untouched: this is one committed WAL entry on top of the existing snapshot, not a file-level wipe.

Errors

Returns a crate::GraphError only if the change-free removal cores hit a structural inconsistency (e.g. a missing edge row for a live index entry) — the same error surface the truncate path exposes.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn create_property_index( &mut self, label: DbString, property: DbString, kind: TypedIndexKind, ) -> GraphResult<()>

Register a durable node property index in the active write transaction.

Errors

Returns GraphError::PropertyIndexAlreadyExists if the pair already exists, or GraphError::IndexValueRejected if any existing non-null value for (label, property) cannot be admitted to kind.

pub fn create_property_index_named( &mut self, label: DbString, property: DbString, kind: TypedIndexKind, name: Option<DbString>, ) -> GraphResult<()>

Register a durable node property index with optional catalog name.

pub fn create_edge_property_index( &mut self, label: DbString, property: DbString, kind: TypedIndexKind, ) -> GraphResult<()>

Register a durable edge property index in the active write transaction.

Errors

Returns GraphError::PropertyIndexAlreadyExists if the pair already exists, or GraphError::IndexValueRejected if any existing non-null edge value for (label, property) cannot be admitted to kind.

pub fn create_edge_property_index_named( &mut self, label: DbString, property: DbString, kind: TypedIndexKind, name: Option<DbString>, ) -> GraphResult<()>

Register a durable edge property index with optional catalog name.

pub fn drop_edge_property_index( &mut self, label: DbString, property: DbString, ) -> GraphResult<()>

Drop a durable edge property index from the active write transaction.

The operation is idempotent. Dropping an absent index succeeds and emits no WAL change.

pub fn drop_property_index( &mut self, label: DbString, property: DbString, ) -> GraphResult<()>

Drop a durable node property index from the active write transaction.

The operation is idempotent. Dropping an absent index succeeds and emits no WAL change.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn remove_node_property( &mut self, id: NodeId, property: DbString, ) -> GraphResult<()>

Remove a property from an alive node and emit Change::NodePropertyRemoved.

The mutation is a no-op when property is absent.

pub fn remove_edge_property( &mut self, id: EdgeId, property: DbString, ) -> GraphResult<()>

Remove a property from an alive edge and emit Change::EdgePropertyRemoved.

The mutation is a no-op when property is absent.

pub fn remove_node_label( &mut self, id: NodeId, label: DbString, ) -> GraphResult<()>

Remove a label from an alive node and emit Change::NodeLabelRemoved.

The mutation is a no-op when label is absent.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn create_text_index( &mut self, label: DbString, property: DbString, ) -> GraphResult<()>

Register a durable node text index in the active write transaction.

Errors

Returns GraphError::TextIndexAlreadyExists if the pair already exists, or GraphError::Inconsistent if index construction observes corrupt graph columns.

pub fn create_text_index_named( &mut self, label: DbString, property: DbString, name: Option<DbString>, ) -> GraphResult<()>

Register a durable node text index with optional catalog name.

pub fn drop_text_index( &mut self, label: DbString, property: DbString, ) -> GraphResult<()>

Drop a durable node text index from the active write transaction.

The operation is idempotent. Dropping an absent index succeeds and emits no WAL change.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn create_vector_index( &mut self, label: DbString, property: DbString, kind: VectorIndexKind, dimension: u32, ) -> GraphResult<()>

Register a durable node vector index in the active write transaction.

Errors

Returns GraphError::VectorIndexAlreadyExists if the pair already exists, GraphError::VectorIndexInvalidDimension when dimension is zero, or GraphError::VectorIndexValueRejected if an existing non-null value for (label, property) is not a vector with dimension.

pub fn create_vector_index_named( &mut self, label: DbString, property: DbString, kind: VectorIndexKind, dimension: u32, name: Option<DbString>, ) -> GraphResult<()>

Register a durable node vector index with optional catalog name.

pub fn create_vector_index_named_with_config( &mut self, label: DbString, property: DbString, kind: VectorIndexKind, dimension: u32, name: Option<DbString>, hnsw_config: Option<HnswIndexConfig>, ) -> GraphResult<()>

Register a durable node vector index with optional HNSW construction config.

pub fn create_vector_index_named_with_configs( &mut self, label: DbString, property: DbString, kind: VectorIndexKind, dimension: u32, name: Option<DbString>, config: VectorIndexConfig, ) -> GraphResult<()>

Register a durable node vector index with optional ANN construction config.

pub fn drop_vector_index( &mut self, label: DbString, property: DbString, ) -> GraphResult<()>

Drop a durable node vector index from the active write transaction.

The operation is idempotent. Dropping an absent index succeeds and emits no WAL change.

impl<'tx, 'g> Mutator<'tx, 'g>

pub fn create_node( &mut self, labels: LabelSet, props: PropertyMap, ) -> GraphResult<NodeId>

Create a node, emit Change::NodeCreated, and return its ID.

Errors

Returns GraphError::RowSpaceExhausted when the dense row store fills the v1 row-index range (max 2^32 rows).

pub fn create_edge( &mut self, label: DbString, source: NodeId, target: NodeId, props: PropertyMap, ) -> GraphResult<EdgeId>

Create an edge between two alive nodes.

pub fn update_node( &mut self, id: NodeId, labels_diff: LabelDiff, props_diff: PropertyDiff, ) -> GraphResult<()>

Update an alive node and emit Change::NodeUpdated.

pub fn update_edge( &mut self, id: EdgeId, props_diff: PropertyDiff, ) -> GraphResult<()>

Update an alive edge and emit Change::EdgeUpdated.

Edge labels are immutable, so property updates do not touch idx_edge_label.

pub fn schema_change(&mut self, graph: GraphId, change: SchemaChange)

Append a raw SchemaChange WAL payload through the write funnel.

This is a pass-through accumulator: catalog graph mutation and closed-graph validation are handled by higher-level validation layers (the typed catalog DDL methods on this Mutator — e.g. create_node_type — call those layers and then funnel here).

Why: this is the single, canonical funnel entry for a SchemaChanged change record (hard rule 11 — every mutation routes through the one Mutator). It is intentionally retained as a pub funnel surface even though no GQL caller reaches it directly today: the catalog DDL methods are the production producers, and keeping the low-level entry public means any future schema-event producer routes through the same funnel rather than re-implementing the write path. Tests and benches drive it directly to exercise the raw funnel without the DDL validation layer on top.

pub fn index_provider_by_tag( &self, tag: ProviderTag, ) -> Option<Arc<dyn IndexProvider>>

Look up a registered index provider through the held write transaction.

pub fn read(&self) -> &SeleneGraph

Borrow the transaction-local working graph.