module Redis::Commands::SortedSets

Public Instance Methods

bzpopmax(*args) click to toggle source

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

or block until one is available.

@example Popping a member from a sorted set

redis.bzpopmax('zset', 1)
#=> ['zset', 'b', 2.0]

@example Popping a member from multiple sorted sets

redis.bzpopmax('zset1', 'zset2', 1)
#=> ['zset1', 'b', 2.0]

@params keys [Array<String>] one or multiple keys of the sorted sets @params timeout [Integer] the maximum number of seconds to block

@return [Array<String, String, Float>] a touple of key, member and score @return [nil] when no element could be popped and the timeout expired

# File lib/redis/commands/sorted_sets.rb, line 185
def bzpopmax(*args)
  _bpop(:bzpopmax, args) do |reply|
    reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
  end
end
bzpopmin(*args) click to toggle source

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

or block until one is available.

@example Popping a member from a sorted set

redis.bzpopmin('zset', 1)
#=> ['zset', 'a', 1.0]

@example Popping a member from multiple sorted sets

redis.bzpopmin('zset1', 'zset2', 1)
#=> ['zset1', 'a', 1.0]

@params keys [Array<String>] one or multiple keys of the sorted sets @params timeout [Integer] the maximum number of seconds to block

@return [Array<String, String, Float>] a touple of key, member and score @return [nil] when no element could be popped and the timeout expired

# File lib/redis/commands/sorted_sets.rb, line 206
def bzpopmin(*args)
  _bpop(:bzpopmin, args) do |reply|
    reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
  end
end
zadd(key, *args, nx: nil, xx: nil, lt: nil, gt: nil, ch: nil, incr: nil) click to toggle source

Add one or more members to a sorted set, or update the score for members that already exist.

@example Add a single ‘[score, member]` pair to a sorted set

redis.zadd("zset", 32.0, "member")

@example Add an array of ‘[score, member]` pairs to a sorted set

redis.zadd("zset", [[32.0, "a"], [64.0, "b"]])

@param [String] key @param [[Float, String], Array<[Float, String]>] args

- a single `[score, member]` pair
- an array of `[score, member]` pairs

@param [Hash] options

- `:xx => true`: Only update elements that already exist (never
add elements)
- `:nx => true`: Don't update already existing elements (always
add new elements)
- `:lt => true`: Only update existing elements if the new score
is less than the current score
- `:gt => true`: Only update existing elements if the new score
is greater than the current score
- `:ch => true`: Modify the return value from the number of new
elements added, to the total number of elements changed (CH is an
abbreviation of changed); changed elements are new elements added
and elements already existing for which the score was updated
- `:incr => true`: When this option is specified ZADD acts like
ZINCRBY; only one score-element pair can be specified in this mode

@return [Boolean, Integer, Float]

- `Boolean` when a single pair is specified, holding whether or not it was
**added** to the sorted set.
- `Integer` when an array of pairs is specified, holding the number of
pairs that were **added** to the sorted set.
- `Float` when option :incr is specified, holding the score of the member
after incrementing it.
# File lib/redis/commands/sorted_sets.rb, line 53
def zadd(key, *args, nx: nil, xx: nil, lt: nil, gt: nil, ch: nil, incr: nil)
  command = [:zadd, key]
  command << "NX" if nx
  command << "XX" if xx
  command << "LT" if lt
  command << "GT" if gt
  command << "CH" if ch
  command << "INCR" if incr

  if args.size == 1 && args[0].is_a?(Array)
    members_to_add = args[0]
    return 0 if members_to_add.empty?

    # Variadic: return float if INCR, integer if !INCR
    send_command(command + members_to_add, &(incr ? Floatify : nil))
  elsif args.size == 2
    # Single pair: return float if INCR, boolean if !INCR
    send_command(command + args, &(incr ? Floatify : Boolify))
  else
    raise ArgumentError, "wrong number of arguments"
  end
end
zcard(key) click to toggle source

Get the number of members in a sorted set.

@example

redis.zcard("zset")
  # => 4

@param [String] key @return [Integer]

# File lib/redis/commands/sorted_sets.rb, line 14
def zcard(key)
  send_command([:zcard, key])
end
zcount(key, min, max) click to toggle source

