Redis

https://docs.rs/redis/latest/
Admin
Redis-rs is a Rust client library for Redis that provides both low-level and high-level APIs for...
Tokens:2,051,990
Snippets:15,957
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### setup_connection async function (partial)

Source: https://docs.rs/redis/latest/src/redis/aio/mod.rs.html?search=std%3A%3Avec

Starts the async connection setup function that takes a codec, connection info, and optional cache config. The visible portion is truncated at the end of the provided source.

```rust
pub(super) async fn setup_connection<T>(
    codec: &mut T,
    connection_info: &RedisConnectionInfo,
    #[cfg(feature = "cache-aio")] cache_config: Option<crate::caching::CacheConfig>,
) -> RedisResult<()>
where
    T: Sink<Vec<u8>, Error = RedisError>,
    T: Stream<Item = RedisResult<Value>>,
    T: Unpin + Send + 'static,
{
    if execute_connection_pipeline(
        codec,
        connection_setup_pipeline(
            connection_info,
            true,
```

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

### get method example

Source: https://docs.rs/redis/latest/redis/struct.InfoDict.html?search=u32+-%3E+bool

Shows how to use InfoDict::get to retrieve a value by key. The key may be any borrowed form of the map's key type, but Hash and Eq must match. The example creates a HashMap, inserts a value, and asserts the result.

```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);

```

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

### Example: using SetOptions with conditional_set, value_comparison, get, and with_expiration

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

Shows how to build a SetOptions instance with default settings, then chain methods to set an existence check (NX), a value comparison (ifeq), the GET option, and an expiration (EX 60). The resulting options are passed to con.set_options.

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

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

### HashMap::get example

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

Example for the `get` method on `HashMap`, showing how to retrieve a value by key and handle missing keys.

```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);
```

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

### Open client and get connection

Source: https://docs.rs/redis/latest/redis/struct.Client.html

Example usage of opening a client and getting a connection. The open call does not connect yet, but get_connection does.

```rust
let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let con = client.get_connection().unwrap();
```

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

### ClusterPipeline query Example

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

Creates a pipeline, issues SET and GET commands, and retrieves the GET results as a tuple.

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

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

### Example: tracking hot keys on a standalone connection

Source: https://docs.rs/redis/latest/redis/trait.HotkeysCommands.html?search=

Example of using HOTKEYS on a standalone connection. It starts tracking by CPU time for 60 seconds, performs operations, retrieves hot key metrics (returning None when no session state is available), prints the CPU time entries, and stops tracking.

```rust
use redis::{HotkeysCommands, HotkeysOptions};

let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_connection()?;

// Start tracking hot keys by CPU time percentage for 60 seconds
let opts = HotkeysOptions::new_with_cpu()
    .with_duration_secs(60);
con.hotkeys_start(opts)?;

// ... perform operations ...

// Get hot keys metrics. `None` means no tracking session state is available
// (e.g. reset or never started).
if let Some(response) = con.hotkeys_get()? {
    if let Some(cpu_keys) = response.by_cpu_time_us.as_ref() {
        for entry in cpu_keys {
            println!("Key: {}, CPU time: {}", entry.key, entry.value);
        }
    }
}

// Stop tracking
con.hotkeys_stop()?;
```

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

### Build TLS client and perform async SET/MGET

Source: https://docs.rs/redis/latest/src/redis/client.rs.html?search=

Example from the documentation comment for `Client::build_with_tls` showing how to create a TLS-enabled client with client and root certificates, then use it to set and get keys asynchronously. Requires the `tls-rustls` feature. The example reads certificate files, builds the client, and demonstrates both `con.set` and `redis::cmd` usage.

```rust
let key_file = File::open(key_file).expect("cannot open private key file");
let mut client_key_vec = Vec::new();
BufReader::new(key_file)
    .read_to_end(&mut client_key_vec)
    .expect("Unable to read client key file");

let client = Client::build_with_tls(
    url,
    TlsCertificates {
        client_tls: Some(ClientTlsConfig{
            client_cert: client_cert_vec,
            client_key: client_key_vec,
        }),
        root_cert: Some(root_cert_vec),
    }
)
.expect("Unable to build client");

let connection_info = client.get_connection_info();

println!(">>> connection info: {connection_info:?}");

let mut con = client.get_multiplexed_async_connection().await?;

con.set("key1", b"foo").await?;

redis::cmd("SET")
    .arg(&["key2", "bar"])
    .exec_async(&mut con)
    .await?;

let result = redis::cmd("MGET")
    .arg(&["key1", "key2"])
    .query_async(&mut con)
    .await;
assert_eq!(result, Ok(("foo".to_string(), b"bar".to_vec())));
println!("Result from MGET: {result:?}");

Ok(())

```

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

