Redis

https://docs.rs/redis/0.32.7/redis/
Admin
Redis-rs is a Rust client library for Redis that provides both low-level and high-level APIs for...
Tokens:532,562
Snippets:4,676
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### HashMap get method example

Source: https://docs.rs/redis/0.32.7/redis/struct.InfoDict.html

Demonstrates the usage of the `get` method on a HashMap to retrieve a value by key.

```rust
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```

--------------------------------

### Async Cluster Connection Example

Source: https://docs.rs/redis/0.32.7/redis/cluster_async/index.html

Demonstrates establishing an asynchronous connection to a Redis Cluster and performing basic SET and GET operations.

```rust
use redis::cluster::ClusterClient;
use redis::AsyncCommands;

async fn fetch_an_integer() -> String {
    let nodes = vec!["redis://127.0.0.1/"];
    let client = ClusterClient::new(nodes).unwrap();
    let mut connection = client.get_async_connection().await.unwrap();
    let _: () = connection.set("test", "test_data").await.unwrap();
    let rv: String = connection.get("test").await.unwrap();
    return rv;
}
```

--------------------------------

### Connect to Redis Sentinel (Sync)

Source: https://docs.rs/redis/0.32.7/redis/index.html

Use SentinelClient to find a primary Redis node. This example demonstrates synchronous connection setup.

```rust
use redis::{ Commands, RedisConnectionInfo };
use redis::sentinel::{ SentinelServerType, SentinelClient, SentinelNodeConnectionInfo };

let nodes = vec!["redis://127.0.0.1:6379/", "redis://127.0.0.1:6378/", "redis://127.0.0.1:6377/"];
let mut sentinel = SentinelClient::build(
    nodes,
    String::from("primary1"),
    Some(SentinelNodeConnectionInfo {
        tls_mode: Some(redis::TlsMode::Insecure),
        redis_connection_info: None,
    }),
    redis::sentinel::SentinelServerType::Master,
)
.unwrap();

let primary = sentinel.get_connection().unwrap();
```

--------------------------------

### Basic String Operations: GET and SET

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Demonstrates the usage of `get` and `set` commands for retrieving and storing string values in Redis. Ensure the `redis` crate is imported.

```rust
pub trait TypedCommands: ConnectionLike + Sized {
    // Provided methods
    fn get<'a, K: ToRedisArgs + Send + Sync + 'a>(
        &'a mut self,
        key: K,
    ) -> RedisResult<Option<String>> { ... }
    fn set<'a, K: ToRedisArgs + Send + Sync + 'a, V: ToRedisArgs + Send + Sync + 'a>(
        &'a mut self,
        key: K,
        value: V,
    ) -> RedisResult<()> { ... }

```

--------------------------------

### Connect to Redis Sentinel (Async)

Source: https://docs.rs/redis/0.32.7/redis/index.html

Use SentinelClient to find a primary Redis node asynchronously. This example demonstrates async connection setup using futures.

```rust
use futures::prelude::*;
use redis::{ Commands, RedisConnectionInfo };
use redis::sentinel::{ SentinelServerType, SentinelClient, SentinelNodeConnectionInfo };

let nodes = vec!["redis://127.0.0.1:6379/", "redis://127.0.0.1:6378/", "redis://127.0.0.1:6377/"];
let mut sentinel = SentinelClient::build(
    nodes,
    String::from("primary1"),
    Some(SentinelNodeConnectionInfo {
        tls_mode: Some(redis::TlsMode::Insecure),
        redis_connection_info: None,
    }),
    redis::sentinel::SentinelServerType::Master,
)
.unwrap();

let primary = sentinel.get_async_connection().await.unwrap();
```

--------------------------------

### Default VEmbOptions

Source: https://docs.rs/redis/0.32.7/redis/struct.VEmbOptions.html

Shows how to get the default VEmbOptions. This is useful as a starting point for configuring VEMB command options.

```rust
let opts = VEmbOptions::default();
```

--------------------------------

### RadiusOptions Usage Example

Source: https://docs.rs/redis/0.32.7/redis/geo/struct.RadiusOptions.html

Demonstrates how to create and configure RadiusOptions for a geospatial query. This example shows setting a limit and ordering results by distance.

```APIDOC
## RadiusOptions Usage Example

This example demonstrates how to configure `RadiusOptions` to customize a geospatial query.

### Description

This snippet shows how to use the `RadiusOptions` struct to specify parameters for the `geo_radius` command, such as limiting the number of results and ordering them by distance.

### Method

This is a conceptual example demonstrating the use of the `RadiusOptions` struct and its methods within a Rust context. It is not a direct API endpoint.

### Parameters

This example utilizes methods of the `RadiusOptions` struct:

- `default()`: Creates a default `RadiusOptions` instance.
- `order(RadiusOrder::Asc)`: Sets the results to be ordered in ascending order (closest first).
- `limit(limit)`: Limits the number of results returned to the specified `limit`.

### Request Example

```rust
use redis::{Commands, RedisResult};
use redis::geo::{RadiusSearchResult, RadiusOptions, RadiusOrder, Unit};

