Atomically decrement and return the integer value for the specified key, creating it if it does not exist

redis.del "counter"
redis.decr "counter" # => -1

Atomically decrement and return the integer value for the specified key by the specified amount, creating it if it does not exist

redis.del "counter"
redis.decrby "counter", 2 # => -2

Delete all specified keys and return the number of keys deleted.

redis.set "foo", "12"
redis.del ["foo", "bar"] # => 1
redis.del ["foo", "bar"] # => 0

Delete all specified keys and return the number of keys deleted.

redis.set "foo", "12"
redis.del "foo", "bar" # => 1
redis.del "foo", "bar" # => 0

Evaluate the given Lua script, either referenced by SHA with #evalsha or directly with #eval.

NOTE Use #eval only for very trivial scripts and #evalsha for larger or frequently executed scripts to amortize parse/compile time as well as send fewer bytes along the wire.

NOTE Use #eval_ro and #evalsha_ro in a clustered environment to evaluate the scripts on read-only replicas.

script = <<-LUA
  return "this script was " + ARGV[1]
LUA

sha = redis.script_load(script)
redis.eval(script, args: ["evaluated on the fly"]
redis.evalsha(sha, args: ["precompiled"])

Evaluate the given Lua script, either referenced by SHA with #evalsha or directly with #eval.

NOTE Use #eval only for very trivial scripts and #evalsha for larger or frequently executed scripts to amortize parse/compile time as well as send fewer bytes along the wire.

NOTE Use #eval_ro and #evalsha_ro in a clustered environment to evaluate the scripts on read-only replicas.

script = <<-LUA
  return "this script was " + ARGV[1]
LUA

sha = redis.script_load(script)
redis.eval(script, args: ["evaluated on the fly"]
redis.evalsha(sha, args: ["precompiled"])

Evaluate the given Lua script, either referenced by SHA with #evalsha or directly with #eval.

NOTE Use #eval only for very trivial scripts and #evalsha for larger or frequently executed scripts to amortize parse/compile time as well as send fewer bytes along the wire.

NOTE Use #eval_ro and #evalsha_ro in a clustered environment to evaluate the scripts on read-only replicas.

script = <<-LUA
  return "this script was " + ARGV[1]
LUA

sha = redis.script_load(script)
redis.eval(script, args: ["evaluated on the fly"]
redis.evalsha(sha, args: ["precompiled"])

Evaluate the given Lua script, either referenced by SHA with #evalsha or directly with #eval.

NOTE Use #eval only for very trivial scripts and #evalsha for larger or frequently executed scripts to amortize parse/compile time as well as send fewer bytes along the wire.

NOTE Use #eval_ro and #evalsha_ro in a clustered environment to evaluate the scripts on read-only replicas.

script = <<-LUA
  return "this script was " + ARGV[1]
LUA

sha = redis.script_load(script)
redis.eval(script, args: ["evaluated on the fly"]
redis.evalsha(sha, args: ["precompiled"])

Return the number of specified keys that exist

redis.exists("foo", "bar") # => 0
redis.set "foo", "exists now"
redis.exists("foo", "bar") # => 1
redis.set "bar", "also exists now"
redis.exists("foo", "bar") # => 2

Delete all the keys of all the existing databases, not just the currently selected one.

Delete all the keys of the currently selected DB

EXPERIMENTAL RediSearch support is still under development. Some APIs may change while details are discovered.

Get the value for the specified key

redis.set "foo", "bar"
redis.get("foo") # => "bar"

Instantiate a Redis::Graph::Client backed by this Redis::Client.

Atomically increment and return the integer value for the specified key, creating it if it does not exist

redis.del "counter"
redis.incr "counter" # => 1

Atomically increment and return the integer value for the specified key by the specified amount, creating it if it does not exist

redis.del "counter"
redis.incrby "counter", 2 # => 2

Return a Redis::JSON instance that wraps the current Redis::Client or Redis::Cluster.

EXPERIMENTAL Support for the RedisJSON module is still under development and subject to change.

Get the keys whose names follow the specified glob pattern. If a pattern is not specified, it will return all keys by default. Be careful when using this command on Redis servers with a lot of traffic and millions of keys.

redis.keys       # => ["foo", "bar", "baz"]
redis.keys("f*") # => ["foo"]
redis.keys("b*") # => ["bar", "baz"]

Execute the given command and return the result from the server. Commands must be an Enumerable and its size method must be re-entrant.

run({"set", "foo", "bar"})

Return an array where each entry is 1 if the corresponding entry in the list of shas exists or 0 if it does not.

Return an array where each entry is 1 if the corresponding entry in the list of shas exists or 0 if it does not.

Flush the Lua scripts cache, see the official docs.

redis.script_flush :async # Flush scripts asynchronously
redis.script_flush :sync  # Flush scripts immediately

Kill the currently executing #eval script, assuming no write operation was yet performed by the script.

Preload a Lua script, returning the SHA of the script to pass to #evalsha.

sha = redis.script_load(<<-LUA)
  return "Hello " + ARGV[1]
LUA

redis.evalsha(sha, args: ["world"]) # => "Hello world"

Set a given key to a given value, optionally specifying time-to-live (TTL).

• ex: TTL in seconds (mnemonic: "ex" = "expiration")
• px: TTL in milliseconds
• nx: Only set this key if it does not exist (mnemonic: "nx" = it does "not exist")
• xx: only set this key if it does exist (mnemonic: "xx" = it "exists exists" — look, I don't make the rules)
• keepttl: If there is a TTL already set on the key, retain that TTL instead of overwriting it

redis.set "foo", "bar", ex: 1
redis.get("foo") # => "bar"
sleep 1.second
redis.get("foo") # => nil

Return a Redis::TimeSeries that wraps the current Redis::Client or Redis::Cluster.