Struct RedisStore 

pub struct RedisStore { /* private fields */ }

Implementations

impl RedisStore

pub fn new(config: RedisStoreConfig) -> Result<Self, RedisStoreError>

Examples found in repository

examples/external_stores.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let redis_url = env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".to_owned());
    let mongo_url =
        env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://127.0.0.1:27017".to_owned());
    let sqlite_url = env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite::memory:".to_owned());

    let redis = RedisStore::new(RedisStoreConfig::new(redis_url))?;
    let sql = SqliteStore::connect_sqlite(SqlStoreConfig::new(sqlite_url)).await?;
    let mongo = MongoStore::connect(MongoStoreConfig::new(mongo_url, "rust_zero_example")).await?;

    redis.ping().await?;
    sql.health_check().await?;
    mongo.health_check().await?;
    println!("Redis, SQLite, and MongoDB are ready");
    Ok(())
}

pub fn with_metrics(self, metrics: RedisStoreMetrics) -> Self

Installs metrics for commands executed by this store.

pub async fn ping(&self) -> Result<(), RedisStoreError>

Examples found in repository

examples/external_stores.rs (line 17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let redis_url = env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1/".to_owned());
    let mongo_url =
        env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://127.0.0.1:27017".to_owned());
    let sqlite_url = env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite::memory:".to_owned());

    let redis = RedisStore::new(RedisStoreConfig::new(redis_url))?;
    let sql = SqliteStore::connect_sqlite(SqlStoreConfig::new(sqlite_url)).await?;
    let mongo = MongoStore::connect(MongoStoreConfig::new(mongo_url, "rust_zero_example")).await?;

    redis.ping().await?;
    sql.health_check().await?;
    mongo.health_check().await?;
    println!("Redis, SQLite, and MongoDB are ready");
    Ok(())
}

pub async fn do_command<T: FromRedisValue>( &self, command: Cmd, ) -> Result<T, RedisStoreError>

Executes an arbitrary Redis command using this store’s connection and timeout policy.

Arguments are passed through exactly as provided. In particular, keys in a raw command are not automatically namespaced with RedisStoreConfig::key_prefix; callers can use Self::prefixed_key when constructing commands that should share the store namespace.

pub fn prefixed_key(&self, key: &str) -> String

Applies this store’s configured namespace to a key for use with Self::do_command.

pub async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, RedisStoreError>

pub async fn get_json<T: DeserializeOwned>( &self, key: &str, ) -> Result<Option<T>, RedisStoreError>

pub async fn get_string( &self, key: &str, ) -> Result<Option<String>, RedisStoreError>

pub async fn set( &self, key: &str, value: impl AsRef<[u8]>, ttl: Option<Duration>, ) -> Result<(), RedisStoreError>

pub async fn set_json<T: Serialize>( &self, key: &str, value: &T, ttl: Option<Duration>, ) -> Result<(), RedisStoreError>

pub async fn set_if_absent( &self, key: &str, value: impl AsRef<[u8]>, ttl: Option<Duration>, ) -> Result<bool, RedisStoreError>

pub async fn get_many( &self, keys: &[&str], ) -> Result<Vec<Option<Vec<u8>>>, RedisStoreError>

pub async fn set_many<V: AsRef<[u8]>>( &self, entries: &[(&str, V)], ) -> Result<(), RedisStoreError>

pub async fn delete(&self, keys: &[&str]) -> Result<u64, RedisStoreError>

pub async fn exists(&self, key: &str) -> Result<bool, RedisStoreError>

pub async fn increment( &self, key: &str, amount: i64, ) -> Result<i64, RedisStoreError>

pub async fn decrement( &self, key: &str, amount: i64, ) -> Result<i64, RedisStoreError>

pub async fn expire( &self, key: &str, ttl: Duration, ) -> Result<bool, RedisStoreError>

pub async fn persist(&self, key: &str) -> Result<bool, RedisStoreError>

pub async fn ttl(&self, key: &str) -> Result<RedisTtl, RedisStoreError>

pub async fn hash_get( &self, key: &str, field: &str, ) -> Result<Option<Vec<u8>>, RedisStoreError>

pub async fn hash_set( &self, key: &str, field: &str, value: impl AsRef<[u8]>, ) -> Result<bool, RedisStoreError>

pub async fn hash_get_all( &self, key: &str, ) -> Result<HashMap<Vec<u8>, Vec<u8>>, RedisStoreError>

pub async fn hash_delete( &self, key: &str, fields: &[&str], ) -> Result<u64, RedisStoreError>

pub async fn hash_increment( &self, key: &str, field: &str, amount: i64, ) -> Result<i64, RedisStoreError>

pub async fn list_push_front<V: AsRef<[u8]>>( &self, key: &str, values: &[V], ) -> Result<u64, RedisStoreError>

pub async fn list_push_back<V: AsRef<[u8]>>( &self, key: &str, values: &[V], ) -> Result<u64, RedisStoreError>

pub async fn list_pop_front( &self, key: &str, ) -> Result<Option<Vec<u8>>, RedisStoreError>

pub async fn list_pop_back( &self, key: &str, ) -> Result<Option<Vec<u8>>, RedisStoreError>