fn nearest_in_radius(
    con: &mut redis::Connection,
    key: &str,
    longitude: f64,
    latitude: f64,
    meters: f64,
    limit: usize,
) -> RedisResult<Vec<RadiusSearchResult>> {
    let opts = RadiusOptions::default()
        .order(RadiusOrder::Asc)
        .limit(limit);
    con.geo_radius(key, longitude, latitude, meters, Unit::Meters, opts)
}
```

### Response

This example returns a `RedisResult` which, upon success, contains a `Vec<RadiusSearchResult>`.

#### Success Response

- **Vec<RadiusSearchResult>** - A vector of search results, each containing information about a location within the specified radius.
```

--------------------------------

### HashMap with_capacity example

Source: https://docs.rs/redis/0.32.7/redis/struct.InfoDict.html

Shows how to create a HashMap with a specified initial capacity.

```rust
use std::collections::HashMap;
let map: HashMap<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);
```

--------------------------------

### HashMap keys iterator example

Source: https://docs.rs/redis/0.32.7/redis/struct.InfoDict.html

Demonstrates iterating over the keys of a HashMap.

```rust
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for key in map.keys() {
    println!("{key}");
}
```

--------------------------------

### Example Usage of LposOptions

Source: https://docs.rs/redis/0.32.7/redis/struct.LposOptions.html

Demonstrates how to create and configure LposOptions to fetch list positions with specific criteria. Requires the `redis` crate and a `redis::Connection`.

```rust
use redis::{Commands, RedisResult, LposOptions};
fn fetch_list_position(
    con: &mut redis::Connection,
    key: &str,
    value: &str,
    count: usize,
    rank: isize,
    maxlen: usize,
) -> RedisResult<Vec<usize>> {
    let opts = LposOptions::default()
        .count(count)
        .rank(rank)
        .maxlen(maxlen);
    con.lpos(key, value, opts)
}
```

--------------------------------

### Redis Transaction Example

Source: https://docs.rs/redis/0.32.7/redis/fn.transaction.html

This example demonstrates how to use the `transaction` function to atomically increment a Redis key. It watches the key, performs a get and set operation within the transaction, and retrieves the final value.

```rust
use redis::Commands;
let key = "the_key";
let (new_val,) : (isize,) = redis::transaction(&mut con, &[key], |con, pipe| {
    let old_val : isize = con.get(key)?;
    pipe
        .set(key, old_val + 1).ignore()
        .get(key).query(con)
})?;
println!("The incremented number is: {}", new_val);
```

--------------------------------

### Example: Sending Protobufs to Redis with reserve_space_for_args

Source: https://docs.rs/redis/0.32.7/redis/trait.RedisWrite.html

Demonstrates how to use reserve_space_for_args to pre-allocate space for multiple arguments when sending Protobuf messages to Redis.

```rust
use prost::Message;

let to_send: Vec<SomeType> = todo!();
let mut cmd = Cmd::new();

// Calculate and reserve the space for the args
cmd.reserve_space_for_args(to_send.iter().map(Message::encoded_len));

// Write the args to the buffer
for arg in to_send {
    // Encode the type directly into the Cmd buffer
    // Supplying the required capacity again is not needed for Cmd,
    // but can be useful for other implementers like Vec<Vec<u8>>.
    arg.encode(cmd.bufmut_for_next_arg(arg.encoded_len()));
}

```

--------------------------------

### Get all messages in a stream in reverse

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterPipeline.html

A reverse version of `xrange_all`, retrieving all messages from a stream starting from the most recent.

```shell
XREVRANGE key + -
```

--------------------------------

### FlushAll Options Example

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Shows how to use FlushAll with specific options, such as controlling persistence. This allows for more granular control over the flush operation.

```rust
fn flushall_options<'a>(
        &'a mut self,
        options: &'a FlushAllOptions,
    ) -> RedisResult<()> { ... }
```

--------------------------------

### Redis Pub/Sub Connection and Message Handling Example

Source: https://docs.rs/redis/0.32.7/redis/struct.PubSub.html

Demonstrates how to create a PubSub connection, subscribe to channels, and continuously listen for and process incoming messages. Ensure you have a Redis server running and accessible.

```rust
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_connection()?;
let mut pubsub = con.as_pubsub();
pubsub.subscribe("channel_1")?;
pubsub.subscribe("channel_2")?;

loop {
    let msg = pubsub.get_message()?;
    let payload : String = msg.get_payload()?;
    println!("channel '{}': {}", msg.get_channel_name(), payload);
}
```

--------------------------------

### Example Usage of CopyOptions

Source: https://docs.rs/redis/0.32.7/redis/struct.CopyOptions.html

Demonstrates how to create and configure CopyOptions for the Redis COPY command. Use this when you need to copy a key to another database or replace an existing key.

```rust
use redis::{Commands, RedisResult, CopyOptions, SetExpiry, ExistenceCheck};
fn copy_value(
    con: &mut redis::Connection,
    old: &str,
    new: &str,
) -> RedisResult<Vec<usize>> {
    let opts = CopyOptions::default()
        .db("my_other_db")
        .replace(true);
    con.copy(old, new, opts)
}
```

--------------------------------

### Get a reverse range of messages in a stream

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterPipeline.html

Retrieves messages from a stream in reverse order. Similar to `xrange` but starts from the most recent messages.

```shell
XREVRANGE key end start
```

--------------------------------

### FlushDb Options Example

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Illustrates using FlushDb with specific options, providing finer control over the database clearing process.

```rust
fn flushdb_options<'a>(
        &'a mut self,
        options: &'a FlushDbOptions,
    ) -> RedisResult<()> { ... }
```

--------------------------------

### HashMap values iterator example