Count the members in a sorted set with scores within the given values.

@example Count members with score ‘>= 5` and `< 100`

redis.zcount("zset", "5", "(100")
  # => 2

@example Count members with scores ‘> 5`

redis.zcount("zset", "(5", "+inf")
  # => 2

@param [String] key @param [String] min

- inclusive minimum score is specified verbatim
- exclusive minimum score is specified by prefixing `(`

@param [String] max

- inclusive maximum score is specified verbatim
- exclusive maximum score is specified by prefixing `(`

@return [Integer] number of members in within the specified range

# File lib/redis/commands/sorted_sets.rb, line 612
def zcount(key, min, max)
  send_command([:zcount, key, min, max])
end
zdiff(*keys, with_scores: false) click to toggle source

Return the difference between the first and all successive input sorted sets

@example

redis.zadd("zsetA", [[1.0, "v1"], [2.0, "v2"]])
redis.zadd("zsetB", [[3.0, "v2"], [2.0, "v3"]])
redis.zdiff("zsetA", "zsetB")
  => ["v1"]

@example With scores

redis.zadd("zsetA", [[1.0, "v1"], [2.0, "v2"]])
redis.zadd("zsetB", [[3.0, "v2"], [2.0, "v3"]])
redis.zdiff("zsetA", "zsetB", :with_scores => true)
  => [["v1", 1.0]]

@param [String, Array<String>] keys one or more keys to compute the difference @param [Hash] options

- `:with_scores => true`: include scores in output

@return [Array<String>, Array<[String, Float]>]

- when `:with_scores` is not specified, an array of members
- when `:with_scores` is specified, an array with `[member, score]` pairs
# File lib/redis/commands/sorted_sets.rb, line 721
def zdiff(*keys, with_scores: false)
  _zsets_operation(:zdiff, *keys, with_scores: with_scores)
end
zdiffstore(*args) click to toggle source

Compute the difference between the first and all successive input sorted sets and store the resulting sorted set in a new key

@example

redis.zadd("zsetA", [[1.0, "v1"], [2.0, "v2"]])
redis.zadd("zsetB", [[3.0, "v2"], [2.0, "v3"]])
redis.zdiffstore("zsetA", "zsetB")
  # => 1

@param [String] destination destination key @param [Array<String>] keys source keys @return [Integer] number of elements in the resulting sorted set

# File lib/redis/commands/sorted_sets.rb, line 737
def zdiffstore(*args)
  _zsets_operation_store(:zdiffstore, *args)
end
zincrby(key, increment, member) click to toggle source

Increment the score of a member in a sorted set.

@example

redis.zincrby("zset", 32.0, "a")
  # => 64.0

@param [String] key @param [Float] increment @param [String] member @return [Float] score of the member after incrementing it

# File lib/redis/commands/sorted_sets.rb, line 86
def zincrby(key, increment, member)
  send_command([:zincrby, key, increment, member], &Floatify)
end
zinter(*args) click to toggle source

Return the intersection of multiple sorted sets

@example Retrieve the intersection of ‘2*zsetA` and `1*zsetB`

redis.zinter("zsetA", "zsetB", :weights => [2.0, 1.0])
  # => ["v1", "v2"]

@example Retrieve the intersection of ‘2*zsetA` and `1*zsetB`, and their scores

redis.zinter("zsetA", "zsetB", :weights => [2.0, 1.0], :with_scores => true)
  # => [["v1", 3.0], ["v2", 6.0]]

@param [String, Array<String>] keys one or more keys to intersect @param [Hash] options

- `:weights => [Float, Float, ...]`: weights to associate with source
sorted sets
- `:aggregate => String`: aggregate function to use (sum, min, max, ...)
- `:with_scores => true`: include scores in output

@return [Array<String>, Array<[String, Float]>]

- when `:with_scores` is not specified, an array of members
- when `:with_scores` is specified, an array with `[member, score]` pairs
# File lib/redis/commands/sorted_sets.rb, line 635
def zinter(*args)
  _zsets_operation(:zinter, *args)
end
zinterstore(*args) click to toggle source

Intersect multiple sorted sets and store the resulting sorted set in a new key.

