Enum rustis::commands::GraphValue

pub enum GraphValue {
    Null,
    String(Vec<u8>),
    Integer(i64),
    Boolean(bool),
    Double(f64),
    Array(Vec<GraphValue>),
    Edge(GraphEdge),
    Node(GraphNode),
    Path(GraphPath),
    Map(HashMap<String, GraphValue>),
    Point((f32, f32)),
}

Available on crate feature redis-graph only.

Object model for the different RedisGraph Data Types

Variants

Null

In RedisGraph, null is used to stand in for an unknown or missing value.

String(Vec<u8>)

RedisGraph strings are Unicode character sequences.

Integer(i64)

All RedisGraph integers are treated as 64-bit signed integers.

Boolean(bool)

Boolean values are specified as true or false.

Double(f64)

All RedisGraph floating-point values are treated as 64-bit signed doubles.

Array(Vec<GraphValue>)

Arrays are ordered lists of elements.

Edge(GraphEdge)

Relationships are persistent graph elements that connect one node to another.

Node(GraphNode)

Nodes are persistent graph elements that can be connected to each other via relationships.

Path(GraphPath)

Paths are alternating sequences of nodes and edges, starting and ending with a node.

Map(HashMap<String, GraphValue>)

Maps are order-agnostic collections of key-value pairs.

Point((f32, f32))

The Point data type is a set of latitude/longitude coordinates, stored within RedisGraph as a pair of 32-bit floats.

Implementations

impl GraphValue

pub fn into<T>(self) -> Result<T>

where T: FromGraphValue,

A GraphValue to user type conversion that consumes the input value.

Errors

Any parsing error (Error::Client) due to incompatibility between Value variant and taget type

Trait Implementations

impl Clone for GraphValue

fn clone(&self) -> GraphValue

Returns a copy 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<'de> Deserialize<'de> for GraphValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for GraphValue

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for GraphValue