Source: https://docs.rs/redis/0.32.7/redis/struct.InfoDict.html

Demonstrates iterating over the values of a HashMap.

```rust
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for val in map.values() {
    println!("{val}");
}
```

--------------------------------

### FlushDb Example

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Demonstrates the basic FlushDb command to remove all keys from the currently selected database. Use with caution.

```rust
fn flushdb<'a>(&'a mut self) -> RedisResult<()> { ... }
```

--------------------------------

### Basic Redis Pipeline Example

Source: https://docs.rs/redis/0.32.7/redis/struct.Pipeline.html

Demonstrates how to send multiple commands (SET and MGET) in a single pipeline and retrieve results. Use `ignore()` to skip return values for commands like SET.

```rust
let ((k1, k2),) : ((i32, i32),) = redis::pipe()
    .cmd("SET").arg("key_1").arg(42).ignore()
    .cmd("SET").arg("key_2").arg(43).ignore()
    .cmd("MGET").arg(&["key_1", "key_2"]).query(&mut con).unwrap();
```

--------------------------------

### Get Integer Example

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Demonstrates retrieving a single key's value as an integer using get_int. The return type is Option<isize> to handle missing keys or non-integer values.

```rust
fn get_int<K: ToRedisArgs>(&mut self, key: K) -> RedisResult<Option<isize>> { ... }
```

--------------------------------

### FlushAll Example

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Demonstrates the basic FlushAll command to remove all keys from all databases. This is a destructive operation.

```rust
fn flushall<'a>(&'a mut self) -> RedisResult<()> { ... }
```

--------------------------------

### Example Usage of FlushAllOptions

Source: https://docs.rs/redis/0.32.7/redis/struct.FlushAllOptions.html

Demonstrates how to create and use FlushAllOptions with the flushall command in a Redis connection. The blocking option is set to true.

```rust
use redis::{Commands, RedisResult, FlushAllOptions};
fn flushall_sync(
    con: &mut redis::Connection,
) -> RedisResult<()> {
    let opts = FlushAllOptions{blocking: true};
    con.flushall_options(&opts)
}
```

--------------------------------

### Get Count of Pending Messages in a Range

Source: https://docs.rs/redis/0.32.7/redis/struct.Cmd.html

Returns a list of all pending messages within a specified range (start to end) for a stream and consumer group. Useful for paginating pending messages.

```rust
pub fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs>(
    key: K,
    group: G,
    start: S,
    end: E,
    count: C,
) -> Self
```

```shell
XPENDING <key> <group> <start> <stop> <count>
```

--------------------------------

### Basic Cmd Creation

Source: https://docs.rs/redis/0.32.7/redis/struct.Cmd.html

Demonstrates the basic usage of creating a Redis command using Cmd::new() and chaining arguments.

```rust
redis::Cmd::new().arg("SET").arg("my_key").arg(42);
```

--------------------------------

### Get Pending Messages by Range

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterPipeline.html

Returns a list of all pending messages within a specified range (start, end, count) for a stream and group. Useful for paginating pending messages. The return type is StreamPendingCountReply.

```rust
pub fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs>(
    &mut self,
    key: K,
    group: G,
    start: S,
    end: E,
    count: C,
) -> &mut Self
```

```redis
XPENDING <key> <group> <start> <stop> <count>
```

--------------------------------

### Get Pending Messages by Consumer

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncCommands.html

Retrieves a list of pending messages within a specified range (start, stop, count) for a given stream key, consumer group, and specific consumer. Requires the `streams` feature.

```rust
XPENDING <key> <group> <start> <stop> <count> <consumer>
```

--------------------------------

### Scan Options Example

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Shows how to use SCAN with ScanOptions to control the iteration, such as setting a cursor or count. This allows for paginated or filtered key retrieval.

```rust
fn scan_options<RV: FromRedisValue>(
        &mut self,
        opts: ScanOptions,
    ) -> RedisResult<Iter<'_, RV>> { ... }
```

--------------------------------

### Get Pending Messages by Range

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncCommands.html

Retrieves a list of all pending messages within a specified range (start, stop, count) for a given stream key and consumer group. Useful for paginating pending messages. Requires the `streams` feature.

```rust
XPENDING <key> <group> <start> <stop> <count>
```

--------------------------------

### get

Source: https://docs.rs/redis/0.32.7/redis/aio/struct.MultiplexedConnection.html