### Test slot_map_get_all_primaries setup

Source: https://docs.rs/redis/latest/src/redis/cluster_handling/slot_map.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the test for getting all primaries by creating a slot map.

```rust
let slot_map = get_slot_map();
```

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

### Example: Creating an FT.CREATE command with FtCreateCommand

Source: https://docs.rs/redis/latest/redis/search/create/struct.FtCreateCommand.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to build an FT.CREATE command using FtCreateCommand::new with a schema, set options for hash data type, and convert to a redis::Cmd.

```rust
use redis::{schema, search::*};

let cmd = FtCreateCommand::new("my_index", schema! { "title" => SchemaTextField::new() })
    .options(CreateOptions::new().on(IndexDataType::Hash))
    .into_cmd();
```

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

### Using AsyncCommands trait for async connections

Source: https://docs.rs/redis/latest/src/redis/commands/macros.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use the AsyncCommands trait to get an asynchronous connection and send commands. The example is incomplete and only shows the setup part.

```rust
use redis::AsyncCommands;
# async fn do_something() -> redis::RedisResult<()> {
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
```

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

### Open async Redis connection with AsyncCommands

Source: https://docs.rs/redis/latest/src/redis/commands/macros.rs.html?search=std%3A%3Avec

Starts an asynchronous Redis connection using the AsyncCommands trait. The snippet is incomplete; it only shows the setup portion of a larger async example. Requires a running Redis server at redis://127.0.0.1/.

```rust
use redis::AsyncCommands;
# async fn do_something() -> redis::RedisResult<()> {
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;

```

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

### Start hotkey tracking with HotkeysOptions

Source: https://docs.rs/redis/latest/redis/struct.HotkeysOptions.html?search=

Shows how to create a HotkeysOptions with both CPU and network metrics enabled and a 60-second duration, then start hotkey tracking with the HOTKEYS START command.

```rust
use redis::{HotkeysOptions, HotkeysCommands};

let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_connection()?;

// Track hotkeys by both CPU and network usage for 60 seconds
let opts = HotkeysOptions::new_with_cpu()
    .and_net()
    .with_duration_secs(60);

con.hotkeys_start(opts)?;
```

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

### Compilation failure example for GET with multiple values

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

Example demonstrating that commands like `get` now only accept values that serialize into a single Redis value. This code is expected to fail compilation because `get` receives multiple values.

```rust
use redis::Commands;
fn main() -> redis::RedisResult<()> {
    let client = redis::Client::open("redis://127.0.0.1/")?;
    let mut con = client.get_connection()?;
    // `get` should fail compilation, because it receives multiple values
    _ = con.get(["foo","bar"]);
    Ok(())
}
```

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

### CreateOptions example for FT.CREATE

Source: https://docs.rs/redis/latest/src/redis/commands/search/create/options.rs.html?search=

Shows how to construct a CreateOptions instance for the FT.CREATE command, setting the index data type to Hash, a key prefix, and the default language to English.

```rust
use redis::search::{CreateOptions, IndexDataType, SearchLanguage};

let options = CreateOptions::new()
    .on(IndexDataType::Hash)
    .prefix("blog:post:")
    .language(SearchLanguage::English);
```

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

### Internal helper: setup_connection

Source: https://docs.rs/redis/latest/src/redis/aio/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets up a connection by executing the connection setup pipeline. Takes a codec, connection info, and optional cache config when the cache-aio feature is enabled.

```rust
124pub(super) async fn setup_connection<T>(
125    codec: &mut T,
126    connection_info: &RedisConnectionInfo,
127    #[cfg(feature = "cache-aio")] cache_config: Option<crate::caching::CacheConfig>,
128) -> RedisResult<()>
129where
130    T: Sink<Vec<u8>, Error = RedisError>,
131    T: Stream<Item = RedisResult<Value>>,
132    T: Unpin + Send + 'static,
133{
134    if execute_connection_pipeline(
135        codec,
        connection_setup_pipeline(
136            connection_info,
            true,
```

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

### Test setup: helper functions and strategy initialization

Source: https://docs.rs/redis/latest/src/redis/cluster_handling/read_routing/round_robin_replica.rs.html

Provides helper functions `node` and `setup_strategy` used in tests. `setup_strategy` creates a `RoundRobinReplicaStrategy` and configures a topology with two shards, each having two replicas, to test round-robin behavior.

