Enum MutationEvent 

pub enum MutationEvent {
    CreateNode {
        id: NodeId,
        labels: Vec<String>,
        properties: Properties,
    },
    CreateRelationship {
        id: RelationshipId,
        src: NodeId,
        dst: NodeId,
        rel_type: String,
        properties: Properties,
    },
    SetNodeProperty {
        node_id: NodeId,
        key: String,
        value: PropertyValue,
    },
    RemoveNodeProperty {
        node_id: NodeId,
        key: String,
    },
    AddNodeLabel {
        node_id: NodeId,
        label: String,
    },
    RemoveNodeLabel {
        node_id: NodeId,
        label: String,
    },
    SetRelationshipProperty {
        rel_id: RelationshipId,
        key: String,
        value: PropertyValue,
    },
    RemoveRelationshipProperty {
        rel_id: RelationshipId,
        key: String,
    },
    DeleteRelationship {
        rel_id: RelationshipId,
    },
    DeleteNode {
        node_id: NodeId,
    },
    DetachDeleteNode {
        node_id: NodeId,
    },
    Clear,
    CreateIndex {
        request: IndexRequest,
        if_not_exists: bool,
    },
    DropIndex {
        name: String,
        if_exists: bool,
    },
    CreateConstraint {
        request: ConstraintRequest,
        if_not_exists: bool,
    },
    DropConstraint {
        name: String,
        if_exists: bool,
    },
}

A durable, replayable mutation against a graph store.

Each variant mirrors a method on GraphStorageMut. Applying every event in order against a store initialised from the snapshot whose wal_lsn immediately precedes the first event reproduces the committed state.

The enum derives Serialize/Deserialize for non-WAL observers and tooling; the production WAL uses its own compact tagged codec.

Variants

CreateNode

Fields

id: NodeId

Id the backend allocated for the new node. Captured so replay against a clean store produces the same id assignment as the original (next_node_id advances deterministically).

labels: Vec<String>

properties: Properties

CreateRelationship

Fields

id: RelationshipId

src: NodeId

dst: NodeId

rel_type: String

properties: Properties

SetNodeProperty

Fields

node_id: NodeId

key: String

value: PropertyValue

RemoveNodeProperty

Fields

node_id: NodeId

key: String

AddNodeLabel

Fields

node_id: NodeId

label: String

RemoveNodeLabel

Fields

node_id: NodeId

label: String

SetRelationshipProperty

Fields

rel_id: RelationshipId

key: String

value: PropertyValue

RemoveRelationshipProperty

Fields

rel_id: RelationshipId

key: String

DeleteRelationship

Fields

rel_id: RelationshipId

DeleteNode

Fields

node_id: NodeId

DetachDeleteNode

Fields

node_id: NodeId

Clear

CreateIndex

Catalog-level mutation: register an index in the catalog. Replay re-applies via the same register_index path with the recorder detached, so events do not duplicate themselves.

Fields

request: IndexRequest

if_not_exists: bool

DropIndex

Catalog-level mutation: drop an index by name.

Fields

name: String

if_exists: bool

CreateConstraint

Catalog-level mutation: register a constraint in the catalog.

Fields

request: ConstraintRequest

if_not_exists: bool

DropConstraint

Catalog-level mutation: drop a constraint by name. The store cascades to the backing index when the constraint owned one.

Fields

name: String

if_exists: bool

Trait Implementations

impl Clone for MutationEvent

fn clone(&self) -> MutationEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MutationEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MutationEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MutationEvent

fn eq(&self, other: &MutationEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MutationEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MutationEvent