Get the value of a key. If key is a vec this becomes an `MGET` (if using `TypedCommands`, you should specifically use `mget` to get the correct return type.

```APIDOC
## get

### Description
Get the value of a key. If key is a vec this becomes an `MGET` (if using `TypedCommands`, you should specifically use `mget` to get the correct return type.

### Method
`get<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(&'a mut self, key: K) -> RedisFuture<'a, RV>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None provided.

### Response
#### Success Response (200)
`RedisFuture<'a, RV>` where `RV: FromRedisValue`

#### Response Example
None provided.
```

--------------------------------

### Hash Get All - Async

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncTypedCommands.html

Get all the fields and values in a hash.

```rust
fn hgetall<'a, K: ToRedisArgs + Send + Sync + 'a>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, HashMap<String, String>> { ... }
```

--------------------------------

### get

Source: https://docs.rs/redis/0.32.7/redis/struct.Connection.html

Get the value of a key. If key is a vec this becomes an `MGET`.

```APIDOC
## get<'a, K, RV>

### Description
Get the value of a key. If the key is a vector, this operation becomes an `MGET`.

### Signature
`fn get<'a, K: ToRedisArgs, RV: FromRedisValue>(&mut self, key: K) -> RedisResult<RV>`

### Type Parameters
* `K`: Type that can be converted into Redis arguments (the key).
* `RV`: Type that can be created from a Redis value (the return type).

### Parameters
* `key`: The key to retrieve the value from.
```

--------------------------------

### Subscribe to Channels Example

Source: https://docs.rs/redis/0.32.7/redis/trait.PubSubCommands.html

Demonstrates subscribing to a channel and using ControlFlow to stop after a specific number of messages.

```rust
use redis::{PubSubCommands, ControlFlow};
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_connection()?;
let mut count = 0;
con.subscribe(&["foo"], |msg| {
    // do something with message
    assert_eq!(msg.get_channel(), Ok(String::from("foo")));

    // increment messages seen counter
    count += 1;
    match count {
        // stop after receiving 10 messages
        10 => ControlFlow::Break(()),
        _ => ControlFlow::Continue,
    }
})?;
```

--------------------------------

### ClusterPipeline::cmd

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterPipeline.html

Starts a new command within the pipeline, allowing further arguments to be added.

```APIDOC
## ClusterPipeline::cmd

### Description
Starts a new command. Functions such as `arg` then become available to add more arguments to that command.

### Method
`cmd(&mut self, name: &str) -> &mut Self`

### Parameters
#### Path Parameters
- **name** (&str) - Required - The name of the command to start.

### Returns
A mutable reference to the `ClusterPipeline` instance, allowing further command configuration.
```

--------------------------------

### Redis Client Get Name Command

Source: https://docs.rs/redis/0.32.7/redis/trait.Commands.html

Gets the current connection name in Redis.

```rust
fn client_getname<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV> { ... }
```

--------------------------------

### Async Cluster Pipelining Example

Source: https://docs.rs/redis/0.32.7/redis/cluster_async/index.html

Shows how to perform multiple Redis commands asynchronously in a pipeline using the cluster connection. Commands are ignored after execution.

```rust
use redis::cluster::ClusterClient;
use redis::{Value, AsyncCommands};

async fn fetch_an_integer() -> redis::RedisResult<() > {
    let nodes = vec!["redis://127.0.0.1/"];
    let client = ClusterClient::new(nodes).unwrap();
    let mut connection = client.get_async_connection().await.unwrap();
    let key = "test";

    redis::pipe()
        .rpush(key, "123").ignore()
        .ltrim(key, -10, -1).ignore()
        .expire(key, 60).ignore()
        .exec_async(&mut connection).await
}
```

--------------------------------

### get

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterPipeline.html

Get the value of a key. If key is a vec this becomes an `MGET`. Redis Docs

```APIDOC
## pub fn get<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

### Description
Retrieves the value associated with a given key.

### Parameters
#### Path Parameters
- **key** (K) - The key whose value is to be retrieved.

### Returns
- **&mut Self** - A mutable reference to the pipeline.

### Notes
- If the key is a vector, this operation becomes an `MGET`.

### Source
Redis Docs
```

--------------------------------

### get

Source: https://docs.rs/redis/0.32.7/redis/struct.Pipeline.html

Get the value of a key within a pipeline. This operation is part of the `Pipeline` trait.

```APIDOC
## get

### Description
Get the value of a key.

### Method
Pipeline

### Endpoint
get

### Parameters
#### Path Parameters
- **key** (K: ToRedisArgs) - Required - The key to retrieve the value for.

### Response
#### Success Response
- Returns the pipeline itself for chaining operations.
```

--------------------------------

### Scan Example

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Demonstrates the basic SCAN command to iterate over keys in the database. The return type RV can be specified to match the expected key type.

```rust
fn scan<RV: FromRedisValue>(&mut self) -> RedisResult<Iter<'_, RV>> { ... }
```

--------------------------------

### Set Key with Options Example

Source: https://docs.rs/redis/0.32.7/redis/struct.SetOptions.html

Demonstrates how to set a key-value pair in Redis with specific options like conditional setting (NX), retrieving the previous value, and setting an expiration time using SetOptions.

```rust
use redis::{Commands, RedisResult, SetOptions, SetExpiry, ExistenceCheck};
fn set_key_value(
    con: &mut redis::Connection,
    key: &str,
    value: &str,
) -> RedisResult<Vec<usize>> {
    let opts = SetOptions::default()
        .conditional_set(ExistenceCheck::NX)
        .get(true)
        .with_expiration(SetExpiry::EX(60));
    con.set_options(key, value, opts)
}
```

--------------------------------

### get

Source: https://docs.rs/redis/0.32.7/redis/aio/struct.ConnectionManager.html

Get the value of a key. Available on crate feature `aio` only. If key is a vec this becomes an `MGET`.

```APIDOC
## get

### Description
Get the value of a key. If key is a vec this becomes an `MGET` (if using `TypedCommands`, you should specifically use `mget` to get the correct return type.
Available on **crate feature`aio`** only.

### Method
GET

### Endpoint
/key/{key}

### Parameters
#### Path Parameters
- **key** (string) - Required - The key to retrieve the value for.

#### Query Parameters
None

### Response
#### Success Response (200)
- **value** (RV) - The value associated with the key, deserialized into the specified return type `RV`.

#### Response Example
```json
{
  "value": "<retrieved_value>"
}
```
```

--------------------------------

### Get Stream Groups Info

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Retrieves information about all consumer groups for a stream. Use this to get an overview of group status.

```rust
fn xinfo_groups<'a, K: ToRedisArgs + Send + Sync + 'a>(
        &'a mut self,
        key: K,
    ) -> RedisResult<StreamInfoGroupsReply> { ... }
```

--------------------------------

### Basic Cluster Connection and Command Execution

Source: https://docs.rs/redis/0.32.7/redis/cluster/index.html

Demonstrates how to establish a connection to a Redis Cluster and perform basic SET and GET operations. Ensure you have Redis instances running on the specified ports.

```rust
use redis::Commands;
use redis::cluster::ClusterClient;

let nodes = vec!["redis://127.0.0.1:6379/", "redis://127.0.0.1:6378/", "redis://127.0.0.1:6377/"];
let client = ClusterClient::new(nodes).unwrap();
let mut connection = client.get_connection().unwrap();

let _: () = connection.set("test", "test_data").unwrap();
let rv: String = connection.get("test").unwrap();

assert_eq!(rv, "test_data");
```

--------------------------------

### Configuring VAddOptions for Redis

Source: https://docs.rs/redis/0.32.7/redis/struct.VAddOptions.html

Demonstrates how to create and configure VAddOptions for the VADD command. This includes setting reduction dimension, check-and-set style, quantization, build exploration factor, attributes, and max number of links.

```rust
use redis::{Commands, RedisResult, VAddOptions, VectorQuantization};
fn add_vector(
    con: &mut redis::Connection,
    key: &str,
    vector: &[f64],
    element: &str,
) -> RedisResult<bool> {
    let opts = VAddOptions::default()
        .set_reduction_dimension(5)
        .set_check_and_set_style(true)
        .set_quantization(VectorQuantization::Q8)
        .set_build_exploration_factor(300)
        .set_attributes(serde_json::json!({"name": "Vector attribute name", "description": "Vector attribute description"}))
        .set_max_number_of_links(16);
    con.vadd_options(key, redis::VectorAddInput::Values(redis::EmbeddingInput::Float64(vector)), element, &opts)
}
```

--------------------------------

### get

Source: https://docs.rs/redis/0.32.7/redis/aio/struct.MultiplexedConnection.html

Get the value of a key. If the key does not exist, `None` is returned. This command is available only when the `aio` crate feature is enabled.

```APIDOC
## fn get<'a, K: ToRedisArgs + Send + Sync + 'a>(
&'a mut self,
key: K,
) -> RedisFuture<'a, Option<String>>

### Description
Get the value of a key.

### Parameters
#### Path Parameters
- **key** (K) - Required - The key to retrieve.

### Returns
A `RedisFuture` that resolves to an `Option<String>` containing the value if the key exists, otherwise `None`.
```

--------------------------------

### Get Integer Value

Source: https://docs.rs/redis/0.32.7/redis/trait.TypedCommands.html

Retrieves a value from Redis and attempts to convert it into an `Option<isize>`. Returns `None` if the key does not exist or the value cannot be converted.

```rust
fn get_int<K: ToRedisArgs>(&mut self, key: K) -> RedisResult<Option<isize>>
```

--------------------------------

### Create a ClusterClient with default parameters

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterClient.html

Use this to create a ClusterClient with default settings. It performs basic checks on initial node URLs and passwords but does not establish connections.

```rust
pub fn new<T: IntoConnectionInfo>( initial_nodes: impl IntoIterator<Item = T>, ) -> RedisResult<ClusterClient>
```

--------------------------------

### Get Channel Name as String

Source: https://docs.rs/redis/0.32.7/redis/struct.Msg.html

A convenience method to get a string version of the channel name. Returns "?" if the channel is not valid UTF-8.

```rust
pub fn get_channel_name(&self) -> &str
```

--------------------------------

### Example Usage of RadiusOptions

Source: https://docs.rs/redis/0.32.7/redis/geo/struct.RadiusOptions.html

Demonstrates how to use RadiusOptions to configure a GEORADIUS command, limiting results and ordering them by distance.

```rust
use redis::{Commands, RedisResult};
use redis::geo::{RadiusSearchResult, RadiusOptions, RadiusOrder, Unit};
fn nearest_in_radius(
    con: &mut redis::Connection,
    key: &str,
    longitude: f64,
    latitude: f64,
    meters: f64,
    limit: usize,
) -> RedisResult<Vec<RadiusSearchResult>> {
    let opts = RadiusOptions::default()
        .order(RadiusOrder::Asc)
        .limit(limit);
    con.geo_radius(key, longitude, latitude, meters, Unit::Meters, opts)
}
```

--------------------------------

### Create a ClusterClientBuilder

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterClient.html

Use this to start building a ClusterClient with custom configurations. It takes an iterator of initial node connection information.

```rust
pub fn builder<T: IntoConnectionInfo>( initial_nodes: impl IntoIterator<Item = T>, ) -> ClusterClientBuilder
```

--------------------------------

### Get HashMap Entry for Modification

Source: https://docs.rs/redis/0.32.7/redis/struct.InfoDict.html

Gets the given key’s corresponding entry for in-place manipulation. Available only on crate features `cluster` and `cluster-async`.

```rust
use std::collections::HashMap;

let mut letters = HashMap::new();

for ch in "a short treatise on fungi".chars() {
    letters.entry(ch).and_modify(|counter| *counter += 1).or_insert(1);
}

assert_eq!(letters[&'s'], 2);
assert_eq!(letters[&'t'], 3);
assert_eq!(letters[&'u'], 1);
assert_eq!(letters.get(&'y'), None);
```

--------------------------------

### Shorter Cmd Creation with `cmd` helper

Source: https://docs.rs/redis/0.32.7/redis/struct.Cmd.html

Shows a more concise way to create a Redis command using the `cmd` helper function.

```rust
redis::cmd("SET").arg("my_key").arg(42);
```

--------------------------------

### Basic Redis Command Execution (cmd)

Source: https://docs.rs/redis/0.32.7/redis/trait.Commands.html

This snippet demonstrates the traditional way of executing Redis commands using `redis::cmd` and `exec`. It's useful for understanding the underlying mechanism before adopting the trait-based approach.

```rust
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_connection()?;
redis::cmd("SET").arg("my_key").arg(42).exec(&mut con).unwrap();
assert_eq!(redis::cmd("GET").arg("my_key").query(&mut con), Ok(42));
```

--------------------------------

### Set Consumer Group Starting ID with XGROUP SETID

Source: https://docs.rs/redis/0.32.7/redis/struct.Pipeline.html

Alters the starting message ID from which consumers in an existing consumer group will read. Available on the `streams` crate feature.

```redis
XGROUP SETID <key> <groupname> <id or $> 
```

```rust
pub fn xgroup_setid<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs>(
    &mut self,
    key: K,
    group: G,
    id: ID,
) -> &mut Self
```

--------------------------------

### Create PubSub Instance

Source: https://docs.rs/redis/0.32.7/redis/struct.Connection.html

Creates a `PubSub` instance for this connection.

```rust
pub fn as_pubsub(&mut self) -> PubSub<'_>
```

--------------------------------

### Get the rank of a member in a sorted set (descending)

Source: https://docs.rs/redis/0.32.7/redis/trait.Commands.html

Use `zrevrank` to get the rank (position) of a member in a sorted set, ordered in descending score. Requires `ToRedisArgs` for key and member, and `FromRedisValue` for the result.

```rust
fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
        &mut self,
        key: K,
        member: M,
    ) -> RedisResult<RV> { ... }
```

--------------------------------

### Asynchronous Querying with Cmd

Source: https://docs.rs/redis/0.32.7/redis/struct.Cmd.html

Provides an example of asynchronously sending a command to a Redis connection and retrieving a result. Requires the 'aio' feature.

```rust
cmd.query_async(&mut con).await.expect("Query failed");
```

--------------------------------

### mget

Source: https://docs.rs/redis/0.32.7/redis/aio/struct.MultiplexedConnection.html

Get values of keys.

```APIDOC
## mget

### Description
Get values of keys.

### Method
`mget<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(&'a mut self, key: K) -> RedisFuture<'a, RV>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None provided.

### Response
#### Success Response (200)
`RedisFuture<'a, RV>` where `RV: FromRedisValue`

#### Response Example
None provided.
```

--------------------------------

### Connection::as_pubsub

Source: https://docs.rs/redis/0.32.7/redis/struct.Connection.html

Creates a `PubSub` instance for this connection, enabling publish/subscribe functionality.

```APIDOC
## Connection::as_pubsub

### Description
Creates a `PubSub` instance for this connection.

### Method
`&mut self`

### Returns
* `PubSub<'_>`
```

--------------------------------

### XPENDING CONSUMER COUNT

Source: https://docs.rs/redis/0.32.7/redis/trait.Commands.html

An alternate version of `xpending_count` which filters by `consumer` name. Start and end follow the same rules `xrange` args. Set start to `-` and end to `+` for the entire stream. Take note of the StreamPendingCountReply return type.

```APIDOC
## XPENDING CONSUMER COUNT

### Description
Filters pending messages in a stream by consumer name.

### Method
`xpending_consumer_count`

### Parameters
- `key`: The key of the stream.
- `group`: The consumer group name.
- `start`: The start ID for filtering (e.g., `-` for the beginning).
- `end`: The end ID for filtering (e.g., `+` for the end).
- `count`: The maximum number of pending messages to return.
- `consumer`: The name of the consumer to filter by.

### Return Type
`StreamPendingCountReply`
```

--------------------------------

### Comparing Raw Commands vs JsonCommands

Source: https://docs.rs/redis/0.32.7/redis/trait.JsonCommands.html

Examples showing the difference between using raw redis commands and the ergonomic JsonCommands trait methods.

```rust
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}]"#)));
```

```rust
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]"#)));
```

--------------------------------

### get_del

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncTypedCommands.html

Get the value of a key and then delete it.

```APIDOC
## fn get_del

