Struct RedisStore 

pub struct RedisStore { /* private fields */ }

Cloneable Redis client.

Cloning copies the prefix and an Arc inside [redis::aio::ConnectionManager]; it does not open another TCP connection. Commands issued on any clone share that multiplexed connection and the database selected by the URL.

Implementations

impl RedisStore

pub async fn incr_by_expire( &self, key: &str, by: i64, ttl: Duration, ) -> Result<i64, RedisError>

INCRBY plus an expiry for a key that has none, as one atomic server-side script.

A missing key starts at 0. The key receives ttl only when it has no expiry afterwards (it was created by this call, or was persistent); an existing deadline is kept. The two steps cannot be separated by an expiry or eviction, so the key is never left without a TTL.

Errors

RedisError::Invalid when ttl is below 1ms or above i64::MAX / 2 milliseconds, before any command is sent. Otherwise connection or command errors (the value is not an integer, or it would overflow).

pub async fn admit_marker( &self, args: MarkerAdmission<'_>, ) -> Result<MarkerReply, RedisError>

Admit a marker in one script: check the epoch, find or create the marker, and count the creation against the window’s budget.

The window is floor(server TIME / window), so every process agrees on it whatever its own clock says; the counter expires after twice the window on the same server clock. Nothing is created when the epoch differs or the budget is spent. The counter key is built inside the script, so this requires a single (non-cluster) deployment. The script enables effects replication itself where Redis needs it (before 7), so TIME followed by writes is accepted.

Errors

RedisError::Invalid when window is below 1ms or above i64::MAX / 4 milliseconds, before any command is sent. Otherwise connection or command errors.

pub async fn rotate_marker( &self, marker: &str, epoch_key: &str, epoch: &str, ttl: Duration, ) -> Result<(), RedisError>

Set epoch_key to epoch with a lifetime and delete marker, as one MULTI/EXEC round trip.

Errors

RedisError::Invalid when ttl is below 1ms or above i64::MAX / 2 milliseconds. Otherwise connection or command errors.

impl RedisStore

pub fn capabilities() -> BackendCapabilities

Capabilities of this adapter.

The value does not depend on a connection. Checking it never performs I/O.

pub fn require(feature: Feature) -> Result<(), RedisError>

Reject feature when Redis cannot honour it.

No connection is used. Isolation levels, savepoints, joins, row locking and the other relational Features all fail here.

Errors

RedisError::Capability when feature is not supported.

pub async fn connect(url: &str) -> Result<Self, RedisError>

Open url (for example redis://127.0.0.1:6379/15) with an empty prefix.

The path selects the database. Database 15 is the one the live tests use.

Errors

RedisError::Connection when the URL is invalid or the server cannot be reached.

pub async fn connect_with( client: Client, config: ConnectionManagerConfig, ) -> Result<Self, RedisError>

Connect a configured client, including custom TLS trust roots.

Args: client: Driver client with transport, certificate and DB policy. config: Retry, timeout and multiplexed admission limits.

Returns: Connected store with an empty key prefix.

Errors

Connection, authentication or certificate verification failure.

pub fn with_prefix(&self, prefix: impl Into<String>) -> Self

Clone this client with prefix replacing the current namespace.

The prefix is concatenated in front of every logical key. It is not appended to the previous prefix. "app:" turns "user" into "app:user". An empty prefix stores logical keys unchanged.

pub fn prefix(&self) -> &str

Namespace prepended to logical keys.

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

Physical key stored in Redis for the logical key.

pub fn database(&self) -> i64

Database index selected by the connection URL.

This is the index the client was configured with. It is not a live SELECT.

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

GET. Ok(None) when the key is absent.

Errors

Connection, command, or UTF-8 decode errors. A wrong-type key is a command error.

pub async fn set( &self, key: &str, value: &str, ttl: Option<Duration>, ) -> Result<(), RedisError>

SET. ttl of None stores the key with no expiry and clears any previous one.

Errors

RedisError::Invalid when ttl is below 1ms or above i64::MAX / 2 milliseconds, before any command is sent. Otherwise connection or command errors.

pub async fn set_nx(&self, key: &str, value: &str) -> Result<bool, RedisError>

SET key value NX. Ok(true) when this call created the key.

An existing key is left unchanged, including its expiry. This form does not set a TTL; use set or expire, or a pipeline SET with NX and PX, when the new key must expire.

Errors

Connection or command errors.

pub async fn set_nx_px( &self, key: &str, value: &str, ttl: Duration, ) -> Result<bool, RedisError>

SET key value NX PX ms as one command. Ok(true) when this call created the key; an existing key keeps its value and expiry.

Creation and expiry are one atomic server step: no observer sees the key without its TTL, and dropping the returned future either sends the whole command or none of it. ttl is truncated to whole milliseconds.

Errors

RedisError::Invalid when ttl is below 1ms or above i64::MAX / 2 milliseconds, before any command is sent. Otherwise connection or command errors.

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

DEL for one logical key. The number is 1 when the key was removed and 0 otherwise.

Errors

Connection or command errors.

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

EXISTS for one logical key.

Errors

Connection or command errors.

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

PEXPIRE. Ok(false) when the key does not exist.

Errors

RedisError::Invalid when ttl is below 1ms or too large, before any command is sent. Otherwise connection or command errors.

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

PTTL.

Errors

Connection or command errors, including an unexpected numeric reply.

pub async fn incr_by(&self, key: &str, by: i64) -> Result<i64, RedisError>

INCRBY. Creates the key at zero first when it is absent. by may be negative.

Errors

Connection or command errors (the value is not an integer, or it would overflow).

pub async fn hget( &self, key: &str, field: &str, ) -> Result<Option<String>, RedisError>

HGET. Ok(None) when the key or field is absent.

Errors

Connection, command, or UTF-8 decode errors.

pub async fn hset( &self, key: &str, field: &str, value: &str, ) -> Result<u64, RedisError>

HSET of one field. Returns how many fields were newly created (0 when updated).

Errors

Connection or command errors.

pub async fn hset_many<I, F, V>( &self, key: &str, fields: I, ) -> Result<u64, RedisError>

where I: IntoIterator<Item = (F, V)>, F: AsRef<str>, V: AsRef<str>,

HSET of many fields in one command. Returns how many fields were newly created.

Errors

RedisError::Invalid when fields is empty, before any command is sent. Otherwise connection or command errors.

pub async fn hgetall( &self, key: &str, ) -> Result<HashMap<String, String>, RedisError>

HGETALL. An absent key is an empty map, which is how Redis replies.

Field order is not significant.

Errors

Connection, command, or UTF-8 decode errors.

pub async fn hdel<I, F>(&self, key: &str, fields: I) -> Result<u64, RedisError>

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

HDEL. Returns how many of fields were removed.

Errors

RedisError::Invalid when fields is empty, before any command is sent. Otherwise connection or command errors.

pub async fn sadd<I, M>(&self, key: &str, members: I) -> Result<u64, RedisError>

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

SADD. Returns how many of members were newly inserted.

Errors

RedisError::Invalid when members is empty, before any command is sent. Otherwise connection or command errors.

pub async fn srem<I, M>(&self, key: &str, members: I) -> Result<u64, RedisError>

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

SREM. Returns how many of members were removed.

Errors

RedisError::Invalid when members is empty, before any command is sent. Otherwise connection or command errors.

pub async fn smembers(&self, key: &str) -> Result<HashSet<String>, RedisError>

SMEMBERS. An absent key is an empty set.

Errors

Connection, command, or UTF-8 decode errors.

pub async fn sismember( &self, key: &str, member: &str, ) -> Result<bool, RedisError>

SISMEMBER.

Errors

Connection or command errors.

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

where T: DeserializeOwned,

GET decoded as JSON. Ok(None) when the key is absent.

A stored JSON null is Ok(Some) when T accepts null, and a decode error when it does not.

Errors

RedisError::Decode when the bytes are not UTF-8 or not JSON of type T. Connection and command errors from get.

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

where T: Serialize,

SET of value encoded as compact JSON.

Errors

RedisError::Invalid when value cannot be serialized or ttl is not acceptable, before any command is sent. Otherwise the errors of set.

pub async fn pipeline<T, F>(&self, build: F) -> Result<T, RedisError>

where T: FromRedisValue, F: FnOnce(&mut Pipeline),

Run build inside one atomic MULTI/EXEC.

build receives a [redis::Pipeline] already switched to atomic mode. Keys are not prefixed for these raw commands: pass them through key. Replies decode as T, one element per command that was not ignored, in order.

Redis runs the queued commands with no other client’s commands interleaved. That is not a SQL transaction. A command that fails while EXEC is running does not roll back earlier commands in the same batch. A command Redis rejects while queueing (wrong arity, unknown command) aborts the whole batch, and none of it is applied. There are no savepoints and no isolation levels; ask require before building a pipeline that would need them.

Errors

Connection or command errors, including EXECABORT and a reply shape T cannot decode.

pub async fn delete_namespace(&self) -> Result<u64, RedisError>

Delete every key in this namespace with SCAN and DEL.

The match pattern is the prefix with glob metacharacters escaped, then *. An empty prefix is refused so this cannot wipe a database. This method never sends FLUSHDB or FLUSHALL.

Errors

RedisError::Invalid when the prefix is empty, before any command is sent. Otherwise connection or command errors.

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.

impl Debug for RedisStore

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

Formats the value using the given formatter.