Class Redis
In: lib/redis.rb
lib/redis/connection/hiredis.rb
lib/redis/connection/registry.rb
lib/redis/connection/command_helper.rb
lib/redis/connection/synchrony.rb
lib/redis/connection/ruby.rb
lib/redis/subscribe.rb
lib/redis/version.rb
lib/redis/pipeline.rb
lib/redis/client.rb
lib/redis/hash_ring.rb
lib/redis/distributed.rb
lib/redis/errors.rb
Parent: Object

Methods

[]   []=   _bpop   _eval   append   auth   bgrewriteaof   bgsave   bitcount   bitop   blpop   brpop   brpoplpush   config   connect   current   current=   dbsize   debug   decr   decrby   del   deprecate   discard   dump   echo   eval   evalsha   exec   exists   expire   expireat   flushall   flushdb   get   getbit   getrange   getset   hdel   hexists   hget   hgetall   hincrby   hincrbyfloat   hkeys   hlen   hmget   hmset   hset   hsetnx   hvals   id   incr   incrby   incrbyfloat   info   inspect   keys   lastsave   lindex   linsert   llen   lpop   lpush   lpushx   lrange   lrem   lset   ltrim   mapped_hmget   mapped_hmset   mapped_mget   mapped_mset   mapped_msetnx   method_missing   mget   monitor   move   mset   msetnx   multi   new   object   persist   pexpire   pexpireat   ping   pipelined   psetex   psubscribe   pttl   publish   punsubscribe   quit   randomkey   rename   renamenx   restore   rpop   rpoplpush   rpush   rpushx   sadd   save   scard   script   sdiff   sdiffstore   select   set   setbit   setex   setnx   setrange   shutdown   sinter   sinterstore   sismember   slaveof   slowlog   smembers   smove   sort   spop   srandmember   srem   strlen   subscribe   subscribed?   sunion   sunionstore   sync   synchronize   time   ttl   type   unsubscribe   unwatch   watch   with_reconnect   without_reconnect   zadd   zcard   zcount   zincrby   zinterstore   zrange   zrangebyscore   zrank   zrem   zremrangebyrank   zremrangebyscore   zrevrange   zrevrangebyscore   zrevrank   zscore   zunionstore  

Included Modules

MonitorMixin

Classes and Modules

Module Redis::Connection
Class Redis::BaseConnectionError
Class Redis::BaseError
Class Redis::BasicObject
Class Redis::CannotConnectError
Class Redis::Client
Class Redis::CommandError
Class Redis::ConnectionError
Class Redis::Distributed
Class Redis::Future
Class Redis::FutureNotReady
Class Redis::HashRing
Class Redis::InheritedError
Class Redis::Pipeline
Class Redis::ProtocolError
Class Redis::SubscribedClient
Class Redis::Subscription
Class Redis::TimeoutError

Constants

VERSION = "3.0.3"

Attributes

client  [R] 

Public Class methods

@deprecated The preferred way to create a new client object is using `new`.

            This method does not actually establish a connection to Redis,
            in contrary to what you might expect.

Public Instance methods

[](key)

Alias for get

[]=(key, value)

Alias for set

Append a value to a key.

@param [String] key @param [String] value value to append @return [Fixnum] length of the string after appending

Authenticate to the server.

@param [String] password must match the password specified in the

  `requirepass` directive in the configuration file

@return [String] `OK`

Asynchronously rewrite the append-only file.

@return [String] `OK`

Asynchronously save the dataset to disk.

@return [String] `OK`

Count the number of set bits in a range of the string value stored at key.

@param [String] key @param [Fixnum] start start index @param [Fixnum] stop stop index @return [Fixnum] the number of bits set to 1

Perform a bitwise operation between strings and store the resulting string in a key.

@param [String] operation e.g. `and`, `or`, `xor`, `not` @param [String] destkey destination key @param [String, Array<String>] keys one or more source keys to perform `operation` @return [Fixnum] the length of the string stored in `destkey`

Remove and get the first element in a list, or block until one is available.

@example With timeout

  list, element = redis.blpop("list", :timeout => 5)
    # => nil on timeout
    # => ["list", "element"] on success

@example Without timeout

  list, element = redis.blpop("list")
    # => ["list", "element"]

