Class: Redis2
- Inherits:
-
Object
- Object
- Redis2
- Includes:
- MonitorMixin
- Defined in:
- lib/redis2.rb,
lib/redis2/client.rb,
lib/redis2/errors.rb,
lib/redis2/version.rb,
lib/redis2/pipeline.rb,
lib/redis2/hash_ring.rb,
lib/redis2/subscribe.rb,
lib/redis2/distributed.rb,
lib/redis2/connection/ruby.rb,
lib/redis2/connection/hiredis.rb,
lib/redis2/connection/registry.rb,
lib/redis2/connection/synchrony.rb,
lib/redis2/connection/command_helper.rb
Defined Under Namespace
Modules: Connection Classes: BaseConnectionError, BaseError, BasicObject, CannotConnectError, Client, CommandError, ConnectionError, Distributed, Future, FutureNotReady, HashRing, InheritedError, Pipeline, ProtocolError, SubscribedClient, Subscription, TimeoutError
Constant Summary collapse
- VERSION =
"3.0.7.1"
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 Redis2, 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.
-
#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 ⇒ Object
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) ⇒ Object
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 = {}) ⇒ Redis2
constructor
A new instance of Redis2.
- #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) ⇒ Object
Set one or more hash values.
-
#mapped_mget(*keys) ⇒ Hash
Get the values of all the given keys.
-
#mapped_mset(hash) ⇒ Object
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) ⇒ Object
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.
-
#ping ⇒ String
Ping the server.
- #pipelined ⇒ Object
-
#psetex(key, ttl, value) ⇒ Object
Set the time to live in milliseconds of a key.
-
#psubscribe(*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.
-
#punsubscribe(*channels) ⇒ Object
Stop listening for messages posted to channels matching the given patterns.
-
#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) ⇒ Object
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.
-
#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) ⇒ Object
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.
- #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, Fixnum
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.
-
#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.
-
#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
2453 2454 2455 2456 2457 |
# File 'lib/redis2.rb', line 2453 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.
12 13 14 |
# File 'lib/redis2.rb', line 12 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 Redis2,
in contrary to what you might expect.
17 18 19 |
# File 'lib/redis2.rb', line 17 def self.connect( = {}) new() end |
.current ⇒ Object
21 22 23 |
# File 'lib/redis2.rb', line 21 def self.current @current ||= Redis2.new end |
.current=(redis) ⇒ Object
25 26 27 |
# File 'lib/redis2.rb', line 25 def self.current=(redis) @current = redis end |
.deprecate(message, trace = caller[0]) ⇒ Object
8 9 10 |
# File 'lib/redis2.rb', line 8 def self.deprecate(, trace = caller[0]) $stderr.puts "\n#{} (in #{trace})" end |
Instance Method Details
#_bpop(cmd, args) ⇒ Object
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 |
# File 'lib/redis2.rb', line 1040 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
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 |
# File 'lib/redis2.rb', line 2203 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
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 |
# File 'lib/redis2.rb', line 2266 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.
881 882 883 884 885 |
# File 'lib/redis2.rb', line 881 def append(key, value) synchronize do |client| client.call([:append, key, value]) end end |
#auth(password) ⇒ String
Authenticate to the server.
64 65 66 67 68 |
# File 'lib/redis2.rb', line 64 def auth(password) synchronize do |client| client.call([:auth, password]) end end |
#bgrewriteaof ⇒ String
Asynchronously rewrite the append-only file.
117 118 119 120 121 |
# File 'lib/redis2.rb', line 117 def bgrewriteaof synchronize do |client| client.call([:bgrewriteaof]) end end |
#bgsave ⇒ String
Asynchronously save the dataset to disk.
126 127 128 129 130 |
# File 'lib/redis2.rb', line 126 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.
893 894 895 896 897 |
# File 'lib/redis2.rb', line 893 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.
905 906 907 908 909 |
# File 'lib/redis2.rb', line 905 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.
919 920 921 922 923 924 925 926 927 928 929 930 |
# File 'lib/redis2.rb', line 919 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.
1086 1087 1088 |
# File 'lib/redis2.rb', line 1086 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.
1102 1103 1104 |
# File 'lib/redis2.rb', line 1102 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.
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 |
# File 'lib/redis2.rb', line 1117 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 |
#config(action, *args) ⇒ String, Hash
Get or set server configuration parameters.
137 138 139 140 141 142 143 144 145 146 147 |
# File 'lib/redis2.rb', line 137 def config(action, *args) synchronize do |client| client.call([:config, action] + args) do |reply| if reply.kind_of?(Array) && action == :get Hash[_pairify(reply)] else reply end end end end |
#connected? ⇒ Boolean
Test whether or not the client is connected
55 56 57 |
# File 'lib/redis2.rb', line 55 def connected? @original_client.connected? end |
#dbsize ⇒ Fixnum
Return the number of keys in the selected database.
152 153 154 155 156 |
# File 'lib/redis2.rb', line 152 def dbsize synchronize do |client| client.call([:dbsize]) end end |
#debug(*args) ⇒ Object
158 159 160 161 162 |
# File 'lib/redis2.rb', line 158 def debug(*args) synchronize do |client| client.call([:debug] + args) end end |
#decr(key) ⇒ Fixnum
Decrement the integer value of a key by one.
584 585 586 587 588 |
# File 'lib/redis2.rb', line 584 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.
599 600 601 602 603 |
# File 'lib/redis2.rb', line 599 def decrby(key, decrement) synchronize do |client| client.call([:decrby, key, decrement]) end end |
#del(*keys) ⇒ Fixnum
Delete one or more keys.
416 417 418 419 420 |
# File 'lib/redis2.rb', line 416 def del(*keys) synchronize do |client| client.call([:del] + keys) end end |
#discard ⇒ Object
Discard all commands issued after MULTI.
Only call this method when #multi
was called without a block.
2149 2150 2151 2152 2153 |
# File 'lib/redis2.rb', line 2149 def discard synchronize do |client| client.call([:discard]) end end |
#dump(key) ⇒ String
Return a serialized version of the value stored at a key.
374 375 376 377 378 |
# File 'lib/redis2.rb', line 374 def dump(key) synchronize do |client| client.call([:dump, key]) end end |
#dup ⇒ Object
2449 2450 2451 |
# File 'lib/redis2.rb', line 2449 def dup self.class.new(@options) end |
#echo(value) ⇒ String
Echo the given string.
94 95 96 97 98 |
# File 'lib/redis2.rb', line 94 def echo(value) synchronize do |client| client.call([:echo, value]) end end |
#eval(*args) ⇒ Object
Evaluate Lua script.
2237 2238 2239 |
# File 'lib/redis2.rb', line 2237 def eval(*args) _eval(:eval, args) end |
#evalsha(*args) ⇒ Object
Evaluate Lua script by its SHA.
2262 2263 2264 |
# File 'lib/redis2.rb', line 2262 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.
2135 2136 2137 2138 2139 |
# File 'lib/redis2.rb', line 2135 def exec synchronize do |client| client.call([:exec]) end end |
#exists(key) ⇒ Boolean
Determine if a key exists.
426 427 428 429 430 |
# File 'lib/redis2.rb', line 426 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.
309 310 311 312 313 |
# File 'lib/redis2.rb', line 309 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.
320 321 322 323 324 |
# File 'lib/redis2.rb', line 320 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.
167 168 169 170 171 |
# File 'lib/redis2.rb', line 167 def flushall synchronize do |client| client.call([:flushall]) end end |
#flushdb ⇒ String
Remove all keys from the current database.
176 177 178 179 180 |
# File 'lib/redis2.rb', line 176 def flushdb synchronize do |client| client.call([:flushdb]) end end |
#get(key) ⇒ String Also known as: []
Get the value of a key.
784 785 786 787 788 |
# File 'lib/redis2.rb', line 784 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.
870 871 872 873 874 |
# File 'lib/redis2.rb', line 870 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.
847 848 849 850 851 |
# File 'lib/redis2.rb', line 847 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.
938 939 940 941 942 |
# File 'lib/redis2.rb', line 938 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.
1891 1892 1893 1894 1895 |
# File 'lib/redis2.rb', line 1891 def hdel(key, field) synchronize do |client| client.call([:hdel, key, field]) end end |
#hexists(key, field) ⇒ Boolean
Determine if a hash field exists.
1902 1903 1904 1905 1906 |
# File 'lib/redis2.rb', line 1902 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.
1842 1843 1844 1845 1846 |
# File 'lib/redis2.rb', line 1842 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.
1956 1957 1958 1959 1960 |
# File 'lib/redis2.rb', line 1956 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.
1914 1915 1916 1917 1918 |
# File 'lib/redis2.rb', line 1914 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.
1926 1927 1928 1929 1930 |
# File 'lib/redis2.rb', line 1926 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.
1936 1937 1938 1939 1940 |
# File 'lib/redis2.rb', line 1936 def hkeys(key) synchronize do |client| client.call([:hkeys, key]) end end |
#hlen(key) ⇒ Fixnum
Get the number of fields in a hash.
1775 1776 1777 1778 1779 |
# File 'lib/redis2.rb', line 1775 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.
1859 1860 1861 1862 1863 |
# File 'lib/redis2.rb', line 1859 def hmget(key, *fields, &blk) synchronize do |client| client.call([:hmget, key] + fields, &blk) end end |
#hmset(key, *attrs) ⇒ Object
Set one or more hash values.
1816 1817 1818 1819 1820 |
# File 'lib/redis2.rb', line 1816 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
2339 2340 2341 2342 2343 |
# File 'lib/redis2.rb', line 2339 def hscan(key, cursor, ={}) _scan(:hscan, cursor, [key], ) do |reply| [reply[0], _pairify(reply[1])] end end |
#hscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a hash
2356 2357 2358 2359 2360 2361 2362 2363 2364 |
# File 'lib/redis2.rb', line 2356 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.
1787 1788 1789 1790 1791 |
# File 'lib/redis2.rb', line 1787 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.
1799 1800 1801 1802 1803 |
# File 'lib/redis2.rb', line 1799 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.
1946 1947 1948 1949 1950 |
# File 'lib/redis2.rb', line 1946 def hvals(key) synchronize do |client| client.call([:hvals, key]) end end |
#id ⇒ Object
2441 2442 2443 |
# File 'lib/redis2.rb', line 2441 def id @original_client.id end |
#incr(key) ⇒ Fixnum
Increment the integer value of a key by one.
613 614 615 616 617 |
# File 'lib/redis2.rb', line 613 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.
628 629 630 631 632 |
# File 'lib/redis2.rb', line 628 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.
643 644 645 646 647 |
# File 'lib/redis2.rb', line 643 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.
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 |
# File 'lib/redis2.rb', line 186 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
2445 2446 2447 |
# File 'lib/redis2.rb', line 2445 def inspect "#<Redis2 client v#{Redis2::VERSION} for #{id}>" end |
#keys(pattern = "*") ⇒ Array<String>
Find all keys matching the given pattern.
436 437 438 439 440 441 442 443 444 445 446 |
# File 'lib/redis2.rb', line 436 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.
211 212 213 214 215 |
# File 'lib/redis2.rb', line 211 def lastsave synchronize do |client| client.call([:lastsave]) end end |
#lindex(key, index) ⇒ String
Get an element from a list by its index.
1138 1139 1140 1141 1142 |
# File 'lib/redis2.rb', line 1138 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.
1152 1153 1154 1155 1156 |
# File 'lib/redis2.rb', line 1152 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.
959 960 961 962 963 |
# File 'lib/redis2.rb', line 959 def llen(key) synchronize do |client| client.call([:llen, key]) end end |
#lpop(key) ⇒ String
Remove and get the first element in a list.
1013 1014 1015 1016 1017 |
# File 'lib/redis2.rb', line 1013 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
970 971 972 973 974 |
# File 'lib/redis2.rb', line 970 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.
981 982 983 984 985 |
# File 'lib/redis2.rb', line 981 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.
1164 1165 1166 1167 1168 |
# File 'lib/redis2.rb', line 1164 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.
1179 1180 1181 1182 1183 |
# File 'lib/redis2.rb', line 1179 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.
1191 1192 1193 1194 1195 |
# File 'lib/redis2.rb', line 1191 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.
1203 1204 1205 1206 1207 |
# File 'lib/redis2.rb', line 1203 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.
1876 1877 1878 1879 1880 1881 1882 1883 1884 |
# File 'lib/redis2.rb', line 1876 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) ⇒ Object
Set one or more hash values.
1833 1834 1835 |
# File 'lib/redis2.rb', line 1833 def mapped_hmset(key, hash) hmset(key, hash.to_a.flatten) end |
#mapped_mget(*keys) ⇒ Hash
Get the values of all the given keys.
818 819 820 821 822 823 824 825 826 |
# File 'lib/redis2.rb', line 818 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) ⇒ Object
Set one or more values.
746 747 748 |
# File 'lib/redis2.rb', line 746 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.
776 777 778 |
# File 'lib/redis2.rb', line 776 def mapped_msetnx(hash) msetnx(hash.to_a.flatten) end |
#mget(*keys, &blk) ⇒ Array<String>
Get the values of all the given keys.
802 803 804 805 806 |
# File 'lib/redis2.rb', line 802 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.
401 402 403 404 405 406 407 408 409 410 |
# File 'lib/redis2.rb', line 401 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.
223 224 225 226 227 |
# File 'lib/redis2.rb', line 223 def monitor(&block) synchronize do |client| client.call_loop([:monitor], &block) end end |
#move(key, db) ⇒ Boolean
Move a key to another database.
467 468 469 470 471 |
# File 'lib/redis2.rb', line 467 def move(key, db) synchronize do |client| client.call([:move, key, db], &_boolify) end end |
#mset(*args) ⇒ Object
Set one or more values.
730 731 732 733 734 |
# File 'lib/redis2.rb', line 730 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.
760 761 762 763 764 |
# File 'lib/redis2.rb', line 760 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.
2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 |
# File 'lib/redis2.rb', line 2108 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
473 474 475 476 477 |
# File 'lib/redis2.rb', line 473 def object(*args) synchronize do |client| client.call([:object] + args) end end |
#persist(key) ⇒ Boolean
Remove the expiration from a key.
298 299 300 301 302 |
# File 'lib/redis2.rb', line 298 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.
342 343 344 345 346 |
# File 'lib/redis2.rb', line 342 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.
353 354 355 356 357 |
# File 'lib/redis2.rb', line 353 def pexpireat(key, ms_unix_time) synchronize do |client| client.call([:pexpireat, key, ms_unix_time], &_boolify) end end |
#ping ⇒ String
Ping the server.
84 85 86 87 88 |
# File 'lib/redis2.rb', line 84 def ping synchronize do |client| client.call([:ping]) end end |
#pipelined ⇒ Object
2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 |
# File 'lib/redis2.rb', line 2066 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) ⇒ Object
Set the time to live in milliseconds of a key.
703 704 705 706 707 |
# File 'lib/redis2.rb', line 703 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.
1991 1992 1993 1994 1995 |
# File 'lib/redis2.rb', line 1991 def psubscribe(*channels, &block) synchronize do |client| _subscription(:psubscribe, channels, block) end end |
#pttl(key) ⇒ Fixnum
Get the time to live (in milliseconds) for a key.
364 365 366 367 368 |
# File 'lib/redis2.rb', line 364 def pttl(key) synchronize do |client| client.call([:pttl, key]) end end |
#publish(channel, message) ⇒ Object
Post a message to a channel.
1963 1964 1965 1966 1967 |
# File 'lib/redis2.rb', line 1963 def publish(channel, ) synchronize do |client| client.call([:publish, channel, ]) end end |
#punsubscribe(*channels) ⇒ Object
Stop listening for messages posted to channels matching the given patterns.
1998 1999 2000 2001 2002 2003 |
# File 'lib/redis2.rb', line 1998 def punsubscribe(*channels) synchronize do |client| raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed? client.punsubscribe(*channels) end end |
#quit ⇒ String
Close the connection.
103 104 105 106 107 108 109 110 111 112 |
# File 'lib/redis2.rb', line 103 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.
482 483 484 485 486 |
# File 'lib/redis2.rb', line 482 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.
493 494 495 496 497 |
# File 'lib/redis2.rb', line 493 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.
504 505 506 507 508 |
# File 'lib/redis2.rb', line 504 def renamenx(old_name, new_name) synchronize do |client| client.call([:renamenx, old_name, new_name], &_boolify) end end |
#restore(key, ttl, serialized_value) ⇒ Object
Create a key using the serialized value, previously obtained using DUMP.
386 387 388 389 390 |
# File 'lib/redis2.rb', line 386 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.
1023 1024 1025 1026 1027 |
# File 'lib/redis2.rb', line 1023 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.
1034 1035 1036 1037 1038 |
# File 'lib/redis2.rb', line 1034 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
992 993 994 995 996 |
# File 'lib/redis2.rb', line 992 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.
1003 1004 1005 1006 1007 |
# File 'lib/redis2.rb', line 1003 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.
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 |
# File 'lib/redis2.rb', line 1227 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.
232 233 234 235 236 |
# File 'lib/redis2.rb', line 232 def save synchronize do |client| client.call([:save]) end end |
#scan(cursor, options = {}) ⇒ String+
Scan the keyspace
2299 2300 2301 |
# File 'lib/redis2.rb', line 2299 def scan(cursor, ={}) _scan(:scan, cursor, [], ) end |
#scan_each(options = {}, &block) ⇒ Enumerator
Scan the keyspace
2318 2319 2320 2321 2322 2323 2324 2325 2326 |
# File 'lib/redis2.rb', line 2318 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.
1213 1214 1215 1216 1217 |
# File 'lib/redis2.rb', line 1213 def scard(key) synchronize do |client| client.call([:scard, key]) end end |
#script(subcommand, *args) ⇒ String, ...
Control remote script registry.
2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 |
# File 'lib/redis2.rb', line 2179 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.
1325 1326 1327 1328 1329 |
# File 'lib/redis2.rb', line 1325 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.
1336 1337 1338 1339 1340 |
# File 'lib/redis2.rb', line 1336 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.
74 75 76 77 78 79 |
# File 'lib/redis2.rb', line 74 def select(db) synchronize do |client| client.db = db client.call([:select, db]) end end |
#set(key, value, options = {}) ⇒ String, Boolean Also known as: []=
Set the string value of a key.
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 |
# File 'lib/redis2.rb', line 659 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, &_boolify_set) 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.
859 860 861 862 863 |
# File 'lib/redis2.rb', line 859 def setbit(key, offset, value) synchronize do |client| client.call([:setbit, key, offset, value]) end end |
#setex(key, ttl, value) ⇒ Object
Set the time to live in seconds of a key.
691 692 693 694 695 |
# File 'lib/redis2.rb', line 691 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.
714 715 716 717 718 |
# File 'lib/redis2.rb', line 714 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.
834 835 836 837 838 |
# File 'lib/redis2.rb', line 834 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.
239 240 241 242 243 244 245 246 247 248 249 250 |
# File 'lib/redis2.rb', line 239 def shutdown synchronize do |client| client.with_reconnect(false) do begin client.call([:shutdown]) rescue ConnectionError # This means Redis2 has probably exited. nil end end end end |
#sinter(*keys) ⇒ Array<String>
Intersect multiple sets.
1346 1347 1348 1349 1350 |
# File 'lib/redis2.rb', line 1346 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.
1357 1358 1359 1360 1361 |
# File 'lib/redis2.rb', line 1357 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.
1305 1306 1307 1308 1309 |
# File 'lib/redis2.rb', line 1305 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.
253 254 255 256 257 |
# File 'lib/redis2.rb', line 253 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)
264 265 266 267 268 269 270 |
# File 'lib/redis2.rb', line 264 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.
1315 1316 1317 1318 1319 |
# File 'lib/redis2.rb', line 1315 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.
1294 1295 1296 1297 1298 |
# File 'lib/redis2.rb', line 1294 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.
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 |
# File 'lib/redis2.rb', line 535 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.
1267 1268 1269 1270 1271 |
# File 'lib/redis2.rb', line 1267 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.
1278 1279 1280 1281 1282 1283 1284 1285 1286 |
# File 'lib/redis2.rb', line 1278 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.
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 |
# File 'lib/redis2.rb', line 1249 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
2416 2417 2418 |
# File 'lib/redis2.rb', line 2416 def sscan(key, cursor, ={}) _scan(:sscan, cursor, [key], ) end |
#sscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a set
2431 2432 2433 2434 2435 2436 2437 2438 2439 |
# File 'lib/redis2.rb', line 2431 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.
949 950 951 952 953 |
# File 'lib/redis2.rb', line 949 def strlen(key) synchronize do |client| client.call([:strlen, key]) end end |
#subscribe(*channels, &block) ⇒ Object
Listen for messages published to the given channels.
1976 1977 1978 1979 1980 |
# File 'lib/redis2.rb', line 1976 def subscribe(*channels, &block) synchronize do |client| _subscription(:subscribe, channels, block) end end |
#subscribed? ⇒ Boolean
1969 1970 1971 1972 1973 |
# File 'lib/redis2.rb', line 1969 def subscribed? synchronize do |client| client.kind_of? SubscribedClient end end |
#sunion(*keys) ⇒ Array<String>
Add multiple sets.
1367 1368 1369 1370 1371 |
# File 'lib/redis2.rb', line 1367 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.
1378 1379 1380 1381 1382 |
# File 'lib/redis2.rb', line 1378 def sunionstore(destination, *keys) synchronize do |client| client.call([:sunionstore, destination] + keys) end end |
#sync ⇒ Object
Internal command used for replication.
273 274 275 276 277 |
# File 'lib/redis2.rb', line 273 def sync synchronize do |client| client.call([:sync]) end end |
#synchronize ⇒ Object
38 39 40 |
# File 'lib/redis2.rb', line 38 def synchronize mon_synchronize { yield(@client) } end |
#time ⇒ Array<Fixnum>
Return the server time.
286 287 288 289 290 291 292 |
# File 'lib/redis2.rb', line 286 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.
331 332 333 334 335 |
# File 'lib/redis2.rb', line 331 def ttl(key) synchronize do |client| client.call([:ttl, key]) end end |
#type(key) ⇒ String
Determine the type stored at key.
570 571 572 573 574 |
# File 'lib/redis2.rb', line 570 def type(key) synchronize do |client| client.call([:type, key]) end end |
#unsubscribe(*channels) ⇒ Object
Stop listening for messages posted to the given channels.
1983 1984 1985 1986 1987 1988 |
# File 'lib/redis2.rb', line 1983 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.
2060 2061 2062 2063 2064 |
# File 'lib/redis2.rb', line 2060 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.
2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 |
# File 'lib/redis2.rb', line 2035 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
43 44 45 46 47 |
# File 'lib/redis2.rb', line 43 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
50 51 52 |
# File 'lib/redis2.rb', line 50 def without_reconnect(&blk) with_reconnect(false, &blk) end |
#zadd(key, *args) ⇒ Boolean, Fixnum
Add one or more members to a sorted set, or update the score for members that already exist.
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 |
# File 'lib/redis2.rb', line 1416 def zadd(key, *args) synchronize do |client| if args.size == 1 && args[0].is_a?(Array) # Variadic: return integer client.call([:zadd, key] + args[0]) elsif args.size == 2 # Single pair: return boolean client.call([:zadd, key, args[0], args[1]], &_boolify) else raise ArgumentError, "wrong number of arguments" end end end |
#zcard(key) ⇒ Fixnum
Get the number of members in a sorted set.
1392 1393 1394 1395 1396 |
# File 'lib/redis2.rb', line 1392 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.
1710 1711 1712 1713 1714 |
# File 'lib/redis2.rb', line 1710 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.
1440 1441 1442 1443 1444 |
# File 'lib/redis2.rb', line 1440 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.
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 |
# File 'lib/redis2.rb', line 1730 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.
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 |
# File 'lib/redis2.rb', line 1510 def zrange(key, start, stop, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << "WITHSCORES" block = _floatify_pairs end synchronize do |client| client.call([:zrange, key, start, stop] + args, &block) end end |
#zrangebyscore(key, min, max, options = {}) ⇒ Array<String>, Array<[String, Float]>
Return a range of members in a sorted set, by score.
1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 |
# File 'lib/redis2.rb', line 1620 def zrangebyscore(key, min, max, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << "WITHSCORES" block = _floatify_pairs 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.
1556 1557 1558 1559 1560 |
# File 'lib/redis2.rb', line 1556 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.
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 |
# File 'lib/redis2.rb', line 1463 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.
1587 1588 1589 1590 1591 |
# File 'lib/redis2.rb', line 1587 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.
1687 1688 1689 1690 1691 |
# File 'lib/redis2.rb', line 1687 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.
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 |
# File 'lib/redis2.rb', line 1536 def zrevrange(key, start, stop, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << "WITHSCORES" block = _floatify_pairs end synchronize do |client| client.call([:zrevrange, key, start, stop] + args, &block) 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.
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 |
# File 'lib/redis2.rb', line 1652 def zrevrangebyscore(key, max, min, = {}) args = [] with_scores = [:with_scores] || [:withscores] if with_scores args << ["WITHSCORES"] block = _floatify_pairs 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.
1568 1569 1570 1571 1572 |
# File 'lib/redis2.rb', line 1568 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
2378 2379 2380 2381 2382 |
# File 'lib/redis2.rb', line 2378 def zscan(key, cursor, ={}) _scan(:zscan, cursor, [key], ) do |reply| [reply[0], _floatify_pairs.call(reply[1])] end end |
#zscan_each(key, options = {}, &block) ⇒ Enumerator
Scan a sorted set
2395 2396 2397 2398 2399 2400 2401 2402 2403 |
# File 'lib/redis2.rb', line 2395 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.
1486 1487 1488 1489 1490 |
# File 'lib/redis2.rb', line 1486 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.
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 |
# File 'lib/redis2.rb', line 1757 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 |