### Description
Get the value of a key and delete it.

### Parameters
- **key** (K): The key whose value is to be retrieved and deleted.

### Returns
- `RedisFuture<'a, Option<String>>`: A future that resolves to an `Option` containing the key's value if it existed before deletion, or `None`.
```

--------------------------------

### keys

Source: https://docs.rs/redis/0.32.7/redis/aio/struct.MultiplexedConnection.html

Gets all keys matching pattern.

```APIDOC
## keys

### Description
Gets all keys matching pattern.

### Method
`keys<'a, K: ToRedisArgs + Send + Sync + 'a, RV>(&'a mut self, key: K) -> RedisFuture<'a, RV>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None provided.

### Response
#### Success Response (200)
`RedisFuture<'a, RV>` where `RV: FromRedisValue`

#### Response Example
None provided.
```

--------------------------------

### HashMap get_key_value method example

Source: https://docs.rs/redis/0.32.7/redis/struct.InfoDict.html

Demonstrates the usage of the `get_key_value` method on a HashMap to retrieve both the key and value.

```rust
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);
```

--------------------------------

### json_arr_index_ss

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterPipeline.html

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. Available on `crate feature`json` only.

```APIDOC
## pub fn json_arr_index_ss<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize>(
&mut self,
key: K,
path: P,
value: &'a V,
start: &'a isize,
stop: &'a isize,
) -> RedisResult<&mut Self>

### Description
Retrieves elements from a JSON array within a specified range.

### Parameters
#### Path Parameters
- **key** (K) - Description for key
- **path** (P) - Description for path
- **value** (V) - The value to search for
- **start** (isize) - The starting index for the range (inclusive). Defaults to 0.
- **stop** (isize) - The stopping index for the range (inclusive). Defaults to 0.

### Returns
- **RedisResult<&mut Self>** - A mutable reference to the pipeline.

### Available on
- crate feature`json`
```