@example Blocking pop on multiple lists

  list, element = redis.blpop(["list", "another_list"])
    # => ["list", "element"]

@param [String, Array<String>] keys one or more keys to perform the

  blocking pop on

@param [Hash] options

  - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout

@return [nil, [String, String]]

  - `nil` when the operation timed out
  - tuple of the list that was popped from and element was popped otherwise

Remove and get the last element in a list, or block until one is available.

@param [String, Array<String>] keys one or more keys to perform the

  blocking pop on

@param [Hash] options

  - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout

@return [nil, [String, String]]

  - `nil` when the operation timed out
  - tuple of the list that was popped from and element was popped otherwise

@see blpop

Pop a value from a list, push it to another list and return it; or block until one is available.

@param [String] source source key @param [String] destination destination key @param [Hash] options

  - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout

@return [nil, String]

  - `nil` when the operation timed out
  - the element was popped and pushed otherwise

Get or set server configuration parameters.

@param [String] action e.g. `get`, `set`, `resetstat` @return [String, Hash] string reply, or hash when retrieving more than one

  property with `CONFIG GET`

Return the number of keys in the selected database.

@return [Fixnum]

Decrement the integer value of a key by one.

@example

  redis.decr("value")
    # => 4

@param [String] key @return [Fixnum] value after decrementing it

Decrement the integer value of a key by the given number.

@example

  redis.decrby("value", 5)
    # => 0

@param [String] key @param [Fixnum] decrement @return [Fixnum] value after decrementing it

Delete one or more keys.

@param [String, Array<String>] keys @return [Fixnum] number of keys that were deleted

Discard all commands issued after MULTI.

Only call this method when `multi` was called *without* a block.

@return `"OK"`

@see multi @see exec

Return a serialized version of the value stored at a key.

@param [String] key @return [String] serialized_value

Echo the given string.

@param [String] value @return [String]

Evaluate Lua script.

@example EVAL without KEYS nor ARGV

  redis.eval("return 1")
    # => 1

@example EVAL with KEYS and ARGV as array arguments

  redis.eval("return { KEYS, ARGV }", ["k1", "k2"], ["a1", "a2"])
    # => [["k1", "k2"], ["a1", "a2"]]

@example EVAL with KEYS and ARGV in a hash argument

  redis.eval("return { KEYS, ARGV }", :keys => ["k1", "k2"], :argv => ["a1", "a2"])
    # => [["k1", "k2"], ["a1", "a2"]]

@param [Array<String>] keys optional array with keys to pass to the script @param [Array<String>] argv optional array with arguments to pass to the script @param [Hash] options

  - `:keys => Array<String>`: optional array with keys to pass to the script
  - `:argv => Array<String>`: optional array with arguments to pass to the script

@return depends on the script

@see script @see evalsha

Evaluate Lua script by its SHA.

@example EVALSHA without KEYS nor ARGV

  redis.evalsha(sha)
    # => <depends on script>

@example EVALSHA with KEYS and ARGV as array arguments

  redis.evalsha(sha, ["k1", "k2"], ["a1", "a2"])
    # => <depends on script>

@example EVALSHA with KEYS and ARGV in a hash argument

  redis.evalsha(sha, :keys => ["k1", "k2"], :argv => ["a1", "a2"])
    # => <depends on script>

@param [Array<String>] keys optional array with keys to pass to the script @param [Array<String>] argv optional array with arguments to pass to the script @param [Hash] options

  - `:keys => Array<String>`: optional array with keys to pass to the script
  - `:argv => Array<String>`: optional array with arguments to pass to the script

@return depends on the script

@see script @see eval

Execute all commands issued after MULTI.

Only call this method when `multi` was called *without* a block.

@return [nil, Array<…>]

  - when commands were not executed, `nil`
  - when commands were executed, an array with their replies

@see multi @see discard

Determine if a key exists.

@param [String] key @return [Boolean]

Set a key‘s time to live in seconds.

@param [String] key @param [Fixnum] seconds time to live @return [Boolean] whether the timeout was set or not

Set the expiration for a key as a UNIX timestamp.

@param [String] key @param [Fixnum] unix_time expiry time specified as a UNIX timestamp @return [Boolean] whether the timeout was set or not

Remove all keys from all databases.

