pub struct Connection { /* private fields */ }
Expand description
Represents a stateful redis TCP connection.
Implementations§
source§impl Connection
impl Connection
A connection is an object that represents a single redis connection. It provides basic support for sending encoded commands into a redis connection and to read a response from it. It’s bound to a single database and can only be created from the client.
You generally do not much with this object other than passing it to
Cmd
objects.
sourcepub fn send_packed_command(&mut self, cmd: &[u8]) -> RedisResult<()>
pub fn send_packed_command(&mut self, cmd: &[u8]) -> RedisResult<()>
Sends an already encoded (packed) command into the TCP socket and
does not read a response. This is useful for commands like
MONITOR
which yield multiple items. This needs to be used with
care because it changes the state of the connection.
sourcepub fn recv_response(&mut self) -> RedisResult<Value>
pub fn recv_response(&mut self) -> RedisResult<Value>
Fetches a single response from the connection. This is useful
if used in combination with send_packed_command
.
sourcepub fn set_write_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
pub fn set_write_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
Sets the write timeout for the connection.
If the provided value is None
, then send_packed_command
call will
block indefinitely. It is an error to pass the zero Duration
to this
method.
sourcepub fn set_read_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
pub fn set_read_timeout(&self, dur: Option<Duration>) -> RedisResult<()>
Sets the read timeout for the connection.
If the provided value is None
, then recv_response
call will
block indefinitely. It is an error to pass the zero Duration
to this
method.
Trait Implementations§
source§impl ConnectionLike for Connection
impl ConnectionLike for Connection
source§fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<Value>
fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<Value>
source§fn get_db(&self) -> i64
fn get_db(&self) -> i64
source§fn check_connection(&mut self) -> bool
fn check_connection(&mut self) -> bool
PING
internally).source§fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
source§impl PubSubCommands for Connection
impl PubSubCommands for Connection
source§fn subscribe<C, F, U>(&mut self, channels: C, func: F) -> RedisResult<U>
fn subscribe<C, F, U>(&mut self, channels: C, func: F) -> RedisResult<U>
source§fn psubscribe<P, F, U>(&mut self, patterns: P, func: F) -> RedisResult<U>
fn psubscribe<P, F, U>(&mut self, patterns: P, func: F) -> RedisResult<U>
Auto Trait Implementations§
impl Freeze for Connection
impl !RefUnwindSafe for Connection
impl Send for Connection
impl Sync for Connection
impl Unpin for Connection
impl !UnwindSafe for Connection
Blanket Implementations§
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
source§impl<T> Commands for Twhere
T: ConnectionLike,
impl<T> Commands for Twhere
T: ConnectionLike,
source§fn get<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn get<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
MGET
.source§fn mget<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn mget<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn keys<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn keys<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn set<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn set<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn set_options<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
options: SetOptions,
) -> RedisResult<RV>
fn set_options<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, options: SetOptions, ) -> RedisResult<RV>
source§fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)],
) -> RedisResult<RV>
fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)], ) -> RedisResult<RV>
source§fn mset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)],
) -> RedisResult<RV>
fn mset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)], ) -> RedisResult<RV>
source§fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
seconds: u64,
) -> RedisResult<RV>
fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, seconds: u64, ) -> RedisResult<RV>
source§fn pset_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
milliseconds: u64,
) -> RedisResult<RV>
fn pset_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, milliseconds: u64, ) -> RedisResult<RV>
source§fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)],
) -> RedisResult<RV>
fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)], ) -> RedisResult<RV>
source§fn getset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn getset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn getrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
from: isize,
to: isize,
) -> RedisResult<RV>
fn getrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, from: isize, to: isize, ) -> RedisResult<RV>
source§fn setrange<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: isize,
value: V,
) -> RedisResult<RV>
fn setrange<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: isize, value: V, ) -> RedisResult<RV>
source§fn del<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn del<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn exists<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn exists<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn key_type<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn key_type<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn expire<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
seconds: i64,
) -> RedisResult<RV>
fn expire<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, seconds: i64, ) -> RedisResult<RV>
source§fn expire_at<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64,
) -> RedisResult<RV>
fn expire_at<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64, ) -> RedisResult<RV>
source§fn pexpire<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ms: i64,
) -> RedisResult<RV>
fn pexpire<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ms: i64, ) -> RedisResult<RV>
source§fn pexpire_at<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64,
) -> RedisResult<RV>
fn pexpire_at<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64, ) -> RedisResult<RV>
source§fn persist<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn persist<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn ttl<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn ttl<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn pttl<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn pttl<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn get_ex<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
expire_at: Expiry,
) -> RedisResult<RV>
fn get_ex<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, expire_at: Expiry, ) -> RedisResult<RV>
source§fn get_del<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn get_del<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn rename<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
new_key: N,
) -> RedisResult<RV>
fn rename<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, new_key: N, ) -> RedisResult<RV>
source§fn rename_nx<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
new_key: N,
) -> RedisResult<RV>
fn rename_nx<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, new_key: N, ) -> RedisResult<RV>
source§fn unlink<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn unlink<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn append<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn append<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn incr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
delta: V,
) -> RedisResult<RV>
fn incr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, delta: V, ) -> RedisResult<RV>
INCRBY
or INCRBYFLOAT
depending on the type.source§fn decr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
delta: V,
) -> RedisResult<RV>
fn decr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, delta: V, ) -> RedisResult<RV>
source§fn setbit<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: usize,
value: bool,
) -> RedisResult<RV>
fn setbit<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: usize, value: bool, ) -> RedisResult<RV>
source§fn getbit<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: usize,
) -> RedisResult<RV>
fn getbit<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: usize, ) -> RedisResult<RV>
source§fn bitcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn bitcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn bitcount_range<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: usize,
end: usize,
) -> RedisResult<RV>
fn bitcount_range<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: usize, end: usize, ) -> RedisResult<RV>
source§fn bit_and<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S,
) -> RedisResult<RV>
fn bit_and<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S, ) -> RedisResult<RV>
source§fn bit_or<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S,
) -> RedisResult<RV>
fn bit_or<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S, ) -> RedisResult<RV>
source§fn bit_xor<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S,
) -> RedisResult<RV>
fn bit_xor<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S, ) -> RedisResult<RV>
source§fn bit_not<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckey: S,
) -> RedisResult<RV>
fn bit_not<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckey: S, ) -> RedisResult<RV>
source§fn strlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn strlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn hget<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
) -> RedisResult<RV>
fn hget<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, ) -> RedisResult<RV>
source§fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
) -> RedisResult<RV>
fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, ) -> RedisResult<RV>
source§fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
value: V,
) -> RedisResult<RV>
fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, value: V, ) -> RedisResult<RV>
source§fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
value: V,
) -> RedisResult<RV>
fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, value: V, ) -> RedisResult<RV>
source§fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
items: &'a [(F, V)],
) -> RedisResult<RV>
fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, items: &'a [(F, V)], ) -> RedisResult<RV>
source§fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
delta: D,
) -> RedisResult<RV>
fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, delta: D, ) -> RedisResult<RV>
source§fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
) -> RedisResult<RV>
fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, ) -> RedisResult<RV>
source§fn hkeys<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn hkeys<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn hvals<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn hvals<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn hgetall<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn hgetall<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn hlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn hlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn blmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> RedisResult<RV>
fn blmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> RedisResult<RV>
source§fn blmpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> RedisResult<RV>
fn blmpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize, ) -> RedisResult<RV>
count
elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.source§fn blpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64,
) -> RedisResult<RV>
fn blpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64, ) -> RedisResult<RV>
source§fn brpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64,
) -> RedisResult<RV>
fn brpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64, ) -> RedisResult<RV>
source§fn brpoplpush<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> RedisResult<RV>
fn brpoplpush<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, timeout: f64, ) -> RedisResult<RV>
source§fn lindex<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
index: isize,
) -> RedisResult<RV>
fn lindex<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, index: isize, ) -> RedisResult<RV>
source§fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pivot: P,
value: V,
) -> RedisResult<RV>
fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pivot: P, value: V, ) -> RedisResult<RV>
source§fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pivot: P,
value: V,
) -> RedisResult<RV>
fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pivot: P, value: V, ) -> RedisResult<RV>
source§fn llen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn llen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn lmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> RedisResult<RV>
fn lmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> RedisResult<RV>
source§fn lmpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> RedisResult<RV>
fn lmpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, numkeys: usize, key: K, dir: Direction, count: usize, ) -> RedisResult<RV>
count
elements from the first non-empty list key from the list of
provided key names.source§fn lpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<NonZeroUsize>,
) -> RedisResult<RV>
fn lpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<NonZeroUsize>, ) -> RedisResult<RV>
count
first elements of the list stored at key. Read moresource§fn lpos<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
options: LposOptions,
) -> RedisResult<RV>
fn lpos<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, options: LposOptions, ) -> RedisResult<RV>
source§fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn lrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> RedisResult<RV>
fn lrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize, ) -> RedisResult<RV>
source§fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize,
value: V,
) -> RedisResult<RV>
fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize, value: V, ) -> RedisResult<RV>
source§fn ltrim<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> RedisResult<RV>
fn ltrim<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize, ) -> RedisResult<RV>
source§fn lset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
index: isize,
value: V,
) -> RedisResult<RV>
fn lset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, index: isize, value: V, ) -> RedisResult<RV>
source§fn rpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<NonZeroUsize>,
) -> RedisResult<RV>
fn rpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<NonZeroUsize>, ) -> RedisResult<RV>
count
last elements of the list stored at key Read moresource§fn rpoplpush<'a, K: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
dstkey: D,
) -> RedisResult<RV>
fn rpoplpush<'a, K: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, dstkey: D, ) -> RedisResult<RV>
source§fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
) -> RedisResult<RV>
fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, ) -> RedisResult<RV>
source§fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
) -> RedisResult<RV>
fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, ) -> RedisResult<RV>
source§fn scard<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn scard<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn sdiff<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K,
) -> RedisResult<RV>
fn sdiff<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K, ) -> RedisResult<RV>
source§fn sdiffstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K,
) -> RedisResult<RV>
fn sdiffstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K, ) -> RedisResult<RV>
source§fn sinter<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K,
) -> RedisResult<RV>
fn sinter<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K, ) -> RedisResult<RV>
source§fn sinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K,
) -> RedisResult<RV>
fn sinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K, ) -> RedisResult<RV>
source§fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
) -> RedisResult<RV>
fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, ) -> RedisResult<RV>
source§fn smismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M,
) -> RedisResult<RV>
fn smismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M, ) -> RedisResult<RV>
source§fn smembers<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn smembers<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn smove<'a, S: ToRedisArgs, D: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
member: M,
) -> RedisResult<RV>
fn smove<'a, S: ToRedisArgs, D: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, member: M, ) -> RedisResult<RV>
source§fn spop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn spop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn srandmember<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn srandmember<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn srandmember_multiple<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: usize,
) -> RedisResult<RV>
fn srandmember_multiple<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: usize, ) -> RedisResult<RV>
source§fn srem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
) -> RedisResult<RV>
fn srem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, ) -> RedisResult<RV>
source§fn sunion<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K,
) -> RedisResult<RV>
fn sunion<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K, ) -> RedisResult<RV>
source§fn sunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K,
) -> RedisResult<RV>
fn sunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K, ) -> RedisResult<RV>
source§fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
score: S,
) -> RedisResult<RV>
fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, score: S, ) -> RedisResult<RV>
source§fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
items: &'a [(S, M)],
) -> RedisResult<RV>
fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, items: &'a [(S, M)], ) -> RedisResult<RV>
source§fn zcard<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
) -> RedisResult<RV>
fn zcard<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ) -> RedisResult<RV>
source§fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
) -> RedisResult<RV>
fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, ) -> RedisResult<RV>
source§fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
delta: D,
) -> RedisResult<RV>
fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, delta: D, ) -> RedisResult<RV>
source§fn zinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K],
) -> RedisResult<RV>
fn zinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K], ) -> RedisResult<RV>
source§fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K],
) -> RedisResult<RV>
fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K], ) -> RedisResult<RV>
source§fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K],
) -> RedisResult<RV>
fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K], ) -> RedisResult<RV>
source§fn zinterstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> RedisResult<RV>
fn zinterstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisResult<RV>
Commands::zinterstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zinterstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> RedisResult<RV>
fn zinterstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisResult<RV>
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.source§fn zinterstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> RedisResult<RV>
fn zinterstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisResult<RV>
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.source§fn zlexcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
) -> RedisResult<RV>
fn zlexcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, ) -> RedisResult<RV>
source§fn bzpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64,
) -> RedisResult<RV>
fn bzpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64, ) -> RedisResult<RV>
source§fn zpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize,
) -> RedisResult<RV>
fn zpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize, ) -> RedisResult<RV>
source§fn bzpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64,
) -> RedisResult<RV>
fn bzpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64, ) -> RedisResult<RV>
source§fn zpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize,
) -> RedisResult<RV>
fn zpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize, ) -> RedisResult<RV>
source§fn bzmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize,
) -> RedisResult<RV>
fn bzmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: &'a [K], count: isize, ) -> RedisResult<RV>
source§fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
count: isize,
) -> RedisResult<RV>
fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], count: isize, ) -> RedisResult<RV>
source§fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize,
) -> RedisResult<RV>
fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: &'a [K], count: isize, ) -> RedisResult<RV>
source§fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
count: isize,
) -> RedisResult<RV>
fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], count: isize, ) -> RedisResult<RV>
source§fn zrandmember<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<isize>,
) -> RedisResult<RV>
fn zrandmember<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<isize>, ) -> RedisResult<RV>
count == None
)source§fn zrandmember_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize,
) -> RedisResult<RV>
fn zrandmember_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize, ) -> RedisResult<RV>
source§fn zrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> RedisResult<RV>
fn zrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize, ) -> RedisResult<RV>
source§fn zrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> RedisResult<RV>
fn zrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize, ) -> RedisResult<RV>
source§fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
) -> RedisResult<RV>
fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, ) -> RedisResult<RV>
source§fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisResult<RV>
fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisResult<RV>
source§fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
) -> RedisResult<RV>
fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, ) -> RedisResult<RV>
source§fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisResult<RV>
fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisResult<RV>
source§fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
) -> RedisResult<RV>
fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, ) -> RedisResult<RV>
source§fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
) -> RedisResult<RV>
fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, ) -> RedisResult<RV>
source§fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisResult<RV>
fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisResult<RV>
source§fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisResult<RV>
fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisResult<RV>
source§fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
) -> RedisResult<RV>
fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, ) -> RedisResult<RV>
source§fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M,
) -> RedisResult<RV>
fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M, ) -> RedisResult<RV>
source§fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
) -> RedisResult<RV>
fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, ) -> RedisResult<RV>
source§fn zremrangebyrank<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> RedisResult<RV>
fn zremrangebyrank<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize, ) -> RedisResult<RV>
source§fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
) -> RedisResult<RV>
fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, ) -> RedisResult<RV>
source§fn zrevrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> RedisResult<RV>
fn zrevrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize, ) -> RedisResult<RV>
source§fn zrevrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> RedisResult<RV>
fn zrevrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize, ) -> RedisResult<RV>
source§fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
) -> RedisResult<RV>
fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, ) -> RedisResult<RV>
source§fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
) -> RedisResult<RV>
fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, ) -> RedisResult<RV>
source§fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisResult<RV>
fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisResult<RV>
source§fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisResult<RV>
fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisResult<RV>
source§fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
) -> RedisResult<RV>
fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, ) -> RedisResult<RV>
source§fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
) -> RedisResult<RV>
fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, ) -> RedisResult<RV>
source§fn zscore_multiple<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: &'a [M],
) -> RedisResult<RV>
fn zscore_multiple<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: &'a [M], ) -> RedisResult<RV>
source§fn zunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K],
) -> RedisResult<RV>
fn zunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K], ) -> RedisResult<RV>
source§fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K],
) -> RedisResult<RV>
fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K], ) -> RedisResult<RV>
source§fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K],
) -> RedisResult<RV>
fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K], ) -> RedisResult<RV>
source§fn zunionstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> RedisResult<RV>
fn zunionstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisResult<RV>
Commands::zunionstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zunionstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> RedisResult<RV>
fn zunionstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisResult<RV>
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.source§fn zunionstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> RedisResult<RV>
fn zunionstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> RedisResult<RV>
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.