module Redis::Commands

Overview

All Redis commands are defined in this module. Any paradigm that needs to use these commands simply overrides #run, which takes a single command object, which must be an Enumerable.

TODO Add more Redis commands from https://redis.io/commands

Included Modules

• Redis::Commands::Hash
• Redis::Commands::List
• Redis::Commands::Set
• Redis::Commands::SortedSet
• Redis::Commands::Stream

Direct including types

• Redis::Cluster
• Redis::Connection
• Redis::Pipeline
• Redis::Transaction

Defined in:

Instance Method Summary

• #decr(key : String)

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

• #decrby(key : String, amount : Int | String)

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

• #del(*keys : String)

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

• #exists(*keys : String)

  Return the number of specified keys that exist

• #expire(key : String, ttl : Int)
• #expireat(key : String, at : Time)
• #flushdb
• #ft

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

• #get(key : String)

  Get the value for the specified key

• #incr(key : String)

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

• #incrby(key : String, amount : Int | String)

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

• #info
• #json

  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.

• #keys(pattern = "*")

  Get the keys whose names follow the specified glob pattern.

• #mget(keys : Enumerable(String))
• #mset(data : Hash(String, String))
• #pexpire(key : String, ttl : Int)
• #pexpireat(key : String, at : Time)
• #pttl(key : String)
• #publish(channel : String, message : String)
• #run(command)

  Execute the given command and return the result from the server.

• #scan(cursor : String = "0", match : String | Nil = nil, count : String | Int | Nil = nil, type : String | Nil = nil)
• #set(key : String, value : String, ex : String | Int | Nil = nil, px : String | Int | Nil = nil, nx = false, xx = false, keepttl = false)

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

• #set(key, value, ex : Time, nx = false, xx = false, keepttl = false)
• #set(key, value, ex : Time::Span, nx = false, xx = false, keepttl = false)
• #ts

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

• #ttl(key : String)
• #type(key : String)
• #unlink(keys : Enumerable(String))
• #unlink(*keys : String)

Instance Method Detail

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

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

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

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

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

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

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

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

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

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