--------------------------------

### Hash Values - Async

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncTypedCommands.html

Get all the values in a hash.

```rust
fn hvals<'a, K: ToRedisArgs + Send + Sync + 'a>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, Vec<String>> { ... }
```

--------------------------------

### Hash Keys - Async

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncTypedCommands.html

Get all the fields in a hash.

```rust
fn hkeys<'a, K: ToRedisArgs + Send + Sync + 'a>(
        &'a mut self,
        key: K,
    ) -> RedisFuture<'a, Vec<String>> { ... }
```

--------------------------------

### Initialize ConnectionManager with Configuration

Source: https://docs.rs/redis/0.32.7/redis/aio/struct.ConnectionManager.html

Connects to the server using a detailed configuration object, including retry logic, maximum delay, and timeouts for responses and connections.

```rust
pub async fn new_with_config(
    client: Client,
    config: ConnectionManagerConfig,
) -> RedisResult<Self>
```

--------------------------------

### GETDEL Command

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncTypedCommands.html

Get the value of a key and delete it.

```APIDOC
## GETDEL

### Description
Get the value of a key and delete it.

### Method
DELETE (Implicit)

### Endpoint
/key/{key}/getdel

### Parameters
#### Path Parameters
- **key** (string) - Required - The key to get and delete.

### Response
#### Success Response (200)
- **value** (string | null) - The value of the key before deletion, or null if the key did not exist.

### Response Example
```json
{
  "value": "some_value"
}
```
```json
{
  "value": null
}
```
```

