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, BasicObject, CannotConnectError, Client, CommandError, ConnectionError, Distributed, Future, FutureNotReady, HashRing, InheritedError, Pipeline, ProtocolError, SubscribedClient, Subscription, TimeoutError
Constant Summary collapse
- VERSION =
"3.3.0"
Instance Attribute Summary collapse
-
#client ⇒ Object
readonly
Returns the value of attribute client.
Class Method Summary collapse
-
.connect(options = {}) ⇒ Object
deprecated
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. - .current ⇒ Object
- .current=(redis) ⇒ Object
- .deprecate(message, trace = caller[0]) ⇒ Object
Instance Method Summary collapse
- #_bpop(cmd, args) ⇒ 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.
-
#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.
-
#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 ⇒ String
Remove all keys from all databases.
-
#flushdb ⇒ String
Remove all keys from the current database.
-
#get(key) ⇒ String
(also: #[])
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 ⇒ 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) ⇒ 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
(also: #[]=)
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) ⇒ String
Remove and return a 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.
-
#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
2698 2699 2700 2701 2702 |
# File 'lib/redis.rb', line 2698 def method_missing(command, *args) synchronize do |client| client.call([command] + args) end end |
Instance Attribute Details
#client ⇒ Object (readonly)
Returns the value of attribute client.
10 11 12 |
# File 'lib/redis.rb', line 10 def client @client end |
Class Method Details
.connect(options = {}) ⇒ Object
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.
15 16 17 |
# File 'lib/redis.rb', line 15 def self.connect( = {}) new() end |
.current ⇒ Object
19 20 21 |
# File 'lib/redis.rb', line 19 def self.current @current ||= Redis.new end |
.current=(redis) ⇒ Object
23 24 25 |
# File 'lib/redis.rb', line 23 def self.current=(redis) @current = redis end |
.deprecate(message, trace = caller[0]) ⇒ Object
6 7 8 |
# File 'lib/redis.rb', line 6 def self.deprecate(, trace = caller[0]) $stderr.puts "\n#{} (in #{trace})" end |
Instance Method Details
#_bpop(cmd, args) ⇒ Object
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 |
# File 'lib/redis.rb', line 1116 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 |
#_eval(cmd, args) ⇒ Object
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 |
# File 'lib/redis.rb', line 2385 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
2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 |
# File 'lib/redis.rb', line 2448 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.
957 958 959 960 961 |
# File 'lib/redis.rb', line 957 def append(key, value) synchronize do |client| client.call([:append, key, value]) end end |
#auth(password) ⇒ String
Authenticate to the server.
127 128 129 130 131 |
# File 'lib/redis.rb', line 127 def auth(password) synchronize do |client| client.call([:auth, password]) end end |
#bgrewriteaof ⇒ String
Asynchronously rewrite the append-only file.
180 181 182 183 184 |
# File 'lib/redis.rb', line 180 def bgrewriteaof synchronize do |client| client.call([:bgrewriteaof]) end end |
#bgsave ⇒ String
Asynchronously save the dataset to disk.
189 190 191 192 193 |
# File 'lib/redis.rb', line 189 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.
969 970 971 972 973 |
# File 'lib/redis.rb', line 969 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.
981 982 983 984 985 |
# File 'lib/redis.rb', line 981 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.
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 |
# File 'lib/redis.rb', line 995 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.
1162 1163 1164 |
# File 'lib/redis.rb', line 1162 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.
1178 1179 1180 |
# File 'lib/redis.rb', line 1178 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.
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 |
# File 'lib/redis.rb', line 1193 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.
92 93 94 95 96 |
# File 'lib/redis.rb', line 92 def call(*command) synchronize do |client| client.call(command) end end |
#close ⇒ Object Also known as: disconnect!
Disconnect the client as quickly and silently as possible.
79 80 81 |
# File 'lib/redis.rb', line 79 def close @original_client.disconnect end |
#commit ⇒ Object
Sends all commands in the queue.
See http://redis.io/topics/pipelining for more details.
112 113 114 115 116 117 118 119 120 |
# File 'lib/redis.rb', line 112 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.
200 201 202 203 204 205 206 207 208 209 210 |
# File 'lib/redis.rb', line 200 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
74 75 76 |
# File 'lib/redis.rb', line 74 def connected? @original_client.connected? end |
#dbsize ⇒ Fixnum
Return the number of keys in the selected database.
215 216 217 218 219 |
# File 'lib/redis.rb', line 215 def dbsize synchronize do |client| client.call([:dbsize]) end end |
#debug(*args) ⇒ Object
221 222 223 224 225 |
# File 'lib/redis.rb', line 221 def debug(*args) synchronize do |client| client.call([:debug] + args) end end |
#decr(key) ⇒ Fixnum
Decrement the integer value of a key by one.
660 661 662 663 664 |
# File 'lib/redis.rb', line 660 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.
675 676 677 678 679 |
# File 'lib/redis.rb', line 675 def decrby(key, decrement) synchronize do |client| client.call([:decrby, key, decrement]) end end |
#del(*keys) ⇒ Fixnum
Delete one or more keys.
492 493 494 495 496 |
# File 'lib/redis.rb', line 492 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.
2331 2332 2333 2334 2335 |
# File 'lib/redis.rb', line 2331 def discard synchronize do |client| client.call([:discard]) end end |
#dump(key) ⇒ String
Return a serialized version of the value stored at a key.
450 451 452 453 454 |
# File 'lib/redis.rb', line 450 def dump(key) synchronize do |client| client.call([:dump, key]) end end |
#dup ⇒ Object
2694 2695 2696 |
# File 'lib/redis.rb', line 2694 def dup self.class.new(@options) end |
#echo(value) ⇒ String
Echo the given string.
157 158 159 160 161 |
# File 'lib/redis.rb', line 157 def echo(value) synchronize do |client| client.call([:echo, value]) end end |
#eval(*args) ⇒ Object
Evaluate Lua script.
2419 2420 2421 |
# File 'lib/redis.rb', line 2419 def eval(*args) _eval(:eval, args) end |
#evalsha(*args) ⇒ Object
Evaluate Lua script by its SHA.
2444 2445 2446 |
# File 'lib/redis.rb', line 2444 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.
2317 2318 2319 2320 2321 |
# File 'lib/redis.rb', line 2317 def exec synchronize do |client| client.call([:exec]) end end |
#exists(key) ⇒ Boolean
Determine if a key exists.
502 503 504 505 506 |
# File 'lib/redis.rb', line 502 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.
372 373 374 375 376 |
# File 'lib/redis.rb', line 372 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.
383 384 385 386 387 |
# File 'lib/redis.rb', line 383 def expireat(key, unix_time) synchronize do |client| client.call([:expireat, key, unix_time], &Boolify) end end |
#flushall ⇒ String
Remove all keys from all databases.
230 231 232 233 234 |
# File 'lib/redis.rb', line 230 def flushall synchronize do |client| client.call([:flushall]) end end |
#flushdb ⇒ String
Remove all keys from the current database.
239 240 241 242 243 |
# File 'lib/redis.rb', line 239 def flushdb synchronize do |client| client.call([:flushdb]) end end |
#get(key) ⇒ String Also known as: []
Get the value of a key.
860 861 862 863 864 |
# File 'lib/redis.rb', line 860 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.
946 947 948 949 950 |
# File 'lib/redis.rb', line 946 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.
923 924 925 926 927 |
# File 'lib/redis.rb', line 923 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.
1014 1015 1016 1017 1018 |
# File 'lib/redis.rb', line 1014 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.
2051 2052 2053 2054 2055 |
# File 'lib/redis.rb', line 2051 def hdel(key, field) synchronize do |client| client.call([:hdel, key, field]) end end |
#hexists(key, field) ⇒ Boolean
Determine if a hash field exists.
2062 2063 2064 2065 2066 |
# File 'lib/redis.rb', line 2062 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.
2002 2003 2004 2005 2006 |
# File 'lib/redis.rb', line 2002 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.
2116 2117 2118 2119 2120 |
# File 'lib/redis.rb', line 2116 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.
2074 2075 2076 2077 2078 |
# File 'lib/redis.rb', line 2074 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.
2086 2087 2088 2089 2090 |
# File 'lib/redis.rb', line 2086 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.
2096 2097 2098 2099 2100 |
# File 'lib/redis.rb', line 2096 def hkeys(key) synchronize do |client| client.call([:hkeys, key]) end end |
#hlen(key) ⇒ Fixnum
Get the number of fields in a hash.
1935 1936 1937 1938 1939 |
# File 'lib/redis.rb', line 1935 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.
2019 2020 2021 2022 2023 |
# File 'lib/redis.rb', line 2019 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.
1976 1977 1978 1979 1980 |
# File 'lib/redis.rb', line 1976 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
2521 2522 2523 2524 2525 |
# File 'lib/redis.rb', line 2521 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
2538 2539 2540 2541 2542 2543 2544 2545 2546 |
# File 'lib/redis.rb', line 2538 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.
1947 1948 1949 1950 1951 |
# File 'lib/redis.rb', line 1947 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.
1959 1960 1961 1962 1963 |
# File 'lib/redis.rb', line 1959 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.
2106 2107 2108 2109 2110 |
# File 'lib/redis.rb', line 2106 def hvals(key) synchronize do |client| client.call([:hvals, key]) end end |
#id ⇒ Object
2686 2687 2688 |
# File 'lib/redis.rb', line 2686 def id @original_client.id end |
#incr(key) ⇒ Fixnum
Increment the integer value of a key by one.
689 690 691 692 693 |
# File 'lib/redis.rb', line 689 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.
704 705 706 707 708 |
# File 'lib/redis.rb', line 704 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.
719 720 721 722 723 |
# File 'lib/redis.rb', line 719 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.
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 |
# File 'lib/redis.rb', line 249 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
2690 2691 2692 |
# File 'lib/redis.rb', line 2690 def inspect "#<Redis client v#{Redis::VERSION} for #{id}>" end |
#keys(pattern = "*") ⇒ Array<String>
Find all keys matching the given pattern.
512 513 514 515 516 517 518 519 520 521 522 |
# File 'lib/redis.rb', line 512 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.
274 275 276 277 278 |
# File 'lib/redis.rb', line 274 def lastsave synchronize do |client| client.call([:lastsave]) end end |
#lindex(key, index) ⇒ String
Get an element from a list by its index.
1214 1215 1216 1217 1218 |
# File 'lib/redis.rb', line 1214 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.
1228 1229 1230 1231 1232 |
# File 'lib/redis.rb', line 1228 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.
1035 1036 1037 1038 1039 |
# File 'lib/redis.rb', line 1035 def llen(key) synchronize do |client| client.call([:llen, key]) end end |
#lpop(key) ⇒ String
Remove and get the first element in a list.
1089 1090 1091 1092 1093 |
# File 'lib/redis.rb', line 1089 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
1046 1047 1048 1049 1050 |
# File 'lib/redis.rb', line 1046 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.
1057 1058 1059 1060 1061 |
# File 'lib/redis.rb', line 1057 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.
1240 1241 1242 1243 1244 |
# File 'lib/redis.rb', line 1240 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.
1255 1256 1257 1258 1259 |
# File 'lib/redis.rb', line 1255 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.
1267 1268 1269 1270 1271 |
# File 'lib/redis.rb', line 1267 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.
1279 1280 1281 1282 1283 |
# File 'lib/redis.rb', line 1279 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.
2036 2037 2038 2039 2040 2041 2042 2043 2044 |
# File 'lib/redis.rb', line 2036 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.
1993 1994 1995 |
# File 'lib/redis.rb', line 1993 def mapped_hmset(key, hash) hmset(key, hash.to_a.flatten) end |
#mapped_mget(*keys) ⇒ Hash
Get the values of all the given keys.
894 895 896 897 898 899 900 901 902 |
# File 'lib/redis.rb', line 894 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.
822 823 824 |
# File 'lib/redis.rb', line 822 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.
852 853 854 |
# File 'lib/redis.rb', line 852 def mapped_msetnx(hash) msetnx(hash.to_a.flatten) end |
#mget(*keys, &blk) ⇒ Array<String>
Get the values of all the given keys.
878 879 880 881 882 |
# File 'lib/redis.rb', line 878 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.
477 478 479 480 481 482 483 484 485 486 |
# File 'lib/redis.rb', line 477 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.
286 287 288 289 290 |
# File 'lib/redis.rb', line 286 def monitor(&block) synchronize do |client| client.call_loop([:monitor], &block) end end |
#move(key, db) ⇒ Boolean
Move a key to another database.
543 544 545 546 547 |
# File 'lib/redis.rb', line 543 def move(key, db) synchronize do |client| client.call([:move, key, db], &Boolify) end end |
#mset(*args) ⇒ String
Set one or more values.
806 807 808 809 810 |
# File 'lib/redis.rb', line 806 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.
836 837 838 839 840 |
# File 'lib/redis.rb', line 836 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.
2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 |
# File 'lib/redis.rb', line 2290 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
549 550 551 552 553 |
# File 'lib/redis.rb', line 549 def object(*args) synchronize do |client| client.call([:object] + args) end end |
#persist(key) ⇒ Boolean
Remove the expiration from a key.
361 362 363 364 365 |
# File 'lib/redis.rb', line 361 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.
412 413 414 415 416 |
# File 'lib/redis.rb', line 412 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.
423 424 425 426 427 |
# File 'lib/redis.rb', line 423 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.
2628 2629 2630 2631 2632 |
# File 'lib/redis.rb', line 2628 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.
2641 2642 2643 2644 2645 |
# File 'lib/redis.rb', line 2641 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.
2653 2654 2655 2656 2657 |
# File 'lib/redis.rb', line 2653 def pfmerge(dest_key, *source_key) synchronize do |client| client.call([:pfmerge, dest_key, *source_key], &BoolifySet) end end |
#ping ⇒ String
Ping the server.
147 148 149 150 151 |
# File 'lib/redis.rb', line 147 def ping synchronize do |client| client.call([:ping]) end end |
#pipelined ⇒ Object
2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 |
# File 'lib/redis.rb', line 2248 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.
779 780 781 782 783 |
# File 'lib/redis.rb', line 779 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.
2158 2159 2160 2161 2162 |
# File 'lib/redis.rb', line 2158 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.
2165 2166 2167 2168 2169 |
# File 'lib/redis.rb', line 2165 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.
440 441 442 443 444 |
# File 'lib/redis.rb', line 440 def pttl(key) synchronize do |client| client.call([:pttl, key]) end end |
#publish(channel, message) ⇒ Object
Post a message to a channel.
2123 2124 2125 2126 2127 |
# File 'lib/redis.rb', line 2123 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.
2181 2182 2183 2184 2185 |
# File 'lib/redis.rb', line 2181 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.
2172 2173 2174 2175 2176 2177 |
# File 'lib/redis.rb', line 2172 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.
104 105 106 |
# File 'lib/redis.rb', line 104 def queue(*command) @queue[Thread.current.object_id] << command end |
#quit ⇒ String
Close the connection.
166 167 168 169 170 171 172 173 174 175 |
# File 'lib/redis.rb', line 166 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.
558 559 560 561 562 |
# File 'lib/redis.rb', line 558 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.
569 570 571 572 573 |
# File 'lib/redis.rb', line 569 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.
580 581 582 583 584 |
# File 'lib/redis.rb', line 580 def renamenx(old_name, new_name) synchronize do |client| client.call([:renamenx, old_name, new_name], &Boolify) end end |
#restore(key, ttl, serialized_value) ⇒ String
Create a key using the serialized value, previously obtained using DUMP.
462 463 464 465 466 |
# File 'lib/redis.rb', line 462 def restore(key, ttl, serialized_value) synchronize do |client| client.call([:restore, key, ttl, serialized_value]) end end |
#rpop(key) ⇒ String
Remove and get the last element in a list.
1099 1100 1101 1102 1103 |
# File 'lib/redis.rb', line 1099 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.
1110 1111 1112 1113 1114 |
# File 'lib/redis.rb', line 1110 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
1068 1069 1070 1071 1072 |
# File 'lib/redis.rb', line 1068 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.
1079 1080 1081 1082 1083 |
# File 'lib/redis.rb', line 1079 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.
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 |
# File 'lib/redis.rb', line 1303 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.
295 296 297 298 299 |
# File 'lib/redis.rb', line 295 def save synchronize do |client| client.call([:save]) end end |
#scan(cursor, options = {}) ⇒ String+
Scan the keyspace
2481 2482 2483 |
# File 'lib/redis.rb', line 2481 def scan(cursor, ={}) _scan(:scan, cursor, [], ) end |
#scan_each(options = {}, &block) ⇒ Enumerator
Scan the keyspace
2500 2501 2502 2503 2504 2505 2506 2507 2508 |
# File 'lib/redis.rb', line 2500 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.
1289 1290 1291 1292 1293 |
# File 'lib/redis.rb', line 1289 def scard(key) synchronize do |client| client.call([:scard, key]) end end |
#script(subcommand, *args) ⇒ String, ...
Control remote script registry.
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 |
# File 'lib/redis.rb', line 2361 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.
1401 1402 1403 1404 1405 |
# File 'lib/redis.rb', line 1401 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.
1412 1413 1414 1415 1416 |
# File 'lib/redis.rb', line 1412 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.
137 138 139 140 141 142 |
# File 'lib/redis.rb', line 137 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)
2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 |
# File 'lib/redis.rb', line 2664 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 Also known as: []=
Set the string value of a key.
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 |
# File 'lib/redis.rb', line 735 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.
935 936 937 938 939 |
# File 'lib/redis.rb', line 935 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.
767 768 769 770 771 |
# File 'lib/redis.rb', line 767 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.
790 791 792 793 794 |
# File 'lib/redis.rb', line 790 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.
910 911 912 913 914 |
# File 'lib/redis.rb', line 910 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.
302 303 304 305 306 307 308 309 310 311 312 313 |
# File 'lib/redis.rb', line 302 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.
1422 1423 1424 1425 1426 |
# File 'lib/redis.rb', line 1422 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.
1433 1434 1435 1436 1437 |
# File 'lib/redis.rb', line 1433 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.
1381 1382 1383 1384 1385 |
# File 'lib/redis.rb', line 1381 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.
316 317 318 319 320 |
# File 'lib/redis.rb', line 316 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)
327 328 329 330 331 332 333 |
# File 'lib/redis.rb', line 327 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.
1391 1392 1393 1394 1395 |
# File 'lib/redis.rb', line 1391 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.
1370 1371 1372 1373 1374 |
# File 'lib/redis.rb', line 1370 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.
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 |
# File 'lib/redis.rb', line 611 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) ⇒ String
Remove and return a random member from a set.
1343 1344 1345 1346 1347 |
# File 'lib/redis.rb', line 1343 def spop(key) synchronize do |client| client.call([:spop, key]) end end |
#srandmember(key, count = nil) ⇒ String
Get one or more random members from a set.
1354 1355 1356 1357 1358 1359 1360 1361 1362 |
# File 'lib/redis.rb', line 1354 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.
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 |
# File 'lib/redis.rb', line 1325 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
2598 2599 2600 |
# File 'lib/redis.rb', line 2598 def sscan(key, cursor, ={}) _scan(:sscan, cursor, [key], ) end |
#sscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a set
2613 2614 2615 2616 2617 2618 2619 2620 2621 |
# File 'lib/redis.rb', line 2613 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.
1025 1026 1027 1028 1029 |
# File 'lib/redis.rb', line 1025 def strlen(key) synchronize do |client| client.call([:strlen, key]) end end |
#subscribe(*channels, &block) ⇒ Object
Listen for messages published to the given channels.
2136 2137 2138 2139 2140 |
# File 'lib/redis.rb', line 2136 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.
2143 2144 2145 2146 2147 |
# File 'lib/redis.rb', line 2143 def subscribe_with_timeout(timeout, *channels, &block) synchronize do |client| _subscription(:subscribe_with_timeout, timeout, channels, block) end end |
#subscribed? ⇒ Boolean
2129 2130 2131 2132 2133 |
# File 'lib/redis.rb', line 2129 def subscribed? synchronize do |client| client.kind_of? SubscribedClient end end |
#sunion(*keys) ⇒ Array<String>
Add multiple sets.
1443 1444 1445 1446 1447 |
# File 'lib/redis.rb', line 1443 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.
1454 1455 1456 1457 1458 |
# File 'lib/redis.rb', line 1454 def sunionstore(destination, *keys) synchronize do |client| client.call([:sunionstore, destination] + keys) end end |
#sync ⇒ Object
Internal command used for replication.
336 337 338 339 340 |
# File 'lib/redis.rb', line 336 def sync synchronize do |client| client.call([:sync]) end end |
#synchronize ⇒ Object
57 58 59 |
# File 'lib/redis.rb', line 57 def synchronize mon_synchronize { yield(@client) } end |
#time ⇒ Array<Fixnum>
Return the server time.
349 350 351 352 353 354 355 |
# File 'lib/redis.rb', line 349 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.
401 402 403 404 405 |
# File 'lib/redis.rb', line 401 def ttl(key) synchronize do |client| client.call([:ttl, key]) end end |
#type(key) ⇒ String
Determine the type stored at key.
646 647 648 649 650 |
# File 'lib/redis.rb', line 646 def type(key) synchronize do |client| client.call([:type, key]) end end |
#unsubscribe(*channels) ⇒ Object
Stop listening for messages posted to the given channels.
2150 2151 2152 2153 2154 2155 |
# File 'lib/redis.rb', line 2150 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.
2242 2243 2244 2245 2246 |
# File 'lib/redis.rb', line 2242 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.
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 |
# File 'lib/redis.rb', line 2217 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
62 63 64 65 66 |
# File 'lib/redis.rb', line 62 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
69 70 71 |
# File 'lib/redis.rb', line 69 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.
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 |
# File 'lib/redis.rb', line 1505 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.
1468 1469 1470 1471 1472 |
# File 'lib/redis.rb', line 1468 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.
1870 1871 1872 1873 1874 |
# File 'lib/redis.rb', line 1870 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.
1546 1547 1548 1549 1550 |
# File 'lib/redis.rb', line 1546 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.
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 |
# File 'lib/redis.rb', line 1890 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 |
#zrange(key, start, stop, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members in a sorted set, by index.
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 |
# File 'lib/redis.rb', line 1616 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
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 |
# File 'lib/redis.rb', line 1720 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.
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 |
# File 'lib/redis.rb', line 1780 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.
1662 1663 1664 1665 1666 |
# File 'lib/redis.rb', line 1662 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.
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 |
# File 'lib/redis.rb', line 1569 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.
1693 1694 1695 1696 1697 |
# File 'lib/redis.rb', line 1693 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.
1847 1848 1849 1850 1851 |
# File 'lib/redis.rb', line 1847 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.
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 |
# File 'lib/redis.rb', line 1642 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.
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 |
# File 'lib/redis.rb', line 1742 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.
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 |
# File 'lib/redis.rb', line 1812 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.
1674 1675 1676 1677 1678 |
# File 'lib/redis.rb', line 1674 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
2560 2561 2562 2563 2564 |
# File 'lib/redis.rb', line 2560 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
2577 2578 2579 2580 2581 2582 2583 2584 2585 |
# File 'lib/redis.rb', line 2577 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.
1592 1593 1594 1595 1596 |
# File 'lib/redis.rb', line 1592 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.
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 |
# File 'lib/redis.rb', line 1917 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 |