Struct redis::Pipeline [−] [src]

pub struct Pipeline {
    // some fields omitted
}

Represents a redis command pipeline.

Methods

`impl Pipeline`

A pipeline allows you to send multiple commands in one go to the redis server. API wise it's very similar to just using a command but it allows multiple commands to be chained and some features such as iteration are not available.

Basic example:

let ((k1, k2),) : ((i32, i32),) = redis::pipe()
    .cmd("SET").arg("key_1").arg(42).ignore()
    .cmd("SET").arg("key_2").arg(43).ignore()
    .cmd("MGET").arg(&["key_1", "key_2"]).query(&con).unwrap();

As you can see with cmd you can start a new command. By default each command produces a value but for some you can ignore them by calling ignore on the command. That way it will be skipped in the return value which is useful for SET commands and others, which do not have a useful return value.

`fn new() -> Pipeline`

Creates an empty pipeline. For consistency with the cmd api a pipe function is provided as alias.

`fn cmd(&mut self, name: &str) -> &mut Pipeline`

Starts a new command. Functions such as arg then become available to add more arguments to that command.

`fn add_command(&mut self, cmd: &Cmd) -> &mut Pipeline`

Adds a command to the pipeline.

`fn arg<T: ToRedisArgs>(&mut self, arg: T) -> &mut Pipeline`

Adds an argument to the last started command. This works similar to the arg method of the Cmd object.

Note that this function fails the task if executed on an empty pipeline.

`fn ignore(&mut self) -> &mut Pipeline`

Instructs the pipeline to ignore the return value of this command. It will still be ensured that it is not an error, but any successful result is just thrown away. This makes result processing through tuples much easier because you do not need to handle all the items you do not care about.

Note that this function fails the task if executed on an empty pipeline.

`fn atomic(&mut self) -> &mut Pipeline`

This enables atomic mode. In atomic mode the whole pipeline is enclosed in MULTI/EXEC. From the user's point of view nothing changes however. This is easier than using MULTI/EXEC yourself as the format does not change.

let (k1, k2) : (i32, i32) = redis::pipe()
    .atomic()
    .cmd("GET").arg("key_1")
    .cmd("GET").arg("key_2").query(&con).unwrap();

`fn query<T: FromRedisValue>(&self, con: &ConnectionLike) -> RedisResult<T>`

Executes the pipeline and fetches the return values. Since most pipelines return different types it's recommended to use tuple matching to process the results:

let (k1, k2) : (i32, i32) = redis::pipe()
    .cmd("SET").arg("key_1").arg(42).ignore()
    .cmd("SET").arg("key_2").arg(43).ignore()
    .cmd("GET").arg("key_1")
    .cmd("GET").arg("key_2").query(&con).unwrap();

`fn execute(&self, con: &ConnectionLike)`

This is a shortcut to query() that does not return a value and will fail the task if the query of the pipeline fails.

This is equivalent to a call of query like this:

let _ : () = redis::pipe().cmd("PING").query(&con).unwrap();

Trait Implementations

`impl PipelineCommands for Pipeline`

`fn perform(&mut self, cmd: &Cmd) -> &mut Pipeline`

`fn get<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn set<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, items: &[(K, V)]) -> &mut Self`

`fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V, seconds: usize) -> &mut Self`

`fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, items: &[(K, V)]) -> &mut Self`

`fn getset<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn del<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn exists<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn expire<'a, K: ToRedisArgs>(&mut self, key: K, seconds: usize) -> &mut Self`

`fn expire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self`

`fn pexpire<'a, K: ToRedisArgs>(&mut self, key: K, ms: usize) -> &mut Self`

`fn pexpire_at<'a, K: ToRedisArgs>(&mut self, key: K, ts: usize) -> &mut Self`

`fn persist<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn rename<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self`

`fn rename_nx<'a, K: ToRedisArgs>(&mut self, key: K, new_key: K) -> &mut Self`

`fn append<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn incr<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, delta: V) -> &mut Self`

`fn setbit<'a, K: ToRedisArgs>(&mut self, key: K, offset: usize, value: bool) -> &mut Self`

`fn getbit<'a, K: ToRedisArgs>(&mut self, key: K, offset: usize) -> &mut Self`

`fn bitcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn bitcount_range<'a, K: ToRedisArgs>(&mut self, key: K, start: usize, end: usize) -> &mut Self`

`fn bit_and<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self`

`fn bit_or<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self`

`fn bit_xor<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self`

`fn bit_not<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckey: K) -> &mut Self`

`fn strlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn hget<'a, K: ToRedisArgs, F: ToRedisArgs>(&mut self, key: K, field: F) -> &mut Self`

`fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs>(&mut self, key: K, field: F) -> &mut Self`

`fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, field: F, value: V) -> &mut Self`

`fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, field: F, value: V) -> &mut Self`

`fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, items: &[(F, V)]) -> &mut Self`

`fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs>(&mut self, key: K, field: F, delta: D) -> &mut Self`

`fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs>(&mut self, key: K, field: F) -> &mut Self`

`fn hkeys<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn hvals<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn hgetall<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn hlen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn blpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self`

`fn brpop<'a, K: ToRedisArgs>(&mut self, key: K, timeout: usize) -> &mut Self`

`fn brpoplpush<'a, K: ToRedisArgs>(&mut self, srckey: K, dstkey: K, timeout: usize) -> &mut Self`

`fn lindex<'a, K: ToRedisArgs>(&mut self, key: K, index: isize) -> &mut Self`

`fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, pivot: P, value: V) -> &mut Self`

`fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, pivot: P, value: V) -> &mut Self`

`fn llen<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn lpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn lrange<'a, K: ToRedisArgs>(&mut self, key: K, start: isize, stop: isize) -> &mut Self`

`fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, count: isize, value: V) -> &mut Self`

`fn ltrim<'a, K: ToRedisArgs>(&mut self, key: K, start: isize, stop: isize) -> &mut Self`

`fn rpop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn rpoplpush<'a, K: ToRedisArgs>(&mut self, key: K, dstkey: K) -> &mut Self`

`fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs>(&mut self, key: K, value: V) -> &mut Self`

`fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, member: M) -> &mut Self`

`fn scard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn sdiff<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self`

`fn sdiffstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self`

`fn sinter<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self`

`fn sdinterstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self`

`fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, member: M) -> &mut Self`

`fn smembers<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn smove<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, srckey: K, dstkey: K, member: M) -> &mut Self`

`fn spop<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn srandmember<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn srandmember_multiple<'a, K: ToRedisArgs>(&mut self, key: K, count: usize) -> &mut Self`

`fn srem<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, member: M) -> &mut Self`

`fn sunion<'a, K: ToRedisArgs>(&mut self, keys: K) -> &mut Self`

`fn sunionstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: K) -> &mut Self`

`fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, member: M, score: S) -> &mut Self`

`fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, items: &[(S, M)]) -> &mut Self`

`fn zcard<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM) -> &mut Self`

`fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs>(&mut self, key: K, member: M, delta: D) -> &mut Self`

`fn zinterstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: &[K]) -> &mut Self`

`fn zinterstore_min<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: &[K]) -> &mut Self`

`fn zinterstore_max<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: &[K]) -> &mut Self`

`fn zlexcount<'a, K: ToRedisArgs, L: ToRedisArgs>(&mut self, key: K, min: L, max: L) -> &mut Self`

`fn zrange<'a, K: ToRedisArgs>(&mut self, key: K, start: isize, stop: isize) -> &mut Self`

`fn zrange_withscores<'a, K: ToRedisArgs>(&mut self, key: K, start: isize, stop: isize) -> &mut Self`

`fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM) -> &mut Self`

`fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM, offset: isize, count: isize) -> &mut Self`

`fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, max: MM, min: M) -> &mut Self`

`fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, max: MM, min: M, offset: isize, count: isize) -> &mut Self`

`fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM) -> &mut Self`

`fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM) -> &mut Self`

`fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM, offset: isize, count: isize) -> &mut Self`

`fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM, offset: isize, count: isize) -> &mut Self`

`fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, member: M) -> &mut Self`

`fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, members: M) -> &mut Self`

`fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM) -> &mut Self`

`fn zrembyrank<'a, K: ToRedisArgs>(&mut self, key: K, start: isize, stop: isize) -> &mut Self`

`fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs>(&mut self, key: K, min: M, max: MM) -> &mut Self`

`fn zrevrange<'a, K: ToRedisArgs>(&mut self, key: K, start: isize, stop: isize) -> &mut Self`

`fn zrevrange_withscores<'a, K: ToRedisArgs>(&mut self, key: K, start: isize, stop: isize) -> &mut Self`

`fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, max: MM, min: M) -> &mut Self`

`fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, max: MM, min: M) -> &mut Self`

`fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, max: MM, min: M, offset: isize, count: isize) -> &mut Self`

`fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, max: MM, min: M, offset: isize, count: isize) -> &mut Self`

`fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, member: M) -> &mut Self`

`fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs>(&mut self, key: K, member: M) -> &mut Self`

`fn zunionstore<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: &[K]) -> &mut Self`

`fn zunionstore_min<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: &[K]) -> &mut Self`

`fn zunionstore_max<'a, K: ToRedisArgs>(&mut self, dstkey: K, keys: &[K]) -> &mut Self`

`fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs>(&mut self, key: K, element: E) -> &mut Self`

`fn pfcount<'a, K: ToRedisArgs>(&mut self, key: K) -> &mut Self`

`fn pfmerge<'a, K: ToRedisArgs>(&mut self, dstkey: K, srckeys: K) -> &mut Self`