@return [String] `OK`

Remove all keys from the current database.

@return [String] `OK`

Get the value of a key.

@param [String] key @return [String]

Returns the bit value at offset in the string value stored at key.

@param [String] key @param [Fixnum] offset bit offset @return [Fixnum] `0` or `1`

Get a substring of the string stored at a key.

@param [String] key @param [Fixnum] start zero-based start offset @param [Fixnum] stop zero-based end offset. Use -1 for representing

  the end of the string

@return [Fixnum] `0` or `1`

Set the string value of a key and return its old value.

@param [String] key @param [String] value value to replace the current value with @return [String] the old value stored in the key, or `nil` if the key

  did not exist

Delete one or more hash fields.

@param [String] key @param [String, Array<String>] field @return [Fixnum] the number of fields that were removed from the hash

Determine if a hash field exists.

@param [String] key @param [String] field @return [Boolean] whether or not the field exists in the hash

Get the value of a hash field.

@param [String] key @param [String] field @return [String]

Get all the fields and values in a hash.

@param [String] key @return [Hash<String, String>]

Increment the integer value of a hash field by the given integer number.

@param [String] key @param [String] field @param [Fixnum] increment @return [Fixnum] value of the field after incrementing it

Increment the numeric value of a hash field by the given float number.

@param [String] key @param [String] field @param [Float] increment @return [Float] value of the field after incrementing it

Get all the fields in a hash.

@param [String] key @return [Array<String>]

Get the number of fields in a hash.

@param [String] key @return [Fixnum] number of fields in the hash

Get the values of all the given hash fields.

@example

  redis.hmget("hash", "f1", "f2")
    # => ["v1", "v2"]

@param [String] key @param [Array<String>] fields array of fields @return [Array<String>] an array of values for the specified fields

@see mapped_hmget

Set one or more hash values.

@example

  redis.hmset("hash", "f1", "v1", "f2", "v2")
    # => "OK"

@param [String] key @param [Array<String>] attrs array of fields and values @return `"OK"`

@see mapped_hmset

Set the string value of a hash field.

@param [String] key @param [String] field @param [String] value @return [Boolean] whether or not the field was *added* to the hash

Set the value of a hash field, only if the field does not exist.

@param [String] key @param [String] field @param [String] value @return [Boolean] whether or not the field was *added* to the hash

Get all the values in a hash.

@param [String] key @return [Array<String>]

Increment the integer value of a key by one.

@example

  redis.incr("value")
    # => 6

@param [String] key @return [Fixnum] value after incrementing it

Increment the integer value of a key by the given integer number.

@example

  redis.incrby("value", 5)
    # => 10

@param [String] key @param [Fixnum] increment @return [Fixnum] value after incrementing it

Increment the numeric value of a key by the given float number.

@example

  redis.incrbyfloat("value", 1.23)
    # => 1.23

@param [String] key @param [Float] increment @return [Float] value after incrementing it

Get information and statistics about the server.

@param [String, Symbol] cmd e.g. "commandstats" @return [Hash<String, String>]

Find all keys matching the given pattern.

@param [String] pattern @return [Array<String>]

Get the UNIX time stamp of the last successful save to disk.

@return [Fixnum]

Get an element from a list by its index.

@param [String] key @param [Fixnum] index @return [String]

Insert an element before or after another element in a list.

@param [String] key @param [String, Symbol] where `BEFORE` or `AFTER` @param [String] pivot reference element @param [String] value @return [Fixnum] length of the list after the insert operation, or `-1`

  when the element `pivot` was not found

Get the length of a list.

@param [String] key @return [Fixnum]

Remove and get the first element in a list.

@param [String] key @return [String]

Prepend one or more values to a list, creating the list if it doesn‘t exist

@param [String] key @param [String, Array] string value, or array of string values to push @return [Fixnum] the length of the list after the push operation

Prepend a value to a list, only if the list exists.

@param [String] key @param [String] value @return [Fixnum] the length of the list after the push operation

Get a range of elements from a list.

@param [String] key @param [Fixnum] start start index @param [Fixnum] stop stop index @return [Array<String>]

Remove elements from a list.

@param [String] key @param [Fixnum] count number of elements to remove. Use a positive

  value to remove the first `count` occurrences of `value`. A negative
  value to remove the last `count` occurrences of `value`. Or zero, to
  remove all occurrences of `value` from the list.