@example Compute the intersection of ‘2*zsetA` with `1*zsetB`, summing their scores

redis.zinterstore("zsetC", ["zsetA", "zsetB"], :weights => [2.0, 1.0], :aggregate => "sum")
  # => 4

@param [String] destination destination key @param [Array<String>] keys source keys @param [Hash] options

- `:weights => [Array<Float>]`: weights to associate with source
sorted sets
- `:aggregate => String`: aggregate function to use (sum, min, max)

@return [Integer] number of elements in the resulting sorted set

# File lib/redis/commands/sorted_sets.rb, line 654
def zinterstore(*args)
  _zsets_operation_store(:zinterstore, *args)
end
zlexcount(key, min, max) click to toggle source

Count the members, with the same score in a sorted set, within the given lexicographical range.

@example Count members matching a

redis.zlexcount("zset", "[a", "[a\xff")
  # => 1

@example Count members matching a-z

redis.zlexcount("zset", "[a", "[z\xff")
  # => 26

@param [String] key @param [String] min

- inclusive minimum is specified by prefixing `(`
- exclusive minimum is specified by prefixing `[`

@param [String] max

- inclusive maximum is specified by prefixing `(`
- exclusive maximum is specified by prefixing `[`

@return [Integer] number of members within the specified lexicographical range

# File lib/redis/commands/sorted_sets.rb, line 443
def zlexcount(key, min, max)
  send_command([:zlexcount, key, min, max])
end
zmscore(key, *members) click to toggle source

Get the scores associated with the given members in a sorted set.

@example Get the scores for members “a” and “b”

redis.zmscore("zset", "a", "b")
  # => [32.0, 48.0]

@param [String] key @param [String, Array<String>] members @return [Array<Float>] scores of the members

# File lib/redis/commands/sorted_sets.rb, line 234
def zmscore(key, *members)
  send_command([:zmscore, key, *members]) do |reply|
    reply.map(&Floatify)
  end
end
zpopmax(key, count = nil) click to toggle source

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

@example Popping a member

redis.zpopmax('zset')
#=> ['b', 2.0]

@example With count option

redis.zpopmax('zset', 2)
#=> [['b', 2.0], ['a', 1.0]]

@params key [String] a key of the sorted set @params count [Integer] a number of members

@return [Array<String, Float>] element and score pair if count is not specified @return [Array<Array<String, Float>>] list of popped elements and scores

# File lib/redis/commands/sorted_sets.rb, line 138
def zpopmax(key, count = nil)
  command = [:zpopmax, key]
  command << Integer(count) if count
  send_command(command) do |members|
    members = FloatifyPairs.call(members)
    count.to_i > 1 ? members : members.first
  end
end
zpopmin(key, count = nil) click to toggle source

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

@example Popping a member

redis.zpopmin('zset')
#=> ['a', 1.0]

@example With count option

redis.zpopmin('zset', 2)
#=> [['a', 1.0], ['b', 2.0]]

@params key [String] a key of the sorted set @params count [Integer] a number of members

@return [Array<String, Float>] element and score pair if count is not specified @return [Array<Array<String, Float>>] list of popped elements and scores

# File lib/redis/commands/sorted_sets.rb, line 161
def zpopmin(key, count = nil)
  command = [:zpopmin, key]
  command << Integer(count) if count
  send_command(command) do |members|
    members = FloatifyPairs.call(members)
    count.to_i > 1 ? members : members.first
  end
end
zrandmember(key, count = nil, withscores: false, with_scores: withscores) click to toggle source

Get one or more random members from a sorted set.

@example Get one random member

redis.zrandmember("zset")
  # => "a"

@example Get multiple random members

redis.zrandmember("zset", 2)
  # => ["a", "b"]

@example Get multiple random members with scores

redis.zrandmember("zset", 2, with_scores: true)
  # => [["a", 2.0], ["b", 3.0]]

@param [String] key @param [Integer] count @param [Hash] options

- `:with_scores => true`: include scores in output

@return [nil, String, Array<String>, Array<[String, Float]>]

- when `key` does not exist or set is empty, `nil`
- when `count` is not specified, a member
- when `count` is specified and `:with_scores` is not specified, an array of members
- when `:with_scores` is specified, an array with `[member, score]` pairs
# File lib/redis/commands/sorted_sets.rb, line 262
def zrandmember(key, count = nil, withscores: false, with_scores: withscores)
  if with_scores && count.nil?
    raise ArgumentError, "count argument must be specified"
  end

  args = [:zrandmember, key]
  args << Integer(count) if count

  if with_scores
    args << "WITHSCORES"
    block = FloatifyPairs
  end

  send_command(args, &block)
end
zrange(key, start, stop, byscore: false, by_score: byscore, bylex: false, by_lex: bylex, rev: false, limit: nil, withscores: false, with_scores: withscores) click to toggle source

Return a range of members in a sorted set, by index, score or lexicographical ordering.

@example Retrieve all members from a sorted set, by index

redis.zrange("zset", 0, -1)
  # => ["a", "b"]

@example Retrieve all members and their scores from a sorted set

redis.zrange("zset", 0, -1, :with_scores => true)
  # => [["a", 32.0], ["b", 64.0]]

@param [String] key @param [Integer] start start index @param [Integer] stop stop index @param [Hash] options

- `:by_score => false`: return members by score
- `:by_lex => false`: return members by lexicographical ordering
- `:rev => false`: reverse the ordering, from highest to lowest
- `:limit => [offset, count]`: skip `offset` members, return a maximum of
`count` members
- `:with_scores => true`: include scores in output

@return [Array<String>, Array<[String, Float]>]

- when `:with_scores` is not specified, an array of members
- when `:with_scores` is specified, an array with `[member, score]` pairs
# File lib/redis/commands/sorted_sets.rb, line 301
def zrange(key, start, stop, byscore: false, by_score: byscore, bylex: false, by_lex: bylex,
           rev: false, limit: nil, withscores: false, with_scores: withscores)

  if by_score && by_lex
    raise ArgumentError, "only one of :by_score or :by_lex can be specified"
  end

  args = [:zrange, key, start, stop]

  if by_score
    args << "BYSCORE"
  elsif by_lex
    args << "BYLEX"
  end

  args << "REV" if rev

  if limit
    args << "LIMIT"
    args.concat(limit.map { |l| Integer(l) })
  end

  if with_scores
    args << "WITHSCORES"
    block = FloatifyPairs
  end

  send_command(args, &block)
end
zrangebylex(key, min, max, limit: nil) click to toggle source

Return a range of members with the same score in a sorted set, by lexicographical ordering

@example Retrieve members matching a

redis.zrangebylex("zset", "[a", "[a\xff")
  # => ["aaren", "aarika", "abagael", "abby"]

@example Retrieve the first 2 members matching a

redis.zrangebylex("zset", "[a", "[a\xff", :limit => [0, 2])
  # => ["aaren", "aarika"]

@param [String] key @param [String] min

- inclusive minimum is specified by prefixing `(`
- exclusive minimum is specified by prefixing `[`

@param [String] max

- inclusive maximum is specified by prefixing `(`
- exclusive maximum is specified by prefixing `[`

@param [Hash] options

- `:limit => [offset, count]`: skip `offset` members, return a maximum of
`count` members

@return [Array<String>, Array<[String, Float]>]

# File lib/redis/commands/sorted_sets.rb, line 468
def zrangebylex(key, min, max, limit: nil)
  args = [:zrangebylex, key, min, max]

  if limit
    args << "LIMIT"
    args.concat(limit.map { |l| Integer(l) })
  end

  send_command(args)
end
zrangebyscore(key, min, max, withscores: false, with_scores: withscores, limit: nil) click to toggle source

Return a range of members in a sorted set, by score.

@example Retrieve members with score ‘>= 5` and `< 100`

redis.zrangebyscore("zset", "5", "(100")
  # => ["a", "b"]

@example Retrieve the first 2 members with score ‘>= 0`

redis.zrangebyscore("zset", "0", "+inf", :limit => [0, 2])
  # => ["a", "b"]

@example Retrieve members and their scores with scores ‘> 5`

redis.zrangebyscore("zset", "(5", "+inf", :with_scores => true)
  # => [["a", 32.0], ["b", 64.0]]

@param [String] key @param [String] min

- inclusive minimum score is specified verbatim
- exclusive minimum score is specified by prefixing `(`

@param [String] max

- inclusive maximum score is specified verbatim
- exclusive maximum score is specified by prefixing `(`

@param [Hash] options

- `:with_scores => true`: include scores in output
- `:limit => [offset, count]`: skip `offset` members, return a maximum of
`count` members

@return [Array<String>, Array<[String, Float]>]

- when `:with_scores` is not specified, an array of members
- when `:with_scores` is specified, an array with `[member, score]` pairs
# File lib/redis/commands/sorted_sets.rb, line 528
def zrangebyscore(key, min, max, withscores: false, with_scores: withscores, limit: nil)
  args = [:zrangebyscore, key, min, max]

  if with_scores
    args << "WITHSCORES"
    block = FloatifyPairs
  end

  if limit
    args << "LIMIT"
    args.concat(limit.map { |l| Integer(l) })
  end

  send_command(args, &block)
end
zrangestore(dest_key, src_key, start, stop, byscore: false, by_score: byscore, bylex: false, by_lex: bylex, rev: false, limit: nil) click to toggle source

Select a range of members in a sorted set, by index, score or lexicographical ordering and store the resulting sorted set in a new key.

@example

redis.zadd("foo", [[1.0, "s1"], [2.0, "s2"], [3.0, "s3"]])
redis.zrangestore("bar", "foo", 0, 1)
  # => 2
redis.zrange("bar", 0, -1)
  # => ["s1", "s2"]

@return [Integer] the number of elements in the resulting sorted set @see zrange

# File lib/redis/commands/sorted_sets.rb, line 343
def zrangestore(dest_key, src_key, start, stop, byscore: false, by_score: byscore,
                bylex: false, by_lex: bylex, rev: false, limit: nil)
  if by_score && by_lex
    raise ArgumentError, "only one of :by_score or :by_lex can be specified"
  end

  args = [:zrangestore, dest_key, src_key, start, stop]

  if by_score
    args << "BYSCORE"
  elsif by_lex
    args << "BYLEX"
  end

  args << "REV" if rev

  if limit
    args << "LIMIT"
    args.concat(limit.map { |l| Integer(l) })
  end

  send_command(args)
end
zrank(key, member) click to toggle source

Determine the index of a member in a sorted set.

@param [String] key @param [String] member @return [Integer]

# File lib/redis/commands/sorted_sets.rb, line 394
def zrank(key, member)
  send_command([:zrank, key, member])
end
zrem(key, member) click to toggle source

Remove one or more members from a sorted set.

@example Remove a single member from a sorted set

redis.zrem("zset", "a")

@example Remove an array of members from a sorted set

redis.zrem("zset", ["a", "b"])

@param [String] key @param [String, Array<String>] member

- a single member
- an array of members

@return [Boolean, Integer]

- `Boolean` when a single member is specified, holding whether or not it
was removed from the sorted set
- `Integer` when an array of pairs is specified, holding the number of
members that were removed to the sorted set
# File lib/redis/commands/sorted_sets.rb, line 107
def zrem(key, member)
  if member.is_a?(Array)
    members_to_remove = member
    return 0 if members_to_remove.empty?
  end

  send_command([:zrem, key, member]) do |reply|
    if member.is_a? Array
      # Variadic: return integer
      reply
    else
      # Single argument: return boolean
      Boolify.call(reply)
    end
  end
end
zremrangebyrank(key, start, stop) click to toggle source

Remove all members in a sorted set within the given indexes.

@example Remove first 5 members

redis.zremrangebyrank("zset", 0, 4)
  # => 5

@example Remove last 5 members

redis.zremrangebyrank("zset", -5, -1)
  # => 5

@param [String] key @param [Integer] start start index @param [Integer] stop stop index @return [Integer] number of members that were removed

# File lib/redis/commands/sorted_sets.rb, line 421
def zremrangebyrank(key, start, stop)
  send_command([:zremrangebyrank, key, start, stop])
end
zremrangebyscore(key, min, max) click to toggle source

Remove all members in a sorted set within the given scores.

@example Remove members with score ‘>= 5` and `< 100`

redis.zremrangebyscore("zset", "5", "(100")
  # => 2

@example Remove members with scores ‘> 5`

redis.zremrangebyscore("zset", "(5", "+inf")
  # => 2

@param [String] key @param [String] min

- inclusive minimum score is specified verbatim
- exclusive minimum score is specified by prefixing `(`

@param [String] max

- inclusive maximum score is specified verbatim
- exclusive maximum score is specified by prefixing `(`

@return [Integer] number of members that were removed

# File lib/redis/commands/sorted_sets.rb, line 591
def zremrangebyscore(key, min, max)
  send_command([:zremrangebyscore, key, min, max])
end
zrevrange(key, start, stop, withscores: false, with_scores: withscores) click to toggle source

Return a range of members in a sorted set, by index, with scores ordered from high to low.

@example Retrieve all members from a sorted set

redis.zrevrange("zset", 0, -1)
  # => ["b", "a"]

@example Retrieve all members and their scores from a sorted set

redis.zrevrange("zset", 0, -1, :with_scores => true)
  # => [["b", 64.0], ["a", 32.0]]

@see zrange

# File lib/redis/commands/sorted_sets.rb, line 378
def zrevrange(key, start, stop, withscores: false, with_scores: withscores)
  args = [:zrevrange, key, Integer(start), Integer(stop)]

  if with_scores
    args << "WITHSCORES"
    block = FloatifyPairs
  end

  send_command(args, &block)
end
zrevrangebylex(key, max, min, limit: nil) click to toggle source

Return a range of members with the same score in a sorted set, by reversed lexicographical ordering. Apart from the reversed ordering, zrevrangebylex is similar to zrangebylex.

@example Retrieve members matching a

redis.zrevrangebylex("zset", "[a", "[a\xff")
  # => ["abbygail", "abby", "abagael", "aaren"]

@example Retrieve the last 2 members matching a

redis.zrevrangebylex("zset", "[a", "[a\xff", :limit => [0, 2])
  # => ["abbygail", "abby"]

@see zrangebylex

# File lib/redis/commands/sorted_sets.rb, line 490
def zrevrangebylex(key, max, min, limit: nil)
  args = [:zrevrangebylex, key, max, min]

  if limit
    args << "LIMIT"
    args.concat(limit.map { |l| Integer(l) })
  end

  send_command(args)
end
zrevrangebyscore(key, max, min, withscores: false, with_scores: withscores, limit: nil) click to toggle source

Return a range of members in a sorted set, by score, with scores ordered from high to low.

@example Retrieve members with score ‘< 100` and `>= 5`

redis.zrevrangebyscore("zset", "(100", "5")
  # => ["b", "a"]

@example Retrieve the first 2 members with score ‘<= 0`

redis.zrevrangebyscore("zset", "0", "-inf", :limit => [0, 2])
  # => ["b", "a"]

@example Retrieve members and their scores with scores ‘> 5`

redis.zrevrangebyscore("zset", "+inf", "(5", :with_scores => true)
  # => [["b", 64.0], ["a", 32.0]]

@see zrangebyscore

# File lib/redis/commands/sorted_sets.rb, line 558
def zrevrangebyscore(key, max, min, withscores: false, with_scores: withscores, limit: nil)
  args = [:zrevrangebyscore, key, max, min]

  if with_scores
    args << "WITHSCORES"
    block = FloatifyPairs
  end

  if limit
    args << "LIMIT"
    args.concat(limit.map { |l| Integer(l) })
  end

  send_command(args, &block)
end
zrevrank(key, member) click to toggle source

Determine the index of a member in a sorted set, with scores ordered from high to low.

@param [String] key @param [String] member @return [Integer]

# File lib/redis/commands/sorted_sets.rb, line 404
def zrevrank(key, member)
  send_command([:zrevrank, key, member])
end
zscan(key, cursor, **options) click to toggle source

Scan a sorted set

@example Retrieve the first batch of key/value pairs in a hash

redis.zscan("zset", 0)

@param [String, Integer] cursor the cursor of the iteration @param [Hash] options

- `:match => String`: only return keys matching the pattern
- `:count => Integer`: return count keys at most per iteration

@return [String, Array<[String, Float]>] the next cursor and all found

members and scores
# File lib/redis/commands/sorted_sets.rb, line 754
def zscan(key, cursor, **options)
  _scan(:zscan, cursor, [key], **options) do |reply|
    [reply[0], FloatifyPairs.call(reply[1])]
  end
end
zscan_each(key, **options, &block) click to toggle source

Scan a sorted set

@example Retrieve all of the members/scores in a sorted set

redis.zscan_each("zset").to_a
# => [["key70", "70"], ["key80", "80"]]

@param [Hash] options

- `:match => String`: only return keys matching the pattern
- `:count => Integer`: return count keys at most per iteration

@return [Enumerator] an enumerator for all found scores and members

# File lib/redis/commands/sorted_sets.rb, line 771
def zscan_each(key, **options, &block)
  return to_enum(:zscan_each, key, **options) unless block_given?

  cursor = 0
  loop do
    cursor, values = zscan(key, cursor, **options)
    values.each(&block)
    break if cursor == "0"
  end
end
zscore(key, member) click to toggle source

Get the score associated with the given member in a sorted set.

@example Get the score for member “a”

redis.zscore("zset", "a")
  # => 32.0

@param [String] key @param [String] member @return [Float] score of the member

# File lib/redis/commands/sorted_sets.rb, line 221
def zscore(key, member)
  send_command([:zscore, key, member], &Floatify)
end
zunion(*args) click to toggle source

Return the union of multiple sorted sets

@example Retrieve the union of ‘2*zsetA` and `1*zsetB`

redis.zunion("zsetA", "zsetB", :weights => [2.0, 1.0])
  # => ["v1", "v2"]

@example Retrieve the union of ‘2*zsetA` and `1*zsetB`, and their scores

redis.zunion("zsetA", "zsetB", :weights => [2.0, 1.0], :with_scores => true)
  # => [["v1", 3.0], ["v2", 6.0]]

@param [String, Array<String>] keys one or more keys to union @param [Hash] options

- `:weights => [Array<Float>]`: weights to associate with source
sorted sets
- `:aggregate => String`: aggregate function to use (sum, min, max)
- `:with_scores => true`: include scores in output

@return [Array<String>, Array<[String, Float]>]

- when `:with_scores` is not specified, an array of members
- when `:with_scores` is specified, an array with `[member, score]` pairs
# File lib/redis/commands/sorted_sets.rb, line 678
def zunion(*args)
  _zsets_operation(:zunion, *args)
end
zunionstore(*args) click to toggle source

Add multiple sorted sets and store the resulting sorted set in a new key.

@example Compute the union of ‘2*zsetA` with `1*zsetB`, summing their scores

redis.zunionstore("zsetC", ["zsetA", "zsetB"], :weights => [2.0, 1.0], :aggregate => "sum")
  # => 8

@param [String] destination destination key @param [Array<String>] keys source keys @param [Hash] options

- `:weights => [Float, Float, ...]`: weights to associate with source
sorted sets
- `:aggregate => String`: aggregate function to use (sum, min, max, ...)

@return [Integer] number of elements in the resulting sorted set

# File lib/redis/commands/sorted_sets.rb, line 696
def zunionstore(*args)
  _zsets_operation_store(:zunionstore, *args)
end

Private Instance Methods

_zsets_operation(cmd, *keys, weights: nil, aggregate: nil, with_scores: false) click to toggle source
# File lib/redis/commands/sorted_sets.rb, line 784
def _zsets_operation(cmd, *keys, weights: nil, aggregate: nil, with_scores: false)
  keys.flatten!(1)
  command = [cmd, keys.size].concat(keys)

  if weights
    command << "WEIGHTS"
    command.concat(weights)
  end

  command << "AGGREGATE" << aggregate if aggregate

  if with_scores
    command << "WITHSCORES"
    block = FloatifyPairs
  end

  send_command(command, &block)
end
_zsets_operation_store(cmd, destination, keys, weights: nil, aggregate: nil) click to toggle source
# File lib/redis/commands/sorted_sets.rb, line 803
def _zsets_operation_store(cmd, destination, keys, weights: nil, aggregate: nil)
  keys.flatten!(1)
  command = [cmd, destination, keys.size].concat(keys)

  if weights
    command << "WEIGHTS"
    command.concat(weights)
  end

  command << "AGGREGATE" << aggregate if aggregate

  send_command(command)
end