Struct GraphEdge 

pub struct GraphEdge {
    pub id: EdgeId,
    pub from: NodeId,
    pub to: NodeId,
    pub edge_type: String,
    pub weight: f32,
    pub attrs: Vec<(String, Value)>,
    pub valid_from: Option<u64>,
    pub valid_to: Option<u64>,
    pub source: Option<SourceRef>,
}

One edge: its id, endpoints, type, weight, attributes, and an optional valid-time window for bitemporal facts.

Fields

id: EdgeId

from: NodeId

to: NodeId

edge_type: String

weight: f32

attrs: Vec<(String, Value)>

valid_from: Option<u64>

Valid-time start (epoch micros): when the relationship became true. None is open-ended. The system-time axis (when observed) is the upsert’s log offset, so a fact can be superseded by closing valid_to and opening a new edge rather than overwriting. Absent on the wire when unset.

valid_to: Option<u64>

Valid-time end (epoch micros): when the relationship stopped being true. None is still valid.

source: Option<SourceRef>

The source that most recently asserted this relationship, if known. See SourceRef.

Implementations

impl GraphEdge

pub fn relate( from: &GraphNode, edge_type: impl Into<String>, to: &GraphNode, ) -> Self

An edge of edge_type from from to to, weight 1.0. Its id is content-addressed over the endpoints and type, so the same relationship is one edge. The ergonomic way to relate two GraphNodes for an upsert.

pub fn with_source(self, source: SourceRef) -> Self

Set the source that asserted this relationship. See SourceRef. The edge id is unchanged: provenance is metadata, not identity.

pub fn valid(self, from: Option<u64>, to: Option<u64>) -> Self

Set the valid-time window (epoch micros) on this edge, for a bitemporal fact. Either bound may be None for open-ended. The edge id is unchanged: validity is metadata on the relationship, not part of its identity, so re-observing the same relationship with a new window updates the same edge.

pub fn valid_at(&self, at: u64) -> bool

Whether this edge’s valid-time window contains at (epoch micros). An open bound is treated as unbounded, so an edge with no window always holds. The half-open convention is [valid_from, valid_to).

Trait Implementations

impl Clone for GraphEdge

fn clone(&self) -> GraphEdge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphEdge

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GraphEdge

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for GraphEdge

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for GraphEdge

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 GraphEdge