pub trait Commands:
ConnectionLike
+ Send
+ Sized
+ 'static {
Show 122 methods
// Provided methods
fn get<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn keys<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn set<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn set_multiple<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
items: &[(K, V)],
) -> RedisFuture<(Self, RV)> { ... }
fn set_ex<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
seconds: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn set_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn mset_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
items: &[(K, V)],
) -> RedisFuture<(Self, RV)> { ... }
fn getset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn getrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
from: isize,
to: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn setrange<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
offset: isize,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn del<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn exists<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn expire<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
seconds: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn expire_at<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
ts: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn pexpire<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
ms: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn pexpire_at<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
ts: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn persist<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn ttl<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn rename<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
new_key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn rename_nx<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
new_key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn append<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn incr<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
delta: V,
) -> RedisFuture<(Self, RV)> { ... }
fn setbit<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
offset: usize,
value: bool,
) -> RedisFuture<(Self, RV)> { ... }
fn getbit<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
offset: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn bitcount<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn bitcount_range<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: usize,
end: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn bit_and<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn bit_or<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn bit_xor<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn bit_not<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
srckey: K,
) -> RedisFuture<(Self, RV)> { ... }
fn strlen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn hget<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
) -> RedisFuture<(Self, RV)> { ... }
fn hdel<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
) -> RedisFuture<(Self, RV)> { ... }
fn hset<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn hset_nx<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn hset_multiple<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
items: &[(F, V)],
) -> RedisFuture<(Self, RV)> { ... }
fn hincr<K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
delta: D,
) -> RedisFuture<(Self, RV)> { ... }
fn hexists<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
) -> RedisFuture<(Self, RV)> { ... }
fn hkeys<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn hvals<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn hgetall<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn hlen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn blpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
timeout: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn brpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
timeout: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn brpoplpush<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
srckey: K,
dstkey: K,
timeout: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn lindex<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
index: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn linsert_before<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pivot: P,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn linsert_after<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pivot: P,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn llen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn lpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn lpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn lpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn lrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn lrem<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
count: isize,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn ltrim<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn lset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
index: isize,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn rpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn rpoplpush<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
dstkey: K,
) -> RedisFuture<(Self, RV)> { ... }
fn rpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn rpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)> { ... }
fn sadd<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)> { ... }
fn scard<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn sdiff<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
keys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn sdiffstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn sinter<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
keys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn sinterstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn sismember<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)> { ... }
fn smembers<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn smove<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
srckey: K,
dstkey: K,
member: M,
) -> RedisFuture<(Self, RV)> { ... }
fn spop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn srandmember<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn srandmember_multiple<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
count: usize,
) -> RedisFuture<(Self, RV)> { ... }
fn srem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)> { ... }
fn sunion<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
keys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn sunionstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn zadd<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
score: S,
) -> RedisFuture<(Self, RV)> { ... }
fn zadd_multiple<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
items: &[(S, M)],
) -> RedisFuture<(Self, RV)> { ... }
fn zcard<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn zcount<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)> { ... }
fn zincr<K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
delta: D,
) -> RedisFuture<(Self, RV)> { ... }
fn zinterstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)> { ... }
fn zinterstore_min<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)> { ... }
fn zinterstore_max<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)> { ... }
fn zlexcount<K: ToRedisArgs, L: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: L,
max: L,
) -> RedisFuture<(Self, RV)> { ... }
fn zrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrange_withscores<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrangebylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)> { ... }
fn zrangebylex_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrangebylex<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrangebylex_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrangebyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)> { ... }
fn zrangebyscore_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)> { ... }
fn zrangebyscore_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrangebyscore_limit_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)> { ... }
fn zrem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
members: M,
) -> RedisFuture<(Self, RV)> { ... }
fn zrembylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)> { ... }
fn zrembyrank<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrembyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrange_withscores<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrangebyscore<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrangebyscore_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrangebyscore_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrangebyscore_limit_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)> { ... }
fn zrevrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)> { ... }
fn zscore<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)> { ... }
fn zunionstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)> { ... }
fn zunionstore_min<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)> { ... }
fn zunionstore_max<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)> { ... }
fn pfadd<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
element: E,
) -> RedisFuture<(Self, RV)> { ... }
fn pfcount<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)> { ... }
fn pfmerge<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)> { ... }
fn publish<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
channel: K,
message: E,
) -> RedisFuture<(Self, RV)> { ... }
fn scan<RV: FromRedisValue + Send + 'static>(
self,
) -> RedisScanStream<Self, RV> { ... }
fn scan_match<P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
pattern: P,
) -> RedisScanStream<Self, RV> { ... }
fn hscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisScanStream<Self, RV> { ... }
fn hscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pattern: P,
) -> RedisScanStream<Self, RV> { ... }
fn sscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisScanStream<Self, RV> { ... }
fn sscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pattern: P,
) -> RedisScanStream<Self, RV> { ... }
fn zscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisScanStream<Self, RV> { ... }
fn zscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pattern: P,
) -> RedisScanStream<Self, RV> { ... }
}
Expand description
Asynchronous version of redis::Commands
.
§Constraints
The arguments of scan commands are required to implement Clone
because
they need to create multiple redis::Cmd
objects internally.
Provided Methods§
Sourcefn get<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn get<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Get the value of a key. If key is a vec this becomes an MGET
.
Sourcefn keys<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn keys<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Gets all keys matching pattern
Sourcefn set<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn set<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, RV)>
Set the string value of a key.
Sourcefn set_multiple<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
items: &[(K, V)],
) -> RedisFuture<(Self, RV)>
fn set_multiple<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, items: &[(K, V)], ) -> RedisFuture<(Self, RV)>
Sets multiple keys to their values.
Sourcefn set_ex<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
seconds: usize,
) -> RedisFuture<(Self, RV)>
fn set_ex<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, seconds: usize, ) -> RedisFuture<(Self, RV)>
Set the value and expiration of a key.
Sourcefn set_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn set_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, RV)>
Set the value of a key, only if the key does not exist
Sourcefn mset_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
items: &[(K, V)],
) -> RedisFuture<(Self, RV)>
fn mset_nx<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, items: &[(K, V)], ) -> RedisFuture<(Self, RV)>
Sets multiple keys to their values failing if at least one already exists.
Sourcefn getset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn getset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, RV)>
Set the string value of a key and return its old value.
Sourcefn getrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
from: isize,
to: isize,
) -> RedisFuture<(Self, RV)>
fn getrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, from: isize, to: isize, ) -> RedisFuture<(Self, RV)>
Get a range of bytes/substring from the value of a key. Negative values provide an offset from the end of the value.
Sourcefn setrange<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
offset: isize,
value: V,
) -> RedisFuture<(Self, RV)>
fn setrange<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, offset: isize, value: V, ) -> RedisFuture<(Self, RV)>
Overwrite the part of the value stored in key at the specified offset.
Sourcefn del<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn del<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Delete one or more keys.
Sourcefn exists<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn exists<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Determine if a key exists.
Sourcefn expire<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
seconds: usize,
) -> RedisFuture<(Self, RV)>
fn expire<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, seconds: usize, ) -> RedisFuture<(Self, RV)>
Set a key’s time to live in seconds.
Sourcefn expire_at<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
ts: usize,
) -> RedisFuture<(Self, RV)>
fn expire_at<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ts: usize, ) -> RedisFuture<(Self, RV)>
Set the expiration for a key as a UNIX timestamp.
Sourcefn pexpire<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
ms: usize,
) -> RedisFuture<(Self, RV)>
fn pexpire<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ms: usize, ) -> RedisFuture<(Self, RV)>
Set a key’s time to live in milliseconds.
Sourcefn pexpire_at<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
ts: usize,
) -> RedisFuture<(Self, RV)>
fn pexpire_at<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ts: usize, ) -> RedisFuture<(Self, RV)>
Set the expiration for a key as a UNIX timestamp in milliseconds.
Sourcefn persist<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn persist<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Remove the expiration from a key.
Sourcefn ttl<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn ttl<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Check the expiration time of a key.
Sourcefn rename<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
new_key: K,
) -> RedisFuture<(Self, RV)>
fn rename<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, new_key: K, ) -> RedisFuture<(Self, RV)>
Rename a key.
Sourcefn rename_nx<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
new_key: K,
) -> RedisFuture<(Self, RV)>
fn rename_nx<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, new_key: K, ) -> RedisFuture<(Self, RV)>
Rename a key, only if the new key does not exist.
Sourcefn append<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn append<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, RV)>
Append a value to a key.
Sourcefn incr<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
delta: V,
) -> RedisFuture<(Self, RV)>
fn incr<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, delta: V, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
offset: usize,
value: bool,
) -> RedisFuture<(Self, RV)>
fn setbit<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, offset: usize, value: bool, ) -> RedisFuture<(Self, RV)>
Sets or clears the bit at offset in the string value stored at key.
Sourcefn getbit<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
offset: usize,
) -> RedisFuture<(Self, RV)>
fn getbit<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, offset: usize, ) -> RedisFuture<(Self, RV)>
Returns the bit value at offset in the string value stored at key.
Sourcefn bitcount<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn bitcount<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Count set bits in a string.
Sourcefn bitcount_range<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: usize,
end: usize,
) -> RedisFuture<(Self, RV)>
fn bitcount_range<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: usize, end: usize, ) -> RedisFuture<(Self, RV)>
Count set bits in a string in a range.
Sourcefn bit_and<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)>
fn bit_and<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, srckeys: K, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)>
fn bit_or<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, srckeys: K, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)>
fn bit_xor<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, srckeys: K, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
srckey: K,
) -> RedisFuture<(Self, RV)>
fn bit_not<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, srckey: K, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn strlen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Get the length of the value stored in a key.
Sourcefn hget<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
) -> RedisFuture<(Self, RV)>
fn hget<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, field: F, ) -> RedisFuture<(Self, RV)>
Gets a single (or multiple) fields from a hash.
Sourcefn hdel<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
) -> RedisFuture<(Self, RV)>
fn hdel<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, field: F, ) -> RedisFuture<(Self, RV)>
Deletes a single (or multiple) fields from a hash.
Sourcefn hset<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
value: V,
) -> RedisFuture<(Self, RV)>
fn hset<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, field: F, value: V, ) -> RedisFuture<(Self, RV)>
Sets a single field in a hash.
Sourcefn hset_nx<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
value: V,
) -> RedisFuture<(Self, RV)>
fn hset_nx<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, field: F, value: V, ) -> RedisFuture<(Self, RV)>
Sets a single field in a hash if it does not exist.
Sourcefn hset_multiple<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
items: &[(F, V)],
) -> RedisFuture<(Self, RV)>
fn hset_multiple<K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, items: &[(F, V)], ) -> RedisFuture<(Self, RV)>
Sets a multiple fields in a hash.
Sourcefn hincr<K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
delta: D,
) -> RedisFuture<(Self, RV)>
fn hincr<K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, field: F, delta: D, ) -> RedisFuture<(Self, RV)>
Increments a value.
Sourcefn hexists<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
field: F,
) -> RedisFuture<(Self, RV)>
fn hexists<K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, field: F, ) -> RedisFuture<(Self, RV)>
Checks if a field in a hash exists.
Sourcefn hkeys<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn hkeys<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Gets all the keys in a hash.
Sourcefn hvals<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn hvals<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Gets all the values in a hash.
Sourcefn hgetall<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn hgetall<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Gets all the fields and values in a hash.
Sourcefn hlen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn hlen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Gets the length of a hash.
Sourcefn blpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
timeout: usize,
) -> RedisFuture<(Self, RV)>
fn blpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, timeout: usize, ) -> RedisFuture<(Self, RV)>
Remove and get the first element in a list, or block until one is available.
Sourcefn brpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
timeout: usize,
) -> RedisFuture<(Self, RV)>
fn brpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, timeout: usize, ) -> RedisFuture<(Self, RV)>
Remove and get the last element in a list, or block until one is available.
Sourcefn brpoplpush<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
srckey: K,
dstkey: K,
timeout: usize,
) -> RedisFuture<(Self, RV)>
fn brpoplpush<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, srckey: K, dstkey: K, timeout: usize, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
index: isize,
) -> RedisFuture<(Self, RV)>
fn lindex<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, index: isize, ) -> RedisFuture<(Self, RV)>
Get an element from a list by its index.
Sourcefn linsert_before<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pivot: P,
value: V,
) -> RedisFuture<(Self, RV)>
fn linsert_before<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, pivot: P, value: V, ) -> RedisFuture<(Self, RV)>
Insert an element before another element in a list.
Sourcefn linsert_after<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pivot: P,
value: V,
) -> RedisFuture<(Self, RV)>
fn linsert_after<K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, pivot: P, value: V, ) -> RedisFuture<(Self, RV)>
Insert an element after another element in a list.
Sourcefn llen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn llen<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Returns the length of the list stored at key.
Sourcefn lpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn lpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Removes and returns the first element of the list stored at key.
Sourcefn lpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn lpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, RV)>
Insert all the specified values at the head of the list stored at key.
Sourcefn lpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn lpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)>
fn lrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: isize, stop: isize, ) -> RedisFuture<(Self, RV)>
Returns the specified elements of the list stored at key.
Sourcefn lrem<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
count: isize,
value: V,
) -> RedisFuture<(Self, RV)>
fn lrem<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, count: isize, value: V, ) -> RedisFuture<(Self, RV)>
Removes the first count occurrences of elements equal to value from the list stored at key.
Sourcefn ltrim<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)>
fn ltrim<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: isize, stop: isize, ) -> RedisFuture<(Self, RV)>
Trim an existing list so that it will contain only the specified range of elements specified.
Sourcefn lset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
index: isize,
value: V,
) -> RedisFuture<(Self, RV)>
fn lset<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, index: isize, value: V, ) -> RedisFuture<(Self, RV)>
Sets the list element at index to value
Sourcefn rpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn rpop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Removes and returns the last element of the list stored at key.
Sourcefn rpoplpush<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
dstkey: K,
) -> RedisFuture<(Self, RV)>
fn rpoplpush<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, dstkey: K, ) -> RedisFuture<(Self, RV)>
Pop a value from a list, push it to another list and return it.
Sourcefn rpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn rpush<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, RV)>
Insert all the specified values at the tail of the list stored at key.
Sourcefn rpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
value: V,
) -> RedisFuture<(Self, RV)>
fn rpush_exists<K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, value: V, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)>
fn sadd<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, ) -> RedisFuture<(Self, RV)>
Add one or more members to a set.
Sourcefn scard<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn scard<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Get the number of members in a set.
Sourcefn sdiff<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
keys: K,
) -> RedisFuture<(Self, RV)>
fn sdiff<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, keys: K, ) -> RedisFuture<(Self, RV)>
Subtract multiple sets.
Sourcefn sdiffstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: K,
) -> RedisFuture<(Self, RV)>
fn sdiffstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: K, ) -> RedisFuture<(Self, RV)>
Subtract multiple sets and store the resulting set in a key.
Sourcefn sinter<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
keys: K,
) -> RedisFuture<(Self, RV)>
fn sinter<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, keys: K, ) -> RedisFuture<(Self, RV)>
Intersect multiple sets.
Sourcefn sinterstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: K,
) -> RedisFuture<(Self, RV)>
fn sinterstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: K, ) -> RedisFuture<(Self, RV)>
Intersect multiple sets and store the resulting set in a key.
Sourcefn sismember<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)>
fn sismember<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, ) -> RedisFuture<(Self, RV)>
Determine if a given value is a member of a set.
Sourcefn smembers<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn smembers<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Get all the members in a set.
Sourcefn smove<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
srckey: K,
dstkey: K,
member: M,
) -> RedisFuture<(Self, RV)>
fn smove<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, srckey: K, dstkey: K, member: M, ) -> RedisFuture<(Self, RV)>
Move a member from one set to another.
Sourcefn spop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn spop<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Remove and return a random member from a set.
Sourcefn srandmember<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn srandmember<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Get one random member from a set.
Sourcefn srandmember_multiple<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
count: usize,
) -> RedisFuture<(Self, RV)>
fn srandmember_multiple<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, count: usize, ) -> RedisFuture<(Self, RV)>
Get multiple random members from a set.
Sourcefn srem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)>
fn srem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, ) -> RedisFuture<(Self, RV)>
Remove one or more members from a set.
Sourcefn sunion<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
keys: K,
) -> RedisFuture<(Self, RV)>
fn sunion<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, keys: K, ) -> RedisFuture<(Self, RV)>
Add multiple sets.
Sourcefn sunionstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: K,
) -> RedisFuture<(Self, RV)>
fn sunionstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: K, ) -> RedisFuture<(Self, RV)>
Add multiple sets and store the resulting set in a key.
Sourcefn zadd<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
score: S,
) -> RedisFuture<(Self, RV)>
fn zadd<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, score: S, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
items: &[(S, M)],
) -> RedisFuture<(Self, RV)>
fn zadd_multiple<K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, items: &[(S, M)], ) -> RedisFuture<(Self, RV)>
Add multiple members to a sorted set, or update its score if it already exists.
Sourcefn zcard<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn zcard<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Get the number of members in a sorted set.
Sourcefn zcount<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)>
fn zcount<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, ) -> RedisFuture<(Self, RV)>
Count the members in a sorted set with scores within the given values.
Sourcefn zincr<K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
delta: D,
) -> RedisFuture<(Self, RV)>
fn zincr<K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, delta: D, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)>
fn zinterstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: &[K], ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)>
fn zinterstore_min<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: &[K], ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)>
fn zinterstore_max<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: &[K], ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
min: L,
max: L,
) -> RedisFuture<(Self, RV)>
fn zlexcount<K: ToRedisArgs, L: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: L, max: L, ) -> RedisFuture<(Self, RV)>
Count the number of members in a sorted set between a given lexicographical range.
Sourcefn zrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)>
fn zrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: isize, stop: isize, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by index
Sourcefn zrange_withscores<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)>
fn zrange_withscores<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: isize, stop: isize, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by index with scores.
Sourcefn zrangebylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)>
fn zrangebylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by lexicographical range.
Sourcefn zrangebylex_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)>
fn zrangebylex_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
max: MM,
min: M,
) -> RedisFuture<(Self, RV)>
fn zrevrangebylex<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, max: MM, min: M, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by lexicographical range.
Sourcefn zrevrangebylex_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)>
fn zrevrangebylex_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)>
fn zrangebyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by score.
Sourcefn zrangebyscore_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)>
fn zrangebyscore_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)>
fn zrangebyscore_limit<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)>
fn zrangebyscore_limit_withscores<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by score with limit with scores.
Sourcefn zrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)>
fn zrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, ) -> RedisFuture<(Self, RV)>
Determine the index of a member in a sorted set.
Sourcefn zrem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
members: M,
) -> RedisFuture<(Self, RV)>
fn zrem<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, members: M, ) -> RedisFuture<(Self, RV)>
Remove one or more members from a sorted set.
Sourcefn zrembylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)>
fn zrembylex<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, ) -> RedisFuture<(Self, RV)>
Remove all members in a sorted set between the given lexicographical range.
Sourcefn zrembyrank<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)>
fn zrembyrank<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: isize, stop: isize, ) -> RedisFuture<(Self, RV)>
Remove all members in a sorted set within the given indexes.
Sourcefn zrembyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
min: M,
max: MM,
) -> RedisFuture<(Self, RV)>
fn zrembyscore<K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, min: M, max: MM, ) -> RedisFuture<(Self, RV)>
Remove all members in a sorted set within the given scores.
Sourcefn zrevrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)>
fn zrevrange<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: isize, stop: isize, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
start: isize,
stop: isize,
) -> RedisFuture<(Self, RV)>
fn zrevrange_withscores<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, start: isize, stop: isize, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
max: MM,
min: M,
) -> RedisFuture<(Self, RV)>
fn zrevrangebyscore<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, max: MM, min: M, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by score.
Sourcefn zrevrangebyscore_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
max: MM,
min: M,
) -> RedisFuture<(Self, RV)>
fn zrevrangebyscore_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, max: MM, min: M, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)>
fn zrevrangebyscore_limit<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> RedisFuture<(Self, RV)>
fn zrevrangebyscore_limit_withscores<K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> RedisFuture<(Self, RV)>
Return a range of members in a sorted set, by score with limit with scores.
Sourcefn zrevrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)>
fn zrevrank<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
member: M,
) -> RedisFuture<(Self, RV)>
fn zscore<K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, member: M, ) -> RedisFuture<(Self, RV)>
Get the score associated with the given member in a sorted set.
Sourcefn zunionstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)>
fn zunionstore<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: &[K], ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)>
fn zunionstore_min<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: &[K], ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
dstkey: K,
keys: &[K],
) -> RedisFuture<(Self, RV)>
fn zunionstore_max<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, keys: &[K], ) -> RedisFuture<(Self, 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 + Send + 'static>(
self,
key: K,
element: E,
) -> RedisFuture<(Self, RV)>
fn pfadd<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, element: E, ) -> RedisFuture<(Self, RV)>
Adds the specified elements to the specified HyperLogLog.
Sourcefn pfcount<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisFuture<(Self, RV)>
fn pfcount<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisFuture<(Self, RV)>
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
Sourcefn pfmerge<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
dstkey: K,
srckeys: K,
) -> RedisFuture<(Self, RV)>
fn pfmerge<K: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, dstkey: K, srckeys: K, ) -> RedisFuture<(Self, RV)>
Merge N different HyperLogLogs into a single one.
Sourcefn publish<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue + Send + 'static>(
self,
channel: K,
message: E,
) -> RedisFuture<(Self, RV)>
fn publish<K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue + Send + 'static>( self, channel: K, message: E, ) -> RedisFuture<(Self, RV)>
Posts a message to the given channel.
Sourcefn scan<RV: FromRedisValue + Send + 'static>(self) -> RedisScanStream<Self, RV>
fn scan<RV: FromRedisValue + Send + 'static>(self) -> RedisScanStream<Self, RV>
Incrementally iterate the keys space.
Sourcefn scan_match<P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
pattern: P,
) -> RedisScanStream<Self, RV>
fn scan_match<P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>( self, pattern: P, ) -> RedisScanStream<Self, RV>
Incrementally iterate the keys space for keys matching a pattern.
Sourcefn hscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisScanStream<Self, RV>
fn hscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisScanStream<Self, RV>
Incrementally iterate hash fields and associated values.
Sourcefn hscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pattern: P,
) -> RedisScanStream<Self, RV>
fn hscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>( self, key: K, pattern: P, ) -> RedisScanStream<Self, RV>
Incrementally iterate hash fields and associated values for field names matching a pattern.
Sourcefn sscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisScanStream<Self, RV>
fn sscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisScanStream<Self, RV>
Incrementally iterate set elements.
Sourcefn sscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pattern: P,
) -> RedisScanStream<Self, RV>
fn sscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>( self, key: K, pattern: P, ) -> RedisScanStream<Self, RV>
Incrementally iterate set elements for elements matching a pattern.
Sourcefn zscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
) -> RedisScanStream<Self, RV>
fn zscan<K: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>( self, key: K, ) -> RedisScanStream<Self, RV>
Incrementally iterate sorted set elements.
Sourcefn zscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>(
self,
key: K,
pattern: P,
) -> RedisScanStream<Self, RV>
fn zscan_match<K: ToRedisArgs + Clone + Send + 'static, P: ToRedisArgs + Clone + Send + 'static, RV: FromRedisValue + Send + 'static>( self, key: K, pattern: P, ) -> RedisScanStream<Self, RV>
Incrementally iterate sorted set elements for elements matching a pattern.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.