--------------------------------

### SentinelClientBuilder::new

Source: https://docs.rs/redis/0.32.7/redis/sentinel/struct.SentinelClientBuilder.html

Creates a new SentinelClientBuilder. This is the entry point for configuring a SentinelClient.

```APIDOC
## SentinelClientBuilder::new

### Description
Creates a new `SentinelClientBuilder`.

### Method
`SentinelClientBuilder::new`

### Parameters
#### Path Parameters
- **sentinels** (T: IntoIterator<Item = ConnectionAddr>) - Required - Addresses of sentinel nodes
- **service_name** (String) - Required - The name of the service to be queried via the sentinels
- **server_type** (SentinelServerType) - Required - The server type to be queried via the sentinels

### Returns
- RedisResult<SentinelClientBuilder>
```

--------------------------------

### Async Cluster Pub/Sub with RESP3

Source: https://docs.rs/redis/0.32.7/redis/cluster_async/index.html

Demonstrates setting up an asynchronous pub/sub connection to a Redis Cluster using the RESP3 protocol and receiving messages via an MPSC channel.

```rust
use redis::cluster::ClusterClientBuilder;
use redis::{Value, AsyncCommands};

async fn fetch_an_integer() -> redis::RedisResult<() > {
    let nodes = vec!["redis://127.0.0.1/?protocol=3"];
    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
    let client = ClusterClientBuilder::new(nodes)
        .use_protocol(redis::ProtocolVersion::RESP3)
        .push_sender(tx).build()?;
    let mut connection = client.get_async_connection().await?;
    connection.subscribe("channel").await?;
    while let Some(msg) = rx.recv().await {
        println!("Got: {:?}", msg);
    }
    Ok(())
}
```

--------------------------------

### pttl

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncCommands.html

Get the time to live for a key in milliseconds.

```APIDOC
## pttl

### Description
Get the time to live for a key in milliseconds.

### Method
Asynchronous

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response
- **RV** (FromRedisValue) - The remaining time to live in milliseconds.
```

--------------------------------

### GET

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncCommands.html

Retrieves the value associated with a given key.

```APIDOC
## GET

### Description
Retrieves the value associated with a given key.

### Method
GET (asynchronous operation)

### Endpoint
Not applicable (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Example usage within an async context
let mut con = redis::aio::Connection::new("127.0.0.1:6379").await.unwrap();
let value: Option<String> = con.get("my_key").await.unwrap();
```