@param [String] value @return [Fixnum] the number of removed elements

Set the value of an element in a list by its index.

@param [String] key @param [Fixnum] index @param [String] value @return [String] `OK`

Trim a list to the specified range.

@param [String] key @param [Fixnum] start start index @param [Fixnum] stop stop index @return [String] `OK`

Get the values of all the given hash fields.

@example

  redis.hmget("hash", "f1", "f2")
    # => { "f1" => "v1", "f2" => "v2" }

@param [String] key @param [Array<String>] fields array of fields @return [Hash] a hash mapping the specified fields to their values

@see hmget

Set one or more hash values.

@example

  redis.mapped_hmset("hash", { "f1" => "v1", "f2" => "v2" })
    # => "OK"

@param [String] key @param [Hash] hash fields mapping to values @return `"OK"`

@see hmset

Get the values of all the given keys.

@example

  redis.mapped_mget("key1", "key1")
    # => { "key1" => "v1", "key2" => "v2" }

@param [Array<String>] keys array of keys @return [Hash] a hash mapping the specified keys to their values

@see mget

Set one or more values.

@example

  redis.mapped_mset({ "f1" => "v1", "f2" => "v2" })
    # => "OK"

@param [Hash] hash keys mapping to values @return `"OK"`

@see mset

Set one or more values, only if none of the keys exist.

@example

  redis.msetnx({ "key1" => "v1", "key2" => "v2" })
    # => true

@param [Hash] hash keys mapping to values @return [Boolean] whether or not all values were set

@see msetnx

Get the values of all the given keys.

@example

  redis.mget("key1", "key1")
    # => ["v1", "v2"]

@param [Array<String>] keys @return [Array<String>] an array of values for the specified keys

@see mapped_mget

Listen for all requests received by the server in real time.

There is no way to interrupt this command.

@yield a block to be called for every line of output @yieldparam [String] line timestamp and command that was executed

Move a key to another database.

@example Move a key to another database

  redis.set "foo", "bar"
    # => "OK"
  redis.move "foo", 2
    # => true
  redis.exists "foo"
    # => false
  redis.select 2
    # => "OK"
  redis.exists "foo"
    # => true
  resis.get "foo"
    # => "bar"

@param [String] key @param [Fixnum] db @return [Boolean] whether the key was moved or not

Set one or more values.

@example

  redis.mset("key1", "v1", "key2", "v2")
    # => "OK"

@param [Array<String>] args array of keys and values @return `"OK"`

@see mapped_mset

Set one or more values, only if none of the keys exist.

@example

  redis.msetnx("key1", "v1", "key2", "v2")
    # => true

@param [Array<String>] args array of keys and values @return [Boolean] whether or not all values were set

@see mapped_msetnx

Mark the start of a transaction block.

Passing a block is optional.

@example With a block

  redis.multi do |multi|
    multi.set("key", "value")
    multi.incr("counter")
  end # => ["OK", 6]

@example Without a block

  redis.multi
    # => "OK"
  redis.set("key", "value")
    # => "QUEUED"
  redis.incr("counter")
    # => "QUEUED"
  redis.exec
    # => ["OK", 6]

@yield [multi] the commands that are called inside this block are cached

  and written to the server upon returning from it

@yieldparam [Redis] multi `self`

@return [String, Array<…>]

  - when a block is not given, `OK`
  - when a block is given, an array with replies

@see watch @see unwatch

Remove the expiration from a key.

@param [String] key @return [Boolean] whether the timeout was removed or not

Set a key‘s time to live in milliseconds.

@param [String] key @param [Fixnum] milliseconds time to live @return [Boolean] whether the timeout was set or not

Set the expiration for a key as number of milliseconds from UNIX Epoch.

@param [String] key @param [Fixnum] ms_unix_time expiry time specified as number of milliseconds from UNIX Epoch. @return [Boolean] whether the timeout was set or not

Ping the server.

@return [String] `PONG`

Set the time to live in milliseconds of a key.

@param [String] key @param [Fixnum] ttl @param [String] value @return `"OK"`

Listen for messages published to channels matching the given patterns.

Get the time to live (in milliseconds) for a key.