```rust
#[cfg(test)]
mod tests {
    use super::*;
    use crate::cluster_handling::read_routing::{Replicas, Shard};

    fn node(host: &str, port: u16) -> NodeAddress {
        NodeAddress::from_parts(host.into(), port)
    }

    fn setup_strategy() -> RoundRobinReplicaStrategy {
        let strategy = RoundRobinReplicaStrategy::new();
        // Two shards: shard 1 owns slots 0-1000, shard 2 owns slots 1001-2000.
        strategy.on_topology_changed(ClusterTopology::from_shards(vec![
            Shard::new(
                vec![(0, 1000)],
                node("primary1", 6379),
                vec![node("replica1a", 6379), node("replica1b", 6379)],
            ),
            Shard::new(
                vec![(1001, 2000)],
                node("primary2", 6379),
                vec![node("replica2a", 6379), node("replica2b", 6379)],
            ),
        ]));
        strategy
    }
```

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

### Create HotkeysOptions with new_with_net()

Source: https://docs.rs/redis/latest/redis/struct.HotkeysOptions.html?search=

Creates options to track hotkeys by network bytes percentage, and shows how to add CPU tracking with and_cpu().

```rust
use redis::HotkeysOptions;

// Track hotkeys by network bytes
let opts = HotkeysOptions::new_with_net();

// Track by both network and CPU
let opts = HotkeysOptions::new_with_net().and_cpu();
```

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

### Route HOTKEYS to all primaries with AllMasters

Source: https://docs.rs/redis/latest/src/redis/commands/hotkeys.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Rust example for cluster-wide HOTKEYS tracking by routing to all primaries with `MultipleNodeRoutingInfo::AllMasters`. `START` and `STOP` use `ResponsePolicy::AllSucceeded` to assert every node accepted the command; `GET` is issued without a response policy so the response is a `Value::Map` keyed by node address, parsed with `HotkeysResponse::from_redis_value`.

```rust
use redis::cluster::ClusterClient;
use redis::cluster_routing::{
    MultipleNodeRoutingInfo, ResponsePolicy, RoutingInfo,
};
use redis::{cmd, from_redis_value, FromRedisValue, HotkeysOptions, HotkeysResponse, Value};

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

// START on every primary and require success everywhere.
// `with_slots` is not used in here and each primary tracks the keys for the slots it owns.
let start_opts = HotkeysOptions::new_with_cpu().and_net();
let _ = connection.route_command(
    &cmd("HOTKEYS").arg("START").arg(&start_opts),
    RoutingInfo::MultiNode((
        MultipleNodeRoutingInfo::AllMasters,
        Some(ResponsePolicy::AllSucceeded),
    )),
).unwrap();

// ... perform operations ...

// GET from every primary with no policy.
// The cluster client will get back the per-node responses.
let value = connection.route_command(
    &cmd("HOTKEYS").arg("GET"),
    RoutingInfo::MultiNode((MultipleNodeRoutingInfo::AllMasters, None)),
).unwrap();
if let Value::Map(per_node) = value {
    for (addr_val, response_val) in per_node {
        let addr: String = from_redis_value(addr_val).unwrap();
        let snapshot = HotkeysResponse::from_redis_value(response_val).unwrap();
        println!("node {addr}: {} hot keys by CPU",
            snapshot.by_cpu_time_us.as_ref().map(|v| v.len()).unwrap_or(0));
    }
}

// STOP on every primary.
let _ = connection.route_command(
    &cmd("HOTKEYS").arg("STOP"),
    RoutingInfo::MultiNode((
        MultipleNodeRoutingInfo::AllMasters,
        Some(ResponsePolicy::AllSucceeded),
    )),
).unwrap();
```

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

### Create HotkeysOptions with new_with_cpu()

Source: https://docs.rs/redis/latest/redis/struct.HotkeysOptions.html?search=

Creates options to track hotkeys by CPU time percentage, and shows how to add network tracking with and_net().

```rust
use redis::HotkeysOptions;

// Track hotkeys by CPU time
let opts = HotkeysOptions::new_with_cpu();

// Track by both CPU and network
let opts = HotkeysOptions::new_with_cpu().and_net();
```

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

### AsyncCommands usage example with SET and GET

Source: https://docs.rs/redis/latest/redis/trait.AsyncCommands.html?search=std%3A%3Avec

Shows how to use the AsyncCommands trait to run SET and GET commands asynchronously. Requires the 'aio' feature and a running Redis server at 127.0.0.1. The example demonstrates the convenience of the trait methods compared to using the raw command API.

