Class: Redis
- Inherits:
-
Object
- Object
- Redis
- Includes:
- MonitorMixin
- Defined in:
- lib/redis.rb,
lib/redis/client.rb,
lib/redis/errors.rb,
lib/redis/version.rb,
lib/redis/pipeline.rb,
lib/redis/hash_ring.rb,
lib/redis/subscribe.rb,
lib/redis/distributed.rb
Defined Under Namespace
Classes: BaseConnectionError, BaseError, CannotConnectError, Client, CommandError, ConnectionError, Distributed, Future, FutureNotReady, HashRing, InheritedError, Pipeline, ProtocolError, SubscribedClient, Subscription, TimeoutError
Constant Summary collapse
- VERSION =
"4.0.1"
Class Method Summary collapse
Instance Method Summary collapse
- #_bpop(cmd, args) ⇒ Object
- #_client ⇒ Object
- #_eval(cmd, args) ⇒ Object
- #_scan(command, cursor, args, options = {}, &block) ⇒ Object
-
#append(key, value) ⇒ Fixnum
Append a value to a key.
-
#auth(password) ⇒ String
Authenticate to the server.
-
#bgrewriteaof ⇒ String
Asynchronously rewrite the append-only file.
-
#bgsave ⇒ String
Asynchronously save the dataset to disk.
-
#bitcount(key, start = 0, stop = -1)) ⇒ Fixnum
Count the number of set bits in a range of the string value stored at key.
-
#bitop(operation, destkey, *keys) ⇒ Fixnum
Perform a bitwise operation between strings and store the resulting string in a key.
-
#bitpos(key, bit, start = nil, stop = nil) ⇒ Fixnum
Return the position of the first bit set to 1 or 0 in a string.
-
#blpop(*args) ⇒ nil, [String, String]
Remove and get the first element in a list, or block until one is available.
-
#brpop(*args) ⇒ nil, [String, String]
Remove and get the last element in a list, or block until one is available.
-
#brpoplpush(source, destination, options = {}) ⇒ nil, String
Pop a value from a list, push it to another list and return it; or block until one is available.
-
#call(*command) ⇒ Object
Sends a command to Redis and returns its reply.
-
#client(subcommand = nil, *args) ⇒ String, Hash
Manage client connections.
-
#close ⇒ Object
(also: #disconnect!)
Disconnect the client as quickly and silently as possible.
-
#commit ⇒ Object
Sends all commands in the queue.
-
#config(action, *args) ⇒ String, Hash
Get or set server configuration parameters.
-
#connected? ⇒ Boolean
Test whether or not the client is connected.
- #connection ⇒ Object
-
#dbsize ⇒ Fixnum
Return the number of keys in the selected database.
- #debug(*args) ⇒ Object
-
#decr(key) ⇒ Fixnum
Decrement the integer value of a key by one.
-
#decrby(key, decrement) ⇒ Fixnum
Decrement the integer value of a key by the given number.
-
#del(*keys) ⇒ Fixnum
Delete one or more keys.
-
#discard ⇒ String
Discard all commands issued after MULTI.
-
#dump(key) ⇒ String
Return a serialized version of the value stored at a key.
- #dup ⇒ Object
-
#echo(value) ⇒ String
Echo the given string.
-
#eval(*args) ⇒ Object
Evaluate Lua script.
-
#evalsha(*args) ⇒ Object
Evaluate Lua script by its SHA.
-
#exec ⇒ nil, Array<...>
Execute all commands issued after MULTI.
-
#exists(key) ⇒ Boolean
Determine if a key exists.
-
#expire(key, seconds) ⇒ Boolean
Set a key's time to live in seconds.
-
#expireat(key, unix_time) ⇒ Boolean
Set the expiration for a key as a UNIX timestamp.
-
#flushall(options = nil) ⇒ String
Remove all keys from all databases.
-
#flushdb(options = nil) ⇒ String
Remove all keys from the current database.
-
#get(key) ⇒ String
Get the value of a key.
-
#getbit(key, offset) ⇒ Fixnum
Returns the bit value at offset in the string value stored at key.
-
#getrange(key, start, stop) ⇒ Fixnum
Get a substring of the string stored at a key.
-
#getset(key, value) ⇒ String
Set the string value of a key and return its old value.
-
#hdel(key, field) ⇒ Fixnum
Delete one or more hash fields.
-
#hexists(key, field) ⇒ Boolean
Determine if a hash field exists.
-
#hget(key, field) ⇒ String
Get the value of a hash field.
-
#hgetall(key) ⇒ Hash<String, String>
Get all the fields and values in a hash.
-
#hincrby(key, field, increment) ⇒ Fixnum
Increment the integer value of a hash field by the given integer number.
-
#hincrbyfloat(key, field, increment) ⇒ Float
Increment the numeric value of a hash field by the given float number.
-
#hkeys(key) ⇒ Array<String>
Get all the fields in a hash.
-
#hlen(key) ⇒ Fixnum
Get the number of fields in a hash.
-
#hmget(key, *fields, &blk) ⇒ Array<String>
Get the values of all the given hash fields.
-
#hmset(key, *attrs) ⇒ String
Set one or more hash values.
-
#hscan(key, cursor, options = {}) ⇒ String, Array<[String, String]>
Scan a hash.
-
#hscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a hash.
-
#hset(key, field, value) ⇒ Boolean
Set the string value of a hash field.
-
#hsetnx(key, field, value) ⇒ Boolean
Set the value of a hash field, only if the field does not exist.
-
#hvals(key) ⇒ Array<String>
Get all the values in a hash.
- #id ⇒ Object
-
#incr(key) ⇒ Fixnum
Increment the integer value of a key by one.
-
#incrby(key, increment) ⇒ Fixnum
Increment the integer value of a key by the given integer number.
-
#incrbyfloat(key, increment) ⇒ Float
Increment the numeric value of a key by the given float number.
-
#info(cmd = nil) ⇒ Hash<String, String>
Get information and statistics about the server.
-
#initialize(options = {}) ⇒ Redis
constructor
Create a new client instance.
- #inspect ⇒ Object
-
#keys(pattern = "*") ⇒ Array<String>
Find all keys matching the given pattern.
-
#lastsave ⇒ Fixnum
Get the UNIX time stamp of the last successful save to disk.
-
#lindex(key, index) ⇒ String
Get an element from a list by its index.
-
#linsert(key, where, pivot, value) ⇒ Fixnum
Insert an element before or after another element in a list.
-
#llen(key) ⇒ Fixnum
Get the length of a list.
-
#lpop(key) ⇒ String
Remove and get the first element in a list.
-
#lpush(key, value) ⇒ Fixnum
Prepend one or more values to a list, creating the list if it doesn't exist.
-
#lpushx(key, value) ⇒ Fixnum
Prepend a value to a list, only if the list exists.
-
#lrange(key, start, stop) ⇒ Array<String>
Get a range of elements from a list.
-
#lrem(key, count, value) ⇒ Fixnum
Remove elements from a list.
-
#lset(key, index, value) ⇒ String
Set the value of an element in a list by its index.
-
#ltrim(key, start, stop) ⇒ String
Trim a list to the specified range.
-
#mapped_hmget(key, *fields) ⇒ Hash
Get the values of all the given hash fields.
-
#mapped_hmset(key, hash) ⇒ String
Set one or more hash values.
-
#mapped_mget(*keys) ⇒ Hash
Get the values of all the given keys.
-
#mapped_mset(hash) ⇒ String
Set one or more values.
-
#mapped_msetnx(hash) ⇒ Boolean
Set one or more values, only if none of the keys exist.
- #method_missing(command, *args) ⇒ Object
-
#mget(*keys, &blk) ⇒ Array<String>
Get the values of all the given keys.
-
#migrate(key, options) ⇒ String
Transfer a key from the connected instance to another instance.
-
#monitor {|line| ... } ⇒ Object
Listen for all requests received by the server in real time.
-
#move(key, db) ⇒ Boolean
Move a key to another database.
-
#mset(*args) ⇒ String
Set one or more values.
-
#msetnx(*args) ⇒ Boolean
Set one or more values, only if none of the keys exist.
-
#multi {|multi| ... } ⇒ String, Array<...>
Mark the start of a transaction block.
- #object(*args) ⇒ Object
-
#persist(key) ⇒ Boolean
Remove the expiration from a key.
-
#pexpire(key, milliseconds) ⇒ Boolean
Set a key's time to live in milliseconds.
-
#pexpireat(key, ms_unix_time) ⇒ Boolean
Set the expiration for a key as number of milliseconds from UNIX Epoch.
-
#pfadd(key, member) ⇒ Boolean
Add one or more members to a HyperLogLog structure.
-
#pfcount(*keys) ⇒ Fixnum
Get the approximate cardinality of members added to HyperLogLog structure.
-
#pfmerge(dest_key, *source_key) ⇒ Boolean
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.
-
#ping(message = nil) ⇒ String
Ping the server.
- #pipelined ⇒ Object
-
#psetex(key, ttl, value) ⇒ String
Set the time to live in milliseconds of a key.
-
#psubscribe(*channels, &block) ⇒ Object
Listen for messages published to channels matching the given patterns.
-
#psubscribe_with_timeout(timeout, *channels, &block) ⇒ Object
Listen for messages published to channels matching the given patterns.
-
#pttl(key) ⇒ Fixnum
Get the time to live (in milliseconds) for a key.
-
#publish(channel, message) ⇒ Object
Post a message to a channel.
-
#pubsub(subcommand, *args) ⇒ Object
Inspect the state of the Pub/Sub subsystem.
-
#punsubscribe(*channels) ⇒ Object
Stop listening for messages posted to channels matching the given patterns.
-
#queue(*command) ⇒ Object
Queues a command for pipelining.
-
#quit ⇒ String
Close the connection.
-
#randomkey ⇒ String
Return a random key from the keyspace.
-
#rename(old_name, new_name) ⇒ String
Rename a key.
-
#renamenx(old_name, new_name) ⇒ Boolean
Rename a key, only if the new key does not exist.
-
#restore(key, ttl, serialized_value, options = {}) ⇒ String
Create a key using the serialized value, previously obtained using DUMP.
-
#rpop(key) ⇒ String
Remove and get the last element in a list.
-
#rpoplpush(source, destination) ⇒ nil, String
Remove the last element in a list, append it to another list and return it.
-
#rpush(key, value) ⇒ Fixnum
Append one or more values to a list, creating the list if it doesn't exist.
-
#rpushx(key, value) ⇒ Fixnum
Append a value to a list, only if the list exists.
-
#sadd(key, member) ⇒ Boolean, Fixnum
Add one or more members to a set.
-
#save ⇒ String
Synchronously save the dataset to disk.
-
#scan(cursor, options = {}) ⇒ String+
Scan the keyspace.
-
#scan_each(options = {}, &block) ⇒ Enumerator
Scan the keyspace.
-
#scard(key) ⇒ Fixnum
Get the number of members in a set.
-
#script(subcommand, *args) ⇒ String, ...
Control remote script registry.
-
#sdiff(*keys) ⇒ Array<String>
Subtract multiple sets.
-
#sdiffstore(destination, *keys) ⇒ Fixnum
Subtract multiple sets and store the resulting set in a key.
-
#select(db) ⇒ String
Change the selected database for the current connection.
-
#sentinel(subcommand, *args) ⇒ Array<String>, ...
Interact with the sentinel command (masters, master, slaves, failover).
-
#set(key, value, options = {}) ⇒ String, Boolean
Set the string value of a key.
-
#setbit(key, offset, value) ⇒ Fixnum
Sets or clears the bit at offset in the string value stored at key.
-
#setex(key, ttl, value) ⇒ String
Set the time to live in seconds of a key.
-
#setnx(key, value) ⇒ Boolean
Set the value of a key, only if the key does not exist.
-
#setrange(key, offset, value) ⇒ Fixnum
Overwrite part of a string at key starting at the specified offset.
-
#shutdown ⇒ Object
Synchronously save the dataset to disk and then shut down the server.
-
#sinter(*keys) ⇒ Array<String>
Intersect multiple sets.
-
#sinterstore(destination, *keys) ⇒ Fixnum
Intersect multiple sets and store the resulting set in a key.
-
#sismember(key, member) ⇒ Boolean
Determine if a given value is a member of a set.
-
#slaveof(host, port) ⇒ Object
Make the server a slave of another instance, or promote it as master.
-
#slowlog(subcommand, length = nil) ⇒ Array<String>, ...
Interact with the slowlog (get, len, reset).
-
#smembers(key) ⇒ Array<String>
Get all the members in a set.
-
#smove(source, destination, member) ⇒ Boolean
Move a member from one set to another.
-
#sort(key, options = {}) ⇒ Array<String>, ...
Sort the elements in a list, set or sorted set.
-
#spop(key, count = nil) ⇒ String
Remove and return one or more random member from a set.
-
#srandmember(key, count = nil) ⇒ String
Get one or more random members from a set.
-
#srem(key, member) ⇒ Boolean, Fixnum
Remove one or more members from a set.
-
#sscan(key, cursor, options = {}) ⇒ String+
Scan a set.
-
#sscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a set.
-
#strlen(key) ⇒ Fixnum
Get the length of the value stored in a key.
-
#subscribe(*channels, &block) ⇒ Object
Listen for messages published to the given channels.
-
#subscribe_with_timeout(timeout, *channels, &block) ⇒ Object
Listen for messages published to the given channels.
- #subscribed? ⇒ Boolean
-
#sunion(*keys) ⇒ Array<String>
Add multiple sets.
-
#sunionstore(destination, *keys) ⇒ Fixnum
Add multiple sets and store the resulting set in a key.
-
#sync ⇒ Object
Internal command used for replication.
- #synchronize ⇒ Object
-
#time ⇒ Array<Fixnum>
Return the server time.
-
#ttl(key) ⇒ Fixnum
Get the time to live (in seconds) for a key.
-
#type(key) ⇒ String
Determine the type stored at key.
-
#unsubscribe(*channels) ⇒ Object
Stop listening for messages posted to the given channels.
-
#unwatch ⇒ String
Forget about all watched keys.
-
#watch(*keys) ⇒ Object, String
Watch the given keys to determine execution of the MULTI/EXEC block.
-
#with_reconnect(val = true, &blk) ⇒ Object
Run code with the client reconnecting.
-
#without_reconnect(&blk) ⇒ Object
Run code without the client reconnecting.
-
#zadd(key, *args) ⇒ Boolean, ...
Add one or more members to a sorted set, or update the score for members that already exist.
-
#zcard(key) ⇒ Fixnum
Get the number of members in a sorted set.
-
#zcount(key, min, max) ⇒ Fixnum
Count the members in a sorted set with scores within the given values.
-
#zincrby(key, increment, member) ⇒ Float
Increment the score of a member in a sorted set.
-
#zinterstore(destination, keys, options = {}) ⇒ Fixnum
Intersect multiple sorted sets and store the resulting sorted set in a new key.
-
#zlexcount(key, min, max) ⇒ Fixnum
Count the members, with the same score in a sorted set, within the given lexicographical range.
-
#zrange(key, start, stop, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members in a sorted set, by index.
-
#zrangebylex(key, min, max, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members with the same score in a sorted set, by lexicographical ordering.
-
#zrangebyscore(key, min, max, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members in a sorted set, by score.
-
#zrank(key, member) ⇒ Fixnum
Determine the index of a member in a sorted set.
-
#zrem(key, member) ⇒ Boolean, Fixnum
Remove one or more members from a sorted set.
-
#zremrangebyrank(key, start, stop) ⇒ Fixnum
Remove all members in a sorted set within the given indexes.
-
#zremrangebyscore(key, min, max) ⇒ Fixnum
Remove all members in a sorted set within the given scores.
-
#zrevrange(key, start, stop, options = {}) ⇒ Object
Return a range of members in a sorted set, by index, with scores ordered from high to low.
-
#zrevrangebylex(key, max, min, options = {}) ⇒ Object
Return a range of members with the same score in a sorted set, by reversed lexicographical ordering.
-
#zrevrangebyscore(key, max, min, options = {}) ⇒ Object
Return a range of members in a sorted set, by score, with scores ordered from high to low.
-
#zrevrank(key, member) ⇒ Fixnum
Determine the index of a member in a sorted set, with scores ordered from high to low.
-
#zscan(key, cursor, options = {}) ⇒ String, Array<[String, Float]>
Scan a sorted set.
-
#zscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a sorted set.
-
#zscore(key, member) ⇒ Float
Get the score associated with the given member in a sorted set.
-
#zunionstore(destination, keys, options = {}) ⇒ Fixnum
Add multiple sorted sets and store the resulting sorted set in a new key.
Constructor Details
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(command, *args) ⇒ Object
2762 2763 2764 2765 2766 |
# File 'lib/redis.rb', line 2762 def method_missing(command, *args) synchronize do |client| client.call([command] + args) end end |
Class Method Details
.current=(redis) ⇒ Object
10 11 12 |
# File 'lib/redis.rb', line 10 def self.current=(redis) @current = redis end |
Instance Method Details
#_bpop(cmd, args) ⇒ Object
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 |
# File 'lib/redis.rb', line 1141 def _bpop(cmd, args) = {} case args.last when Hash = args.pop when Integer # Issue deprecation notice in obnoxious mode... [:timeout] = args.pop end if args.size > 1 # Issue deprecation notice in obnoxious mode... end keys = args.flatten timeout = [:timeout] || 0 synchronize do |client| command = [cmd, keys, timeout] timeout += client.timeout if timeout > 0 client.call_with_timeout(command, timeout) end end |
#_client ⇒ Object
109 110 111 |
# File 'lib/redis.rb', line 109 def _client @client end |
#_eval(cmd, args) ⇒ Object
2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 |
# File 'lib/redis.rb', line 2439 def _eval(cmd, args) script = args.shift = args.pop if args.last.is_a?(Hash) ||= {} keys = args.shift || [:keys] || [] argv = args.shift || [:argv] || [] synchronize do |client| client.call([cmd, script, keys.length] + keys + argv) end end |
#_scan(command, cursor, args, options = {}, &block) ⇒ Object
2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 |
# File 'lib/redis.rb', line 2502 def _scan(command, cursor, args, = {}, &block) # SSCAN/ZSCAN/HSCAN already prepend the key to +args+. args << cursor if match = [:match] args.concat(["MATCH", match]) end if count = [:count] args.concat(["COUNT", count]) end synchronize do |client| client.call([command] + args, &block) end end |
#append(key, value) ⇒ Fixnum
Append a value to a key.
982 983 984 985 986 |
# File 'lib/redis.rb', line 982 def append(key, value) synchronize do |client| client.call([:append, key, value]) end end |
#auth(password) ⇒ String
Authenticate to the server.
118 119 120 121 122 |
# File 'lib/redis.rb', line 118 def auth(password) synchronize do |client| client.call([:auth, password]) end end |
#bgrewriteaof ⇒ String
Asynchronously rewrite the append-only file.
172 173 174 175 176 |
# File 'lib/redis.rb', line 172 def bgrewriteaof synchronize do |client| client.call([:bgrewriteaof]) end end |
#bgsave ⇒ String
Asynchronously save the dataset to disk.
181 182 183 184 185 |
# File 'lib/redis.rb', line 181 def bgsave synchronize do |client| client.call([:bgsave]) end end |
#bitcount(key, start = 0, stop = -1)) ⇒ Fixnum
Count the number of set bits in a range of the string value stored at key.
994 995 996 997 998 |
# File 'lib/redis.rb', line 994 def bitcount(key, start = 0, stop = -1) synchronize do |client| client.call([:bitcount, key, start, stop]) end end |
#bitop(operation, destkey, *keys) ⇒ Fixnum
Perform a bitwise operation between strings and store the resulting string in a key.
1006 1007 1008 1009 1010 |
# File 'lib/redis.rb', line 1006 def bitop(operation, destkey, *keys) synchronize do |client| client.call([:bitop, operation, destkey] + keys) end end |
#bitpos(key, bit, start = nil, stop = nil) ⇒ Fixnum
Return the position of the first bit set to 1 or 0 in a string.
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 |
# File 'lib/redis.rb', line 1020 def bitpos(key, bit, start=nil, stop=nil) if stop and not start raise(ArgumentError, 'stop parameter specified without start parameter') end synchronize do |client| command = [:bitpos, key, bit] command << start if start command << stop if stop client.call(command) end end |
#blpop(*args) ⇒ nil, [String, String]
Remove and get the first element in a list, or block until one is available.
1187 1188 1189 |
# File 'lib/redis.rb', line 1187 def blpop(*args) _bpop(:blpop, args) end |
#brpop(*args) ⇒ nil, [String, String]
Remove and get the last element in a list, or block until one is available.
1203 1204 1205 |
# File 'lib/redis.rb', line 1203 def brpop(*args) _bpop(:brpop, args) end |
#brpoplpush(source, destination, options = {}) ⇒ nil, String
Pop a value from a list, push it to another list and return it; or block until one is available.
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 |
# File 'lib/redis.rb', line 1218 def brpoplpush(source, destination, = {}) case when Integer # Issue deprecation notice in obnoxious mode... = { :timeout => } end timeout = [:timeout] || 0 synchronize do |client| command = [:brpoplpush, source, destination, timeout] timeout += client.timeout if timeout > 0 client.call_with_timeout(command, timeout) end end |
#call(*command) ⇒ Object
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.
79 80 81 82 83 |
# File 'lib/redis.rb', line 79 def call(*command) synchronize do |client| client.call(command) end end |
#client(subcommand = nil, *args) ⇒ String, Hash
Manage client connections.
208 209 210 211 212 213 214 215 216 217 218 219 220 221 |
# File 'lib/redis.rb', line 208 def client(subcommand = nil, *args) synchronize do |client| client.call([:client, subcommand] + args) do |reply| if subcommand.to_s == "list" reply.lines.map do |line| entries = line.chomp.split(/[ =]/) Hash[entries.each_slice(2).to_a] end else reply end end end end |
#close ⇒ Object Also known as: disconnect!
Disconnect the client as quickly and silently as possible.
66 67 68 |
# File 'lib/redis.rb', line 66 def close @original_client.disconnect end |
#commit ⇒ Object
Sends all commands in the queue.
See http://redis.io/topics/pipelining for more details.
99 100 101 102 103 104 105 106 107 |
# File 'lib/redis.rb', line 99 def commit synchronize do |client| begin client.call_pipelined(@queue[Thread.current.object_id]) ensure @queue.delete(Thread.current.object_id) end end end |
#config(action, *args) ⇒ String, Hash
Get or set server configuration parameters.
192 193 194 195 196 197 198 199 200 201 202 |
# File 'lib/redis.rb', line 192 def config(action, *args) synchronize do |client| client.call([:config, action] + args) do |reply| if reply.kind_of?(Array) && action == :get Hashify.call(reply) else reply end end end end |
#connected? ⇒ Boolean
Test whether or not the client is connected
61 62 63 |
# File 'lib/redis.rb', line 61 def connected? @original_client.connected? end |
#connection ⇒ Object
2752 2753 2754 2755 2756 2757 2758 2759 2760 |
# File 'lib/redis.rb', line 2752 def connection { host: @original_client.host, port: @original_client.port, db: @original_client.db, id: @original_client.id, location: @original_client.location } end |
#dbsize ⇒ Fixnum
Return the number of keys in the selected database.
226 227 228 229 230 |
# File 'lib/redis.rb', line 226 def dbsize synchronize do |client| client.call([:dbsize]) end end |
#debug(*args) ⇒ Object
232 233 234 235 236 |
# File 'lib/redis.rb', line 232 def debug(*args) synchronize do |client| client.call([:debug] + args) end end |
#decr(key) ⇒ Fixnum
Decrement the integer value of a key by one.
689 690 691 692 693 |
# File 'lib/redis.rb', line 689 def decr(key) synchronize do |client| client.call([:decr, key]) end end |
#decrby(key, decrement) ⇒ Fixnum
Decrement the integer value of a key by the given number.
704 705 706 707 708 |
# File 'lib/redis.rb', line 704 def decrby(key, decrement) synchronize do |client| client.call([:decrby, key, decrement]) end end |
#del(*keys) ⇒ Fixnum
Delete one or more keys.
521 522 523 524 525 |
# File 'lib/redis.rb', line 521 def del(*keys) synchronize do |client| client.call([:del] + keys) end end |
#discard ⇒ String
Discard all commands issued after MULTI.
Only call this method when #multi
was called without a block.
2385 2386 2387 2388 2389 |
# File 'lib/redis.rb', line 2385 def discard synchronize do |client| client.call([:discard]) end end |
#dump(key) ⇒ String
Return a serialized version of the value stored at a key.
473 474 475 476 477 |
# File 'lib/redis.rb', line 473 def dump(key) synchronize do |client| client.call([:dump, key]) end end |
#dup ⇒ Object
2748 2749 2750 |
# File 'lib/redis.rb', line 2748 def dup self.class.new(@options) end |
#echo(value) ⇒ String
Echo the given string.
149 150 151 152 153 |
# File 'lib/redis.rb', line 149 def echo(value) synchronize do |client| client.call([:echo, value]) end end |
#eval(*args) ⇒ Object
Evaluate Lua script.
2473 2474 2475 |
# File 'lib/redis.rb', line 2473 def eval(*args) _eval(:eval, args) end |
#evalsha(*args) ⇒ Object
Evaluate Lua script by its SHA.
2498 2499 2500 |
# File 'lib/redis.rb', line 2498 def evalsha(*args) _eval(:evalsha, args) end |
#exec ⇒ nil, Array<...>
Execute all commands issued after MULTI.
Only call this method when #multi
was called without a block.
2371 2372 2373 2374 2375 |
# File 'lib/redis.rb', line 2371 def exec synchronize do |client| client.call([:exec]) end end |
#exists(key) ⇒ Boolean
Determine if a key exists.
531 532 533 534 535 |
# File 'lib/redis.rb', line 531 def exists(key) synchronize do |client| client.call([:exists, key], &Boolify) end end |
#expire(key, seconds) ⇒ Boolean
Set a key's time to live in seconds.
395 396 397 398 399 |
# File 'lib/redis.rb', line 395 def expire(key, seconds) synchronize do |client| client.call([:expire, key, seconds], &Boolify) end end |
#expireat(key, unix_time) ⇒ Boolean
Set the expiration for a key as a UNIX timestamp.
406 407 408 409 410 |
# File 'lib/redis.rb', line 406 def expireat(key, unix_time) synchronize do |client| client.call([:expireat, key, unix_time], &Boolify) end end |
#flushall(options = nil) ⇒ String
Remove all keys from all databases.
243 244 245 246 247 248 249 250 251 |
# File 'lib/redis.rb', line 243 def flushall( = nil) synchronize do |client| if && [:async] client.call([:flushall, :async]) else client.call([:flushall]) end end end |
#flushdb(options = nil) ⇒ String
Remove all keys from the current database.
258 259 260 261 262 263 264 265 266 |
# File 'lib/redis.rb', line 258 def flushdb( = nil) synchronize do |client| if && [:async] client.call([:flushdb, :async]) else client.call([:flushdb]) end end end |
#get(key) ⇒ String
Get the value of a key.
887 888 889 890 891 |
# File 'lib/redis.rb', line 887 def get(key) synchronize do |client| client.call([:get, key]) end end |
#getbit(key, offset) ⇒ Fixnum
Returns the bit value at offset in the string value stored at key.
971 972 973 974 975 |
# File 'lib/redis.rb', line 971 def getbit(key, offset) synchronize do |client| client.call([:getbit, key, offset]) end end |
#getrange(key, start, stop) ⇒ Fixnum
Get a substring of the string stored at a key.
948 949 950 951 952 |
# File 'lib/redis.rb', line 948 def getrange(key, start, stop) synchronize do |client| client.call([:getrange, key, start, stop]) end end |
#getset(key, value) ⇒ String
Set the string value of a key and return its old value.
1039 1040 1041 1042 1043 |
# File 'lib/redis.rb', line 1039 def getset(key, value) synchronize do |client| client.call([:getset, key, value.to_s]) end end |
#hdel(key, field) ⇒ Fixnum
Delete one or more hash fields.
2105 2106 2107 2108 2109 |
# File 'lib/redis.rb', line 2105 def hdel(key, field) synchronize do |client| client.call([:hdel, key, field]) end end |
#hexists(key, field) ⇒ Boolean
Determine if a hash field exists.
2116 2117 2118 2119 2120 |
# File 'lib/redis.rb', line 2116 def hexists(key, field) synchronize do |client| client.call([:hexists, key, field], &Boolify) end end |
#hget(key, field) ⇒ String
Get the value of a hash field.
2056 2057 2058 2059 2060 |
# File 'lib/redis.rb', line 2056 def hget(key, field) synchronize do |client| client.call([:hget, key, field]) end end |
#hgetall(key) ⇒ Hash<String, String>
Get all the fields and values in a hash.
2170 2171 2172 2173 2174 |
# File 'lib/redis.rb', line 2170 def hgetall(key) synchronize do |client| client.call([:hgetall, key], &Hashify) end end |
#hincrby(key, field, increment) ⇒ Fixnum
Increment the integer value of a hash field by the given integer number.
2128 2129 2130 2131 2132 |
# File 'lib/redis.rb', line 2128 def hincrby(key, field, increment) synchronize do |client| client.call([:hincrby, key, field, increment]) end end |
#hincrbyfloat(key, field, increment) ⇒ Float
Increment the numeric value of a hash field by the given float number.
2140 2141 2142 2143 2144 |
# File 'lib/redis.rb', line 2140 def hincrbyfloat(key, field, increment) synchronize do |client| client.call([:hincrbyfloat, key, field, increment], &Floatify) end end |
#hkeys(key) ⇒ Array<String>
Get all the fields in a hash.
2150 2151 2152 2153 2154 |
# File 'lib/redis.rb', line 2150 def hkeys(key) synchronize do |client| client.call([:hkeys, key]) end end |
#hlen(key) ⇒ Fixnum
Get the number of fields in a hash.
1989 1990 1991 1992 1993 |
# File 'lib/redis.rb', line 1989 def hlen(key) synchronize do |client| client.call([:hlen, key]) end end |
#hmget(key, *fields, &blk) ⇒ Array<String>
Get the values of all the given hash fields.
2073 2074 2075 2076 2077 |
# File 'lib/redis.rb', line 2073 def hmget(key, *fields, &blk) synchronize do |client| client.call([:hmget, key] + fields, &blk) end end |
#hmset(key, *attrs) ⇒ String
Set one or more hash values.
2030 2031 2032 2033 2034 |
# File 'lib/redis.rb', line 2030 def hmset(key, *attrs) synchronize do |client| client.call([:hmset, key] + attrs) end end |
#hscan(key, cursor, options = {}) ⇒ String, Array<[String, String]>
Scan a hash
2575 2576 2577 2578 2579 |
# File 'lib/redis.rb', line 2575 def hscan(key, cursor, ={}) _scan(:hscan, cursor, [key], ) do |reply| [reply[0], reply[1].each_slice(2).to_a] end end |
#hscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a hash
2592 2593 2594 2595 2596 2597 2598 2599 2600 |
# File 'lib/redis.rb', line 2592 def hscan_each(key, ={}, &block) return to_enum(:hscan_each, key, ) unless block_given? cursor = 0 loop do cursor, values = hscan(key, cursor, ) values.each(&block) break if cursor == "0" end end |
#hset(key, field, value) ⇒ Boolean
Set the string value of a hash field.
2001 2002 2003 2004 2005 |
# File 'lib/redis.rb', line 2001 def hset(key, field, value) synchronize do |client| client.call([:hset, key, field, value], &Boolify) end end |
#hsetnx(key, field, value) ⇒ Boolean
Set the value of a hash field, only if the field does not exist.
2013 2014 2015 2016 2017 |
# File 'lib/redis.rb', line 2013 def hsetnx(key, field, value) synchronize do |client| client.call([:hsetnx, key, field, value], &Boolify) end end |
#hvals(key) ⇒ Array<String>
Get all the values in a hash.
2160 2161 2162 2163 2164 |
# File 'lib/redis.rb', line 2160 def hvals(key) synchronize do |client| client.call([:hvals, key]) end end |
#id ⇒ Object
2740 2741 2742 |
# File 'lib/redis.rb', line 2740 def id @original_client.id end |
#incr(key) ⇒ Fixnum
Increment the integer value of a key by one.
718 719 720 721 722 |
# File 'lib/redis.rb', line 718 def incr(key) synchronize do |client| client.call([:incr, key]) end end |
#incrby(key, increment) ⇒ Fixnum
Increment the integer value of a key by the given integer number.
733 734 735 736 737 |
# File 'lib/redis.rb', line 733 def incrby(key, increment) synchronize do |client| client.call([:incrby, key, increment]) end end |
#incrbyfloat(key, increment) ⇒ Float
Increment the numeric value of a key by the given float number.
748 749 750 751 752 |
# File 'lib/redis.rb', line 748 def incrbyfloat(key, increment) synchronize do |client| client.call([:incrbyfloat, key, increment], &Floatify) end end |
#info(cmd = nil) ⇒ Hash<String, String>
Get information and statistics about the server.
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 |
# File 'lib/redis.rb', line 272 def info(cmd = nil) synchronize do |client| client.call([:info, cmd].compact) do |reply| if reply.kind_of?(String) reply = Hash[reply.split("\r\n").map do |line| line.split(":", 2) unless line =~ /^(#|$)/ end.compact] if cmd && cmd.to_s == "commandstats" # Extract nested hashes for INFO COMMANDSTATS reply = Hash[reply.map do |k, v| v = v.split(",").map { |e| e.split("=") } [k[/^cmdstat_(.*)$/, 1], Hash[v]] end] end end reply end end end |
#inspect ⇒ Object
2744 2745 2746 |
# File 'lib/redis.rb', line 2744 def inspect "#<Redis client v#{Redis::VERSION} for #{id}>" end |
#keys(pattern = "*") ⇒ Array<String>
Find all keys matching the given pattern.
541 542 543 544 545 546 547 548 549 550 551 |
# File 'lib/redis.rb', line 541 def keys(pattern = "*") synchronize do |client| client.call([:keys, pattern]) do |reply| if reply.kind_of?(String) reply.split(" ") else reply end end end end |
#lastsave ⇒ Fixnum
Get the UNIX time stamp of the last successful save to disk.
297 298 299 300 301 |
# File 'lib/redis.rb', line 297 def lastsave synchronize do |client| client.call([:lastsave]) end end |
#lindex(key, index) ⇒ String
Get an element from a list by its index.
1239 1240 1241 1242 1243 |
# File 'lib/redis.rb', line 1239 def lindex(key, index) synchronize do |client| client.call([:lindex, key, index]) end end |
#linsert(key, where, pivot, value) ⇒ Fixnum
Insert an element before or after another element in a list.
1253 1254 1255 1256 1257 |
# File 'lib/redis.rb', line 1253 def linsert(key, where, pivot, value) synchronize do |client| client.call([:linsert, key, where, pivot, value]) end end |
#llen(key) ⇒ Fixnum
Get the length of a list.
1060 1061 1062 1063 1064 |
# File 'lib/redis.rb', line 1060 def llen(key) synchronize do |client| client.call([:llen, key]) end end |
#lpop(key) ⇒ String
Remove and get the first element in a list.
1114 1115 1116 1117 1118 |
# File 'lib/redis.rb', line 1114 def lpop(key) synchronize do |client| client.call([:lpop, key]) end end |
#lpush(key, value) ⇒ Fixnum
Prepend one or more values to a list, creating the list if it doesn't exist
1071 1072 1073 1074 1075 |
# File 'lib/redis.rb', line 1071 def lpush(key, value) synchronize do |client| client.call([:lpush, key, value]) end end |
#lpushx(key, value) ⇒ Fixnum
Prepend a value to a list, only if the list exists.
1082 1083 1084 1085 1086 |
# File 'lib/redis.rb', line 1082 def lpushx(key, value) synchronize do |client| client.call([:lpushx, key, value]) end end |
#lrange(key, start, stop) ⇒ Array<String>
Get a range of elements from a list.
1265 1266 1267 1268 1269 |
# File 'lib/redis.rb', line 1265 def lrange(key, start, stop) synchronize do |client| client.call([:lrange, key, start, stop]) end end |
#lrem(key, count, value) ⇒ Fixnum
Remove elements from a list.
1280 1281 1282 1283 1284 |
# File 'lib/redis.rb', line 1280 def lrem(key, count, value) synchronize do |client| client.call([:lrem, key, count, value]) end end |
#lset(key, index, value) ⇒ String
Set the value of an element in a list by its index.
1292 1293 1294 1295 1296 |
# File 'lib/redis.rb', line 1292 def lset(key, index, value) synchronize do |client| client.call([:lset, key, index, value]) end end |
#ltrim(key, start, stop) ⇒ String
Trim a list to the specified range.
1304 1305 1306 1307 1308 |
# File 'lib/redis.rb', line 1304 def ltrim(key, start, stop) synchronize do |client| client.call([:ltrim, key, start, stop]) end end |
#mapped_hmget(key, *fields) ⇒ Hash
Get the values of all the given hash fields.
2090 2091 2092 2093 2094 2095 2096 2097 2098 |
# File 'lib/redis.rb', line 2090 def mapped_hmget(key, *fields) hmget(key, *fields) do |reply| if reply.kind_of?(Array) Hash[fields.zip(reply)] else reply end end end |
#mapped_hmset(key, hash) ⇒ String
Set one or more hash values.
2047 2048 2049 |
# File 'lib/redis.rb', line 2047 def mapped_hmset(key, hash) hmset(key, hash.to_a.flatten) end |
#mapped_mget(*keys) ⇒ Hash
Get the values of all the given keys.
919 920 921 922 923 924 925 926 927 |
# File 'lib/redis.rb', line 919 def mapped_mget(*keys) mget(*keys) do |reply| if reply.kind_of?(Array) Hash[keys.zip(reply)] else reply end end end |
#mapped_mset(hash) ⇒ String
Set one or more values.
849 850 851 |
# File 'lib/redis.rb', line 849 def mapped_mset(hash) mset(hash.to_a.flatten) end |
#mapped_msetnx(hash) ⇒ Boolean
Set one or more values, only if none of the keys exist.
879 880 881 |
# File 'lib/redis.rb', line 879 def mapped_msetnx(hash) msetnx(hash.to_a.flatten) end |
#mget(*keys, &blk) ⇒ Array<String>
Get the values of all the given keys.
903 904 905 906 907 |
# File 'lib/redis.rb', line 903 def mget(*keys, &blk) synchronize do |client| client.call([:mget] + keys, &blk) end end |
#migrate(key, options) ⇒ String
Transfer a key from the connected instance to another instance.
506 507 508 509 510 511 512 513 514 515 |
# File 'lib/redis.rb', line 506 def migrate(key, ) host = [:host] || raise(RuntimeError, ":host not specified") port = [:port] || raise(RuntimeError, ":port not specified") db = ([:db] || @client.db).to_i timeout = ([:timeout] || @client.timeout).to_i synchronize do |client| client.call([:migrate, host, port, key, db, timeout]) end end |
#monitor {|line| ... } ⇒ Object
Listen for all requests received by the server in real time.
There is no way to interrupt this command.
309 310 311 312 313 |
# File 'lib/redis.rb', line 309 def monitor(&block) synchronize do |client| client.call_loop([:monitor], &block) end end |
#move(key, db) ⇒ Boolean
Move a key to another database.
572 573 574 575 576 |
# File 'lib/redis.rb', line 572 def move(key, db) synchronize do |client| client.call([:move, key, db], &Boolify) end end |
#mset(*args) ⇒ String
Set one or more values.
833 834 835 836 837 |
# File 'lib/redis.rb', line 833 def mset(*args) synchronize do |client| client.call([:mset] + args) end end |
#msetnx(*args) ⇒ Boolean
Set one or more values, only if none of the keys exist.
863 864 865 866 867 |
# File 'lib/redis.rb', line 863 def msetnx(*args) synchronize do |client| client.call([:msetnx] + args, &Boolify) end end |
#multi {|multi| ... } ⇒ String, Array<...>
Mark the start of a transaction block.
Passing a block is optional.
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 |
# File 'lib/redis.rb', line 2344 def multi synchronize do |client| if !block_given? client.call([:multi]) else begin pipeline = Pipeline::Multi.new original, @client = @client, pipeline yield(self) original.call_pipeline(pipeline) ensure @client = original end end end end |
#object(*args) ⇒ Object
578 579 580 581 582 |
# File 'lib/redis.rb', line 578 def object(*args) synchronize do |client| client.call([:object] + args) end end |
#persist(key) ⇒ Boolean
Remove the expiration from a key.
384 385 386 387 388 |
# File 'lib/redis.rb', line 384 def persist(key) synchronize do |client| client.call([:persist, key], &Boolify) end end |
#pexpire(key, milliseconds) ⇒ Boolean
Set a key's time to live in milliseconds.
435 436 437 438 439 |
# File 'lib/redis.rb', line 435 def pexpire(key, milliseconds) synchronize do |client| client.call([:pexpire, key, milliseconds], &Boolify) end end |
#pexpireat(key, ms_unix_time) ⇒ Boolean
Set the expiration for a key as number of milliseconds from UNIX Epoch.
446 447 448 449 450 |
# File 'lib/redis.rb', line 446 def pexpireat(key, ms_unix_time) synchronize do |client| client.call([:pexpireat, key, ms_unix_time], &Boolify) end end |
#pfadd(key, member) ⇒ Boolean
Add one or more members to a HyperLogLog structure.
2682 2683 2684 2685 2686 |
# File 'lib/redis.rb', line 2682 def pfadd(key, member) synchronize do |client| client.call([:pfadd, key, member], &Boolify) end end |
#pfcount(*keys) ⇒ Fixnum
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.
2695 2696 2697 2698 2699 |
# File 'lib/redis.rb', line 2695 def pfcount(*keys) synchronize do |client| client.call([:pfcount] + keys) end end |
#pfmerge(dest_key, *source_key) ⇒ Boolean
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.
2707 2708 2709 2710 2711 |
# File 'lib/redis.rb', line 2707 def pfmerge(dest_key, *source_key) synchronize do |client| client.call([:pfmerge, dest_key, *source_key], &BoolifySet) end end |
#ping(message = nil) ⇒ String
Ping the server.
139 140 141 142 143 |
# File 'lib/redis.rb', line 139 def ping( = nil) synchronize do |client| client.call([:ping, ].compact) end end |
#pipelined ⇒ Object
2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 |
# File 'lib/redis.rb', line 2302 def pipelined synchronize do |client| begin original, @client = @client, Pipeline.new yield(self) original.call_pipeline(@client) ensure @client = original end end end |
#psetex(key, ttl, value) ⇒ String
Set the time to live in milliseconds of a key.
806 807 808 809 810 |
# File 'lib/redis.rb', line 806 def psetex(key, ttl, value) synchronize do |client| client.call([:psetex, key, ttl, value.to_s]) end end |
#psubscribe(*channels, &block) ⇒ Object
Listen for messages published to channels matching the given patterns.
2212 2213 2214 2215 2216 |
# File 'lib/redis.rb', line 2212 def psubscribe(*channels, &block) synchronize do |client| _subscription(:psubscribe, 0, channels, block) end end |
#psubscribe_with_timeout(timeout, *channels, &block) ⇒ Object
Listen for messages published to channels matching the given patterns. Throw a timeout error if there is no messages for a timeout period.
2219 2220 2221 2222 2223 |
# File 'lib/redis.rb', line 2219 def psubscribe_with_timeout(timeout, *channels, &block) synchronize do |client| _subscription(:psubscribe_with_timeout, timeout, channels, block) end end |
#pttl(key) ⇒ Fixnum
Get the time to live (in milliseconds) for a key.
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.
463 464 465 466 467 |
# File 'lib/redis.rb', line 463 def pttl(key) synchronize do |client| client.call([:pttl, key]) end end |
#publish(channel, message) ⇒ Object
Post a message to a channel.
2177 2178 2179 2180 2181 |
# File 'lib/redis.rb', line 2177 def publish(channel, ) synchronize do |client| client.call([:publish, channel, ]) end end |
#pubsub(subcommand, *args) ⇒ Object
Inspect the state of the Pub/Sub subsystem. Possible subcommands: channels, numsub, numpat.
2235 2236 2237 2238 2239 |
# File 'lib/redis.rb', line 2235 def pubsub(subcommand, *args) synchronize do |client| client.call([:pubsub, subcommand] + args) end end |
#punsubscribe(*channels) ⇒ Object
Stop listening for messages posted to channels matching the given patterns.
2226 2227 2228 2229 2230 2231 |
# File 'lib/redis.rb', line 2226 def punsubscribe(*channels) synchronize do |client| raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed? client.punsubscribe(*channels) end end |
#queue(*command) ⇒ Object
Queues a command for pipelining.
Commands in the queue are executed with the Redis#commit method.
See http://redis.io/topics/pipelining for more details.
91 92 93 |
# File 'lib/redis.rb', line 91 def queue(*command) @queue[Thread.current.object_id] << command end |
#quit ⇒ String
Close the connection.
158 159 160 161 162 163 164 165 166 167 |
# File 'lib/redis.rb', line 158 def quit synchronize do |client| begin client.call([:quit]) rescue ConnectionError ensure client.disconnect end end end |
#randomkey ⇒ String
Return a random key from the keyspace.
587 588 589 590 591 |
# File 'lib/redis.rb', line 587 def randomkey synchronize do |client| client.call([:randomkey]) end end |
#rename(old_name, new_name) ⇒ String
Rename a key. If the new key already exists it is overwritten.
598 599 600 601 602 |
# File 'lib/redis.rb', line 598 def rename(old_name, new_name) synchronize do |client| client.call([:rename, old_name, new_name]) end end |
#renamenx(old_name, new_name) ⇒ Boolean
Rename a key, only if the new key does not exist.
609 610 611 612 613 |
# File 'lib/redis.rb', line 609 def renamenx(old_name, new_name) synchronize do |client| client.call([:renamenx, old_name, new_name], &Boolify) end end |
#restore(key, ttl, serialized_value, options = {}) ⇒ String
Create a key using the serialized value, previously obtained using DUMP.
488 489 490 491 492 493 494 495 |
# File 'lib/redis.rb', line 488 def restore(key, ttl, serialized_value, = {}) args = [:restore, key, ttl, serialized_value] args << 'REPLACE' if [:replace] synchronize do |client| client.call(args) end end |
#rpop(key) ⇒ String
Remove and get the last element in a list.
1124 1125 1126 1127 1128 |
# File 'lib/redis.rb', line 1124 def rpop(key) synchronize do |client| client.call([:rpop, key]) end end |
#rpoplpush(source, destination) ⇒ nil, String
Remove the last element in a list, append it to another list and return it.
1135 1136 1137 1138 1139 |
# File 'lib/redis.rb', line 1135 def rpoplpush(source, destination) synchronize do |client| client.call([:rpoplpush, source, destination]) end end |
#rpush(key, value) ⇒ Fixnum
Append one or more values to a list, creating the list if it doesn't exist
1093 1094 1095 1096 1097 |
# File 'lib/redis.rb', line 1093 def rpush(key, value) synchronize do |client| client.call([:rpush, key, value]) end end |
#rpushx(key, value) ⇒ Fixnum
Append a value to a list, only if the list exists.
1104 1105 1106 1107 1108 |
# File 'lib/redis.rb', line 1104 def rpushx(key, value) synchronize do |client| client.call([:rpushx, key, value]) end end |
#sadd(key, member) ⇒ Boolean, Fixnum
Add one or more members to a set.
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 |
# File 'lib/redis.rb', line 1328 def sadd(key, member) synchronize do |client| client.call([:sadd, key, member]) do |reply| if member.is_a? Array # Variadic: return integer reply else # Single argument: return boolean Boolify.call(reply) end end end end |
#save ⇒ String
Synchronously save the dataset to disk.
318 319 320 321 322 |
# File 'lib/redis.rb', line 318 def save synchronize do |client| client.call([:save]) end end |
#scan(cursor, options = {}) ⇒ String+
Scan the keyspace
2535 2536 2537 |
# File 'lib/redis.rb', line 2535 def scan(cursor, ={}) _scan(:scan, cursor, [], ) end |
#scan_each(options = {}, &block) ⇒ Enumerator
Scan the keyspace
2554 2555 2556 2557 2558 2559 2560 2561 2562 |
# File 'lib/redis.rb', line 2554 def scan_each(={}, &block) return to_enum(:scan_each, ) unless block_given? cursor = 0 loop do cursor, keys = scan(cursor, ) keys.each(&block) break if cursor == "0" end end |
#scard(key) ⇒ Fixnum
Get the number of members in a set.
1314 1315 1316 1317 1318 |
# File 'lib/redis.rb', line 1314 def scard(key) synchronize do |client| client.call([:scard, key]) end end |
#script(subcommand, *args) ⇒ String, ...
Control remote script registry.
2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 |
# File 'lib/redis.rb', line 2415 def script(subcommand, *args) subcommand = subcommand.to_s.downcase if subcommand == "exists" synchronize do |client| arg = args.first client.call([:script, :exists, arg]) do |reply| reply = reply.map { |r| Boolify.call(r) } if arg.is_a?(Array) reply else reply.first end end end else synchronize do |client| client.call([:script, subcommand] + args) end end end |
#sdiff(*keys) ⇒ Array<String>
Subtract multiple sets.
1431 1432 1433 1434 1435 |
# File 'lib/redis.rb', line 1431 def sdiff(*keys) synchronize do |client| client.call([:sdiff] + keys) end end |
#sdiffstore(destination, *keys) ⇒ Fixnum
Subtract multiple sets and store the resulting set in a key.
1442 1443 1444 1445 1446 |
# File 'lib/redis.rb', line 1442 def sdiffstore(destination, *keys) synchronize do |client| client.call([:sdiffstore, destination] + keys) end end |
#select(db) ⇒ String
Change the selected database for the current connection.
128 129 130 131 132 133 |
# File 'lib/redis.rb', line 128 def select(db) synchronize do |client| client.db = db client.call([:select, db]) end end |
#sentinel(subcommand, *args) ⇒ Array<String>, ...
Interact with the sentinel command (masters, master, slaves, failover)
2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 |
# File 'lib/redis.rb', line 2718 def sentinel(subcommand, *args) subcommand = subcommand.to_s.downcase synchronize do |client| client.call([:sentinel, subcommand] + args) do |reply| case subcommand when "get-master-addr-by-name" reply else if reply.kind_of?(Array) if reply[0].kind_of?(Array) reply.map(&Hashify) else Hashify.call(reply) end else reply end end end end end |
#set(key, value, options = {}) ⇒ String, Boolean
Set the string value of a key.
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 |
# File 'lib/redis.rb', line 764 def set(key, value, = {}) args = [] ex = [:ex] args.concat(["EX", ex]) if ex px = [:px] args.concat(["PX", px]) if px nx = [:nx] args.concat(["NX"]) if nx xx = [:xx] args.concat(["XX"]) if xx synchronize do |client| if nx || xx client.call([:set, key, value.to_s] + args, &BoolifySet) else client.call([:set, key, value.to_s] + args) end end end |
#setbit(key, offset, value) ⇒ Fixnum
Sets or clears the bit at offset in the string value stored at key.
960 961 962 963 964 |
# File 'lib/redis.rb', line 960 def setbit(key, offset, value) synchronize do |client| client.call([:setbit, key, offset, value]) end end |
#setex(key, ttl, value) ⇒ String
Set the time to live in seconds of a key.
794 795 796 797 798 |
# File 'lib/redis.rb', line 794 def setex(key, ttl, value) synchronize do |client| client.call([:setex, key, ttl, value.to_s]) end end |
#setnx(key, value) ⇒ Boolean
Set the value of a key, only if the key does not exist.
817 818 819 820 821 |
# File 'lib/redis.rb', line 817 def setnx(key, value) synchronize do |client| client.call([:setnx, key, value.to_s], &Boolify) end end |
#setrange(key, offset, value) ⇒ Fixnum
Overwrite part of a string at key starting at the specified offset.
935 936 937 938 939 |
# File 'lib/redis.rb', line 935 def setrange(key, offset, value) synchronize do |client| client.call([:setrange, key, offset, value.to_s]) end end |
#shutdown ⇒ Object
Synchronously save the dataset to disk and then shut down the server.
325 326 327 328 329 330 331 332 333 334 335 336 |
# File 'lib/redis.rb', line 325 def shutdown synchronize do |client| client.with_reconnect(false) do begin client.call([:shutdown]) rescue ConnectionError # This means Redis has probably exited. nil end end end end |
#sinter(*keys) ⇒ Array<String>
Intersect multiple sets.
1452 1453 1454 1455 1456 |
# File 'lib/redis.rb', line 1452 def sinter(*keys) synchronize do |client| client.call([:sinter] + keys) end end |
#sinterstore(destination, *keys) ⇒ Fixnum
Intersect multiple sets and store the resulting set in a key.
1463 1464 1465 1466 1467 |
# File 'lib/redis.rb', line 1463 def sinterstore(destination, *keys) synchronize do |client| client.call([:sinterstore, destination] + keys) end end |
#sismember(key, member) ⇒ Boolean
Determine if a given value is a member of a set.
1411 1412 1413 1414 1415 |
# File 'lib/redis.rb', line 1411 def sismember(key, member) synchronize do |client| client.call([:sismember, key, member], &Boolify) end end |
#slaveof(host, port) ⇒ Object
Make the server a slave of another instance, or promote it as master.
339 340 341 342 343 |
# File 'lib/redis.rb', line 339 def slaveof(host, port) synchronize do |client| client.call([:slaveof, host, port]) end end |
#slowlog(subcommand, length = nil) ⇒ Array<String>, ...
Interact with the slowlog (get, len, reset)
350 351 352 353 354 355 356 |
# File 'lib/redis.rb', line 350 def slowlog(subcommand, length=nil) synchronize do |client| args = [:slowlog, subcommand] args << length if length client.call args end end |
#smembers(key) ⇒ Array<String>
Get all the members in a set.
1421 1422 1423 1424 1425 |
# File 'lib/redis.rb', line 1421 def smembers(key) synchronize do |client| client.call([:smembers, key]) end end |
#smove(source, destination, member) ⇒ Boolean
Move a member from one set to another.
1400 1401 1402 1403 1404 |
# File 'lib/redis.rb', line 1400 def smove(source, destination, member) synchronize do |client| client.call([:smove, source, destination, member], &Boolify) end end |
#sort(key, options = {}) ⇒ Array<String>, ...
Sort the elements in a list, set or sorted set.
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 |
# File 'lib/redis.rb', line 640 def sort(key, = {}) args = [] by = [:by] args.concat(["BY", by]) if by limit = [:limit] args.concat(["LIMIT"] + limit) if limit get = Array([:get]) args.concat(["GET"].product(get).flatten) unless get.empty? order = [:order] args.concat(order.split(" ")) if order store = [:store] args.concat(["STORE", store]) if store synchronize do |client| client.call([:sort, key] + args) do |reply| if get.size > 1 && !store if reply reply.each_slice(get.size).to_a end else reply end end end end |
#spop(key, count = nil) ⇒ String
Remove and return one or more random member from a set.
1369 1370 1371 1372 1373 1374 1375 1376 1377 |
# File 'lib/redis.rb', line 1369 def spop(key, count = nil) synchronize do |client| if count.nil? client.call([:spop, key]) else client.call([:spop, key, count]) end end end |
#srandmember(key, count = nil) ⇒ String
Get one or more random members from a set.
1384 1385 1386 1387 1388 1389 1390 1391 1392 |
# File 'lib/redis.rb', line 1384 def srandmember(key, count = nil) synchronize do |client| if count.nil? client.call([:srandmember, key]) else client.call([:srandmember, key, count]) end end end |
#srem(key, member) ⇒ Boolean, Fixnum
Remove one or more members from a set.
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 |
# File 'lib/redis.rb', line 1350 def srem(key, member) synchronize do |client| client.call([:srem, key, member]) do |reply| if member.is_a? Array # Variadic: return integer reply else # Single argument: return boolean Boolify.call(reply) end end end end |
#sscan(key, cursor, options = {}) ⇒ String+
Scan a set
2652 2653 2654 |
# File 'lib/redis.rb', line 2652 def sscan(key, cursor, ={}) _scan(:sscan, cursor, [key], ) end |
#sscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a set
2667 2668 2669 2670 2671 2672 2673 2674 2675 |
# File 'lib/redis.rb', line 2667 def sscan_each(key, ={}, &block) return to_enum(:sscan_each, key, ) unless block_given? cursor = 0 loop do cursor, keys = sscan(key, cursor, ) keys.each(&block) break if cursor == "0" end end |
#strlen(key) ⇒ Fixnum
Get the length of the value stored in a key.
1050 1051 1052 1053 1054 |
# File 'lib/redis.rb', line 1050 def strlen(key) synchronize do |client| client.call([:strlen, key]) end end |
#subscribe(*channels, &block) ⇒ Object
Listen for messages published to the given channels.
2190 2191 2192 2193 2194 |
# File 'lib/redis.rb', line 2190 def subscribe(*channels, &block) synchronize do |client| _subscription(:subscribe, 0, channels, block) end end |
#subscribe_with_timeout(timeout, *channels, &block) ⇒ Object
Listen for messages published to the given channels. Throw a timeout error if there is no messages for a timeout period.
2197 2198 2199 2200 2201 |
# File 'lib/redis.rb', line 2197 def subscribe_with_timeout(timeout, *channels, &block) synchronize do |client| _subscription(:subscribe_with_timeout, timeout, channels, block) end end |
#subscribed? ⇒ Boolean
2183 2184 2185 2186 2187 |
# File 'lib/redis.rb', line 2183 def subscribed? synchronize do |client| client.kind_of? SubscribedClient end end |
#sunion(*keys) ⇒ Array<String>
Add multiple sets.
1473 1474 1475 1476 1477 |
# File 'lib/redis.rb', line 1473 def sunion(*keys) synchronize do |client| client.call([:sunion] + keys) end end |
#sunionstore(destination, *keys) ⇒ Fixnum
Add multiple sets and store the resulting set in a key.
1484 1485 1486 1487 1488 |
# File 'lib/redis.rb', line 1484 def sunionstore(destination, *keys) synchronize do |client| client.call([:sunionstore, destination] + keys) end end |
#sync ⇒ Object
Internal command used for replication.
359 360 361 362 363 |
# File 'lib/redis.rb', line 359 def sync synchronize do |client| client.call([:sync]) end end |
#synchronize ⇒ Object
44 45 46 |
# File 'lib/redis.rb', line 44 def synchronize mon_synchronize { yield(@client) } end |
#time ⇒ Array<Fixnum>
Return the server time.
372 373 374 375 376 377 378 |
# File 'lib/redis.rb', line 372 def time synchronize do |client| client.call([:time]) do |reply| reply.map(&:to_i) if reply end end end |
#ttl(key) ⇒ Fixnum
Get the time to live (in seconds) for a key.
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.
424 425 426 427 428 |
# File 'lib/redis.rb', line 424 def ttl(key) synchronize do |client| client.call([:ttl, key]) end end |
#type(key) ⇒ String
Determine the type stored at key.
675 676 677 678 679 |
# File 'lib/redis.rb', line 675 def type(key) synchronize do |client| client.call([:type, key]) end end |
#unsubscribe(*channels) ⇒ Object
Stop listening for messages posted to the given channels.
2204 2205 2206 2207 2208 2209 |
# File 'lib/redis.rb', line 2204 def unsubscribe(*channels) synchronize do |client| raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed? client.unsubscribe(*channels) end end |
#unwatch ⇒ String
Forget about all watched keys.
2296 2297 2298 2299 2300 |
# File 'lib/redis.rb', line 2296 def unwatch synchronize do |client| client.call([:unwatch]) end end |
#watch(*keys) ⇒ Object, String
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.
2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 |
# File 'lib/redis.rb', line 2271 def watch(*keys) synchronize do |client| res = client.call([:watch] + keys) if block_given? begin yield(self) rescue ConnectionError raise rescue StandardError unwatch raise end else res end end end |
#with_reconnect(val = true, &blk) ⇒ Object
Run code with the client reconnecting
49 50 51 52 53 |
# File 'lib/redis.rb', line 49 def with_reconnect(val=true, &blk) synchronize do |client| client.with_reconnect(val, &blk) end end |
#without_reconnect(&blk) ⇒ Object
Run code without the client reconnecting
56 57 58 |
# File 'lib/redis.rb', line 56 def without_reconnect(&blk) with_reconnect(false, &blk) end |
#zadd(key, *args) ⇒ Boolean, ...
Add one or more members to a sorted set, or update the score for members that already exist.
1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 |
# File 'lib/redis.rb', line 1535 def zadd(key, *args) #, options = [] if args.last.is_a?(Hash) = args.pop nx = [:nx] << "NX" if nx xx = [:xx] << "XX" if xx ch = [:ch] << "CH" if ch incr = [:incr] << "INCR" if incr end synchronize do |client| if args.size == 1 && args[0].is_a?(Array) # Variadic: return float if INCR, integer if !INCR client.call([:zadd, key] + + args[0], &(incr ? Floatify : nil)) elsif args.size == 2 # Single pair: return float if INCR, boolean if !INCR client.call([:zadd, key] + + args, &(incr ? Floatify : Boolify)) else raise ArgumentError, "wrong number of arguments" end end end |
#zcard(key) ⇒ Fixnum
Get the number of members in a sorted set.
1498 1499 1500 1501 1502 |
# File 'lib/redis.rb', line 1498 def zcard(key) synchronize do |client| client.call([:zcard, key]) end end |
#zcount(key, min, max) ⇒ Fixnum
Count the members in a sorted set with scores within the given values.
1924 1925 1926 1927 1928 |
# File 'lib/redis.rb', line 1924 def zcount(key, min, max) synchronize do |client| client.call([:zcount, key, min, max]) end end |
#zincrby(key, increment, member) ⇒ Float
Increment the score of a member in a sorted set.
1576 1577 1578 1579 1580 |
# File 'lib/redis.rb', line 1576 def zincrby(key, increment, member) synchronize do |client| client.call([:zincrby, key, increment, member], &Floatify) end end |
#zinterstore(destination, keys, options = {}) ⇒ Fixnum
Intersect multiple sorted sets and store the resulting sorted set in a new key.
1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 |
# File 'lib/redis.rb', line 1944 def zinterstore(destination, keys, = {}) args = [] weights = [:weights] args.concat(["WEIGHTS"] + weights) if weights aggregate = [:aggregate] args.concat(["AGGREGATE", aggregate]) if aggregate synchronize do |client| client.call([:zinterstore, destination, keys.size] + keys + args) end end |
#zlexcount(key, min, max) ⇒ Fixnum
Count the members, with the same score in a sorted set, within the given lexicographical range.
1747 1748 1749 1750 1751 |
# File 'lib/redis.rb', line 1747 def zlexcount(key, min, max) synchronize do |client| client.call([:zlexcount, key, min, max]) end end |
#zrange(key, start, stop, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members in a sorted set, by index.
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 |
# File 'lib/redis.rb', line 1646 def zrange(key, start, stop, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << "WITHSCORES" block = FloatifyPairs end synchronize do |client| client.call([:zrange, key, start, stop] + args, &block) end end |
#zrangebylex(key, min, max, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members with the same score in a sorted set, by lexicographical ordering
1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 |
# File 'lib/redis.rb', line 1774 def zrangebylex(key, min, max, = {}) args = [] limit = [:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrangebylex, key, min, max] + args) end end |
#zrangebyscore(key, min, max, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members in a sorted set, by score.
1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 |
# File 'lib/redis.rb', line 1834 def zrangebyscore(key, min, max, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << "WITHSCORES" block = FloatifyPairs end limit = [:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrangebyscore, key, min, max] + args, &block) end end |
#zrank(key, member) ⇒ Fixnum
Determine the index of a member in a sorted set.
1692 1693 1694 1695 1696 |
# File 'lib/redis.rb', line 1692 def zrank(key, member) synchronize do |client| client.call([:zrank, key, member]) end end |
#zrem(key, member) ⇒ Boolean, Fixnum
Remove one or more members from a sorted set.
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 |
# File 'lib/redis.rb', line 1599 def zrem(key, member) synchronize do |client| client.call([:zrem, key, member]) do |reply| if member.is_a? Array # Variadic: return integer reply else # Single argument: return boolean Boolify.call(reply) end end end end |
#zremrangebyrank(key, start, stop) ⇒ Fixnum
Remove all members in a sorted set within the given indexes.
1723 1724 1725 1726 1727 |
# File 'lib/redis.rb', line 1723 def zremrangebyrank(key, start, stop) synchronize do |client| client.call([:zremrangebyrank, key, start, stop]) end end |
#zremrangebyscore(key, min, max) ⇒ Fixnum
Remove all members in a sorted set within the given scores.
1901 1902 1903 1904 1905 |
# File 'lib/redis.rb', line 1901 def zremrangebyscore(key, min, max) synchronize do |client| client.call([:zremrangebyscore, key, min, max]) end end |
#zrevrange(key, start, stop, options = {}) ⇒ Object
Return a range of members in a sorted set, by index, with scores ordered from high to low.
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 |
# File 'lib/redis.rb', line 1672 def zrevrange(key, start, stop, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << "WITHSCORES" block = FloatifyPairs end synchronize do |client| client.call([:zrevrange, key, start, stop] + args, &block) end end |
#zrevrangebylex(key, max, min, options = {}) ⇒ Object
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.
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 |
# File 'lib/redis.rb', line 1796 def zrevrangebylex(key, max, min, = {}) args = [] limit = [:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrevrangebylex, key, max, min] + args) end end |
#zrevrangebyscore(key, max, min, options = {}) ⇒ Object
Return a range of members in a sorted set, by score, with scores ordered from high to low.
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 |
# File 'lib/redis.rb', line 1866 def zrevrangebyscore(key, max, min, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << ["WITHSCORES"] block = FloatifyPairs end limit = [:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrevrangebyscore, key, max, min] + args, &block) end end |
#zrevrank(key, member) ⇒ Fixnum
Determine the index of a member in a sorted set, with scores ordered from high to low.
1704 1705 1706 1707 1708 |
# File 'lib/redis.rb', line 1704 def zrevrank(key, member) synchronize do |client| client.call([:zrevrank, key, member]) end end |
#zscan(key, cursor, options = {}) ⇒ String, Array<[String, Float]>
Scan a sorted set
2614 2615 2616 2617 2618 |
# File 'lib/redis.rb', line 2614 def zscan(key, cursor, ={}) _scan(:zscan, cursor, [key], ) do |reply| [reply[0], FloatifyPairs.call(reply[1])] end end |
#zscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a sorted set
2631 2632 2633 2634 2635 2636 2637 2638 2639 |
# File 'lib/redis.rb', line 2631 def zscan_each(key, ={}, &block) return to_enum(:zscan_each, key, ) unless block_given? cursor = 0 loop do cursor, values = zscan(key, cursor, ) values.each(&block) break if cursor == "0" end end |
#zscore(key, member) ⇒ Float
Get the score associated with the given member in a sorted set.
1622 1623 1624 1625 1626 |
# File 'lib/redis.rb', line 1622 def zscore(key, member) synchronize do |client| client.call([:zscore, key, member], &Floatify) end end |
#zunionstore(destination, keys, options = {}) ⇒ Fixnum
Add multiple sorted sets and store the resulting sorted set in a new key.
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 |
# File 'lib/redis.rb', line 1971 def zunionstore(destination, keys, = {}) args = [] weights = [:weights] args.concat(["WEIGHTS"] + weights) if weights aggregate = [:aggregate] args.concat(["AGGREGATE", aggregate]) if aggregate synchronize do |client| client.call([:zunionstore, destination, keys.size] + keys + args) end end |