module Protocol::Redis::Methods::Generic

Public Instance Methods

del(*keys) click to toggle source

Delete a key. O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1). @see redis.io/commands/del @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 33
def del(*keys)
        if keys.any?
                call('DEL', *keys)
        end
end
dump(key) click to toggle source

Return a serialized version of the value stored at the specified key. O(1) to access the key and additional O(N*M) to serialized it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). @see redis.io/commands/dump @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 42
def dump(key)
        call('DUMP', key)
end
exists(key, *keys) click to toggle source

Determine if a key exists. O(1). @see redis.io/commands/exists @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 49
def exists(key, *keys)
        call('EXISTS', key, *keys)
end
expire(key, seconds) click to toggle source

Set a key's time to live in seconds. O(1). @see redis.io/commands/expire @param key [Key] @param seconds [Integer]

# File lib/protocol/redis/methods/generic.rb, line 57
def expire(key, seconds)
        call('EXPIRE', key, seconds)
end
expireat(key, time) click to toggle source

Set the expiration for a key as a UNIX timestamp. O(1). @see redis.io/commands/expireat @param key [Key] @param timestamp [Posix time]

# File lib/protocol/redis/methods/generic.rb, line 65
def expireat(key, time)
        case time
        when DateTime, Time, Date
                timestamp = time.strftime('%s').to_i
        else
                timestamp = time
        end
        
        call('EXPIREAT', key, timestamp)
end
keys(pattern) click to toggle source

Find all keys matching the given pattern. O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length. @see redis.io/commands/keys @param pattern [Pattern]

# File lib/protocol/redis/methods/generic.rb, line 79
def keys(pattern)
        call('KEYS', pattern)
end
migrate(host, port, destination = 0, keys:, timeout: 0, copy: false, replace: false, auth: nil) click to toggle source

Atomically transfer a key from a Redis instance to another one. This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed. @see redis.io/commands/migrate @param host [String] @param port [String] @param key [Enum] @param destination-db [Integer] @param timeout [Integer] @param copy [Enum] @param replace [Enum]

# File lib/protocol/redis/methods/generic.rb, line 92
def migrate(host, port, destination = 0, keys:, timeout: 0, copy: false, replace: false, auth: nil)
        raise ArgumentError, "Must provide keys" if keys.empty?
        
        arguments = [host, port]
        
        if keys.size == 1
                arguments.append(*keys)
        else
                arguments.append("")
        end
        
        arguments.append(destination, timeout)
        
        if copy
                arguments.append("COPY")
        end
        
        if replace
                arguments.append("REPLACE")
        end
        
        if auth
                arguments.append("AUTH", auth)
        end
        
        if keys.size > 1
                arguments.append("KEYS", *keys)
        end
        
        call("MIGRATE", *arguments)
end
move(key, db) click to toggle source

Move a key to another database. O(1). @see redis.io/commands/move @param key [Key] @param db [Integer]

# File lib/protocol/redis/methods/generic.rb, line 128
def move(key, db)
        call('MOVE', key, db)
end
object(subcommand, *arguments) click to toggle source

Inspect the internals of Redis objects. O(1) for all the currently implemented subcommands. @see redis.io/commands/object @param subcommand [String] @param arguments [String]

# File lib/protocol/redis/methods/generic.rb, line 136
def object(subcommand, *arguments)
        call('OBJECT', subcommand, *arguments)
end
persist(key) click to toggle source

Remove the expiration from a key. O(1). @see redis.io/commands/persist @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 143
def persist(key)
        call('PERSIST', key)
end
pexpire(key, milliseconds) click to toggle source

Set a key's time to live in milliseconds. O(1). @see redis.io/commands/pexpire @param key [Key] @param milliseconds [Integer]

# File lib/protocol/redis/methods/generic.rb, line 151
def pexpire(key, milliseconds)
        call('PEXPIRE', milliseconds)
end
pexpireat(key, time) click to toggle source

Set the expiration for a key as a UNIX timestamp specified in milliseconds. O(1). @see redis.io/commands/pexpireat @param key [Key] @param milliseconds-timestamp [Posix time]