```rust
use redis::AsyncCommands;
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
redis::cmd("SET").arg("my_key").arg(42i32).exec_async(&mut con).await?;
assert_eq!(redis::cmd("GET").arg("my_key").query_async(&mut con).await, Ok(42i32));
```

```rust
use redis::AsyncCommands;
use redis::Commands;
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
let _: () = con.set("my_key", 42i32).await?;
assert_eq!(con.get("my_key").await, Ok(42i32));
```

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

### Query INFO and get role value

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

Example showing how to query the INFO command and retrieve a value (role) as Option<String> using the get method.

```rust
let info : redis::InfoDict = redis::cmd("INFO").query(&mut con)?;
let role : Option<String> = info.get("role");
```

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

### Create HotkeysOptions with CPU tracking

Source: https://docs.rs/redis/latest/src/redis/commands/hotkeys.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating HotkeysOptions with CPU tracking enabled, and then adding network tracking via and_net().

```rust
use redis::HotkeysOptions;

// Track hotkeys by CPU time
let opts = HotkeysOptions::new_with_cpu();

// Track by both CPU and network
let opts = HotkeysOptions::new_with_cpu().and_net();

```

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

### AsyncCommands usage example

Source: https://docs.rs/redis/latest/src/redis/commands/macros.rs.html?search=u32+-%3E+bool

Example of using the AsyncCommands trait to set and get a value asynchronously. It uses a multiplexed async connection and demonstrates the generated command methods.

```rust
use redis::AsyncCommands;
# async fn do_something() -> redis::RedisResult<()> {
use redis::Commands;
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
let _: () = con.set("my_key", 42i32).await?;
assert_eq!(con.get("my_key").await, Ok(42i32));
# Ok(()) }

```

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

### HOTKEYS GET

Source: https://docs.rs/redis/latest/src/redis/commands/mod.rs.html

Starts tracking hot keys and returns the current hot keys response.

```APIDOC
## HOTKEYS GET

### Description
Starts tracking hot keys and returns the current hot keys response.

### Method
HOTKEYS

### Endpoint
HOTKEYS GET

### Parameters
None

### Request Example
```text
HOTKEYS GET
```

### Response
#### Success Response
- **HotkeysResponse** (object) - The response containing hot keys information.

#### Response Example
```json
{
  "hotkeys": []
}
```
```

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

### Example: Using RadiusOptions with geo_radius

Source: https://docs.rs/redis/latest/redis/geo/struct.RadiusOptions.html?search=std%3A%3Avec

Shows how to create RadiusOptions with default settings, set ascending order and a limit, then pass them to the geo_radius command. Requires the geospatial feature.

```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)
}

```

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

### Asynchronous command example

Source: https://docs.rs/redis/latest/src/redis/commands/macros.rs.html?search=u32+-%3E+bool

Shows the beginning of an asynchronous example using `AsyncCommands` and `get_multiplexed_async_connection`.

```rust
use redis::AsyncCommands;
# async fn do_something() -> redis::RedisResult<()> {
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
# Ok(()) }
```

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

### Async SET/GET with AsyncCommands

Source: https://docs.rs/redis/latest/src/redis/commands/macros.rs.html?search=

Shows how to use the async commands trait to set and get a value, converting to a concrete type. The example uses `set` and `get` methods on a multiplexed async connection.

```rust
redis::cmd("SET").arg("my_key").arg(42i32).exec_async(&mut con).await?;
redis::cmd("GET").arg("my_key").query_async(&mut con).await
```

```rust
use redis::AsyncCommands;
# async fn do_something() -> redis::RedisResult<()> {
use redis::Commands;
let client = redis::Client::open("redis://127.0.0.1/")?;
let mut con = client.get_multiplexed_async_connection().await?;
let _: () = con.set("my_key", 42i32).await?;
assert_eq!(con.get("my_key").await, Ok(42i32));
# Ok(()) }
```

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

### AsyncHotkeysCommands for ConnectionManager

Source: https://docs.rs/redis/latest/redis/aio/struct.ConnectionManager.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to start, get, stop, and reset hot keys tracking on a Redis connection.

