JsonCommands in redis - Rust
Description: Implements RedisJSON commands for connection like objects. This allows you to send commands straight to a connection or client. It is also implemented for redis results of clients which makes for very convenient access in some basic cases.

Skip to main content

## JsonCommands

# Trait JsonCommands

Source

    pub trait JsonCommands: ConnectionLike + Sized {
    Show 20 methods    // Provided methods
        fn json_arr_append<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            value: &'a V,
        ) -> RedisResult<RV> { ... }
        fn json_arr_index<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            value: &'a V,
        ) -> RedisResult<RV> { ... }
        fn json_arr_index_ss<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            value: &'a V,
            start: &'a isize,
            stop: &'a isize,
        ) -> RedisResult<RV> { ... }
        fn json_arr_insert<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            index: i64,
            value: &'a V,
        ) -> RedisResult<RV> { ... }
        fn json_arr_len<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_arr_pop<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            index: i64,
        ) -> RedisResult<RV> { ... }
        fn json_arr_trim<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            start: i64,
            stop: i64,
        ) -> RedisResult<RV> { ... }
        fn json_clear<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_del<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_get<'a, K: ToSingleRedisArg, P: ToRedisArgs, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_mget<'a, K: ToRedisArgs, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_num_incr_by<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            value: i64,
        ) -> RedisResult<RV> { ... }
        fn json_obj_keys<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_obj_len<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_set<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            value: &'a V,
        ) -> RedisResult<RV> { ... }
        fn json_mset<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>(
            &mut self,
            key_path_values: &'a [(K, P, V)],
        ) -> RedisResult<RV> { ... }
        fn json_str_append<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
            value: V,
        ) -> RedisResult<RV> { ... }
        fn json_str_len<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_toggle<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
        fn json_type<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>(
            &mut self,
            key: K,
            path: P,
        ) -> RedisResult<RV> { ... }
    }

Available on crate feature `json` only.
Expand description

Implements RedisJSON commands for connection like objects. This allows you to send commands straight to a connection or client. It is also implemented for redis results of clients which makes for very convenient access in some basic cases.

This allows you to use nicer syntax for some common operations. For instance this code:

    use redis::JsonCommands;
    use serde_json::json;
    let client = redis::Client::open("redis://127.0.0.1/")?;
    let mut con = client.get_connection()?;
    redis::cmd("JSON.SET").arg("my_key").arg("$").arg(&json!({"item": 42i32}).to_string()).exec(&mut con).unwrap();
    assert_eq!(redis::cmd("JSON.GET").arg("my_key").arg("$").query(&mut con), Ok(String::from(r#"[{"item":42}]"#)));

Will become this:

    use redis::JsonCommands;
    use serde_json::json;
    let client = redis::Client::open("redis://127.0.0.1/")?;
    let mut con = client.get_connection()?;
    let _: () = con.json_set("my_key", "$", &json!({"item": 42i32}).to_string())?;
    assert_eq!(con.json_get("my_key", "$"), Ok(String::from(r#"[{"item":42}]"#)));
    assert_eq!(con.json_get("my_key", "$.item"), Ok(String::from(r#"[42]"#)));

With RedisJSON commands, you have to note that all results will be wrapped in square brackets (or empty brackets if not found). If you want to deserialize it with e.g. `serde_json` you have to use `Vec<T>` for your output type instead of `T`.

## Provided Methods§

Source

#### fn json_arr_append<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V, ) -> RedisResult<RV>

Append the JSON `value` to the array at `path` after the last element in it.

Source

#### fn json_arr_index<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V, ) -> RedisResult<RV>

Index array at `path`, returns first occurrence of `value`

Source

#### fn json_arr_index_ss<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V, start: &'a isize, stop: &'a isize, ) -> RedisResult<RV>

Same as `json_arr_index` except takes a `start` and a `stop` value, setting these to `0` will mean they make no effect on the query

The default values for `start` and `stop` are `0`, so pass those in if you want them to take no effect

Source

#### fn json_arr_insert<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, index: i64, value: &'a V, ) -> RedisResult<RV>

Inserts the JSON `value` in the array at `path` before the `index` (shifts to the right).

`index` must be within the array’s range.

Source

#### fn json_arr_len<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Reports the length of the JSON Array at `path` in `key`.

Source

#### fn json_arr_pop<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, index: i64, ) -> RedisResult<RV>

Removes and returns an element from the `index` in the array.

`index` defaults to `-1` (the end of the array).

Source

#### fn json_arr_trim<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, start: i64, stop: i64, ) -> RedisResult<RV>

Trims an array so that it contains only the specified inclusive range of elements.

This command is extremely forgiving and using it with out-of-range indexes will not produce an error. There are a few differences between how RedisJSON v2.0 and legacy versions handle out-of-range indexes.

Source

#### fn json_clear<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Clears container values (Arrays/Objects), and sets numeric values to 0.

Source

#### fn json_del<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Deletes a value at `path`.

Source

#### fn json_get<'a, K: ToSingleRedisArg, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Gets JSON Value at `path`.

With RedisJSON commands, you have to note that all results will be wrapped in square brackets (or empty brackets if not found). If you want to deserialize it with e.g. `serde_json` you have to use `Vec<T>` for your output type instead of `T`.

Source

#### fn json_mget<'a, K: ToRedisArgs, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Gets JSON Values at `path`.

With RedisJSON commands, you have to note that all results will be wrapped in square brackets (or empty brackets if not found). If you want to deserialize it with e.g. `serde_json` you have to use `Vec<T>` for your output type instead of `T`.

Source

#### fn json_num_incr_by<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, value: i64, ) -> RedisResult<RV>

Increments the number value stored at `path` by `number`.

Source

#### fn json_obj_keys<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Returns the keys in the object that’s referenced by `path`.

Source

#### fn json_obj_len<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Reports the number of keys in the JSON Object at `path` in `key`.

Source

#### fn json_set<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V, ) -> RedisResult<RV>

Sets the JSON Value at `path` in `key`.

Source

#### fn json_mset<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: Serialize, RV: FromRedisValue>( &mut self, key_path_values: &'a [(K, P, V)], ) -> RedisResult<RV>

Sets the value at the path per key, for every given tuple.

Source

#### fn json_str_append<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, V: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, value: V, ) -> RedisResult<RV>

Appends the `json-string` values to the string at `path`.

Source

#### fn json_str_len<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Reports the length of the JSON String at `path` in `key`.

Source

#### fn json_toggle<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Toggle a `boolean` value stored at `path`.

Source

#### fn json_type<'a, K: ToSingleRedisArg, P: ToSingleRedisArg, RV: FromRedisValue>( &mut self, key: K, path: P, ) -> RedisResult<RV>

Reports the type of JSON value at `path`.

## Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

## Implementors§

Source§

### impl<T> JsonCommands for T
where T: ConnectionLike,