Trait SortedSetCommands

pub trait SortedSetCommands {
    // Provided methods
    fn zadd<K, M, I>(
        &mut self,
        key: K,
        items: I,
        options: ZAddOptions,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg>,
             I: ArgsOrCollection<(f64, M)> { ... }
    fn zadd_incr<K, M>(
        &mut self,
        key: K,
        condition: ZAddCondition,
        comparison: ZAddComparison,
        change: bool,
        score: f64,
        member: M,
    ) -> PreparedCommand<'_, Self, Option<f64>>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg> { ... }
    fn zcard<K>(&mut self, key: K) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn zcount<K, M1, M2>(
        &mut self,
        key: K,
        min: M1,
        max: M2,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             M1: Into<CommandArg>,
             M2: Into<CommandArg> { ... }
    fn zdiff<K, C, E>(&mut self, keys: C) -> PreparedCommand<'_, Self, Vec<E>>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             E: FromValue { ... }
    fn zdiff_with_scores<K, C, E>(
        &mut self,
        keys: C,
    ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             E: FromValue { ... }
    fn zdiffstore<D, K, C>(
        &mut self,
        destination: D,
        keys: C,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             D: Into<CommandArg>,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K> { ... }
    fn zincrby<K, M>(
        &mut self,
        key: K,
        increment: f64,
        member: M,
    ) -> PreparedCommand<'_, Self, f64>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg> { ... }
    fn zinter<K, C, W, E>(
        &mut self,
        keys: C,
        weights: Option<W>,
        aggregate: ZAggregate,
    ) -> PreparedCommand<'_, Self, Vec<E>>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             W: SingleArgOrCollection<f64>,
             E: FromValue { ... }
    fn zinter_with_scores<K, C, W, E>(
        &mut self,
        keys: C,
        weights: Option<W>,
        aggregate: ZAggregate,
    ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             W: SingleArgOrCollection<f64>,
             E: FromValue { ... }
    fn zintercard<K, C>(
        &mut self,
        keys: C,
        limit: usize,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K> { ... }
    fn zinterstore<D, K, C, W>(
        &mut self,
        destination: D,
        keys: C,
        weights: Option<W>,
        aggregate: ZAggregate,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             D: Into<CommandArg>,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             W: SingleArgOrCollection<f64> { ... }
    fn zlexcount<K, M1, M2>(
        &mut self,
        key: K,
        min: M1,
        max: M2,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             M1: Into<CommandArg>,
             M2: Into<CommandArg> { ... }
    fn zmpop<K, C, E>(
        &mut self,
        keys: C,
        where_: ZWhere,
        count: usize,
    ) -> PreparedCommand<'_, Self, Option<ZMPopResult<E>>>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             E: FromValue { ... }
    fn zmscore<K, M, C>(
        &mut self,
        key: K,
        members: C,
    ) -> PreparedCommand<'_, Self, Vec<Option<f64>>>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg>,
             C: SingleArgOrCollection<M> { ... }
    fn zpopmax<K, M>(
        &mut self,
        key: K,
        count: usize,
    ) -> PreparedCommand<'_, Self, Vec<(M, f64)>>
       where Self: Sized,
             K: Into<CommandArg>,
             M: FromValue { ... }
    fn zpopmin<K, M>(
        &mut self,
        key: K,
        count: usize,
    ) -> PreparedCommand<'_, Self, Vec<(M, f64)>>
       where Self: Sized,
             K: Into<CommandArg>,
             M: FromValue { ... }
    fn zrandmember<K, E>(&mut self, key: K) -> PreparedCommand<'_, Self, E>
       where Self: Sized,
             K: Into<CommandArg>,
             E: FromValue { ... }
    fn zrandmembers<K, E>(
        &mut self,
        key: K,
        count: isize,
    ) -> PreparedCommand<'_, Self, Vec<E>>
       where Self: Sized,
             K: Into<CommandArg>,
             E: FromValue { ... }
    fn zrandmembers_with_scores<K, E>(
        &mut self,
        key: K,
        count: isize,
    ) -> PreparedCommand<'_, Self, Vec<E>>
       where Self: Sized,
             K: Into<CommandArg>,
             E: FromValue { ... }
    fn zrange<K, S, E>(
        &mut self,
        key: K,
        start: S,
        stop: S,
        options: ZRangeOptions,
    ) -> PreparedCommand<'_, Self, Vec<E>>
       where Self: Sized,
             K: Into<CommandArg>,
             S: Into<CommandArg>,
             E: FromValue { ... }
    fn zrange_with_scores<K, S, E>(
        &mut self,
        key: K,
        start: S,
        stop: S,
        options: ZRangeOptions,
    ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>
       where Self: Sized,
             K: Into<CommandArg>,
             S: Into<CommandArg>,
             E: FromValue { ... }
    fn zrangestore<D, S, SS>(
        &mut self,
        dst: D,
        src: S,
        start: SS,
        stop: SS,
        options: ZRangeOptions,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             D: Into<CommandArg>,
             S: Into<CommandArg>,
             SS: Into<CommandArg> { ... }
    fn zrank<K, M>(
        &mut self,
        key: K,
        member: M,
    ) -> PreparedCommand<'_, Self, Option<usize>>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg> { ... }
    fn zrem<K, M, C>(
        &mut self,
        key: K,
        members: C,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg>,
             C: SingleArgOrCollection<M> { ... }
    fn zremrangebylex<K, S>(
        &mut self,
        key: K,
        start: S,
        stop: S,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             S: Into<CommandArg> { ... }
    fn zremrangebyrank<K>(
        &mut self,
        key: K,
        start: isize,
        stop: isize,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn zremrangebyscore<K, S>(
        &mut self,
        key: K,
        start: S,
        stop: S,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             S: Into<CommandArg> { ... }
    fn zrevrank<K, M>(
        &mut self,
        key: K,
        member: M,
    ) -> PreparedCommand<'_, Self, Option<usize>>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg> { ... }
    fn zscan<K, M>(
        &mut self,
        key: K,
        cursor: usize,
        options: ZScanOptions,
    ) -> PreparedCommand<'_, Self, (u64, Vec<(M, f64)>)>
       where Self: Sized,
             K: Into<CommandArg>,
             M: FromValue { ... }
    fn zscore<K, M>(
        &mut self,
        key: K,
        member: M,
    ) -> PreparedCommand<'_, Self, Option<f64>>
       where Self: Sized,
             K: Into<CommandArg>,
             M: Into<CommandArg> { ... }
    fn zunion<K, C, W, E>(
        &mut self,
        keys: C,
        weights: Option<W>,
        aggregate: ZAggregate,
    ) -> PreparedCommand<'_, Self, Vec<E>>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             W: SingleArgOrCollection<f64>,
             E: FromValue { ... }
    fn zunion_with_scores<K, C, W, E>(
        &mut self,
        keys: C,
        weights: Option<W>,
        aggregate: ZAggregate,
    ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             W: SingleArgOrCollection<f64>,
             E: FromValue { ... }
    fn zunionstore<D, K, C, W>(
        &mut self,
        destination: D,
        keys: C,
        weights: Option<W>,
        aggregate: ZAggregate,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             D: Into<CommandArg>,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K>,
             W: SingleArgOrCollection<f64> { ... }
}

A group of Redis commands related to Sorted Sets

See Also

Redis Sorted Set Commands

Provided Methods

fn zadd<K, M, I>( &mut self, key: K, items: I, options: ZAddOptions, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>, I: ArgsOrCollection<(f64, M)>,

Adds all the specified members with the specified scores to the sorted set stored at key.

Return

• When used without optional arguments, the number of elements added to the sorted set (excluding score updates).
• If the change option is specified, the number of elements that were changed (added or updated).

See Also

https://redis.io/commands/zadd/

fn zadd_incr<K, M>( &mut self, key: K, condition: ZAddCondition, comparison: ZAddComparison, change: bool, score: f64, member: M, ) -> PreparedCommand<'_, Self, Option<f64>>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>,

In this mode ZADD acts like ZINCRBY. Only one score-element pair can be specified in this mode.

Return

The new score of member (a double precision floating point number), or nil if the operation was aborted (when called with either the XX or the NX option).

See Also

https://redis.io/commands/zadd/

fn zcard<K>(&mut self, key: K) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>,

Returns the sorted set cardinality (number of elements) of the sorted set stored at key.

Return

The cardinality (number of elements) of the sorted set, or 0 if key does not exist.

See Also

https://redis.io/commands/zcard/

fn zcount<K, M1, M2>( &mut self, key: K, min: M1, max: M2, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, M1: Into<CommandArg>, M2: Into<CommandArg>,

Returns the number of elements in the sorted set at key with a score between min and max.

Return

The number of elements in the specified score range.

See Also

https://redis.io/commands/zcount/

fn zdiff<K, C, E>(&mut self, keys: C) -> PreparedCommand<'_, Self, Vec<E>>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>, E: FromValue,

This command is similar to zdiffstore, but instead of storing the resulting sorted set, it is returned to the client.

Return

The result of the difference

See Also

https://redis.io/commands/zdiff/

fn zdiff_with_scores<K, C, E>( &mut self, keys: C, ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>, E: FromValue,

This command is similar to zdiffstore, but instead of storing the resulting sorted set, it is returned to the client.

Return

The result of the difference with their scores

See Also

https://redis.io/commands/zdiff/

fn zdiffstore<D, K, C>( &mut self, destination: D, keys: C, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, D: Into<CommandArg>, K: Into<CommandArg>, C: SingleArgOrCollection<K>,

Computes the difference between the first and all successive input sorted sets and stores the result in destination.

Return

The number of elements in the resulting sorted set at destination.

See Also

https://redis.io/commands/zdiffstore/

fn zincrby<K, M>( &mut self, key: K, increment: f64, member: M, ) -> PreparedCommand<'_, Self, f64>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>,

Increments the score of member in the sorted set stored at key by increment.

Return

the new score of member

See Also

https://redis.io/commands/zincrby/

fn zinter<K, C, W, E>( &mut self, keys: C, weights: Option<W>, aggregate: ZAggregate, ) -> PreparedCommand<'_, Self, Vec<E>>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>, W: SingleArgOrCollection<f64>, E: FromValue,

This command is similar to zinterstore, but instead of storing the resulting sorted set, it is returned to the client.

Return

The result of the intersection as an array of members

See Also

https://redis.io/commands/zinter/

fn zinter_with_scores<K, C, W, E>( &mut self, keys: C, weights: Option<W>, aggregate: ZAggregate, ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>, W: SingleArgOrCollection<f64>, E: FromValue,

This command is similar to zinterstore, but instead of storing the resulting sorted set, it is returned to the client.

Return

The result of the intersection as an array of members with their scores

See Also

https://redis.io/commands/zinter/

fn zintercard<K, C>( &mut self, keys: C, limit: usize, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>,

This command is similar to zinter, but instead of returning the result set, it returns just the cardinality of the result.

the algorithm will exit and yield limit as the cardinality. 0 means unlimited

See Also

https://redis.io/commands/zintercard/

fn zinterstore<D, K, C, W>( &mut self, destination: D, keys: C, weights: Option<W>, aggregate: ZAggregate, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, D: Into<CommandArg>, K: Into<CommandArg>, C: SingleArgOrCollection<K>, W: SingleArgOrCollection<f64>,

Computes the intersection of numkeys sorted sets given by the specified keys, and stores the result in destination.

Return

The number of elements in the resulting sorted set at destination.

See Also

https://redis.io/commands/zinterstore/

fn zlexcount<K, M1, M2>( &mut self, key: K, min: M1, max: M2, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, M1: Into<CommandArg>, M2: Into<CommandArg>,

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.

Return

the number of elements in the specified score range.

See Also

https://redis.io/commands/zlexcount/

fn zmpop<K, C, E>( &mut self, keys: C, where_: ZWhere, count: usize, ) -> PreparedCommand<'_, Self, Option<ZMPopResult<E>>>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>, E: FromValue,

Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of key names.

Return

• None if no element could be popped
• A tuple made up of
  • The name of the key from which elements were popped
  • An array of tuples with all the popped members and their scores

See Also

https://redis.io/commands/zmpop/

fn zmscore<K, M, C>( &mut self, key: K, members: C, ) -> PreparedCommand<'_, Self, Vec<Option<f64>>>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>, C: SingleArgOrCollection<M>,

Returns the scores associated with the specified members in the sorted set stored at key.

For every member that does not exist in the sorted set, a nil value is returned.

Return

The list of scores or nil associated with the specified member value

See Also

https://redis.io/commands/zmscore/

fn zpopmax<K, M>( &mut self, key: K, count: usize, ) -> PreparedCommand<'_, Self, Vec<(M, f64)>>

where Self: Sized, K: Into<CommandArg>, M: FromValue,

Removes and returns up to count members with the highest scores in the sorted set stored at key.

Return

The list of popped elements and scores.

See Also

https://redis.io/commands/zpopmax/

fn zpopmin<K, M>( &mut self, key: K, count: usize, ) -> PreparedCommand<'_, Self, Vec<(M, f64)>>

where Self: Sized, K: Into<CommandArg>, M: FromValue,

Removes and returns up to count members with the lowest scores in the sorted set stored at key.

Return

The list of popped elements and scores.

See Also

https://redis.io/commands/zpopmin/

fn zrandmember<K, E>(&mut self, key: K) -> PreparedCommand<'_, Self, E>

where Self: Sized, K: Into<CommandArg>, E: FromValue,

Return a random element from the sorted set value stored at key.

Return

The randomly selected element, or nil when key does not exist.

See Also

https://redis.io/commands/zrandmember/

fn zrandmembers<K, E>( &mut self, key: K, count: isize, ) -> PreparedCommand<'_, Self, Vec<E>>

where Self: Sized, K: Into<CommandArg>, E: FromValue,

Return random elements from the sorted set value stored at key.

Return

• If the provided count argument is positive, return an array of distinct elements. The array’s length is either count or the sorted set’s cardinality (ZCARD), whichever is lower.
• If called with a negative count, the behavior changes and the command is allowed to return the same element multiple times. In this case, the number of returned elements is the absolute value of the specified count.

See Also

https://redis.io/commands/zrandmember/

fn zrandmembers_with_scores<K, E>( &mut self, key: K, count: isize, ) -> PreparedCommand<'_, Self, Vec<E>>

where Self: Sized, K: Into<CommandArg>, E: FromValue,

Return random elements with their scores from the sorted set value stored at key.

Return

• If the provided count argument is positive, return an array of distinct elements with their scores. The array’s length is either count or the sorted set’s cardinality (ZCARD), whichever is lower.
• If called with a negative count, the behavior changes and the command is allowed to return the same element multiple times. In this case, the number of returned elements is the absolute value of the specified count.

See Also

https://redis.io/commands/zrandmember/

fn zrange<K, S, E>( &mut self, key: K, start: S, stop: S, options: ZRangeOptions, ) -> PreparedCommand<'_, Self, Vec<E>>

where Self: Sized, K: Into<CommandArg>, S: Into<CommandArg>, E: FromValue,

Returns the specified range of elements in the sorted set stored at key.

Return

A collection of elements in the specified range

See Also

https://redis.io/commands/zrange/

fn zrange_with_scores<K, S, E>( &mut self, key: K, start: S, stop: S, options: ZRangeOptions, ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>

where Self: Sized, K: Into<CommandArg>, S: Into<CommandArg>, E: FromValue,

Returns the specified range of elements in the sorted set stored at key.

Return

A collection of elements and their scores in the specified range

See Also

https://redis.io/commands/zrange/

fn zrangestore<D, S, SS>( &mut self, dst: D, src: S, start: SS, stop: SS, options: ZRangeOptions, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, D: Into<CommandArg>, S: Into<CommandArg>, SS: Into<CommandArg>,

This command is like zrange, but stores the result in the dst destination key.

Return

The number of elements in the resulting sorted set.

See Also

https://redis.io/commands/zrangestore/

fn zrank<K, M>( &mut self, key: K, member: M, ) -> PreparedCommand<'_, Self, Option<usize>>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>,

Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high.

Return

• If member exists in the sorted set, the rank of member.
• If member does not exist in the sorted set or key does not exist, None.

See Also

https://redis.io/commands/zrank/

fn zrem<K, M, C>( &mut self, key: K, members: C, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>, C: SingleArgOrCollection<M>,

Removes the specified members from the sorted set stored at key.

Return

The number of members removed from the sorted set, not including non existing members.

See Also

https://redis.io/commands/zrem/

fn zremrangebylex<K, S>( &mut self, key: K, start: S, stop: S, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, S: Into<CommandArg>,

When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at key between the lexicographical range specified by min and max.

Return

the number of elements removed.

See Also

https://redis.io/commands/zremrangebylex/

fn zremrangebyrank<K>( &mut self, key: K, start: isize, stop: isize, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>,

Removes all elements in the sorted set stored at key with rank between start and stop.

Return

the number of elements removed.

See Also

https://redis.io/commands/zremrangebyrank/

fn zremrangebyscore<K, S>( &mut self, key: K, start: S, stop: S, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, S: Into<CommandArg>,

Removes all elements in the sorted set stored at key with a score between min and max (inclusive).

Return

the number of elements removed.

See Also

https://redis.io/commands/zremrangebyscore/

fn zrevrank<K, M>( &mut self, key: K, member: M, ) -> PreparedCommand<'_, Self, Option<usize>>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>,

Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low.

Return

• If member exists in the sorted set, the rank of member.
• If member does not exist in the sorted set or key does not exist, None.

See Also

https://redis.io/commands/zrevrank/

fn zscan<K, M>( &mut self, key: K, cursor: usize, options: ZScanOptions, ) -> PreparedCommand<'_, Self, (u64, Vec<(M, f64)>)>

where Self: Sized, K: Into<CommandArg>, M: FromValue,

Iterates elements of Sorted Set types and their associated scores.

Returns

A tuple where

• The first value is the cursor as an unsigned 64 bit number
• The second value is a list of members and their scores in a Vec of Tuples

See Also

https://redis.io/commands/zscan/

fn zscore<K, M>( &mut self, key: K, member: M, ) -> PreparedCommand<'_, Self, Option<f64>>

where Self: Sized, K: Into<CommandArg>, M: Into<CommandArg>,

Returns the score of member in the sorted set at key.

Return

The score of member or nil if keydoes not exist

See Also

https://redis.io/commands/zscore/

fn zunion<K, C, W, E>( &mut self, keys: C, weights: Option<W>, aggregate: ZAggregate, ) -> PreparedCommand<'_, Self, Vec<E>>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>, W: SingleArgOrCollection<f64>, E: FromValue,

This command is similar to zunionstore, but instead of storing the resulting sorted set, it is returned to the client.

Return

The result of the unionsection as an array of members

See Also

https://redis.io/commands/zunion/

fn zunion_with_scores<K, C, W, E>( &mut self, keys: C, weights: Option<W>, aggregate: ZAggregate, ) -> PreparedCommand<'_, Self, Vec<(E, f64)>>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>, W: SingleArgOrCollection<f64>, E: FromValue,

This command is similar to zunionstore, but instead of storing the resulting sorted set, it is returned to the client.

Return

The result of the unionsection as an array of members with their scores

See Also

https://redis.io/commands/zunion/

fn zunionstore<D, K, C, W>( &mut self, destination: D, keys: C, weights: Option<W>, aggregate: ZAggregate, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, D: Into<CommandArg>, K: Into<CommandArg>, C: SingleArgOrCollection<K>, W: SingleArgOrCollection<f64>,

Computes the unionsection of numkeys sorted sets given by the specified keys, and stores the result in destination.

Return

The number of elements in the resulting sorted set at destination.

See Also

https://redis.io/commands/zunionstore/

Implementors

impl SortedSetCommands for Client

impl SortedSetCommands for MultiplexedClient

impl SortedSetCommands for Pipeline

impl SortedSetCommands for Transaction