Struct Json

pub struct Json<T>(pub T);

Json struct is a wrapper to handle the return types from the RedisJSON commands.

RedisJSON usually returns values in square brackets, which you usually had to handle manually:

// You have to manually deserialize this and pull from the Vec
let user_id: String = con.json_get("user", "$.id")?;  // => "[1]"

Instead, Json implements the FromRedisValue trait, removes the square brackets and deserializes from JSON. For this your type don’t even have to implement FromRedisValue, it only requires to be serde Deserialize-able.

#[derive(Serialize, Deserialize)]
struct User { id: u32 }
  
let Json(user_id): Json<u32> = con.json_get("user", "$.id")?;  // => 1
let Json(user): Json<User> = con.json_get("user", "$")?;  // => User { id: 1 }

This command is designed to use RedisJSON commands. You could probably use this type to parse normal command outputs, but it removes the first and last character so it is not recommended.

Tuple Fields

0: T

The inner type to deserialize

Trait Implementations

impl<T: Debug> Debug for Json<T>

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

Formats the value using the given formatter.

impl<T> FromRedisValue for Json<T>

where T: DeserializeOwned,

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_owned_redis_value(v: Value) -> Result<Self, RedisError>

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.

fn from_owned_redis_values(items: Vec<Value>) -> Result<Vec<Self>, RedisError>

The same as from_redis_values, but takes a Vec<Value> instead of a &[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>, RedisError>

Convert bytes to a single element vector.