```APIDOC
## hotkeys_start

### Description
Start tracking hot keys with the given options.

### Method
hotkeys_start

### Signature
fn hotkeys_start(&mut self, opts: HotkeysOptions) -> RedisFuture<'_, ()>

### Parameters
- **opts** (HotkeysOptions) - Required - Options for hot keys tracking.

### Returns
RedisFuture<'_, ()> - A future that resolves to unit on success.

## hotkeys_get

### Description
Get the current hot keys metrics.

### Method
hotkeys_get

### Signature
fn hotkeys_get(&mut self) -> RedisFuture<'_, Option<HotkeysResponse>>

### Returns
RedisFuture<'_, Option<HotkeysResponse>> - A future that resolves to an optional HotkeysResponse containing the metrics.

## hotkeys_stop

### Description
Stop tracking hot keys.

### Method
hotkeys_stop

### Signature
fn hotkeys_stop(&mut self) -> RedisFuture<'_, bool>

### Returns
RedisFuture<'_, bool> - A future that resolves to a boolean indicating success.

## hotkeys_reset

### Description
Reset the hot keys tracking state.

### Method
hotkeys_reset

### Signature
fn hotkeys_reset(&mut self) -> RedisFuture<'_, ()>

### Returns
RedisFuture<'_, ()> - A future that resolves to unit on success.
```

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

### InfoDict example: query INFO command

Source: https://docs.rs/redis/latest/src/redis/types.rs.html?search=

Shows how to use InfoDict to parse the response of the INFO command and retrieve a value by key. The example is no_run and uses a real connection.

```rust
# fn do_something() -> redis::RedisResult<()> {
# let client = redis::Client::open("redis://127.0.0.1/").unwrap();
# let mut con = client.get_connection().unwrap();
let info : redis::InfoDict = redis::cmd("INFO").query(&mut con)?;
let role : Option<String> = info.get("role");
# Ok(()) }
```

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

### Set credentials provider with EntraIdCredentialsProvider

Source: https://docs.rs/redis/latest/redis/aio/struct.ConnectionManagerConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example for set_credentials_provider, available only with the token-based-authentication feature. It creates an EntraIdCredentialsProvider using new_developer_tools, starts it with RetryConfig::default(), and sets it on a ConnectionManagerConfig. The example uses the ? operator, so it must be called from a function returning Result.

```rust
use redis::aio::ConnectionManagerConfig;
use redis::{EntraIdCredentialsProvider, RetryConfig};

let mut provider = EntraIdCredentialsProvider::new_developer_tools()?;
provider.start(RetryConfig::default());

let config = ConnectionManagerConfig::new()
    .set_credentials_provider(provider);
```

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

### Basic Cmd::new() example

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

Basic example of creating a command using Cmd::new() and chaining arguments.

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

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

### Synchronous command example

Source: https://docs.rs/redis/latest/src/redis/commands/macros.rs.html?search=u32+-%3E+bool

Shows the verbose way to execute SET and GET commands using `redis::cmd` before using the `Commands` trait.

```rust
# fn do_something() -> redis::RedisResult<()> {
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));
# Ok(()) }
```

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

### Create HotkeysOptions with network tracking

Source: https://docs.rs/redis/latest/src/redis/commands/hotkeys.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating HotkeysOptions with network tracking enabled, and then adding CPU tracking via and_cpu().

```rust
use redis::HotkeysOptions;

// Track hotkeys by network bytes
let opts = HotkeysOptions::new_with_net();

// Track by both network and CPU
let opts = HotkeysOptions::new_with_net().and_cpu();

```

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

### Query INFO command with InfoDict

Source: https://docs.rs/redis/latest/src/redis/types.rs.html?search=std%3A%3Avec

Shows how to use redis::InfoDict to retrieve a value from the INFO command response. The example opens a client connection, sends the INFO command, and gets the 'role' field as an Option<String>. It is a no_run example that returns a RedisResult.

```rust
```rust,no_run
# fn do_something() -> redis::RedisResult<()> {
# let client = redis::Client::open("redis://127.0.0.1/").unwrap();
# let mut con = client.get_connection().unwrap();
let info : redis::InfoDict = redis::cmd("INFO").query(&mut con)?;
let role : Option<String> = info.get("role");
# Ok(()) }
```
```

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

### Pipelining Example

Source: https://docs.rs/redis/latest/src/redis/cluster_handling/sync_connection/mod.rs.html?search=u32+-%3E+bool

Example from the module docs showing pipelined commands in a cluster.

```rust
use redis::cluster::cluster_pipe;

let mut con = client.get_connection().unwrap();
let key = "test";

cluster_pipe()
    .rpush(key, "123").ignore()
    .ltrim(key, -10, -1).ignore()
    .expire(key, 60).ignore()
    .exec(&mut con).unwrap();
```
Tokens:
Raw