@param [String] key @return [Fixnum] remaining time to live in milliseconds, or -1 if the

  key does not exist or does not have a timeout

Post a message to a channel.

Stop listening for messages posted to channels matching the given patterns.

Close the connection.

@return [String] `OK`

Return a random key from the keyspace.

@return [String]

Rename a key. If the new key already exists it is overwritten.

@param [String] old_name @param [String] new_name @return [String] `OK`

Rename a key, only if the new key does not exist.

@param [String] old_name @param [String] new_name @return [Boolean] whether the key was renamed or not

Create a key using the serialized value, previously obtained using DUMP.

@param [String] key @param [String] ttl @param [String] serialized_value @return `"OK"`

Remove and get the last element in a list.

@param [String] key @return [String]

Remove the last element in a list, append it to another list and return it.

@param [String] source source key @param [String] destination destination key @return [nil, String] the element, or nil when the source key does not exist

Append one or more values to a list, creating the list if it doesn‘t exist

@param [String] key @param [String] value @return [Fixnum] the length of the list after the push operation

Append a value to a list, only if the list exists.

@param [String] key @param [String] value @return [Fixnum] the length of the list after the push operation

Add one or more members to a set.

@param [String] key @param [String, Array<String>] member one member, or array of members @return [Boolean, Fixnum] `Boolean` when a single member is specified,

  holding whether or not adding the member succeeded, or `Fixnum` when an
  array of members is specified, holding the number of members that were
  successfully added

Synchronously save the dataset to disk.

@return [String]

Get the number of members in a set.

@param [String] key @return [Fixnum]

Control remote script registry.

@example Load a script

  sha = redis.script(:load, "return 1")
    # => <sha of this script>

@example Check if a script exists

  redis.script(:exists, sha)
    # => true

@example Check if multiple scripts exist

  redis.script(:exists, [sha, other_sha])
    # => [true, false]

@example Flush the script registry

  redis.script(:flush)
    # => "OK"

@example Kill a running script

  redis.script(:kill)
    # => "OK"

@param [String] subcommand e.g. `exists`, `flush`, `load`, `kill` @param [Array<String>] args depends on subcommand @return [String, Boolean, Array<Boolean>, …] depends on subcommand

@see eval @see evalsha

Subtract multiple sets.

@param [String, Array<String>] keys keys pointing to sets to subtract @return [Array<String>] members in the difference

Subtract multiple sets and store the resulting set in a key.

@param [String] destination destination key @param [String, Array<String>] keys keys pointing to sets to subtract @return [Fixnum] number of elements in the resulting set

Change the selected database for the current connection.

@param [Fixnum] db zero-based index of the DB to use (0 to 15) @return [String] `OK`

Set the string value of a key.

@param [String] key @param [String] value @return `"OK"`

Sets or clears the bit at offset in the string value stored at key.

@param [String] key @param [Fixnum] offset bit offset @param [Fixnum] value bit value `0` or `1` @return [Fixnum] the original bit value stored at `offset`

Set the time to live in seconds of a key.

@param [String] key @param [Fixnum] ttl @param [String] value @return `"OK"`

Set the value of a key, only if the key does not exist.

@param [String] key @param [String] value @return [Boolean] whether the key was set or not

Overwrite part of a string at key starting at the specified offset.

@param [String] key @param [Fixnum] offset byte offset @param [String] value @return [Fixnum] length of the string after it was modified

Synchronously save the dataset to disk and then shut down the server.

Intersect multiple sets.

@param [String, Array<String>] keys keys pointing to sets to intersect @return [Array<String>] members in the intersection

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

@param [String] destination destination key @param [String, Array<String>] keys keys pointing to sets to intersect @return [Fixnum] number of elements in the resulting set

Determine if a given value is a member of a set.

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

Make the server a slave of another instance, or promote it as master.

Interact with the slowlog (get, len, reset)

@param [String] subcommand e.g. `get`, `len`, `reset` @param [Fixnum] length maximum number of entries to return @return [Array<String>, Fixnum, String] depends on subcommand

Get all the members in a set.

@param [String] key @return [Array<String>]

Move a member from one set to another.

@param [String] source source key @param [String] destination destination key @param [String] member member to move from `source` to `destination` @return [Boolean]

