@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.

Create a new client instance

@param [Hash] options @option options [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection: `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket connection: `unix://[path to Redis socket]`. This overrides all other options. @option options [String] :host ("127.0.0.1") server hostname @option options [Fixnum] :port (6379) server port @option options [String] :path path to server socket (overrides host and port) @option options [Float] :timeout (5.0) timeout in seconds @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds @option options [String] :password Password to authenticate against server @option options [Fixnum] :db (0) Database to select after initial connect @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`, `:synchrony` @option options [String] :id ID for the client connection, assigns name to current connection by sending `CLIENT SETNAME` @option options [Hash, Fixnum] :tcp_keepalive Keepalive values, if Fixnum `intvl` and `probe` are calculated based on the value, if Hash `time`, `intvl` and `probes` can be specified as a Fixnum @option options [Fixnum] :reconnect_attempts Number of attempts trying to connect @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not @option options [Array] :sentinels List of sentinels to contact @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`

@return [Redis] a new client instance

Alias for get

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`

Return the position of the first bit set to 1 or 0 in a string.

@param [String] key @param [Fixnum] bit whether to look for the first 1 or 0 bit @param [Fixnum] start start index @param [Fixnum] stop stop index @return [Fixnum] the position of the first 1/0 bit.

                 -1 if looking for 1 and it is not found or start and stop are given.

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

Sends a command to Redis and returns its reply.

Replies are converted to Ruby objects according to the RESP protocol, so you can expect a Ruby array, integer or nil when Redis sends one. Higher level transformations, such as converting an array of pairs into a Ruby hash, are up to consumers.

Redis error replies are raised as Ruby exceptions.

Disconnect the client as quickly and silently as possible.

Sends all commands in the queue.

See redis.io/topics/pipelining for more details.

Get or set server configuration parameters.

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

  property with `CONFIG GET`

Test whether or not the client is connected

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 [String] `"OK"`

@see multi @see exec

Alias for close

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 [String] `"OK"`

@see mapped_hmset

Scan a hash

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

  redis.hscan("hash", 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, String]>] the next cursor and all found keys

Scan a hash

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

  redis.hscan_each("hash").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 keys

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] value 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.mapped_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 a non-empty hash with fields mapping to values @return [String] `"OK"`

@see hmset

Get the values of all the given keys.

@example

  redis.mapped_mget("key1", "key2")
    # => { "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 [String] `"OK"`

@see mset

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

@example

  redis.mapped_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

Transfer a key from the connected instance to another instance.

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

  - `:host => String`: host of instance to migrate to
  - `:port => Integer`: port of instance to migrate to
  - `:db => Integer`: database to migrate to (default: same as source)
  - `:timeout => Integer`: timeout (default: same as connection timeout)

@return [String] `"OK"`

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
  redis.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 [String] `"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

Add one or more members to a HyperLogLog structure.

@param [String] key @param [String, Array<String>] member one member, or array of members @return [Boolean] true if at least 1 HyperLogLog internal register was altered. false otherwise.

Get the approximate cardinality of members added to HyperLogLog structure.

If called with multiple keys, returns the approximate cardinality of the union of the HyperLogLogs contained in the keys.

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

Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of the observed Sets of the source HyperLogLog structures.

@param [String] dest_key destination key @param [String, Array<String>] source_key source key, or array of keys @return [Boolean]

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 [String] `"OK"`

Listen for messages published to channels matching the given patterns.

Listen for messages published to channels matching the given patterns. Throw a timeout error if there is no messages for a timeout period.

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

@param [String] key @return [Fixnum] remaining time to live in milliseconds In Redis 2.6 or older the command returns -1 if the key does not exist or if the key exist but has no associated expire.

Starting with Redis 2.8 the return value in case of error changed:

    - The command returns -2 if the key does not exist.
    - The command returns -1 if the key exists but has no associated expire.

Post a message to a channel.

Inspect the state of the Pub/Sub subsystem. Possible subcommands: channels, numsub, numpat.

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

Queues a command for pipelining.

Commands in the queue are executed with the Redis#commit method.

See redis.io/topics/pipelining for more details.

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 [String] `"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]

Scan the keyspace

@example Retrieve the first batch of keys

  redis.scan(0)
    # => ["4", ["key:21", "key:47", "key:42"]]

@example Retrieve a batch of keys matching a pattern

  redis.scan(4, :match => "key:1?")
    # => ["92", ["key:13", "key:18"]]

@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>] the next cursor and all found keys

Scan the keyspace

@example Retrieve all of the keys (with possible duplicates)

  redis.scan_each.to_a
    # => ["key:21", "key:47", "key:42"]

@example Execute block for each key matching a pattern

  redis.scan_each(:match => "key:1?") {|key| puts key}
    # => key:13
    # => key:18

@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 keys

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`

Interact with the sentinel command (masters, master, slaves, failover)

@param [String] subcommand e.g. `masters`, `master`, `slaves` @param [Array<String>] args depends on subcommand @return [Array<String>, Hash<String, String>, String] depends on subcommand

Set the string value of a key.

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

  - `:ex => Fixnum`: Set the specified expire time, in seconds.
  - `:px => Fixnum`: Set the specified expire time, in milliseconds.
  - `:nx => true`: Only set the key if it does not already exist.
  - `:xx => true`: Only set the key if it already exist.

@return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`

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 [String] `"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 one or more random member from a set.

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

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

Scan a set

@example Retrieve the first batch of keys in a set

  redis.sscan("set", 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>] the next cursor and all found members

Scan a set

@example Retrieve all of the keys in a set

  redis.sscan_each("set").to_a
  # => ["key1", "key2", "key3"]

@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 keys in the set

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.

Listen for messages published to the given channels. Throw a timeout error if there is no messages for a timeout period.

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.

In Redis 2.6 or older the command returns -1 if the key does not exist or if the key exist but has no associated expire.

Starting with Redis 2.8 the return value in case of error changed:

    - The command returns -2 if the key does not exist.
    - The command returns -1 if the key exists but has no associated expire.

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

@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)
  - `: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, Fixnum, Float]

  - `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.
  - `Float` when option :incr is specified, holding the score of the member
  after incrementing it.

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

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 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

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]

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

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

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