Enum Value 

pub enum Value {
    Nil,
    Int(i64),
    BulkString(Bytes),
    Array(Vec<Result<Value>>),
    SimpleString(String),
    Okay,
    Map(Vec<(Value, Value)>),
    Attribute {
        data: Box<Value>,
        attributes: Vec<(Value, Value)>,
    },
    Set(Vec<Value>),
    Double(f64),
    Boolean(bool),
    VerbatimString {
        format: VerbatimFormat,
        text: String,
    },
    BigNumber(BigInt),
    Push {
        kind: PushKind,
        data: Vec<Value>,
    },
}

Internal low-level valkey value enum.

Variants

Nil

A nil response from the server.

Int(i64)

An integer response. Note that there are a few situations in which redis actually returns a string for an integer which is why this library generally treats integers and strings the same for all numeric responses.

BulkString(Bytes)

An arbitrary binary data, usually represents a binary-safe string.

Array(Vec<Result<Value>>)

A response containing an array with more data. This is generally used by redis to express nested structures.

SimpleString(String)

A simple string response, without line breaks and not binary safe.

Okay

A status response which represents the string “OK”.

Map(Vec<(Value, Value)>)

Unordered key,value list from the server. Use as_map_iter function.

Attribute

Attribute value from the server. Client will give data instead of whole Attribute type.

Fields

data: Box<Value>

Data that attributes belong to.

attributes: Vec<(Value, Value)>

Key,Value list of attributes.

Set(Vec<Value>)

Unordered set value from the server.

Double(f64)

A floating number response from the server.

Boolean(bool)

A boolean response from the server.

VerbatimString

First String is format and other is the string

Fields

format: VerbatimFormat

Text’s format type

text: String

Remaining string check format before using!

BigNumber(BigInt)

Very large number that out of the range of the signed 64 bit numbers

Push

Push data from the server.

Fields

kind: PushKind

Push Kind

data: Vec<Value>

Remaining data from push message

Implementations

impl Value

Values are generally not used directly unless you are using the more low level functionality in the library. For the most part this is hidden with the help of the FromValue trait.

While on the redis protocol there is an error type this is already separated at an early point so the value only holds the remaining types.

pub fn looks_like_cursor(&self) -> bool

Checks if the return value looks like it fulfils the cursor protocol. That means the result is an array item of length two with the first one being a cursor and the second an array response.

pub fn as_sequence(&self) -> Option<&Vec<Result<Value>>>

Returns an &Vec<Result<Value>> if self is an Array

pub fn as_plain_sequence(&self) -> Option<&[Value]>

Returns an &[Value] if self is compatible with a plain sequence type (Set or Nil).

pub fn into_sequence(self) -> Result<Vec<Result<Value>>, Value>

Returns a Vec<Result<Value>> if self is compatible with a sequence type, otherwise returns Err(self).

pub fn as_map_iter(&self) -> Option<MapIter<'_>>

Returns an iterator of (&Value, &Value) if self is a Map type

pub fn into_map_iter(self) -> Result<OwnedMapIter, Value>

Returns an iterator of (Value, Value) if self is a Map type. If not, returns Err(self).

pub fn extract_error(self) -> Result<Self>

Extracts a server error from the value, if present.

If the value contains an Err element in an array, this function returns it as an Err(Error). Otherwise, it wraps the value in Ok.

If there are multiple errors (e.g., within an array or map), only the first encountered error is returned.

This function is useful for extracting errors from values that may contain errors.

pub fn extract_error_vec(vec: Vec<Result<Self>>) -> Result<Vec<Result<Self>>>

Extract an error from vec of Result<Value> (Array elements). Returns the first Err found, or the vec unchanged.

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, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromValue for Value

fn from_value(v: &Value) -> Result<Value>

Given a valkey 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_owned_value(v: Value) -> Result<Self>

Given a valkey 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_values(items: &[Value]) -> Result<Vec<Self>>

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

fn from_result_values(items: &[Result<Value>]) -> Result<Vec<Self>>

Like from_values but for array elements that are Result<Value>. Propagates the first Err found, then converts each Ok(Value).

fn from_owned_values(items: Vec<Value>) -> Result<Vec<Self>>

The same as from_values, but takes a Vec<Value> instead of a &[Value].

fn from_owned_result_values(items: Vec<Result<Value>>) -> Result<Vec<Self>>

Like from_owned_values but for array elements that are Result<Value>.

fn from_byte_vec(_vec: &[u8]) -> Option<Vec<Self>>

Convert bytes to a single element vector.

fn from_owned_byte_vec(_vec: Vec<u8>) -> Result<Vec<Self>>

Convert bytes to a single element vector.

impl PartialEq for Value

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

fn arg_idx(&self, idx: usize) -> Option<&[u8]>

Returns a reference to the data for the argument at idx.

fn position(&self, candidate: &[u8]) -> Option<usize>

Returns index of argument that matches candidate, if it exists

fn command(&self) -> Option<Vec<u8>>

Convenience function to return ascii uppercase version of the the first argument (i.e., the command).

impl StructuralPartialEq for Value