pub async fn list_range( &self, key: &str, start: isize, stop: isize, ) -> Result<Vec<Vec<u8>>, RedisStoreError>

pub async fn list_len(&self, key: &str) -> Result<u64, RedisStoreError>

pub async fn set_add<V: AsRef<[u8]>>( &self, key: &str, members: &[V], ) -> Result<u64, RedisStoreError>

pub async fn set_remove<V: AsRef<[u8]>>( &self, key: &str, members: &[V], ) -> Result<u64, RedisStoreError>

pub async fn set_members( &self, key: &str, ) -> Result<HashSet<Vec<u8>>, RedisStoreError>

pub async fn set_contains( &self, key: &str, member: impl AsRef<[u8]>, ) -> Result<bool, RedisStoreError>

pub async fn set_len(&self, key: &str) -> Result<u64, RedisStoreError>

pub async fn sorted_set_add( &self, key: &str, score: f64, member: impl AsRef<[u8]>, ) -> Result<bool, RedisStoreError>

pub async fn sorted_set_remove<V: AsRef<[u8]>>( &self, key: &str, members: &[V], ) -> Result<u64, RedisStoreError>

pub async fn sorted_set_range_with_scores( &self, key: &str, start: isize, stop: isize, ) -> Result<Vec<(Vec<u8>, f64)>, RedisStoreError>

pub async fn sorted_set_score( &self, key: &str, member: impl AsRef<[u8]>, ) -> Result<Option<f64>, RedisStoreError>

pub async fn sorted_set_len(&self, key: &str) -> Result<u64, RedisStoreError>

pub async fn publish( &self, channel: &str, message: impl AsRef<[u8]>, ) -> Result<u64, RedisStoreError>

pub async fn subscribe<I, S>( &self, channels: I, config: RedisSubscriptionConfig, ) -> Result<RedisSubscription, RedisStoreError>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Subscribes to exact channel names using a reconnecting, bounded receiver.

pub async fn psubscribe<I, S>( &self, patterns: I, config: RedisSubscriptionConfig, ) -> Result<RedisSubscription, RedisStoreError>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Subscribes to Redis channel patterns using a reconnecting, bounded receiver.

pub async fn do_pipeline<T: FromRedisValue>( &self, pipeline: &Pipeline, ) -> Result<T, RedisStoreError>

Executes a caller-built Redis pipeline using the shared connection and operation timeout.

Like Self::do_command, pipeline keys are passed through unchanged. Use Self::prefixed_key when adding keys that belong to this store’s namespace.

pub async fn eval<T: FromRedisValue, K: AsRef<str>, A: AsRef<[u8]>>( &self, script: &str, keys: &[K], arguments: &[A], ) -> Result<T, RedisStoreError>

Evaluates a Lua script with automatically prefixed keys and binary-safe arguments.

pub async fn stream_add<V: AsRef<[u8]>>( &self, key: &str, id: Option<&str>, fields: &[(&str, V)], ) -> Result<String, RedisStoreError>

Appends a field/value entry to a Redis stream and returns its generated or explicit ID.

pub async fn stream_read( &self, streams: &[(&str, &str)], count: Option<usize>, block: Option<Duration>, ) -> Result<StreamReadReply, RedisStoreError>

Reads entries from one or more streams using XREAD.

pub async fn stream_group_create( &self, key: &str, group: &str, id: &str, create_stream: bool, ) -> Result<(), RedisStoreError>

Creates a consumer group at id, optionally creating an empty stream first.

pub async fn stream_group_destroy( &self, key: &str, group: &str, ) -> Result<bool, RedisStoreError>

Destroys a consumer group and reports whether it existed.

pub async fn stream_group_read( &self, group: &str, consumer: &str, streams: &[(&str, &str)], count: Option<usize>, block: Option<Duration>, no_ack: bool, ) -> Result<StreamReadReply, RedisStoreError>

Reads stream entries as a consumer group member using XREADGROUP.

pub async fn stream_ack( &self, key: &str, group: &str, ids: &[&str], ) -> Result<u64, RedisStoreError>

Acknowledges delivered stream entries and returns the number newly acknowledged.

pub async fn stream_pending( &self, key: &str, group: &str, ) -> Result<Value, RedisStoreError>

Returns the raw XPENDING summary so callers retain Redis-version-specific fields.

pub async fn stream_claim( &self, key: &str, group: &str, consumer: &str, min_idle: Duration, ids: &[&str], ) -> Result<Value, RedisStoreError>

Claims pending entries for another consumer using XCLAIM.

The response remains a raw Redis value because newer Redis versions may add optional fields while retaining wire compatibility.

pub async fn stream_delete( &self, key: &str, ids: &[&str], ) -> Result<u64, RedisStoreError>

Deletes stream entries and returns the number removed.

pub async fn stream_group_set_id( &self, key: &str, group: &str, id: &str, ) -> Result<(), RedisStoreError>

Moves a Redis stream consumer group’s last-delivered cursor.

id accepts Redis stream IDs as well as the special $ and 0 values. This corresponds to XGROUP SETID, including the helper added by go-zero v1.10.3.

pub fn lock(&self, key: impl Into<String>, ttl: Duration) -> RedisLock

Trait Implementations

impl Clone for RedisStore

fn clone(&self) -> RedisStore

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.