Struct redis::Connection
source · 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 req_packed_commands(
&mut self,
cmd: &[u8],
offset: usize,
count: usize
) -> RedisResult<Vec<Value>>
fn req_packed_commands( &mut self, cmd: &[u8], offset: usize, count: usize ) -> RedisResult<Vec<Value>>
count
responses from it. This is used to implement
pipelining.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 !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 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.source§fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
element: E
) -> RedisResult<RV>
fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, element: E ) -> RedisResult<RV>
source§fn pfcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn pfcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn pfmerge<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn pfmerge<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn publish<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
channel: K,
message: E
) -> RedisResult<RV>
fn publish<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, channel: K, message: E ) -> RedisResult<RV>
source§fn object_encoding<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_encoding<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_idletime<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_idletime<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_freq<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_freq<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_refcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_refcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_getuser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K
) -> RedisResult<RV>
fn acl_getuser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K ) -> RedisResult<RV>
source§fn acl_setuser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K
) -> RedisResult<RV>
fn acl_setuser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K ) -> RedisResult<RV>
source§fn acl_setuser_rules<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K,
rules: &'a [Rule]
) -> RedisResult<RV>
fn acl_setuser_rules<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K, rules: &'a [Rule] ) -> RedisResult<RV>
source§fn acl_deluser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
usernames: &'a [K]
) -> RedisResult<RV>
fn acl_deluser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, usernames: &'a [K] ) -> RedisResult<RV>
source§fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_cat_categoryname<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
categoryname: K
) -> RedisResult<RV>
fn acl_cat_categoryname<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, categoryname: K ) -> RedisResult<RV>
source§fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_genpass_bits<'a, RV: FromRedisValue>(
&mut self,
bits: isize
) -> RedisResult<RV>
fn acl_genpass_bits<'a, RV: FromRedisValue>( &mut self, bits: isize ) -> RedisResult<RV>
source§fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_log<'a, RV: FromRedisValue>(&mut self, count: isize) -> RedisResult<RV>
fn acl_log<'a, RV: FromRedisValue>(&mut self, count: isize) -> RedisResult<RV>
source§fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
source§fn geo_add<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_add<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
source§fn geo_dist<'a, K: ToRedisArgs, M1: ToRedisArgs, M2: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> RedisResult<RV>
fn geo_dist<'a, K: ToRedisArgs, M1: ToRedisArgs, M2: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member1: M1, member2: M2, unit: Unit ) -> RedisResult<RV>
source§fn geo_hash<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_hash<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
source§fn geo_pos<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_pos<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
source§fn geo_radius<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisResult<RV>
fn geo_radius<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, longitude: f64, latitude: f64, radius: f64, unit: Unit, options: RadiusOptions ) -> RedisResult<RV>
source§fn geo_radius_by_member<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisResult<RV>
fn geo_radius_by_member<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, radius: f64, unit: Unit, options: RadiusOptions ) -> RedisResult<RV>
member
. The
member itself is always contained in the results.source§fn xack<'a, K: ToRedisArgs, G: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
ids: &'a [I]
) -> RedisResult<RV>
fn xack<'a, K: ToRedisArgs, G: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, ids: &'a [I] ) -> RedisResult<RV>
source§fn xadd<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn xadd<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, id: ID, items: &'a [(F, V)] ) -> RedisResult<RV>
source§fn xadd_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
id: ID,
map: BTM
) -> RedisResult<RV>
fn xadd_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, id: ID, map: BTM ) -> RedisResult<RV>
key
.
Use *
as the id
for the current timestamp. Read moresource§fn xadd_maxlen<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn xadd_maxlen<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, items: &'a [(F, V)] ) -> RedisResult<RV>
source§fn xadd_maxlen_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> RedisResult<RV>
fn xadd_maxlen_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, map: BTM ) -> RedisResult<RV>
source§fn xclaim<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> RedisResult<RV>
fn xclaim<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID] ) -> RedisResult<RV>
source§fn xclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> RedisResult<RV>
fn xclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], options: StreamClaimOptions ) -> RedisResult<RV>
source§fn xdel<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ids: &'a [ID]
) -> RedisResult<RV>
fn xdel<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ids: &'a [ID] ) -> RedisResult<RV>
source§fn xgroup_create<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_create<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
group
. It expects the stream key
to already exist. Otherwise, use xgroup_create_mkstream
if it doesn’t.
The id
is the starting message id all consumers should read from. Use $
If you want
all consumers to read from the last message added to stream. Read moresource§fn xgroup_create_mkstream<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_create_mkstream<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
group
which makes the stream if it doesn’t exist. Read moresource§fn xgroup_setid<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_setid<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
source§fn xgroup_destroy<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xgroup_destroy<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
source§fn xgroup_delconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C
) -> RedisResult<RV>
fn xgroup_delconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C ) -> RedisResult<RV>
source§fn xinfo_consumers<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xinfo_consumers<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
group
.
Take note of the StreamInfoConsumersReply return type. Read moresource§fn xinfo_groups<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xinfo_groups<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
group
s created for a given stream key
.
Take note of the StreamInfoGroupsReply return type. Read moresource§fn xinfo_stream<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xinfo_stream<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
id
, length, number of groups, etc.)
Take note of the StreamInfoStreamReply return type. Read moresource§fn xlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
key
. Read moresource§fn xpending<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xpending<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
key
and consumer group
and it
returns details about which consumers have pending messages
that haven’t been acked. Read moresource§fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> RedisResult<RV>
fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, start: S, end: E, count: C ) -> RedisResult<RV>
source§fn xpending_consumer_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, CN: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> RedisResult<RV>
fn xpending_consumer_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, CN: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, start: S, end: E, count: C, consumer: CN ) -> RedisResult<RV>
source§fn xrange<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: S,
end: E
) -> RedisResult<RV>
fn xrange<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: S, end: E ) -> RedisResult<RV>
key
. Read moresource§fn xrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
key
.
Use with caution! Read moresource§fn xrange_count<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: S,
end: E,
count: C
) -> RedisResult<RV>
fn xrange_count<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: S, end: E, count: C ) -> RedisResult<RV>
key
. Read moresource§fn xread<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
ids: &'a [ID]
) -> RedisResult<RV>
fn xread<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], ids: &'a [ID] ) -> RedisResult<RV>
id
s for each stream key
.
This is the basic form of reading streams.
For more advanced control, like blocking, limiting, or reading by consumer group
,
see xread_options
. Read moresource§fn xread_options<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions
) -> RedisResult<RV>
fn xread_options<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], ids: &'a [ID], options: &'a StreamReadOptions ) -> RedisResult<RV>
source§fn xrevrange<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
end: E,
start: S
) -> RedisResult<RV>
fn xrevrange<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, end: E, start: S ) -> RedisResult<RV>
source§fn xrevrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xrevrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn xrevrange_count<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
end: E,
start: S,
count: C
) -> RedisResult<RV>
fn xrevrange_count<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, end: E, start: S, count: C ) -> RedisResult<RV>
source§fn xtrim<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen
) -> RedisResult<RV>
fn xtrim<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen ) -> RedisResult<RV>
key
to a MAXLEN count. Read more