Sort the elements in a list, set or sorted set.

@example Retrieve the first 2 elements from an alphabetically sorted "list"

  redis.sort("list", :order => "alpha", :limit => [0, 2])
    # => ["a", "b"]

@example Store an alphabetically descending list in "target"

  redis.sort("list", :order => "desc alpha", :store => "target")
    # => 26

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

  - `:by => String`: use external key to sort elements by
  - `:limit => [offset, count]`: skip `offset` elements, return a maximum
  of `count` elements
  - `:get => [String, Array<String>]`: single key or array of keys to
  retrieve per element in the result
  - `:order => String`: combination of `ASC`, `DESC` and optionally `ALPHA`
  - `:store => String`: key to store the result at

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

  - when `:get` is not specified, or holds a single element, an array of elements
  - when `:get` is specified, and holds more than one element, an array of
  elements where every element is an array with the result for every
  element specified in `:get`
  - when `:store` is specified, the number of elements in the stored result

Remove and return a random member from a set.

@param [String] key @return [String]

Get one or more random members from a set.

@param [String] key @param [Fixnum] count @return [String]

Remove one or more members from a set.

@param [String] key @param [String, Array<String>] member one member, or array of members @return [Boolean, Fixnum] `Boolean` when a single member is specified,

  holding whether or not removing the member succeeded, or `Fixnum` when an
  array of members is specified, holding the number of members that were
  successfully removed

Get the length of the value stored in a key.

@param [String] key @return [Fixnum] the length of the value stored in the key, or 0

  if the key does not exist

Listen for messages published to the given channels.

Add multiple sets.

@param [String, Array<String>] keys keys pointing to sets to unify @return [Array<String>] members in the union

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

@param [String] destination destination key @param [String, Array<String>] keys keys pointing to sets to unify @return [Fixnum] number of elements in the resulting set

Internal command used for replication.

Return the server time.

@example

  r.time # => [ 1333093196, 606806 ]

@return [Array<Fixnum>] tuple of seconds since UNIX epoch and

  microseconds in the current second

Get the time to live (in seconds) for a key.

@param [String] key @return [Fixnum] remaining time to live in seconds, or -1 if the

  key does not exist or does not have a timeout

Determine the type stored at key.

@param [String] key @return [String] `string`, `list`, `set`, `zset`, `hash` or `none`

Stop listening for messages posted to the given channels.

Forget about all watched keys.

@return [String] `OK`

@see watch @see multi

Watch the given keys to determine execution of the MULTI/EXEC block.

Using a block is optional, but is necessary for thread-safety.

An `unwatch` is automatically issued if an exception is raised within the block that is a subclass of StandardError and is not a ConnectionError.

@example With a block

  redis.watch("key") do
    if redis.get("key") == "some value"
      redis.multi do |multi|
        multi.set("key", "other value")
        multi.incr("counter")
      end
    else
      redis.unwatch
    end
  end
    # => ["OK", 6]

@example Without a block

  redis.watch("key")
    # => "OK"

@param [String, Array<String>] keys one or more keys to watch @return [Object] if using a block, returns the return value of the block @return [String] if not using a block, returns `OK`

@see unwatch @see multi

Run code with the client reconnecting

Run code without the client reconnecting

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

@return [Boolean, Fixnum]

  - `Boolean` when a single pair is specified, holding whether or not it was
  **added** to the sorted set
  - `Fixnum` when an array of pairs is specified, holding the number of
  pairs that were **added** to the sorted set

Get the number of members in a sorted set.

@example

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

@param [String] key @return [Fixnum]

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 [Fixnum] number of members in within the specified range

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

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

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

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

@example Retrieve all members from a sorted set

  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 [Fixnum] start start index @param [Fixnum] stop stop index @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

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

Determine the index of a member in a sorted set.

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

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, Fixnum]

  - `Boolean` when a single member is specified, holding whether or not it
  was removed from the sorted set
  - `Fixnum` when an array of pairs is specified, holding the number of
  members that were removed to the sorted set

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 [Fixnum] start start index @param [Fixnum] stop stop index @return [Fixnum] number of members that were removed

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 [Fixnum] number of members that were removed

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

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

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

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

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

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 [Fixnum] number of elements in the resulting sorted set

[Validate]