Enum Value 

pub enum Value {
    Node(NodeId, Node),
    NodeRef(NodeId),
    Edge(EdgeId, Edge),
    EdgeRef(EdgeId, NodeId, NodeId, EdgeType),
    Property(PropertyValue),
    Path {
        nodes: Vec<NodeId>,
        edges: Vec<EdgeId>,
    },
    Null,
}

Value types that can be bound to variables in a query record.

The key design choice here is the late materialization hierarchy:

• NodeRef(id) – a lazy reference. Stores only the 64-bit NodeId. Produced by scan and expand operators. Extremely cheap to create (no heap allocation, no cloning). Properties are resolved on demand via resolve_property(prop, store).

• Node(id, node) – a fully materialized node. Contains a clone of the Node struct with all labels and properties. Produced by ProjectOperator when the RETURN clause requests RETURN n (the entire node), triggering full materialization.

The same lazy/eager split exists for edges: EdgeRef(id, src, tgt, type) carries the structural data (endpoints and type) without property clones, while Edge(id, edge) is fully materialized.

Property(PropertyValue) wraps scalar values (strings, integers, floats, booleans, datetimes, arrays, maps) that result from property access (n.name) or literal expressions. Path stores ordered sequences of node/edge IDs for named path patterns like p = (a)-[]->(b). Null represents the absence of a value, following Cypher’s three-valued logic (true/false/null).

Variants

Node(NodeId, Node)

A fully materialized node

NodeRef(NodeId)

A lazy node reference (no property clone)

Edge(EdgeId, Edge)

A fully materialized edge

EdgeRef(EdgeId, NodeId, NodeId, EdgeType)

A lazy edge reference (structural data only, no property clone)

Property(PropertyValue)

A property value

Path

A path (ordered sequence of node/edge IDs)

Fields

nodes: Vec<NodeId>

edges: Vec<EdgeId>

Null

Null

Implementations

impl Value

pub fn as_node(&self) -> Option<(NodeId, &Node)>

Get as node if this is a fully materialized node value

pub fn as_edge(&self) -> Option<(EdgeId, &Edge)>

Get as edge if this is a fully materialized edge value

pub fn as_property(&self) -> Option<&PropertyValue>

Get as property if this is a property value

pub fn is_null(&self) -> bool

Check if this is null

pub fn node_id(&self) -> Option<NodeId>

Extract NodeId from any node variant (Node or NodeRef)

pub fn edge_id(&self) -> Option<EdgeId>

Extract EdgeId from any edge variant (Edge or EdgeRef)

pub fn edge_endpoints(&self) -> Option<(NodeId, NodeId)>

Extract edge endpoints from any edge variant

pub fn edge_type(&self) -> Option<&EdgeType>

Extract edge type from any edge variant

pub fn is_node(&self) -> bool

Check if this represents a node (Node or NodeRef)

pub fn is_edge(&self) -> bool

Check if this represents an edge (Edge or EdgeRef)

pub fn materialize_node(self, store: &GraphStore) -> Self

Materialize a NodeRef into a full Node by looking it up in the store. Returns self unchanged if already materialized or not a node variant.

pub fn materialize_edge(self, store: &GraphStore) -> Self

Materialize an EdgeRef into a full Edge by looking it up in the store. Returns self unchanged if already materialized or not an edge variant.

pub fn resolve_property( &self, property: &str, store: &GraphStore, ) -> PropertyValue

Resolve a property from this value, using columnar store first, then falling back to materialized node/edge properties or store lookup for refs.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl Hash for Value

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Value

fn eq(&self, other: &Self) -> 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 Eq for Value