pub struct Connection<D: Database>(/* private fields */);Expand description
A request guard which retrieves a single connection to a Database.
For a database type of Db, a request guard of Connection<Db> retrieves a
single connection to Db.
The request guard succeeds if the database was initialized by the
Initializer fairing and a connection is available within
connect_timeout seconds.
- If the
Initializerfairing was not attached, the guard fails with statusInternalServerError. ASentinelguards this condition, and so this type of error is unlikely to occur. ANoneerror is returned. - If a connection is not available within
connect_timeoutseconds or another error occurs, the guard fails with statusServiceUnavailableand the error is returned inSome.
§Deref
A type of Connection<Db> dereferences, mutably and immutably, to the
native database connection type. The driver table
lists the concrete native Deref types.
§Example
use rocket_db_pools::{Database, Connection};
#[derive(Database)]
#[database("db")]
struct Db(Pool);
#[get("/")]
async fn db_op(db: Connection<Db>) {
// use `&*db` to get an immutable borrow to the native connection type
// use `&mut *db` to get a mutable borrow to the native connection type
}Implementations§
Source§impl<D: Database> Connection<D>
impl<D: Database> Connection<D>
Sourcepub fn into_inner(self) -> <D::Pool as Pool>::Connection
pub fn into_inner(self) -> <D::Pool as Pool>::Connection
Returns the internal connection value. See the Connection Deref
column for the expected type of this value.
Note that Connection<D> derefs to the internal connection type, so
using this method is likely unnecessary. See deref
for examples.
§Example
use rocket_db_pools::{Database, Connection};
#[derive(Database)]
#[database("db")]
struct Db(Pool);
#[get("/")]
async fn db_op(db: Connection<Db>) {
let inner = db.into_inner();
}Trait Implementations§
Source§impl<D: Database> Deref for Connection<D>
impl<D: Database> Deref for Connection<D>
Source§impl<D: Database> DerefMut for Connection<D>
impl<D: Database> DerefMut for Connection<D>
Auto Trait Implementations§
impl<D> Forget for Connection<D>
impl<D> Freeze for Connection<D>
impl<D> Move for Connection<D>
impl<D> RefUnwindSafe for Connection<D>
impl<D> Send for Connection<D>
impl<D> Sync for Connection<D>
impl<D> Unpin for Connection<D>
impl<D> UnsafeUnpin for Connection<D>
impl<D> UnwindSafe for Connection<D>
Blanket Implementations§
Source§impl<T> AggregateExpressionMethods for T
impl<T> AggregateExpressionMethods for T
Source§fn aggregate_distinct(self) -> Self::Outputwhere
Self: DistinctDsl,
fn aggregate_distinct(self) -> Self::Outputwhere
Self: DistinctDsl,
DISTINCT modifier for aggregate functions Read moreSource§fn aggregate_all(self) -> Self::Outputwhere
Self: AllDsl,
fn aggregate_all(self) -> Self::Outputwhere
Self: AllDsl,
ALL modifier for aggregate functions Read moreSource§fn aggregate_filter<P>(self, f: P) -> Self::Output
fn aggregate_filter<P>(self, f: P) -> Self::Output
Source§fn aggregate_order<O>(self, o: O) -> Self::Outputwhere
Self: OrderAggregateDsl<O>,
fn aggregate_order<O>(self, o: O) -> Self::Outputwhere
Self: OrderAggregateDsl<O>,
Source§impl<T> AsAny for Twhere
T: Any,
impl<T> AsAny for Twhere
T: Any,
fn as_any_ref(&self) -> &(dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Source§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
Source§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
Source§impl<C> AsyncConnection for C
impl<C> AsyncConnection for C
type TransactionManager = PoolTransactionManager<<<C as Deref>::Target as AsyncConnection>::TransactionManager>
Source§async fn establish(_database_url: &str) -> Result<C, ConnectionError>
async fn establish(_database_url: &str) -> Result<C, ConnectionError>
fn transaction_state( &mut self, ) -> &mut <<C as AsyncConnection>::TransactionManager as TransactionManager<C>>::TransactionStateData
Source§async fn begin_test_transaction(&mut self) -> Result<(), Error>
async fn begin_test_transaction(&mut self) -> Result<(), Error>
fn instrumentation(&mut self) -> &mut (dyn Instrumentation + 'static)
Source§fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)
fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)
Instrumentation implementation for this connectionSource§fn set_prepared_statement_cache_size(&mut self, size: CacheSize)
fn set_prepared_statement_cache_size(&mut self, size: CacheSize)
CacheSize for this connectionSource§fn transaction<'a, 'conn, R, E, F>(
&'conn mut self,
callback: F,
) -> impl Future<Output = Result<R, E>> + Send + 'conn
fn transaction<'a, 'conn, R, E, F>( &'conn mut self, callback: F, ) -> impl Future<Output = Result<R, E>> + Send + 'conn
Source§impl<C> AsyncConnectionCore for C
impl<C> AsyncConnectionCore for C
Source§type ExecuteFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::ExecuteFuture<'conn, 'query>
type ExecuteFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::ExecuteFuture<'conn, 'query>
AsyncConnection::executeSource§type LoadFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::LoadFuture<'conn, 'query>
type LoadFuture<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::LoadFuture<'conn, 'query>
AsyncConnection::loadSource§type Stream<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::Stream<'conn, 'query>
type Stream<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::Stream<'conn, 'query>
AsyncConnection::loadSource§type Row<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::Row<'conn, 'query>
type Row<'conn, 'query> = <<C as Deref>::Target as AsyncConnectionCore>::Row<'conn, 'query>
AsyncConnection::loadSource§type Backend = <<C as Deref>::Target as AsyncConnectionCore>::Backend
type Backend = <<C as Deref>::Target as AsyncConnectionCore>::Backend
fn load<'conn, 'query, T>(
&'conn mut self,
source: T,
) -> <C as AsyncConnectionCore>::LoadFuture<'conn, 'query>where
T: AsQuery + 'query,
<T as AsQuery>::Query: QueryFragment<<C as AsyncConnectionCore>::Backend> + QueryId + 'query,
fn execute_returning_count<'conn, 'query, T>( &'conn mut self, source: T, ) -> <C as AsyncConnectionCore>::ExecuteFuture<'conn, 'query>
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> Commands for Twhere
T: ConnectionLike,
impl<T> Commands for Twhere
T: ConnectionLike,
Source§fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
MGET (if using TypedCommands, you should specifically use mget to get the correct return type.
Redis DocsSource§fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn set_options<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: SetOptions,
) -> Result<RV, RedisError>
fn set_options<'a, K, V, RV>( &mut self, key: K, value: V, options: SetOptions, ) -> Result<RV, RedisError>
Source§fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>
fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>
Source§fn set_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
seconds: u64,
) -> Result<RV, RedisError>
fn set_ex<'a, K, V, RV>( &mut self, key: K, value: V, seconds: u64, ) -> Result<RV, RedisError>
Source§fn pset_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
milliseconds: u64,
) -> Result<RV, RedisError>
fn pset_ex<'a, K, V, RV>( &mut self, key: K, value: V, milliseconds: u64, ) -> Result<RV, RedisError>
Source§fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn mset_nx<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
) -> Result<RV, RedisError>
fn mset_nx<'a, K, V, RV>( &mut self, items: &'a [(K, V)], ) -> Result<RV, RedisError>
Source§fn mset_ex<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
options: MSetOptions,
) -> Result<RV, RedisError>
fn mset_ex<'a, K, V, RV>( &mut self, items: &'a [(K, V)], options: MSetOptions, ) -> Result<RV, RedisError>
Source§fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn getrange<'a, K, RV>(
&mut self,
key: K,
from: isize,
to: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn getrange<'a, K, RV>(
&mut self,
key: K,
from: isize,
to: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn setrange<'a, K, V, RV>(
&mut self,
key: K,
offset: isize,
value: V,
) -> Result<RV, RedisError>
fn setrange<'a, K, V, RV>( &mut self, key: K, offset: isize, value: V, ) -> Result<RV, RedisError>
Source§fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn del_ex<'a, K, RV>(
&mut self,
key: K,
value_comparison: ValueComparison,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn del_ex<'a, K, RV>(
&mut self,
key: K,
value_comparison: ValueComparison,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
match-value - Delete the key only if its value is equal to match-value
IFNE match-value - Delete the key only if its value is not equal to match-value
IFDEQ match-digest - Delete the key only if the digest of its value is equal to match-digest
IFDNE match-digest - Delete the key only if the digest of its value is not equal to match-digest
Redis DocsSource§fn digest<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn digest<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn get_ex<'a, K, RV>(
&mut self,
key: K,
expire_at: Expiry,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn get_ex<'a, K, RV>(
&mut self,
key: K,
expire_at: Expiry,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn copy<'a, KSrc, KDst, Db, RV>(
&mut self,
source: KSrc,
destination: KDst,
options: CopyOptions<Db>,
) -> Result<RV, RedisError>
fn copy<'a, KSrc, KDst, Db, RV>( &mut self, source: KSrc, destination: KDst, options: CopyOptions<Db>, ) -> Result<RV, RedisError>
Source§fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>
fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>
Source§fn rename_nx<'a, K, N, RV>(
&mut self,
key: K,
new_key: N,
) -> Result<RV, RedisError>
fn rename_nx<'a, K, N, RV>( &mut self, key: K, new_key: N, ) -> Result<RV, RedisError>
Source§fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
DEL.
Returns number of keys unlinked.
Redis DocsSource§fn append<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn append<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn incr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
fn incr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
INCRBY or INCRBYFLOAT depending on the type.
If the key does not exist, it is set to 0 before performing the operation.Source§fn decr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
fn decr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
Source§fn increx<'a, K, V, RV>(
&mut self,
key: K,
increment: V,
options: IncrexOptions<V>,
) -> Result<RV, RedisError>
fn increx<'a, K, V, RV>( &mut self, key: K, increment: V, options: IncrexOptions<V>, ) -> Result<RV, RedisError>
Source§fn setbit<'a, K, RV>(
&mut self,
key: K,
offset: usize,
value: bool,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn setbit<'a, K, RV>(
&mut self,
key: K,
offset: usize,
value: bool,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn getbit<'a, K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn getbit<'a, K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn bitcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn bitcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn bitcount_range<'a, K, RV>(
&mut self,
key: K,
start: usize,
end: usize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn bitcount_range<'a, K, RV>(
&mut self,
key: K,
start: usize,
end: usize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn bit_and<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_and<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn bit_or<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_or<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn bit_xor<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_xor<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn bit_not<'a, D, S, RV>(
&mut self,
dstkey: D,
srckey: S,
) -> Result<RV, RedisError>
fn bit_not<'a, D, S, RV>( &mut self, dstkey: D, srckey: S, ) -> Result<RV, RedisError>
Source§fn bit_diff<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_diff<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Perform a set difference to extract the members of X that are not members of any of Y1, Y2,….
Logical representation: X ∧ ¬(Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_diff1<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_diff1<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Perform a relative complement set difference to extract the members of one or more of Y1, Y2,… that are not members of X.
Logical representation: ¬X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_and_or<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_and_or<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Perform an “intersection of union(s)” operation to extract the members of X that are also members of one or more of Y1, Y2,….
Logical representation: X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_one<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_one<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Perform an “exclusive membership” operation to extract the members of exactly one of X, Y1, Y2, ….
Logical representation: (X ∨ Y1 ∨ Y2 ∨ …) ∧ ¬((X ∧ Y1) ∨ (X ∧ Y2) ∨ (Y1 ∧ Y2) ∨ (Y1 ∧ Y3) ∨ …)
Redis Docs
Source§fn strlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn strlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hget<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hget<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
Source§fn hmget<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
fn hmget<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
Source§fn hget_ex<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
expire_at: Expiry,
) -> Result<RV, RedisError>
fn hget_ex<'a, K, F, RV>( &mut self, key: K, fields: F, expire_at: Expiry, ) -> Result<RV, RedisError>
Source§fn hdel<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hdel<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
Source§fn hget_del<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>
fn hget_del<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
Source§fn hset<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>
fn hset<'a, K, F, V, RV>( &mut self, key: K, field: F, value: V, ) -> Result<RV, RedisError>
Source§fn hset_ex<'a, K, F, V, RV>(
&mut self,
key: K,
hash_field_expiration_options: &'a HashFieldExpirationOptions,
fields_values: &'a [(F, V)],
) -> Result<RV, RedisError>
fn hset_ex<'a, K, F, V, RV>( &mut self, key: K, hash_field_expiration_options: &'a HashFieldExpirationOptions, fields_values: &'a [(F, V)], ) -> Result<RV, RedisError>
Source§fn hset_nx<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>
fn hset_nx<'a, K, F, V, RV>( &mut self, key: K, field: F, value: V, ) -> Result<RV, RedisError>
Source§fn hset_multiple<'a, K, F, V, RV>(
&mut self,
key: K,
items: &'a [(F, V)],
) -> Result<RV, RedisError>
fn hset_multiple<'a, K, F, V, RV>( &mut self, key: K, items: &'a [(F, V)], ) -> Result<RV, RedisError>
Source§fn hincr<'a, K, F, D, RV>(
&mut self,
key: K,
field: F,
delta: D,
) -> Result<RV, RedisError>
fn hincr<'a, K, F, D, RV>( &mut self, key: K, field: F, delta: D, ) -> Result<RV, RedisError>
Source§fn hexists<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hexists<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
Source§fn httl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
fn httl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
Source§fn hpttl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
fn hpttl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
Source§fn hexpire<'a, K, F, RV>(
&mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hexpire<'a, K, F, RV>( &mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hexpire_at<'a, K, F, RV>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>
fn hexpire_time<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
Source§fn hpersist<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>
fn hpersist<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
Source§fn hpexpire<'a, K, F, RV>(
&mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hpexpire<'a, K, F, RV>( &mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hpexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hpexpire_at<'a, K, F, RV>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hpexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>
fn hpexpire_time<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
Source§fn hkeys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn hkeys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hvals<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn hvals<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hgetall<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn hgetall<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn hlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn blmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Result<RV, RedisError>
fn blmove<'a, S, D, RV>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> Result<RV, RedisError>
Source§fn blmpop<'a, K, RV>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blmpop<'a, K, RV>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.
Redis DocsSource§fn blpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn brpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn brpoplpush<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Result<RV, RedisError>
fn brpoplpush<'a, S, D, RV>( &mut self, srckey: S, dstkey: D, timeout: f64, ) -> Result<RV, RedisError>
Source§fn lindex<'a, K, RV>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn lindex<'a, K, RV>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn linsert_before<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>
fn linsert_before<'a, K, P, V, RV>( &mut self, key: K, pivot: P, value: V, ) -> Result<RV, RedisError>
Source§fn linsert_after<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>
fn linsert_after<'a, K, P, V, RV>( &mut self, key: K, pivot: P, value: V, ) -> Result<RV, RedisError>
Source§fn llen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn llen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn lmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Result<RV, RedisError>
fn lmove<'a, S, D, RV>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> Result<RV, RedisError>
Source§fn lmpop<'a, K, RV>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lmpop<'a, K, RV>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count elements from the first non-empty list key from the list of
provided key names.
Redis DocsSource§fn lpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn lpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
count first elements of the list stored at key. Read moreSource§fn lpos<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: LposOptions,
) -> Result<RV, RedisError>
fn lpos<'a, K, V, RV>( &mut self, key: K, value: V, options: LposOptions, ) -> Result<RV, RedisError>
Source§fn lpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn lpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn lpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>
fn lpush_exists<'a, K, V, RV>( &mut self, key: K, value: V, ) -> Result<RV, RedisError>
Source§fn lrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn lrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn lrem<'a, K, V, RV>(
&mut self,
key: K,
count: isize,
value: V,
) -> Result<RV, RedisError>
fn lrem<'a, K, V, RV>( &mut self, key: K, count: isize, value: V, ) -> Result<RV, RedisError>
Source§fn ltrim<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn ltrim<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn lset<'a, K, V, RV>(
&mut self,
key: K,
index: isize,
value: V,
) -> Result<RV, RedisError>
fn lset<'a, K, V, RV>( &mut self, key: K, index: isize, value: V, ) -> Result<RV, RedisError>
Source§fn ping<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn ping<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn ping_message<'a, K, RV>(&mut self, message: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn ping_message<'a, K, RV>(&mut self, message: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn rpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn rpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
count last elements of the list stored at key Read moreSource§fn rpoplpush<'a, K, D, RV>(
&mut self,
key: K,
dstkey: D,
) -> Result<RV, RedisError>
fn rpoplpush<'a, K, D, RV>( &mut self, key: K, dstkey: D, ) -> Result<RV, RedisError>
Source§fn rpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn rpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn rpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>
fn rpush_exists<'a, K, V, RV>( &mut self, key: K, value: V, ) -> Result<RV, RedisError>
Source§fn sadd<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn sadd<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn scard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn scard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn sdiff<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiff<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sdiffstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn sdiffstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn sinter<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sinter<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn sinterstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn sismember<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>
fn sismember<'a, K, M, RV>( &mut self, key: K, member: M, ) -> Result<RV, RedisError>
Source§fn smismember<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>
fn smismember<'a, K, M, RV>( &mut self, key: K, members: M, ) -> Result<RV, RedisError>
Source§fn smembers<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn smembers<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn smove<'a, S, D, M, RV>(
&mut self,
srckey: S,
dstkey: D,
member: M,
) -> Result<RV, RedisError>
fn smove<'a, S, D, M, RV>( &mut self, srckey: S, dstkey: D, member: M, ) -> Result<RV, RedisError>
Source§fn spop<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn spop<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn srandmember<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn srandmember<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn srandmember_multiple<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn srandmember_multiple<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn srem<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn srem<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn sunion<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sunion<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn sunionstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zadd<'a, K, S, M, RV>(
&mut self,
key: K,
member: M,
score: S,
) -> Result<RV, RedisError>
fn zadd<'a, K, S, M, RV>( &mut self, key: K, member: M, score: S, ) -> Result<RV, RedisError>
Source§fn zadd_multiple<'a, K, S, M, RV>(
&mut self,
key: K,
items: &'a [(S, M)],
) -> Result<RV, RedisError>
fn zadd_multiple<'a, K, S, M, RV>( &mut self, key: K, items: &'a [(S, M)], ) -> Result<RV, RedisError>
Source§fn zadd_options<'a, K, S, M, RV>(
&mut self,
key: K,
member: M,
score: S,
options: &'a SortedSetAddOptions,
) -> Result<RV, RedisError>
fn zadd_options<'a, K, S, M, RV>( &mut self, key: K, member: M, score: S, options: &'a SortedSetAddOptions, ) -> Result<RV, RedisError>
Source§fn zadd_multiple_options<'a, K, S, M, RV>(
&mut self,
key: K,
items: &'a [(S, M)],
options: &'a SortedSetAddOptions,
) -> Result<RV, RedisError>
fn zadd_multiple_options<'a, K, S, M, RV>( &mut self, key: K, items: &'a [(S, M)], options: &'a SortedSetAddOptions, ) -> Result<RV, RedisError>
Source§fn zcard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zcard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zcount<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zincr<'a, K, M, D, RV>(
&mut self,
key: K,
member: M,
delta: D,
) -> Result<RV, RedisError>
fn zincr<'a, K, M, D, RV>( &mut self, key: K, member: M, delta: D, ) -> Result<RV, RedisError>
Source§fn zinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zinterstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zinterstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zinterstore_min<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zinterstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zinterstore_max<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zinterstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zinterstore_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zinterstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zinterstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zinterstore_min_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zinterstore_min, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zinterstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zinterstore_max_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zinterstore_max, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zlexcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zlexcount<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn bzpopmax<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmax<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zpopmax<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zpopmax<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn bzpopmin<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmin<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zpopmin<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zpopmin<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn bzmpop_max<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_max<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zmpop_max<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_max<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn bzmpop_min<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_min<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zmpop_min<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_min<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrandmember<'a, K, RV>(
&mut self,
key: K,
count: Option<isize>,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zrandmember<'a, K, RV>(
&mut self,
key: K,
count: Option<isize>,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
count == None)
Redis DocsSource§fn zrandmember_withscores<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zrandmember_withscores<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zrangebylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrangebylex<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrangebylex_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrangebylex_limit<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrevrangebylex<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>
fn zrevrangebylex<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, ) -> Result<RV, RedisError>
Source§fn zrevrangebylex_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrevrangebylex_limit<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrangebyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrangebyscore<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrangebyscore_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrangebyscore_withscores<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrangebyscore_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrangebyscore_limit<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrank<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn zrank<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn zrem<'a, K, M, RV>(&mut self, key: K, members: M) -> Result<RV, RedisError>
fn zrem<'a, K, M, RV>(&mut self, key: K, members: M) -> Result<RV, RedisError>
Source§fn zrembylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrembylex<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zremrangebyrank<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zremrangebyrank<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zrembyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrembyscore<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrevrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zrevrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zrevrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zrevrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zrevrangebyscore<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>
fn zrevrangebyscore<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, ) -> Result<RV, RedisError>
Source§fn zrevrangebyscore_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>
fn zrevrangebyscore_withscores<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, ) -> Result<RV, RedisError>
Source§fn zrevrangebyscore_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrevrangebyscore_limit<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrevrank<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>
fn zrevrank<'a, K, M, RV>( &mut self, key: K, member: M, ) -> Result<RV, RedisError>
Source§fn zscore<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn zscore<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn zscore_multiple<'a, K, M, RV>(
&mut self,
key: K,
members: &'a [M],
) -> Result<RV, RedisError>
fn zscore_multiple<'a, K, M, RV>( &mut self, key: K, members: &'a [M], ) -> Result<RV, RedisError>
Source§fn zunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zunionstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zunionstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zunionstore_min<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zunionstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zunionstore_max<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zunionstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zunionstore_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zunionstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zunionstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zunionstore_min_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zunionstore_min, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zunionstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zunionstore_max_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zunionstore_max, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn pfadd<'a, K, E, RV>(&mut self, key: K, element: E) -> Result<RV, RedisError>
fn pfadd<'a, K, E, RV>(&mut self, key: K, element: E) -> Result<RV, RedisError>
Source§fn pfcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn pfmerge<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn pfmerge<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn publish<'a, K, E, RV>(
&mut self,
channel: K,
message: E,
) -> Result<RV, RedisError>
fn publish<'a, K, E, RV>( &mut self, channel: K, message: E, ) -> Result<RV, RedisError>
Source§fn spublish<'a, K, E, RV>(
&mut self,
channel: K,
message: E,
) -> Result<RV, RedisError>
fn spublish<'a, K, E, RV>( &mut self, channel: K, message: E, ) -> Result<RV, RedisError>
Source§fn object_encoding<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn object_encoding<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn object_idletime<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn object_idletime<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn object_freq<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn object_freq<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn object_refcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn object_refcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn client_getname<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn client_getname<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn client_id<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn client_id<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn client_setname<'a, K, RV>(
&mut self,
connection_name: K,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn client_setname<'a, K, RV>(
&mut self,
connection_name: K,
) -> Result<RV, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn flushall<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn flushall<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn flushall_options<'a, RV>(
&mut self,
options: &'a FlushAllOptions,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn flushall_options<'a, RV>(
&mut self,
options: &'a FlushAllOptions,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn flushdb<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn flushdb<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn flushdb_options<'a, RV>(
&mut self,
options: &'a FlushAllOptions,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn flushdb_options<'a, RV>(
&mut self,
options: &'a FlushAllOptions,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
Source§fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
Source§fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToSingleRedisArg,
RV: FromRedisValue,
fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn hscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn sscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn zscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
Source§fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
fn req_packed_commands( &mut self, cmd: &[u8], offset: usize, count: usize, ) -> Result<Vec<Value>, RedisError>
Source§fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
Source§fn get_db(&self) -> i64
fn get_db(&self) -> i64
fn supports_pipelining(&self) -> bool
Source§fn check_connection(&mut self) -> bool
fn check_connection(&mut self) -> bool
PING internally).impl<R> CryptoRng for R
impl<T> CryptoRng for T
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be
downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further
downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<T, A> DynAccess<T> for A
impl<T, A> DynAccess<T> for A
Source§fn load(&self) -> DynGuard<T>
fn load(&self) -> DynGuard<T>
Access::load.Source§impl<K, V, T> Expiry<K, V> for T
impl<K, V, T> Expiry<K, V> for T
Source§fn expire_after_create(
&self,
key: &K,
value: &V,
created_at: Instant,
) -> Option<Duration>
fn expire_after_create( &self, key: &K, value: &V, created_at: Instant, ) -> Option<Duration>
insert and get_with but only when the key
was not present in the cache. Read moreSource§fn expire_after_read(
&self,
key: &K,
value: &V,
read_at: Instant,
duration_until_expiry: Option<Duration>,
last_modified_at: Instant,
) -> Option<Duration>
fn expire_after_read( &self, key: &K, value: &V, read_at: Instant, duration_until_expiry: Option<Duration>, last_modified_at: Instant, ) -> Option<Duration>
get and get_with but only when the key is present in
the cache. Read moreSource§fn expire_after_update(
&self,
key: &K,
value: &V,
updated_at: Instant,
duration_until_expiry: Option<Duration>,
) -> Option<Duration>
fn expire_after_update( &self, key: &K, value: &V, updated_at: Instant, duration_until_expiry: Option<Duration>, ) -> Option<Duration>
insert but only when the key is
already present in the cache. Read moreSource§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.impl<T> Formattable for T
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> IntoSql for T
impl<T> IntoSql for T
Source§fn into_sql<T>(self) -> Self::Expression
fn into_sql<T>(self) -> Self::Expression
self to an expression for Diesel’s query builder. Read moreSource§fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression
fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression
&self to an expression for Diesel’s query builder. Read moreSource§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere
T: ?Sized,
Source§fn fg(&self, value: Color) -> Painted<&T>
fn fg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self with the foreground set to
value.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like red() and
green(), which have the same functionality but are
pithier.
§Example
Set foreground color to white using fg():
use yansi::{Paint, Color};
painted.fg(Color::White);Set foreground color to white using white().
use yansi::Paint;
painted.white();Source§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
Source§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
Source§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
Source§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
Source§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
Source§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
Source§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
Source§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
Source§fn bg(&self, value: Color) -> Painted<&T>
fn bg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self with the background set to
value.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like on_red() and
on_green(), which have the same functionality but
are pithier.
§Example
Set background color to red using fg():
use yansi::{Paint, Color};
painted.bg(Color::Red);Set background color to red using on_red().
use yansi::Paint;
painted.on_red();Source§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
Source§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
Source§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
Source§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
Source§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
Source§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
Source§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
Source§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
Source§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
Source§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
Source§fn attr(&self, value: Attribute) -> Painted<&T>
fn attr(&self, value: Attribute) -> Painted<&T>
Enables the styling Attribute value.
This method should be used rarely. Instead, prefer to use
attribute-specific builder methods like bold() and
underline(), which have the same functionality
but are pithier.
§Example
Make text bold using attr():
use yansi::{Paint, Attribute};
painted.attr(Attribute::Bold);Make text bold using using bold().
use yansi::Paint;
painted.bold();Source§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
Source§fn quirk(&self, value: Quirk) -> Painted<&T>
fn quirk(&self, value: Quirk) -> Painted<&T>
Enables the yansi Quirk value.
This method should be used rarely. Instead, prefer to use quirk-specific
builder methods like mask() and
wrap(), which have the same functionality but are
pithier.
§Example
Enable wrapping using .quirk():
use yansi::{Paint, Quirk};
painted.quirk(Quirk::Wrap);Enable wrapping using wrap().
use yansi::Paint;
painted.wrap();Source§fn clear(&self) -> Painted<&T>
👎Deprecated since 1.0.1: renamed to resetting() due to conflicts with Vec::clear().
The clear() method will be removed in a future release.
fn clear(&self) -> Painted<&T>
renamed to resetting() due to conflicts with Vec::clear().
The clear() method will be removed in a future release.
Source§fn whenever(&self, value: Condition) -> Painted<&T>
fn whenever(&self, value: Condition) -> Painted<&T>
Conditionally enable styling based on whether the Condition value
applies. Replaces any previous condition.
See the crate level docs for more details.
§Example
Enable styling painted only when both stdout and stderr are TTYs:
use yansi::{Paint, Condition};
painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);impl<T> Parsable for T
Source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.Source§impl<T> Pointable for T
impl<T> Pointable for T
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
Source§impl<R> Rng for R
impl<R> Rng for R
Source§fn random<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
fn random<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
StandardUniform distribution. Read moreSource§fn random_iter<T>(self) -> Iter<StandardUniform, Self, T> ⓘ
fn random_iter<T>(self) -> Iter<StandardUniform, Self, T> ⓘ
Source§fn random_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
fn random_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
Source§fn random_bool(&mut self, p: f64) -> bool
fn random_bool(&mut self, p: f64) -> bool
p of being true. Read moreSource§fn random_ratio(&mut self, numerator: u32, denominator: u32) -> bool
fn random_ratio(&mut self, numerator: u32, denominator: u32) -> bool
numerator/denominator of being
true. Read moreSource§fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
Source§fn sample_iter<T, D>(self, distr: D) -> Iter<D, Self, T> ⓘwhere
D: Distribution<T>,
Self: Sized,
fn sample_iter<T, D>(self, distr: D) -> Iter<D, Self, T> ⓘwhere
D: Distribution<T>,
Self: Sized,
Source§fn gen<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
fn gen<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
Renamed to random to avoid conflict with the new gen keyword in Rust 2024.
Rng::random.Source§fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
Renamed to random_range
Rng::random_range.impl<R> RngCore for Rwhere
R: Rng,
Source§impl<R> RngExt for R
impl<R> RngExt for R
Source§fn random<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
fn random<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
StandardUniform distribution. Read moreSource§fn random_iter<T>(self) -> Iter<StandardUniform, Self, T> ⓘ
fn random_iter<T>(self) -> Iter<StandardUniform, Self, T> ⓘ
Source§fn random_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
fn random_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
Source§fn random_bool(&mut self, p: f64) -> bool
fn random_bool(&mut self, p: f64) -> bool
p of being true. Read moreSource§fn random_ratio(&mut self, numerator: u32, denominator: u32) -> bool
fn random_ratio(&mut self, numerator: u32, denominator: u32) -> bool
numerator/denominator of being
true. Read moreSource§fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
Source§fn sample_iter<T, D>(self, distr: D) -> Iter<D, Self, T> ⓘwhere
D: Distribution<T>,
Self: Sized,
fn sample_iter<T, D>(self, distr: D) -> Iter<D, Self, T> ⓘwhere
D: Distribution<T>,
Self: Sized,
Source§impl<C> SimpleAsyncConnection for C
impl<C> SimpleAsyncConnection for C
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.impl<R> TryCryptoRng for R
impl<R> TryCryptoRng for R
Source§impl<R> TryRng for R
impl<R> TryRng for R
Source§impl<R> TryRngCore for Rwhere
R: TryRng,
impl<R> TryRngCore for Rwhere
R: TryRng,
Source§impl<R> TryRngCore for R
impl<R> TryRngCore for R
Source§fn try_next_u32(&mut self) -> Result<u32, <R as TryRngCore>::Error>
fn try_next_u32(&mut self) -> Result<u32, <R as TryRngCore>::Error>
u32.Source§fn try_next_u64(&mut self) -> Result<u64, <R as TryRngCore>::Error>
fn try_next_u64(&mut self) -> Result<u64, <R as TryRngCore>::Error>
u64.Source§fn try_fill_bytes(
&mut self,
dst: &mut [u8],
) -> Result<(), <R as TryRngCore>::Error>
fn try_fill_bytes( &mut self, dst: &mut [u8], ) -> Result<(), <R as TryRngCore>::Error>
dest entirely with random data.Source§fn unwrap_mut(&mut self) -> UnwrapMut<'_, Self>
fn unwrap_mut(&mut self) -> UnwrapMut<'_, Self>
UnwrapMut wrapper.Source§fn read_adapter(&mut self) -> RngReadAdapter<'_, Self> ⓘwhere
Self: Sized,
fn read_adapter(&mut self) -> RngReadAdapter<'_, Self> ⓘwhere
Self: Sized,
RngCore to a RngReadAdapter.Source§impl<T> TypedCommands for Twhere
T: ConnectionLike,
impl<T> TypedCommands for Twhere
T: ConnectionLike,
Source§fn get<'a, K>(&'a mut self, key: K) -> Result<Option<String>, RedisError>
fn get<'a, K>(&'a mut self, key: K) -> Result<Option<String>, RedisError>
MGET (if using TypedCommands, you should specifically use mget to get the correct return type.
Redis DocsSource§fn mget<'a, K>(&'a mut self, key: K) -> Result<Vec<Option<String>>, RedisError>
fn mget<'a, K>(&'a mut self, key: K) -> Result<Vec<Option<String>>, RedisError>
Source§fn keys<'a, K>(&'a mut self, key: K) -> Result<Vec<String>, RedisError>
fn keys<'a, K>(&'a mut self, key: K) -> Result<Vec<String>, RedisError>
Source§fn set<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), RedisError>
fn set<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), RedisError>
Source§fn set_options<'a, K, V>(
&'a mut self,
key: K,
value: V,
options: SetOptions,
) -> Result<Option<String>, RedisError>
fn set_options<'a, K, V>( &'a mut self, key: K, value: V, options: SetOptions, ) -> Result<Option<String>, RedisError>
Source§fn mset<'a, K, V>(&'a mut self, items: &'a [(K, V)]) -> Result<(), RedisError>
fn mset<'a, K, V>(&'a mut self, items: &'a [(K, V)]) -> Result<(), RedisError>
Source§fn set_ex<'a, K, V>(
&'a mut self,
key: K,
value: V,
seconds: u64,
) -> Result<(), RedisError>
fn set_ex<'a, K, V>( &'a mut self, key: K, value: V, seconds: u64, ) -> Result<(), RedisError>
Source§fn pset_ex<'a, K, V>(
&'a mut self,
key: K,
value: V,
milliseconds: u64,
) -> Result<(), RedisError>
fn pset_ex<'a, K, V>( &'a mut self, key: K, value: V, milliseconds: u64, ) -> Result<(), RedisError>
Source§fn set_nx<'a, K, V>(&'a mut self, key: K, value: V) -> Result<bool, RedisError>
fn set_nx<'a, K, V>(&'a mut self, key: K, value: V) -> Result<bool, RedisError>
Source§fn mset_nx<'a, K, V>(
&'a mut self,
items: &'a [(K, V)],
) -> Result<bool, RedisError>
fn mset_nx<'a, K, V>( &'a mut self, items: &'a [(K, V)], ) -> Result<bool, RedisError>
Source§fn mset_ex<'a, K, V>(
&'a mut self,
items: &'a [(K, V)],
options: MSetOptions,
) -> Result<bool, RedisError>
fn mset_ex<'a, K, V>( &'a mut self, items: &'a [(K, V)], options: MSetOptions, ) -> Result<bool, RedisError>
Source§fn getset<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Result<Option<String>, RedisError>
fn getset<'a, K, V>( &'a mut self, key: K, value: V, ) -> Result<Option<String>, RedisError>
Source§fn getrange<'a, K>(
&'a mut self,
key: K,
from: isize,
to: isize,
) -> Result<String, RedisError>
fn getrange<'a, K>( &'a mut self, key: K, from: isize, to: isize, ) -> Result<String, RedisError>
Source§fn setrange<'a, K, V>(
&'a mut self,
key: K,
offset: isize,
value: V,
) -> Result<usize, RedisError>
fn setrange<'a, K, V>( &'a mut self, key: K, offset: isize, value: V, ) -> Result<usize, RedisError>
Source§fn del<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn del<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn del_ex<'a, K>(
&'a mut self,
key: K,
value_comparison: ValueComparison,
) -> Result<usize, RedisError>
fn del_ex<'a, K>( &'a mut self, key: K, value_comparison: ValueComparison, ) -> Result<usize, RedisError>
match-value - Delete the key only if its value is equal to match-value
IFNE match-value - Delete the key only if its value is not equal to match-value
IFDEQ match-digest - Delete the key only if the digest of its value is equal to match-digest
IFDNE match-digest - Delete the key only if the digest of its value is not equal to match-digest
Redis DocsSource§fn digest<'a, K>(&'a mut self, key: K) -> Result<Option<String>, RedisError>
fn digest<'a, K>(&'a mut self, key: K) -> Result<Option<String>, RedisError>
Source§fn exists<'a, K>(&'a mut self, key: K) -> Result<bool, RedisError>
fn exists<'a, K>(&'a mut self, key: K) -> Result<bool, RedisError>
Source§fn key_type<'a, K>(&'a mut self, key: K) -> Result<ValueType, RedisError>
fn key_type<'a, K>(&'a mut self, key: K) -> Result<ValueType, RedisError>
Source§fn expire<'a, K>(&'a mut self, key: K, seconds: i64) -> Result<bool, RedisError>
fn expire<'a, K>(&'a mut self, key: K, seconds: i64) -> Result<bool, RedisError>
Source§fn expire_at<'a, K>(&'a mut self, key: K, ts: i64) -> Result<bool, RedisError>
fn expire_at<'a, K>(&'a mut self, key: K, ts: i64) -> Result<bool, RedisError>
Source§fn pexpire<'a, K>(&'a mut self, key: K, ms: i64) -> Result<bool, RedisError>
fn pexpire<'a, K>(&'a mut self, key: K, ms: i64) -> Result<bool, RedisError>
Source§fn pexpire_at<'a, K>(&'a mut self, key: K, ts: i64) -> Result<bool, RedisError>
fn pexpire_at<'a, K>(&'a mut self, key: K, ts: i64) -> Result<bool, RedisError>
Source§fn expire_time<'a, K>(
&'a mut self,
key: K,
) -> Result<IntegerReplyOrNoOp, RedisError>
fn expire_time<'a, K>( &'a mut self, key: K, ) -> Result<IntegerReplyOrNoOp, RedisError>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pexpire_time<'a, K>(
&'a mut self,
key: K,
) -> Result<IntegerReplyOrNoOp, RedisError>
fn pexpire_time<'a, K>( &'a mut self, key: K, ) -> Result<IntegerReplyOrNoOp, RedisError>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn persist<'a, K>(&'a mut self, key: K) -> Result<bool, RedisError>
fn persist<'a, K>(&'a mut self, key: K) -> Result<bool, RedisError>
Source§fn ttl<'a, K>(&'a mut self, key: K) -> Result<IntegerReplyOrNoOp, RedisError>
fn ttl<'a, K>(&'a mut self, key: K) -> Result<IntegerReplyOrNoOp, RedisError>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn pttl<'a, K>(&'a mut self, key: K) -> Result<IntegerReplyOrNoOp, RedisError>
fn pttl<'a, K>(&'a mut self, key: K) -> Result<IntegerReplyOrNoOp, RedisError>
ExistsButNotRelevant if key exists but has no expiration time.
Redis DocsSource§fn get_ex<'a, K>(
&'a mut self,
key: K,
expire_at: Expiry,
) -> Result<Option<String>, RedisError>
fn get_ex<'a, K>( &'a mut self, key: K, expire_at: Expiry, ) -> Result<Option<String>, RedisError>
Source§fn get_del<'a, K>(&'a mut self, key: K) -> Result<Option<String>, RedisError>
fn get_del<'a, K>(&'a mut self, key: K) -> Result<Option<String>, RedisError>
Source§fn copy<'a, KSrc, KDst, Db>(
&'a mut self,
source: KSrc,
destination: KDst,
options: CopyOptions<Db>,
) -> Result<bool, RedisError>where
KSrc: ToSingleRedisArg + Send + Sync + 'a,
KDst: ToSingleRedisArg + Send + Sync + 'a,
Db: ToString + Send + Sync + 'a,
fn copy<'a, KSrc, KDst, Db>(
&'a mut self,
source: KSrc,
destination: KDst,
options: CopyOptions<Db>,
) -> Result<bool, RedisError>where
KSrc: ToSingleRedisArg + Send + Sync + 'a,
KDst: ToSingleRedisArg + Send + Sync + 'a,
Db: ToString + Send + Sync + 'a,
Source§fn rename<'a, K, N>(&'a mut self, key: K, new_key: N) -> Result<(), RedisError>
fn rename<'a, K, N>(&'a mut self, key: K, new_key: N) -> Result<(), RedisError>
Source§fn rename_nx<'a, K, N>(
&'a mut self,
key: K,
new_key: N,
) -> Result<bool, RedisError>
fn rename_nx<'a, K, N>( &'a mut self, key: K, new_key: N, ) -> Result<bool, RedisError>
Source§fn unlink<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn unlink<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
DEL.
Returns number of keys unlinked.
Redis DocsSource§fn append<'a, K, V>(&'a mut self, key: K, value: V) -> Result<usize, RedisError>
fn append<'a, K, V>(&'a mut self, key: K, value: V) -> Result<usize, RedisError>
Source§fn incr<'a, K, V>(&'a mut self, key: K, delta: V) -> Result<isize, RedisError>
fn incr<'a, K, V>(&'a mut self, key: K, delta: V) -> Result<isize, RedisError>
INCRBY or INCRBYFLOAT depending on the type.
If the key does not exist, it is set to 0 before performing the operation.Source§fn decr<'a, K, V>(&'a mut self, key: K, delta: V) -> Result<isize, RedisError>
fn decr<'a, K, V>(&'a mut self, key: K, delta: V) -> Result<isize, RedisError>
Source§fn increx<'a, K, V>(
&'a mut self,
key: K,
increment: V,
options: IncrexOptions<V>,
) -> Result<IncrexResult, RedisError>
fn increx<'a, K, V>( &'a mut self, key: K, increment: V, options: IncrexOptions<V>, ) -> Result<IncrexResult, RedisError>
Source§fn setbit<'a, K>(
&'a mut self,
key: K,
offset: usize,
value: bool,
) -> Result<bool, RedisError>
fn setbit<'a, K>( &'a mut self, key: K, offset: usize, value: bool, ) -> Result<bool, RedisError>
Source§fn getbit<'a, K>(
&'a mut self,
key: K,
offset: usize,
) -> Result<bool, RedisError>
fn getbit<'a, K>( &'a mut self, key: K, offset: usize, ) -> Result<bool, RedisError>
Source§fn bitcount<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn bitcount<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn bitcount_range<'a, K>(
&'a mut self,
key: K,
start: usize,
end: usize,
) -> Result<usize, RedisError>
fn bitcount_range<'a, K>( &'a mut self, key: K, start: usize, end: usize, ) -> Result<usize, RedisError>
Source§fn bit_and<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<usize, RedisError>
fn bit_and<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<usize, RedisError>
Source§fn bit_or<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<usize, RedisError>
fn bit_or<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<usize, RedisError>
Source§fn bit_xor<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<usize, RedisError>
fn bit_xor<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<usize, RedisError>
Source§fn bit_not<'a, D, S>(
&'a mut self,
dstkey: D,
srckey: S,
) -> Result<usize, RedisError>
fn bit_not<'a, D, S>( &'a mut self, dstkey: D, srckey: S, ) -> Result<usize, RedisError>
Source§fn bit_diff<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<usize, RedisError>
fn bit_diff<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<usize, RedisError>
Perform a set difference to extract the members of X that are not members of any of Y1, Y2,….
Logical representation: X ∧ ¬(Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_diff1<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<usize, RedisError>
fn bit_diff1<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<usize, RedisError>
Perform a relative complement set difference to extract the members of one or more of Y1, Y2,… that are not members of X.
Logical representation: ¬X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_and_or<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<usize, RedisError>
fn bit_and_or<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<usize, RedisError>
Perform an “intersection of union(s)” operation to extract the members of X that are also members of one or more of Y1, Y2,….
Logical representation: X ∧ (Y1 ∨ Y2 ∨ …)
Redis Docs
Source§fn bit_one<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<usize, RedisError>
fn bit_one<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<usize, RedisError>
Perform an “exclusive membership” operation to extract the members of exactly one of X, Y1, Y2, ….
Logical representation: (X ∨ Y1 ∨ Y2 ∨ …) ∧ ¬((X ∧ Y1) ∨ (X ∧ Y2) ∨ (Y1 ∧ Y2) ∨ (Y1 ∧ Y3) ∨ …)
Redis Docs
Source§fn strlen<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn strlen<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn hget<'a, K, F>(
&'a mut self,
key: K,
field: F,
) -> Result<Option<String>, RedisError>
fn hget<'a, K, F>( &'a mut self, key: K, field: F, ) -> Result<Option<String>, RedisError>
Source§fn hmget<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Result<Vec<String>, RedisError>
fn hmget<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Result<Vec<String>, RedisError>
Source§fn hget_ex<'a, K, F>(
&'a mut self,
key: K,
fields: F,
expire_at: Expiry,
) -> Result<Vec<String>, RedisError>
fn hget_ex<'a, K, F>( &'a mut self, key: K, fields: F, expire_at: Expiry, ) -> Result<Vec<String>, RedisError>
Source§fn hdel<'a, K, F>(&'a mut self, key: K, field: F) -> Result<usize, RedisError>
fn hdel<'a, K, F>(&'a mut self, key: K, field: F) -> Result<usize, RedisError>
Source§fn hget_del<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Result<Vec<Option<String>>, RedisError>
fn hget_del<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Result<Vec<Option<String>>, RedisError>
Source§fn hset<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn hset<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn hset_ex<'a, K, F, V>(
&'a mut self,
key: K,
hash_field_expiration_options: &'a HashFieldExpirationOptions,
fields_values: &'a [(F, V)],
) -> Result<bool, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
fn hset_ex<'a, K, F, V>(
&'a mut self,
key: K,
hash_field_expiration_options: &'a HashFieldExpirationOptions,
fields_values: &'a [(F, V)],
) -> Result<bool, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
Source§fn hset_nx<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Result<bool, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn hset_nx<'a, K, F, V>(
&'a mut self,
key: K,
field: F,
value: V,
) -> Result<bool, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn hset_multiple<'a, K, F, V>(
&'a mut self,
key: K,
items: &'a [(F, V)],
) -> Result<(), RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
fn hset_multiple<'a, K, F, V>(
&'a mut self,
key: K,
items: &'a [(F, V)],
) -> Result<(), RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
Source§fn hincr<'a, K, F, D>(
&'a mut self,
key: K,
field: F,
delta: D,
) -> Result<f64, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
fn hincr<'a, K, F, D>(
&'a mut self,
key: K,
field: F,
delta: D,
) -> Result<f64, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
F: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
Source§fn hexists<'a, K, F>(&'a mut self, key: K, field: F) -> Result<bool, RedisError>
fn hexists<'a, K, F>(&'a mut self, key: K, field: F) -> Result<bool, RedisError>
Source§fn httl<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn httl<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hpttl<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hpttl<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hexpire<'a, K, F>(
&'a mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hexpire<'a, K, F>( &'a mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hexpire_at<'a, K, F>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hexpire_at<'a, K, F>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hexpire_time<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hexpire_time<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hpersist<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hpersist<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hpexpire<'a, K, F>(
&'a mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hpexpire<'a, K, F>( &'a mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hpexpire_at<'a, K, F>(
&'a mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hpexpire_at<'a, K, F>( &'a mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hpexpire_time<'a, K, F>(
&'a mut self,
key: K,
fields: F,
) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
fn hpexpire_time<'a, K, F>( &'a mut self, key: K, fields: F, ) -> Result<Vec<IntegerReplyOrNoOp>, RedisError>
Source§fn hkeys<'a, K>(&'a mut self, key: K) -> Result<Vec<String>, RedisError>
fn hkeys<'a, K>(&'a mut self, key: K) -> Result<Vec<String>, RedisError>
Source§fn hvals<'a, K>(&'a mut self, key: K) -> Result<Vec<String>, RedisError>
fn hvals<'a, K>(&'a mut self, key: K) -> Result<Vec<String>, RedisError>
Source§fn hgetall<'a, K>(
&'a mut self,
key: K,
) -> Result<HashMap<String, String>, RedisError>
fn hgetall<'a, K>( &'a mut self, key: K, ) -> Result<HashMap<String, String>, RedisError>
Source§fn hlen<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn hlen<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn blmove<'a, S, D>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Result<Option<String>, RedisError>
fn blmove<'a, S, D>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> Result<Option<String>, RedisError>
Source§fn blmpop<'a, K>(
&'a mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<Option<[String; 2]>, RedisError>
fn blmpop<'a, K>( &'a mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> Result<Option<[String; 2]>, RedisError>
count elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.
Redis DocsSource§fn blpop<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Result<Option<[String; 2]>, RedisError>
fn blpop<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Result<Option<[String; 2]>, RedisError>
Source§fn brpop<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Result<Option<[String; 2]>, RedisError>
fn brpop<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Result<Option<[String; 2]>, RedisError>
Source§fn brpoplpush<'a, S, D>(
&'a mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Result<Option<String>, RedisError>
fn brpoplpush<'a, S, D>( &'a mut self, srckey: S, dstkey: D, timeout: f64, ) -> Result<Option<String>, RedisError>
Source§fn lindex<'a, K>(
&'a mut self,
key: K,
index: isize,
) -> Result<Option<String>, RedisError>
fn lindex<'a, K>( &'a mut self, key: K, index: isize, ) -> Result<Option<String>, RedisError>
Source§fn linsert_before<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Result<isize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn linsert_before<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Result<isize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn linsert_after<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Result<isize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn linsert_after<'a, K, P, V>(
&'a mut self,
key: K,
pivot: P,
value: V,
) -> Result<isize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
P: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn llen<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn llen<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn lmove<'a, S, D>(
&'a mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Result<String, RedisError>
fn lmove<'a, S, D>( &'a mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> Result<String, RedisError>
Source§fn lmpop<'a, K>(
&'a mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<Option<(String, Vec<String>)>, RedisError>
fn lmpop<'a, K>( &'a mut self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> Result<Option<(String, Vec<String>)>, RedisError>
count elements from the first non-empty list key from the list of
provided key names.
Redis DocsSource§fn lpop<'a, RV, K>(
&'a mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>
fn lpop<'a, RV, K>( &'a mut self, key: K, count: Option<NonZero<usize>>, ) -> Result<RV, RedisError>
count first elements of the list stored at key. Read moreSource§fn lpos<'a, RV, K, V>(
&'a mut self,
key: K,
value: V,
options: LposOptions,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
fn lpos<'a, RV, K, V>(
&'a mut self,
key: K,
value: V,
options: LposOptions,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
K: ToSingleRedisArg + Send + Sync + 'a,
V: ToSingleRedisArg + Send + Sync + 'a,
Source§fn lpush<'a, K, V>(&'a mut self, key: K, value: V) -> Result<usize, RedisError>
fn lpush<'a, K, V>(&'a mut self, key: K, value: V) -> Result<usize, RedisError>
Source§fn lpush_exists<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Result<usize, RedisError>
fn lpush_exists<'a, K, V>( &'a mut self, key: K, value: V, ) -> Result<usize, RedisError>
Source§fn lrange<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Result<Vec<String>, RedisError>
fn lrange<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Result<Vec<String>, RedisError>
Source§fn lrem<'a, K, V>(
&'a mut self,
key: K,
count: isize,
value: V,
) -> Result<usize, RedisError>
fn lrem<'a, K, V>( &'a mut self, key: K, count: isize, value: V, ) -> Result<usize, RedisError>
Source§fn ltrim<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Result<(), RedisError>
fn ltrim<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Result<(), RedisError>
Source§fn lset<'a, K, V>(
&'a mut self,
key: K,
index: isize,
value: V,
) -> Result<(), RedisError>
fn lset<'a, K, V>( &'a mut self, key: K, index: isize, value: V, ) -> Result<(), RedisError>
Source§fn ping<'a>(&'a mut self) -> Result<String, RedisError>
fn ping<'a>(&'a mut self) -> Result<String, RedisError>
Source§fn ping_message<'a, K>(&'a mut self, message: K) -> Result<String, RedisError>
fn ping_message<'a, K>(&'a mut self, message: K) -> Result<String, RedisError>
Source§fn rpop<'a, RV, K>(
&'a mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>
fn rpop<'a, RV, K>( &'a mut self, key: K, count: Option<NonZero<usize>>, ) -> Result<RV, RedisError>
count last elements of the list stored at key Read moreSource§fn rpoplpush<'a, K, D>(
&'a mut self,
key: K,
dstkey: D,
) -> Result<Option<String>, RedisError>
fn rpoplpush<'a, K, D>( &'a mut self, key: K, dstkey: D, ) -> Result<Option<String>, RedisError>
Source§fn rpush<'a, K, V>(&'a mut self, key: K, value: V) -> Result<usize, RedisError>
fn rpush<'a, K, V>(&'a mut self, key: K, value: V) -> Result<usize, RedisError>
Source§fn rpush_exists<'a, K, V>(
&'a mut self,
key: K,
value: V,
) -> Result<usize, RedisError>
fn rpush_exists<'a, K, V>( &'a mut self, key: K, value: V, ) -> Result<usize, RedisError>
Source§fn sadd<'a, K, M>(&'a mut self, key: K, member: M) -> Result<usize, RedisError>
fn sadd<'a, K, M>(&'a mut self, key: K, member: M) -> Result<usize, RedisError>
Source§fn scard<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn scard<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn sdiff<'a, K>(&'a mut self, keys: K) -> Result<HashSet<String>, RedisError>
fn sdiff<'a, K>(&'a mut self, keys: K) -> Result<HashSet<String>, RedisError>
Source§fn sdiffstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn sdiffstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn sinter<'a, K>(&'a mut self, keys: K) -> Result<HashSet<String>, RedisError>
fn sinter<'a, K>(&'a mut self, keys: K) -> Result<HashSet<String>, RedisError>
Source§fn sinterstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn sinterstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn sismember<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Result<bool, RedisError>
fn sismember<'a, K, M>( &'a mut self, key: K, member: M, ) -> Result<bool, RedisError>
Source§fn smismember<'a, K, M>(
&'a mut self,
key: K,
members: M,
) -> Result<Vec<bool>, RedisError>
fn smismember<'a, K, M>( &'a mut self, key: K, members: M, ) -> Result<Vec<bool>, RedisError>
Source§fn smembers<'a, K>(&'a mut self, key: K) -> Result<HashSet<String>, RedisError>
fn smembers<'a, K>(&'a mut self, key: K) -> Result<HashSet<String>, RedisError>
Source§fn smove<'a, S, D, M>(
&'a mut self,
srckey: S,
dstkey: D,
member: M,
) -> Result<bool, RedisError>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn smove<'a, S, D, M>(
&'a mut self,
srckey: S,
dstkey: D,
member: M,
) -> Result<bool, RedisError>where
S: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn spop<'a, RV, K>(&'a mut self, key: K) -> Result<RV, RedisError>
fn spop<'a, RV, K>(&'a mut self, key: K) -> Result<RV, RedisError>
Source§fn srandmember<'a, K>(
&'a mut self,
key: K,
) -> Result<Option<String>, RedisError>
fn srandmember<'a, K>( &'a mut self, key: K, ) -> Result<Option<String>, RedisError>
Source§fn srandmember_multiple<'a, K>(
&'a mut self,
key: K,
count: isize,
) -> Result<Vec<String>, RedisError>
fn srandmember_multiple<'a, K>( &'a mut self, key: K, count: isize, ) -> Result<Vec<String>, RedisError>
Source§fn srem<'a, K, M>(&'a mut self, key: K, member: M) -> Result<usize, RedisError>
fn srem<'a, K, M>(&'a mut self, key: K, member: M) -> Result<usize, RedisError>
Source§fn sunion<'a, K>(&'a mut self, keys: K) -> Result<HashSet<String>, RedisError>
fn sunion<'a, K>(&'a mut self, keys: K) -> Result<HashSet<String>, RedisError>
Source§fn sunionstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn sunionstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn zadd<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zadd<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zadd_multiple<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
fn zadd_multiple<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
Source§fn zadd_options<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
options: &'a SortedSetAddOptions,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zadd_options<'a, K, S, M>(
&'a mut self,
key: K,
member: M,
score: S,
options: &'a SortedSetAddOptions,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zadd_multiple_options<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
options: &'a SortedSetAddOptions,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
fn zadd_multiple_options<'a, K, S, M>(
&'a mut self,
key: K,
items: &'a [(S, M)],
options: &'a SortedSetAddOptions,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
S: ToRedisArgs + Send + Sync + 'a,
M: ToRedisArgs + Send + Sync + 'a,
Source§fn zcard<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn zcard<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn zcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zincr<'a, K, M, D>(
&'a mut self,
key: K,
member: M,
delta: D,
) -> Result<f64, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
fn zincr<'a, K, M, D>(
&'a mut self,
key: K,
member: M,
delta: D,
) -> Result<f64, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
D: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zinterstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn zinterstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn zinterstore_min<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn zinterstore_min<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn zinterstore_max<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn zinterstore_max<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn zinterstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zinterstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zinterstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zinterstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zinterstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zinterstore_min, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zinterstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zinterstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zinterstore_max, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zlexcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zlexcount<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn bzpopmax<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Result<Option<(String, String, f64)>, RedisError>
fn bzpopmax<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Result<Option<(String, String, f64)>, RedisError>
Source§fn zpopmax<'a, K>(
&'a mut self,
key: K,
count: isize,
) -> Result<Vec<String>, RedisError>
fn zpopmax<'a, K>( &'a mut self, key: K, count: isize, ) -> Result<Vec<String>, RedisError>
Source§fn bzpopmin<'a, K>(
&'a mut self,
key: K,
timeout: f64,
) -> Result<Option<(String, String, f64)>, RedisError>
fn bzpopmin<'a, K>( &'a mut self, key: K, timeout: f64, ) -> Result<Option<(String, String, f64)>, RedisError>
Source§fn zpopmin<'a, K>(
&'a mut self,
key: K,
count: isize,
) -> Result<Vec<String>, RedisError>
fn zpopmin<'a, K>( &'a mut self, key: K, count: isize, ) -> Result<Vec<String>, RedisError>
Source§fn bzmpop_max<'a, K>(
&'a mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
fn bzmpop_max<'a, K>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
Source§fn zmpop_max<'a, K>(
&'a mut self,
keys: K,
count: isize,
) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
fn zmpop_max<'a, K>( &'a mut self, keys: K, count: isize, ) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
Source§fn bzmpop_min<'a, K>(
&'a mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
fn bzmpop_min<'a, K>( &'a mut self, timeout: f64, keys: K, count: isize, ) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
Source§fn zmpop_min<'a, K>(
&'a mut self,
keys: K,
count: isize,
) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
fn zmpop_min<'a, K>( &'a mut self, keys: K, count: isize, ) -> Result<Option<(String, Vec<(String, f64)>)>, RedisError>
Source§fn zrandmember<'a, RV, K>(
&'a mut self,
key: K,
count: Option<isize>,
) -> Result<RV, RedisError>
fn zrandmember<'a, RV, K>( &'a mut self, key: K, count: Option<isize>, ) -> Result<RV, RedisError>
count == None)
Redis DocsSource§fn zrandmember_withscores<'a, RV, K>(
&'a mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>
fn zrandmember_withscores<'a, RV, K>( &'a mut self, key: K, count: isize, ) -> Result<RV, RedisError>
Source§fn zrange<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Result<Vec<String>, RedisError>
fn zrange<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Result<Vec<String>, RedisError>
Source§fn zrange_withscores<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Result<Vec<(String, f64)>, RedisError>
fn zrange_withscores<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Result<Vec<(String, f64)>, RedisError>
Source§fn zrangebylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebylex_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebylex_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebylex<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebylex<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebylex_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebylex_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<Vec<(String, usize)>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<Vec<(String, usize)>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore_limit<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrangebyscore_limit_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<Vec<(String, usize)>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrangebyscore_limit_withscores<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<Vec<(String, usize)>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrank<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Result<Option<usize>, RedisError>
fn zrank<'a, K, M>( &'a mut self, key: K, member: M, ) -> Result<Option<usize>, RedisError>
Source§fn zrem<'a, K, M>(&'a mut self, key: K, members: M) -> Result<usize, RedisError>
fn zrem<'a, K, M>(&'a mut self, key: K, members: M) -> Result<usize, RedisError>
Source§fn zrembylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrembylex<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zremrangebyrank<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Result<usize, RedisError>
fn zremrangebyrank<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Result<usize, RedisError>
Source§fn zrembyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
fn zrembyscore<'a, K, M, MM>(
&'a mut self,
key: K,
min: M,
max: MM,
) -> Result<usize, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrange<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Result<Vec<String>, RedisError>
fn zrevrange<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Result<Vec<String>, RedisError>
Source§fn zrevrange_withscores<'a, K>(
&'a mut self,
key: K,
start: isize,
stop: isize,
) -> Result<Vec<String>, RedisError>
fn zrevrange_withscores<'a, K>( &'a mut self, key: K, start: isize, stop: isize, ) -> Result<Vec<String>, RedisError>
Source§fn zrevrangebyscore<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebyscore_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebyscore_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore_limit<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrangebyscore_limit_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
fn zrevrangebyscore_limit_withscores<'a, K, MM, M>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<Vec<String>, RedisError>where
K: ToSingleRedisArg + Send + Sync + 'a,
MM: ToSingleRedisArg + Send + Sync + 'a,
M: ToSingleRedisArg + Send + Sync + 'a,
Source§fn zrevrank<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Result<Option<usize>, RedisError>
fn zrevrank<'a, K, M>( &'a mut self, key: K, member: M, ) -> Result<Option<usize>, RedisError>
Source§fn zscore<'a, K, M>(
&'a mut self,
key: K,
member: M,
) -> Result<Option<f64>, RedisError>
fn zscore<'a, K, M>( &'a mut self, key: K, member: M, ) -> Result<Option<f64>, RedisError>
Source§fn zscore_multiple<'a, K, M>(
&'a mut self,
key: K,
members: &'a [M],
) -> Result<Option<Vec<f64>>, RedisError>
fn zscore_multiple<'a, K, M>( &'a mut self, key: K, members: &'a [M], ) -> Result<Option<Vec<f64>>, RedisError>
Source§fn zunionstore<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn zunionstore<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn zunionstore_min<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn zunionstore_min<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn zunionstore_max<'a, D, K>(
&'a mut self,
dstkey: D,
keys: K,
) -> Result<usize, RedisError>
fn zunionstore_max<'a, D, K>( &'a mut self, dstkey: D, keys: K, ) -> Result<usize, RedisError>
Source§fn zunionstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zunionstore_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zunionstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zunionstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zunionstore_min_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zunionstore_min, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn zunionstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
fn zunionstore_max_weights<'a, D, K, W>(
&'a mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<usize, RedisError>where
D: ToSingleRedisArg + Send + Sync + 'a,
K: ToRedisArgs + Send + Sync + 'a,
W: ToRedisArgs + Send + Sync + 'a,
Commands::zunionstore_max, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.
Redis DocsSource§fn pfadd<'a, K, E>(&'a mut self, key: K, element: E) -> Result<bool, RedisError>
fn pfadd<'a, K, E>(&'a mut self, key: K, element: E) -> Result<bool, RedisError>
Source§fn pfcount<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
fn pfcount<'a, K>(&'a mut self, key: K) -> Result<usize, RedisError>
Source§fn pfmerge<'a, D, S>(
&'a mut self,
dstkey: D,
srckeys: S,
) -> Result<(), RedisError>
fn pfmerge<'a, D, S>( &'a mut self, dstkey: D, srckeys: S, ) -> Result<(), RedisError>
Source§fn publish<'a, K, E>(
&'a mut self,
channel: K,
message: E,
) -> Result<usize, RedisError>
fn publish<'a, K, E>( &'a mut self, channel: K, message: E, ) -> Result<usize, RedisError>
Source§fn spublish<'a, K, E>(
&'a mut self,
channel: K,
message: E,
) -> Result<usize, RedisError>
fn spublish<'a, K, E>( &'a mut self, channel: K, message: E, ) -> Result<usize, RedisError>
Source§fn object_encoding<'a, K>(
&'a mut self,
key: K,
) -> Result<Option<String>, RedisError>
fn object_encoding<'a, K>( &'a mut self, key: K, ) -> Result<Option<String>, RedisError>
Source§fn object_idletime<'a, K>(
&'a mut self,
key: K,
) -> Result<Option<usize>, RedisError>
fn object_idletime<'a, K>( &'a mut self, key: K, ) -> Result<Option<usize>, RedisError>
Source§fn object_freq<'a, K>(&'a mut self, key: K) -> Result<Option<usize>, RedisError>
fn object_freq<'a, K>(&'a mut self, key: K) -> Result<Option<usize>, RedisError>
Source§fn object_refcount<'a, K>(
&'a mut self,
key: K,
) -> Result<Option<usize>, RedisError>
fn object_refcount<'a, K>( &'a mut self, key: K, ) -> Result<Option<usize>, RedisError>
Source§fn client_getname<'a>(&'a mut self) -> Result<Option<String>, RedisError>
fn client_getname<'a>(&'a mut self) -> Result<Option<String>, RedisError>
Source§fn client_id<'a>(&'a mut self) -> Result<isize, RedisError>
fn client_id<'a>(&'a mut self) -> Result<isize, RedisError>
Source§fn client_setname<'a, K>(
&'a mut self,
connection_name: K,
) -> Result<(), RedisError>
fn client_setname<'a, K>( &'a mut self, connection_name: K, ) -> Result<(), RedisError>
Source§fn flushall<'a>(&'a mut self) -> Result<(), RedisError>
fn flushall<'a>(&'a mut self) -> Result<(), RedisError>
Source§fn flushall_options<'a>(
&'a mut self,
options: &'a FlushAllOptions,
) -> Result<(), RedisError>
fn flushall_options<'a>( &'a mut self, options: &'a FlushAllOptions, ) -> Result<(), RedisError>
Source§fn flushdb<'a>(&'a mut self) -> Result<(), RedisError>
fn flushdb<'a>(&'a mut self) -> Result<(), RedisError>
Source§fn flushdb_options<'a>(
&'a mut self,
options: &'a FlushAllOptions,
) -> Result<(), RedisError>
fn flushdb_options<'a>( &'a mut self, options: &'a FlushAllOptions, ) -> Result<(), RedisError>
Source§fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
Source§fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
Source§fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToSingleRedisArg,
RV: FromRedisValue,
fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn hscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn sscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToSingleRedisArg,
RV: FromRedisValue,
Source§fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn zscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§fn get_int<K>(&mut self, key: K) -> Result<Option<isize>, RedisError>where
K: ToSingleRedisArg,
fn get_int<K>(&mut self, key: K) -> Result<Option<isize>, RedisError>where
K: ToSingleRedisArg,
Option<isize>.Source§fn mget_ints<K>(&mut self, key: K) -> Result<Vec<Option<isize>>, RedisError>where
K: ToRedisArgs,
fn mget_ints<K>(&mut self, key: K) -> Result<Vec<Option<isize>>, RedisError>where
K: ToRedisArgs,
Option<isize>s.