# File lib/protocol/redis/methods/generic.rb, line 159
def pexpireat(key, time)
        case time.class
        when DateTime, Time, Date 
                timestamp =  time.strftime('%Q').to_i
        else
                timestamp = time
        end
        
        call('PEXPIREAT', key, timestamp)
end
pttl(key) click to toggle source

Get the time to live for a key in milliseconds. O(1). @see redis.io/commands/pttl @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 173
def pttl(key)
        call('PTTL', key)
end
randomkey() click to toggle source

Return a random key from the keyspace. O(1). @see redis.io/commands/randomkey

# File lib/protocol/redis/methods/generic.rb, line 179
def randomkey
        call('RANDOMKEY')
end
rename(key, new_key) click to toggle source

Rename a key. O(1). @see redis.io/commands/rename @param key [Key] @param newkey [Key]

# File lib/protocol/redis/methods/generic.rb, line 187
def rename(key, new_key)
        call('RENAME', key, new_key)
end
renamenx(key, new_key) click to toggle source

Rename a key, only if the new key does not exist. O(1). @see redis.io/commands/renamenx @param key [Key] @param newkey [Key]

# File lib/protocol/redis/methods/generic.rb, line 195
def renamenx(key, new_key)
        call('RENAMENX', key, new_key)
end
restore(key, serialized_value, ttl=0) click to toggle source

Create a key using the provided serialized value, previously obtained using DUMP. O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)). @see redis.io/commands/restore @param key [Key] @param ttl [Integer] @param serialized-value [String] @param replace [Enum] @param absttl [Enum]

# File lib/protocol/redis/methods/generic.rb, line 206
def restore(key, serialized_value, ttl=0)
        call('RESTORE', key, ttl, serialized_value)
end
scan(cursor, match: nil, count: nil, type: nil) click to toggle source

Incrementally iterate the keys space. O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection. @see redis.io/commands/scan @param cursor [Integer]

# File lib/protocol/redis/methods/generic.rb, line 213
def scan(cursor, match: nil, count: nil, type: nil)
        arguments = [cursor]
        
        if match
                arguments.append("MATCH", match)
        end
        
        if count
                arguments.append("COUNT", count)
        end
        
        if type
                arguments.append("TYPE", type)
        end
        
        call("SCAN", *arguments)
end
sort(key, by: nil, offset: nil, count: nil, get: nil, order: 'ASC', alpha: false, store: nil) click to toggle source

Sort the elements in a list, set or sorted set. O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is currently O(N) as there is a copy step that will be avoided in next releases. @see redis.io/commands/sort @param key [Key] @param order [Enum] @param sorting [Enum]

# File lib/protocol/redis/methods/generic.rb, line 236
def sort(key, by: nil, offset: nil, count: nil, get: nil, order: 'ASC', alpha: false, store: nil)
        arguments = []
        
        if by
                arguments.append("BY", by)
        end
        
        if offset and count
                arguments.append("LIMIT", offset, count)
        end
        
        get&.each do |pattern|
                arguments.append("GET", pattern)
        end
        
        if order
                arguments.append(order)
        end
        
        if alpha
                arguments.append("ALPHA")
        end
        
        if store
                arguments.append("STORE", store)
        end
        
        call('SORT', *arguments)
end
touch(key, *keys) click to toggle source

Alters the last access time of a key(s). Returns the number of existing keys specified. O(N) where N is the number of keys that will be touched. @see redis.io/commands/touch @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 269
def touch(key, *keys)
        call('TOUCH', key, *keys)
end
ttl(key) click to toggle source

Get the time to live for a key. O(1). @see redis.io/commands/ttl @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 276
def ttl(key)
        call('TTL', key)
end
type(key) click to toggle source

Determine the type stored at key. O(1). @see redis.io/commands/type @param key [Key]

# File lib/protocol/redis/methods/generic.rb, line 283
def type(key)
        call('TYPE', key)
end
wait(newreplicas, timeout = 0) click to toggle source

Wait for the synchronous replication of all the write commands sent in the context of the current connection. O(1). @see redis.io/commands/wait @param numreplicas [Integer] @param timeout [Integer]

# File lib/protocol/redis/methods/generic.rb, line 298
def wait(newreplicas, timeout = 0)
        call("WAIT", numreplicas, timeout)
end