pub trait Commands: ConnectionLike + Sized {
Show 116 methods
fn get<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV> { ... }
fn set<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn set_multiple<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
items: &[(K, V)]
) -> RedisResult<RV> { ... }
fn set_ex<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V,
seconds: usize
) -> RedisResult<RV> { ... }
fn set_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn mset_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
items: &[(K, V)]
) -> RedisResult<RV> { ... }
fn getset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn del<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV> { ... }
fn exists<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn expire<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
seconds: usize
) -> RedisResult<RV> { ... }
fn expire_at<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ts: usize
) -> RedisResult<RV> { ... }
fn pexpire<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ms: usize
) -> RedisResult<RV> { ... }
fn pexpire_at<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ts: usize
) -> RedisResult<RV> { ... }
fn persist<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn rename<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
new_key: K
) -> RedisResult<RV> { ... }
fn rename_nx<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
new_key: K
) -> RedisResult<RV> { ... }
fn append<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn incr<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
delta: V
) -> RedisResult<RV> { ... }
fn setbit<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
offset: usize,
value: bool
) -> RedisResult<RV> { ... }
fn getbit<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
offset: usize
) -> RedisResult<RV> { ... }
fn bitcount<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn bitcount_range<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: usize,
end: usize
) -> RedisResult<RV> { ... }
fn bit_and<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV> { ... }
fn bit_or<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV> { ... }
fn bit_xor<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV> { ... }
fn bit_not<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckey: K
) -> RedisResult<RV> { ... }
fn strlen<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn hget<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV> { ... }
fn hdel<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV> { ... }
fn hset<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
value: V
) -> RedisResult<RV> { ... }
fn hset_nx<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
value: V
) -> RedisResult<RV> { ... }
fn hset_multiple<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
items: &[(F, V)]
) -> RedisResult<RV> { ... }
fn hincr<K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
delta: D
) -> RedisResult<RV> { ... }
fn hexists<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV> { ... }
fn hkeys<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn hvals<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn hgetall<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn hlen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV> { ... }
fn blpop<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
timeout: usize
) -> RedisResult<RV> { ... }
fn brpop<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
timeout: usize
) -> RedisResult<RV> { ... }
fn brpoplpush<K: ToRedisArgs, RV: FromRedisValue>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> RedisResult<RV> { ... }
fn lindex<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
index: isize
) -> RedisResult<RV> { ... }
fn linsert_before<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV> { ... }
fn linsert_after<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV> { ... }
fn llen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV> { ... }
fn lpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV> { ... }
fn lpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn lpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn lrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV> { ... }
fn lrem<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
count: isize,
value: V
) -> RedisResult<RV> { ... }
fn ltrim<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV> { ... }
fn rpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV> { ... }
fn rpoplpush<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
dstkey: K
) -> RedisResult<RV> { ... }
fn rpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn rpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV> { ... }
fn sadd<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV> { ... }
fn scard<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn sdiff<K: ToRedisArgs, RV: FromRedisValue>(
&self,
keys: K
) -> RedisResult<RV> { ... }
fn sdiffstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV> { ... }
fn sinter<K: ToRedisArgs, RV: FromRedisValue>(
&self,
keys: K
) -> RedisResult<RV> { ... }
fn sdinterstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV> { ... }
fn sismember<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV> { ... }
fn smembers<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn smove<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
srckey: K,
dstkey: K,
member: M
) -> RedisResult<RV> { ... }
fn spop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV> { ... }
fn srandmember<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn srandmember_multiple<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
count: usize
) -> RedisResult<RV> { ... }
fn srem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV> { ... }
fn sunion<K: ToRedisArgs, RV: FromRedisValue>(
&self,
keys: K
) -> RedisResult<RV> { ... }
fn sunionstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV> { ... }
fn zadd<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M,
score: S
) -> RedisResult<RV> { ... }
fn zadd_multiple<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
items: &[(S, M)]
) -> RedisResult<RV> { ... }
fn zcard<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn zcount<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV> { ... }
fn zincr<K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M,
delta: D
) -> RedisResult<RV> { ... }
fn zinterstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV> { ... }
fn zinterstore_min<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV> { ... }
fn zinterstore_max<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV> { ... }
fn zlexcount<K: ToRedisArgs, L: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: L,
max: L
) -> RedisResult<RV> { ... }
fn zrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV> { ... }
fn zrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV> { ... }
fn zrangebylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV> { ... }
fn zrangebylex_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV> { ... }
fn zrevrangebylex<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV> { ... }
fn zrevrangebylex_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV> { ... }
fn zrangebyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV> { ... }
fn zrangebyscore_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV> { ... }
fn zrangebyscore_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV> { ... }
fn zrangebyscore_limit_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV> { ... }
fn zrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV> { ... }
fn zrem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
members: M
) -> RedisResult<RV> { ... }
fn zrembylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV> { ... }
fn zrembyrank<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV> { ... }
fn zrembyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV> { ... }
fn zrevrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV> { ... }
fn zrevrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV> { ... }
fn zrevrangebyscore<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV> { ... }
fn zrevrangebyscore_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV> { ... }
fn zrevrangebyscore_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV> { ... }
fn zrevrangebyscore_limit_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV> { ... }
fn zrevrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV> { ... }
fn zscore<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV> { ... }
fn zunionstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV> { ... }
fn zunionstore_min<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV> { ... }
fn zunionstore_max<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV> { ... }
fn pfadd<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
element: E
) -> RedisResult<RV> { ... }
fn pfcount<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV> { ... }
fn pfmerge<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV> { ... }
fn scan<RV: FromRedisValue>(&self) -> RedisResult<Iter<'_, RV>> { ... }
fn scan_match<P: ToRedisArgs, RV: FromRedisValue>(
&self,
pattern: P
) -> RedisResult<Iter<'_, RV>> { ... }
fn hscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>> { ... }
fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>> { ... }
fn sscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>> { ... }
fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>> { ... }
fn zscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>> { ... }
fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>> { ... }
}
Expand description
Implements common redis commands for connection like objects. This allows you to send commands straight to a connection or client. It is also implemented for redis results of clients which makes for very convenient access in some basic cases.
This allows you to use nicer syntax for some common operations. For instance this code:
let client = try!(td_rredis::Client::open("redis://127.0.0.1/"));
let con = try!(client.get_connection());
td_rredis::cmd("SET").arg("my_key").arg(42).execute(&con);
assert_eq!(td_rredis::cmd("GET").arg("my_key").query(&con), Ok(42));
Will become this:
use td_rredis::Commands;
let client = try!(td_rredis::Client::open("redis://127.0.0.1/"));
let con = try!(client.get_connection());
assert_eq!(con.get("my_key"), Ok(42));
Provided Methods§
sourcefn get<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn get<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Get the value of a key. If key is a vec this becomes an MGET
.
sourcefn set<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn set<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Set the string value of a key.
sourcefn set_multiple<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
items: &[(K, V)]
) -> RedisResult<RV>
fn set_multiple<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
items: &[(K, V)]
) -> RedisResult<RV>
Sets multiple keys to their values.
sourcefn set_ex<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V,
seconds: usize
) -> RedisResult<RV>
fn set_ex<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V,
seconds: usize
) -> RedisResult<RV>
Set the value and expiration of a key.
sourcefn set_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn set_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Set the value of a key, only if the key does not exist
sourcefn mset_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
items: &[(K, V)]
) -> RedisResult<RV>
fn mset_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
items: &[(K, V)]
) -> RedisResult<RV>
Sets multiple keys to their values failing if at least one already exists.
sourcefn getset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn getset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Set the string value of a key and return its old value.
sourcefn del<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn del<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Delete one or more keys.
sourcefn exists<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn exists<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Determine if a key exists.
sourcefn expire<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
seconds: usize
) -> RedisResult<RV>
fn expire<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
seconds: usize
) -> RedisResult<RV>
Set a key’s time to live in seconds.
sourcefn expire_at<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ts: usize
) -> RedisResult<RV>
fn expire_at<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ts: usize
) -> RedisResult<RV>
Set the expiration for a key as a UNIX timestamp.
sourcefn pexpire<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ms: usize
) -> RedisResult<RV>
fn pexpire<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ms: usize
) -> RedisResult<RV>
Set a key’s time to live in milliseconds.
sourcefn pexpire_at<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ts: usize
) -> RedisResult<RV>
fn pexpire_at<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
ts: usize
) -> RedisResult<RV>
Set the expiration for a key as a UNIX timestamp in milliseconds.
sourcefn persist<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn persist<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Remove the expiration from a key.
sourcefn rename<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
new_key: K
) -> RedisResult<RV>
fn rename<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
new_key: K
) -> RedisResult<RV>
Rename a key.
sourcefn rename_nx<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
new_key: K
) -> RedisResult<RV>
fn rename_nx<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
new_key: K
) -> RedisResult<RV>
Rename a key, only if the new key does not exist.
sourcefn append<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn append<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Append a value to a key.
sourcefn incr<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
delta: V
) -> RedisResult<RV>
fn incr<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
delta: V
) -> RedisResult<RV>
Increment the numeric value of a key by the given amount. This
issues a INCRBY
or INCRBYFLOAT
depending on the type.
sourcefn setbit<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
offset: usize,
value: bool
) -> RedisResult<RV>
fn setbit<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
offset: usize,
value: bool
) -> RedisResult<RV>
Sets or clears the bit at offset in the string value stored at key.
sourcefn getbit<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
offset: usize
) -> RedisResult<RV>
fn getbit<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
offset: usize
) -> RedisResult<RV>
Returns the bit value at offset in the string value stored at key.
sourcefn bitcount<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn bitcount<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Count set bits in a string.
sourcefn bitcount_range<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: usize,
end: usize
) -> RedisResult<RV>
fn bitcount_range<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: usize,
end: usize
) -> RedisResult<RV>
Count set bits in a string in a range.
sourcefn bit_and<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
fn bit_and<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
Perform a bitwise AND between multiple keys (containing string values) and store the result in the destination key.
sourcefn bit_or<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
fn bit_or<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
Perform a bitwise OR between multiple keys (containing string values) and store the result in the destination key.
sourcefn bit_xor<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
fn bit_xor<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
Perform a bitwise XOR between multiple keys (containing string values) and store the result in the destination key.
sourcefn bit_not<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckey: K
) -> RedisResult<RV>
fn bit_not<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckey: K
) -> RedisResult<RV>
Perform a bitwise NOT of the key (containing string values) and store the result in the destination key.
sourcefn strlen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn strlen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Get the length of the value stored in a key.
sourcefn hget<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV>
fn hget<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV>
Gets a single (or multiple) fields from a hash.
sourcefn hdel<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV>
fn hdel<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV>
Deletes a single (or multiple) fields from a hash.
sourcefn hset<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
fn hset<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
Sets a single field in a hash.
sourcefn hset_nx<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
fn hset_nx<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
Sets a single field in a hash if it does not exist.
sourcefn hset_multiple<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
items: &[(F, V)]
) -> RedisResult<RV>
fn hset_multiple<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
items: &[(F, V)]
) -> RedisResult<RV>
Sets a multiple fields in a hash.
sourcefn hincr<K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
delta: D
) -> RedisResult<RV>
fn hincr<K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F,
delta: D
) -> RedisResult<RV>
Increments a value.
sourcefn hexists<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV>
fn hexists<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
field: F
) -> RedisResult<RV>
Checks if a field in a hash exists.
sourcefn hkeys<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn hkeys<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Gets all the keys in a hash.
sourcefn hvals<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn hvals<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Gets all the values in a hash.
sourcefn hgetall<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn hgetall<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Gets all the fields and values in a hash.
sourcefn hlen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn hlen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Gets the length of a hash.
sourcefn blpop<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
timeout: usize
) -> RedisResult<RV>
fn blpop<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
timeout: usize
) -> RedisResult<RV>
Remove and get the first element in a list, or block until one is available.
sourcefn brpop<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
timeout: usize
) -> RedisResult<RV>
fn brpop<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
timeout: usize
) -> RedisResult<RV>
Remove and get the last element in a list, or block until one is available.
sourcefn brpoplpush<K: ToRedisArgs, RV: FromRedisValue>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> RedisResult<RV>
fn brpoplpush<K: ToRedisArgs, RV: FromRedisValue>(
&self,
srckey: K,
dstkey: K,
timeout: usize
) -> RedisResult<RV>
Pop a value from a list, push it to another list and return it; or block until one is available.
sourcefn lindex<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
index: isize
) -> RedisResult<RV>
fn lindex<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
index: isize
) -> RedisResult<RV>
Get an element from a list by its index.
sourcefn linsert_before<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
fn linsert_before<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
Insert an element before another element in a list.
sourcefn linsert_after<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
fn linsert_after<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
Insert an element after another element in a list.
sourcefn llen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn llen<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Returns the length of the list stored at key.
sourcefn lpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn lpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Removes and returns the first element of the list stored at key.
sourcefn lpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn lpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Insert all the specified values at the head of the list stored at key.
sourcefn lpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn lpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Inserts a value at the head of the list stored at key, only if key already exists and holds a list.
sourcefn lrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn lrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
Returns the specified elements of the list stored at key.
sourcefn lrem<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
count: isize,
value: V
) -> RedisResult<RV>
fn lrem<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
count: isize,
value: V
) -> RedisResult<RV>
Removes the first count occurrences of elements equal to value from the list stored at key.
sourcefn ltrim<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn ltrim<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
Trim an existing list so that it will contain only the specified range of elements specified.
sourcefn rpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn rpop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Removes and returns the last element of the list stored at key.
sourcefn rpoplpush<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
dstkey: K
) -> RedisResult<RV>
fn rpoplpush<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
dstkey: K
) -> RedisResult<RV>
Pop a value from a list, push it to another list and return it.
sourcefn rpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn rpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Insert all the specified values at the tail of the list stored at key.
sourcefn rpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
fn rpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
value: V
) -> RedisResult<RV>
Inserts value at the tail of the list stored at key, only if key already exists and holds a list.
sourcefn sadd<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
fn sadd<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
Add one or more members to a set.
sourcefn scard<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn scard<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Get the number of members in a set.
sourcefn sdiff<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>
fn sdiff<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>
Subtract multiple sets.
sourcefn sdiffstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV>
fn sdiffstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV>
Subtract multiple sets and store the resulting set in a key.
sourcefn sinter<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>
fn sinter<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>
Intersect multiple sets.
sourcefn sdinterstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV>
fn sdinterstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV>
Intersect multiple sets and store the resulting set in a key.
sourcefn sismember<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
fn sismember<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
Determine if a given value is a member of a set.
sourcefn smembers<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn smembers<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Get all the members in a set.
sourcefn smove<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
srckey: K,
dstkey: K,
member: M
) -> RedisResult<RV>
fn smove<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
srckey: K,
dstkey: K,
member: M
) -> RedisResult<RV>
Move a member from one set to another.
sourcefn spop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn spop<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Remove and return a random member from a set.
sourcefn srandmember<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV>
fn srandmember<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<RV>
Get one random member from a set.
sourcefn srandmember_multiple<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
count: usize
) -> RedisResult<RV>
fn srandmember_multiple<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
count: usize
) -> RedisResult<RV>
Get multiple random members from a set.
sourcefn srem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
fn srem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
Remove one or more members from a set.
sourcefn sunion<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>
fn sunion<K: ToRedisArgs, RV: FromRedisValue>(&self, keys: K) -> RedisResult<RV>
Add multiple sets.
sourcefn sunionstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV>
fn sunionstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: K
) -> RedisResult<RV>
Add multiple sets and store the resulting set in a key.
sourcefn zadd<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M,
score: S
) -> RedisResult<RV>
fn zadd<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M,
score: S
) -> RedisResult<RV>
Add one member to a sorted set, or update its score if it already exists.
sourcefn zadd_multiple<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
items: &[(S, M)]
) -> RedisResult<RV>
fn zadd_multiple<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
items: &[(S, M)]
) -> RedisResult<RV>
Add multiple members to a sorted set, or update its score if it already exists.
sourcefn zcard<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn zcard<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Get the number of members in a sorted set.
sourcefn zcount<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zcount<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
Count the members in a sorted set with scores within the given values.
sourcefn zincr<K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M,
delta: D
) -> RedisResult<RV>
fn zincr<K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M,
delta: D
) -> RedisResult<RV>
Increments the member in a sorted set at key by delta. If the member does not exist, it is added with delta as its score.
sourcefn zinterstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
fn zinterstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
Intersect multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.
sourcefn zinterstore_min<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
fn zinterstore_min<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
Intersect multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.
sourcefn zinterstore_max<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
fn zinterstore_max<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
Intersect multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.
sourcefn zlexcount<K: ToRedisArgs, L: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: L,
max: L
) -> RedisResult<RV>
fn zlexcount<K: ToRedisArgs, L: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: L,
max: L
) -> RedisResult<RV>
Count the number of members in a sorted set between a given lexicographical range.
sourcefn zrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by index
sourcefn zrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by index with scores.
sourcefn zrangebylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
Return a range of members in a sorted set, by lexicographical range.
sourcefn zrangebylex_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebylex_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by lexicographical range with offset and limit.
sourcefn zrevrangebylex<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebylex<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
Return a range of members in a sorted set, by lexicographical range.
sourcefn zrevrangebylex_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebylex_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by lexicographical range with offset and limit.
sourcefn zrangebyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
Return a range of members in a sorted set, by score.
sourcefn zrangebyscore_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebyscore_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
Return a range of members in a sorted set, by score with scores.
sourcefn zrangebyscore_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebyscore_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by score with limit.
sourcefn zrangebyscore_limit_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebyscore_limit_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by score with limit with scores.
sourcefn zrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
fn zrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
Determine the index of a member in a sorted set.
sourcefn zrem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
members: M
) -> RedisResult<RV>
fn zrem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
members: M
) -> RedisResult<RV>
Remove one or more members from a sorted set.
sourcefn zrembylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrembylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
Remove all members in a sorted set between the given lexicographical range.
sourcefn zrembyrank<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrembyrank<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
Remove all members in a sorted set within the given indexes.
sourcefn zrembyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrembyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
Remove all members in a sorted set within the given scores.
sourcefn zrevrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrevrange<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by index, with scores ordered from high to low.
sourcefn zrevrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrevrange_withscores<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by index, with scores ordered from high to low.
sourcefn zrevrangebyscore<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebyscore<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
Return a range of members in a sorted set, by score.
sourcefn zrevrangebyscore_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebyscore_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
Return a range of members in a sorted set, by score with scores.
sourcefn zrevrangebyscore_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebyscore_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by score with limit.
sourcefn zrevrangebyscore_limit_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebyscore_limit_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
Return a range of members in a sorted set, by score with limit with scores.
sourcefn zrevrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
fn zrevrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
Determine the index of a member in a sorted set, with scores ordered from high to low.
sourcefn zscore<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
fn zscore<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
member: M
) -> RedisResult<RV>
Get the score associated with the given member in a sorted set.
sourcefn zunionstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
fn zunionstore<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
Unions multiple sorted sets and store the resulting sorted set in a new key using SUM as aggregation function.
sourcefn zunionstore_min<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
fn zunionstore_min<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
Unions multiple sorted sets and store the resulting sorted set in a new key using MIN as aggregation function.
sourcefn zunionstore_max<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
fn zunionstore_max<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
keys: &[K]
) -> RedisResult<RV>
Unions multiple sorted sets and store the resulting sorted set in a new key using MAX as aggregation function.
sourcefn pfadd<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
element: E
) -> RedisResult<RV>
fn pfadd<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
element: E
) -> RedisResult<RV>
Adds the specified elements to the specified HyperLogLog.
sourcefn pfcount<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
fn pfcount<K: ToRedisArgs, RV: FromRedisValue>(&self, key: K) -> RedisResult<RV>
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
sourcefn pfmerge<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
fn pfmerge<K: ToRedisArgs, RV: FromRedisValue>(
&self,
dstkey: K,
srckeys: K
) -> RedisResult<RV>
Merge N different HyperLogLogs into a single one.
sourcefn scan<RV: FromRedisValue>(&self) -> RedisResult<Iter<'_, RV>>
fn scan<RV: FromRedisValue>(&self) -> RedisResult<Iter<'_, RV>>
Incrementally iterate the keys space.
sourcefn scan_match<P: ToRedisArgs, RV: FromRedisValue>(
&self,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn scan_match<P: ToRedisArgs, RV: FromRedisValue>(
&self,
pattern: P
) -> RedisResult<Iter<'_, RV>>
Incrementally iterate the keys space for keys matching a pattern.
sourcefn hscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn hscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>>
Incrementally iterate hash fields and associated values.
sourcefn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
Incrementally iterate hash fields and associated values for field names matching a pattern.
sourcefn sscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn sscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>>
Incrementally iterate set elements.
sourcefn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
Incrementally iterate set elements for elements matching a pattern.
sourcefn zscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn zscan<K: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K
) -> RedisResult<Iter<'_, RV>>
Incrementally iterate sorted set elements.
sourcefn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
Incrementally iterate sorted set elements for elements matching a pattern.