Enum GraphValue

pub enum GraphValue {
    Unknown(Value),
    Map(GraphMap),
    Point(GeoPoint),
    Path(GraphPath),
    Node(Node),
    Relation(Relationship),
    Array(Vec<GraphValue>),
    Integer(i64),
    Double(f64),
    String(String),
    Boolean(bool),
    Null,
}

An enum containing every possible type that can be returned by redisgraph

Variants

Unknown(Value)

Value is Unknown and stored as a redis::Value

Map(GraphMap)

A Map as returned by

Return {a: 2, b: "Hello"}

Point(GeoPoint)

A Point as returned by

Return point({latitude: 32.070794860, longitude: 34.820751118})

Path(GraphPath)

A Path as returned by

Match p=(:A)-[:B]->(:C) Return p

Node(Node)

A Node as returned by

Match (a:A) Return a

Relation(Relationship)

A Relationship as returned by

Match (:A)-[b:B]->(:C) Return b

Array(Vec<GraphValue>)

A Array as returned by

Return [1, 2.0, "Hi"]

Integer(i64)

A Integer as returned by

Return 1337

Double(f64)

A Double as returned by

Return 1337.0

String(String)

A String as returned by

Return '1337'

Boolean(bool)

A Boolean as returned by

Return true, false, 1=1

Null

A Null type which is returned when an Optinal Match does not match or when a property of a node is returned but the node does not have this property

Trait Implementations

impl Clone for GraphValue

fn clone(&self) -> GraphValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphValue

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

Formats the value using the given formatter.

impl FromGraphValue for GraphValue

fn from_graph_value(value: GraphValue) -> RedisResult<Self>

Converts the GraphValue to the implementing Type

impl FromRedisValue for GraphValue

fn from_redis_value(v: &Value) -> RedisResult<Self>

Given a redis Value this attempts to convert it into the given destination type. If that fails because it’s not compatible an appropriate error is generated.

fn from_redis_values(items: &[Value]) -> Result<Vec<Self>, RedisError>

Similar to from_redis_value but constructs a vector of objects from another vector of values. This primarily exists internally to customize the behavior for vectors of tuples.

impl PartialEq for GraphValue

fn eq(&self, other: &GraphValue) -> 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 StructuralPartialEq for GraphValue