### Response
#### Success Response
- **RV** (FromRedisValue) - The value associated with the key, or None if the key does not exist.
```

--------------------------------

### Basic Redis Connection and Operation

Source: https://docs.rs/redis/0.32.7/redis/index.html

Demonstrates the canonical way to establish a connection to Redis and perform basic operations using the redis-rs client.

```rust
extern crate redis;

fn do_something() -> redis::RedisResult<()> {
    let client = redis::Client::open("redis://127.0.0.1/")?;
    let mut con = client.get_connection()?;

    /* do something here */

    Ok(())
}

```

--------------------------------

### Configuring Command Caching Behavior

Source: https://docs.rs/redis/0.32.7/redis/struct.CommandCacheConfig.html

Example demonstrating how to create and configure a CommandCacheConfig to enable caching with a specific TTL for a Redis command.

```rust
use std::time::Duration;
use redis::{CommandCacheConfig, Cmd};

let ttl = Duration::from_secs(120); // 2 minutes TTL
let config = CommandCacheConfig::new()
    .set_enable_cache(true)
    .set_client_side_ttl(ttl);
let command = Cmd::new().arg("GET").arg("key").set_cache_config(config);
```

--------------------------------

### mget

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterPipeline.html

Get values of keys. Redis Docs

```APIDOC
## pub fn mget<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self

### Description
Retrieves the values associated with multiple keys.

### Parameters
#### Path Parameters
- **key** (K) - A collection of keys whose values are to be retrieved.

### Returns
- **&mut Self** - A mutable reference to the pipeline.

### Source
Redis Docs
```

--------------------------------

### FromIterator Implementation Examples

Source: https://docs.rs/redis/0.32.7/redis/type.RedisResult.html

Demonstrates collecting results into a container, where the process stops upon encountering the first Err.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

--------------------------------

### Create a Consumer Group with XGROUP CREATE

Source: https://docs.rs/redis/0.32.7/redis/struct.Pipeline.html

Used to create a consumer group for a stream. The stream key must exist. The ID specifies the starting message ID for consumers. Use '$' to start from the last message. Available on the `streams` crate feature.

```redis
XGROUP CREATE <key> <groupname> <id or $> 
```

```rust
pub fn xgroup_create<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs>(
    &mut self,
    key: K,
    group: G,
    id: ID,
) -> &mut Self
```

--------------------------------

### hpttl

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncCommands.html

Get one or more fields’ TTL in milliseconds.

```APIDOC
## hpttl

### Description
Get one or more fields’ TTL in milliseconds.

### Method
Not applicable (SDK method)

### Endpoint
Not applicable (SDK method)

### Parameters
- **key** (K): The key of the hash.
- **fields** (F): The fields for which to get the TTL.

### Response
- **RV**: The type of the return value, representing the TTL in milliseconds.
```

--------------------------------

### ClusterClientBuilder::new

Source: https://docs.rs/redis/0.32.7/redis/cluster/struct.ClusterClientBuilder.html

Creates a new ClusterClientBuilder with the provided initial nodes. This is the entry point for building a ClusterClient.

```APIDOC
## ClusterClientBuilder::new

### Description
Creates a new `ClusterClientBuilder` with the provided initial_nodes. This is the same as `ClusterClient::builder(initial_nodes)`.

### Signature
```rust
pub fn new<T: IntoConnectionInfo>( initial_nodes: impl IntoIterator<Item = T> ) -> ClusterClientBuilder
```

### Parameters
* `initial_nodes`: An iterator of items that can be converted into connection information, representing the initial nodes for the cluster client.
```

--------------------------------

### client_getname

Source: https://docs.rs/redis/0.32.7/redis/trait.Commands.html

Gets the name of the current client connection in Redis.

```APIDOC
## client_getname

### Description
Gets the name of the current client connection in Redis.

### Method
Not applicable (SDK method)

### Endpoint
Not applicable (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response
Returns the name of the client connection.

#### Response Example
None
```

--------------------------------

### Subscribe to Channels with Connection Manager

Source: https://docs.rs/redis/0.32.7/redis/aio/struct.ConnectionManager.html

Demonstrates how to subscribe to single or multiple channels using the Connection Manager. Requires RESP3 protocol and a push sender configured in ConnectionManagerConfig. Subscriptions are lost on disconnect unless automatic resubscription is enabled.

```rust
let client = redis::Client::open("redis://127.0.0.1/?protocol=resp3").unwrap();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let config = redis::aio::ConnectionManagerConfig::new().set_push_sender(tx);
let mut con = client.get_connection_manager_with_config(config).await?;
con.psubscribe("channel*_1").await?;
con.psubscribe(&["channel*_2", "channel*_3"]).await?;
```

--------------------------------

### List Index - Async

Source: https://docs.rs/redis/0.32.7/redis/trait.AsyncTypedCommands.html

Get an element from a list by its index.

```rust
fn lindex<'a, K: ToRedisArgs + Send + Sync + 'a>(
        &'a mut self,
        key: K,
        index: isize,
    ) -> RedisFuture<'a, Option<String>> { ... }
```

--------------------------------

### Execute Low-Level SET Command

Source: https://docs.rs/redis/0.32.7/redis/index.html

Demonstrates how to execute a low-level SET command using the `cmd` function. The return value can be ignored by annotating to the unit type `()` if only success is needed.

```rust
fn do_something(con: &mut redis::Connection) -> redis::RedisResult<()> {
    redis::cmd("SET").arg("my_key").arg(42).exec(con)?;
    Ok(())
}
```
Tokens:
Raw