123456789_123456789_123456789_123456789_123456789_

Class: Redis::Distributed

Relationships & Source Files
Namespace Children
Exceptions:
CannotDistribute
Inherits: Object
Defined in: lib/redis/distributed.rb

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(node_configs, options = {}) ⇒ Distributed

[ GitHub ] 

  


# File 'lib/redis/distributed.rb', line 20



def initialize(node_configs, options = {})
  @tag = options[:tag] || /^\{(.+?)\}/
  @ring = options[:ring] || HashRing.new
  @node_configs = node_configs.map(&:dup)
  @default_options = options.dup
  node_configs.each { |node_config| add_node(node_config) }
  @subscribed_node = nil
  @watch_key = nil
end


  







Instance Attribute Details



  

    #ring   (readonly)
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 18



attr_reader :ring


  








  

    #subscribed?  ⇒ Boolean  (readonly)
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 926



def subscribed?
  !!@subscribed_node
end


  







Instance Method Details



  

    #[](key)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 410



def [](key)
  get(key)
end


  








  

    #[]=(key, value)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 414



def []=(key, value)
  set(key, value)
end


  








  

    #_bpop(cmd, args)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 476



def _bpop(cmd, args)
  timeout = if args.last.is_a?(Hash)
    options = args.pop
    options[:timeout]
  end

  args.flatten!(1)

  ensure_same_node(cmd, args) do |node|
    if timeout
      node.__send__(cmd, args, timeout: timeout)
    else
      node.__send__(cmd, args)
    end
  end
end


  








  

    #_eval(cmd, args)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1042



def _eval(cmd, args)
  script = args.shift
  options = args.pop if args.last.is_a?(Hash)
  options ||= {}

  keys = args.shift || options[:keys] || []
  argv = args.shift || options[:argv] || []

  ensure_same_node(cmd, keys) do |node|
    node.send(cmd, script, keys, argv)
  end
end


  








  

    #add_node(options)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 41



def add_node(options)
  options = { url: options } if options.is_a?(String)
  options = @default_options.merge(options)
  options.delete(:tag)
  options.delete(:ring)
  @ring.add_node Redis.new(options)
end


  








  

    #append(key, value)  
  



  

    
Append a value to a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 378



def append(key, value)
  node_for(key).append(key, value)
end


  








  

    #bgsave  
  



  

    
Asynchronously save the dataset to disk.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 74



def bgsave
  on_each_node :bgsave
end


  








  

    #bitcount(key, start = 0, stop = -1,, scale: nil)  
  



  

    
Count the number of set bits in a range of the string value stored at key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 383



def bitcount(key, start = 0, stop = -1, scale: nil)
  node_for(key).bitcount(key, start, stop, scale: scale)
end


  








  

    #bitop(operation, destkey, *keys)  
  



  

    
Perform a bitwise operation between strings and store the resulting string in a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 388



def bitop(operation, destkey, *keys)
  keys.flatten!(1)
  ensure_same_node(:bitop, [destkey] + keys) do |node|
    node.bitop(operation, destkey, keys)
  end
end


  








  

    #bitpos(key, bit, start = nil, stop = nil, scale: nil)  
  



  

    
Return the position of the first bit set to 1 or 0 in a string.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 396



def bitpos(key, bit, start = nil, stop = nil, scale: nil)
  node_for(key).bitpos(key, bit, start, stop, scale: scale)
end


  








  

    #blmove(source, destination, where_source, where_destination, timeout: 0)  
  



  

    
Remove the first/last element in a list and append/prepend it
to another list and return it, or block until one is available.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 432



def blmove(source, destination, where_source, where_destination, timeout: 0)
  ensure_same_node(:lmove, [source, destination]) do |node|
    node.blmove(source, destination, where_source, where_destination, timeout: timeout)
  end
end


  








  

    #blmpop(timeout, *keys, modifier: "LEFT", count: nil)  
  



  

    
Iterate over keys, blocking and removing elements from the first non empty liist found.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 556



def blmpop(timeout, *keys, modifier: "LEFT", count: nil)
  ensure_same_node(:blmpop, keys) do |node|
    node.blmpop(timeout, *keys, modifier: modifier, count: count)
  end
end


  








  

    #blpop(*args)  
  



  

    
Remove and get the first element in a list, or block until one is
available.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 495



def blpop(*args)
  _bpop(:blpop, args)
end


  








  

    #brpop(*args)  
  



  

    
Remove and get the last element in a list, or block until one is
available.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 513



def brpop(*args)
  _bpop(:brpop, args)
end


  








  

    #brpoplpush(source, destination, **options)  
  



  

    
Pop a value from a list, push it to another list and return it; or block
until one is available.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 519



def brpoplpush(source, destination, **options)
  ensure_same_node(:brpoplpush, [source, destination]) do |node|
    node.brpoplpush(source, destination, **options)
  end
end


  








  

    #bzmpop(timeout, *keys, modifier: "MIN", count: nil)  
  



  

    
Iterate over keys, blocking and removing members from the first non empty sorted set found.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 722



def bzmpop(timeout, *keys, modifier: "MIN", count: nil)
  ensure_same_node(:bzmpop, keys) do |node|
    node.bzmpop(timeout, *keys, modifier: modifier, count: count)
  end
end


  








  

    #bzpopmax(*args)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 499



def bzpopmax(*args)
  _bpop(:bzpopmax, args) do |reply|
    reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
  end
end


  








  

    #bzpopmin(*args)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 505



def bzpopmin(*args)
  _bpop(:bzpopmin, args) do |reply|
    reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
  end
end


  








  

    #close  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 69



def close
  on_each_node :close
end


  








  

    #copy(source, destination, **options)  
  



  

    
Copy a value from one key to another.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 226



def copy(source, destination, **options)
  ensure_same_node(:copy, [source, destination]) do |node|
    node.copy(source, destination, **options)
  end
end


  








  

    #dbsize  
  



  

    
Return the number of keys in the selected database.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 79



def dbsize
  on_each_node :dbsize
end


  








  

    #decr(key)  
  



  

    
Decrement the integer value of a key by one.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 266



def decr(key)
  node_for(key).decr(key)
end


  








  

    #decrby(key, decrement)  
  



  

    
Decrement the integer value of a key by the given number.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 271



def decrby(key, decrement)
  node_for(key).decrby(key, decrement)
end


  








  

    #del(*args)  
  



  

    
Delete a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 179



def del(*args)
  args.flatten!(1)
  keys_per_node = args.group_by { |key| node_for(key) }
  keys_per_node.inject(0) do |sum, (node, keys)|
    sum + node.del(*keys)
  end
end


  








  

    #discard  
  



  

    
Discard all commands issued after MULTI.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1009



def discard
  raise CannotDistribute, :discard unless @watch_key

  result = node_for(@watch_key).discard
  @watch_key = nil
  result
end


  








  

    #dump(key)  
  



  

    
Return a serialized version of the value stored at a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 164



def dump(key)
  node_for(key).dump(key)
end


  








  

    #dup  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1069



def dup
  self.class.new(@node_configs, @default_options)
end


  








  

    #echo(value)  
  



  

    
Echo the given string.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 60



def echo(value)
  on_each_node :echo, value
end


  








  

    #ensure_same_node(command, keys) {|node_for(keys.first)| ... }  (protected)
  



  

    
  





  
Yields:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1090



def ensure_same_node(command, keys)
  all = true

  tags = keys.map do |key|
    tag = key_tag(key)
    all = false unless tag
    tag
  end

  if (all && tags.uniq.size != 1) || (!all && keys.uniq.size != 1)
    # Not 1 unique tag or not 1 unique key
    raise CannotDistribute, command
  end

  yield(node_for(keys.first))
end


  








  

    #eval(*args)  
  



  

    
Evaluate Lua script.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1056



def eval(*args)
  _eval(:eval, args)
end


  








  

    #evalsha(*args)  
  



  

    
Evaluate Lua script by its SHA.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1061



def evalsha(*args)
  _eval(:evalsha, args)
end


  








  

    #exec  
  



  

    
Execute all commands issued after MULTI.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1000



def exec
  raise CannotDistribute, :exec unless @watch_key

  result = node_for(@watch_key).exec
  @watch_key = nil
  result
end


  








  

    #exists(*args)  
  



  

    
Determine if a key exists.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 197



def exists(*args)
  args.flatten!(1)
  keys_per_node = args.group_by { |key| node_for(key) }
  keys_per_node.inject(0) do |sum, (node, keys)|
    sum + node.exists(*keys)
  end
end


  








  

    #exists?(*args)  ⇒ Boolean 
  



  

    
Determine if any of the keys exists.


  





  


  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 206



def exists?(*args)
  args.flatten!(1)
  keys_per_node = args.group_by { |key| node_for(key) }
  keys_per_node.each do |node, keys|
    return true if node.exists?(*keys)
  end
  false
end


  








  

    #expire(key, seconds, **kwargs)  
  



  

    
Set a key's time to live in seconds.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 124



def expire(key, seconds, **kwargs)
  node_for(key).expire(key, seconds, **kwargs)
end


  








  

    #expireat(key, unix_time, **kwargs)  
  



  

    
Set the expiration for a key as a UNIX timestamp.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 129



def expireat(key, unix_time, **kwargs)
  node_for(key).expireat(key, unix_time, **kwargs)
end


  








  

    #expiretime(key)  
  



  

    
Get the expiration for a key as a UNIX timestamp.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 134



def expiretime(key)
  node_for(key).expiretime(key)
end


  








  

    #flushall  
  



  

    
Remove all keys from all databases.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 84



def flushall
  on_each_node :flushall
end


  








  

    #flushdb  
  



  

    
Remove all keys from the current database.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 89



def flushdb
  on_each_node :flushdb
end


  








  

    #get(key)  
  



  

    
Get the value of a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 329



def get(key)
  node_for(key).get(key)
end


  








  

    #getbit(key, offset)  
  



  

    
Returns the bit value at offset in the string value stored at key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 373



def getbit(key, offset)
  node_for(key).getbit(key, offset)
end


  








  

    #getdel(key)  
  



  

    
Get the value of a key and delete it.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 334



def getdel(key)
  node_for(key).getdel(key)
end


  








  

    #getex(key, **options)  
  



  

    
Get the value of a key and sets its time to live based on options.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 339



def getex(key, **options)
  node_for(key).getex(key, **options)
end


  








  

    #getrange(key, start, stop)  
  



  

    
Get a substring of the string stored at a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 363



def getrange(key, start, stop)
  node_for(key).getrange(key, start, stop)
end


  








  

    #getset(key, value)  
  



  

    
Set the string value of a key and return its old value.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 401



def getset(key, value)
  node_for(key).getset(key, value)
end


  








  

    #hdel(key, *fields)  
  



  

    
Delete one or more hash fields.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 886



def hdel(key, *fields)
  fields.flatten!(1)
  node_for(key).hdel(key, fields)
end


  








  

    #hexists(key, field)  
  



  

    
Determine if a hash field exists.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 892



def hexists(key, field)
  node_for(key).hexists(key, field)
end


  








  

    #hget(key, field)  
  



  

    
Get the value of a hash field.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 866



def hget(key, field)
  node_for(key).hget(key, field)
end


  








  

    #hgetall(key)  
  



  

    
Get all the fields and values in a hash.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 917



def hgetall(key)
  node_for(key).hgetall(key)
end


  








  

    #hincrby(key, field, increment)  
  



  

    
Increment the integer value of a hash field by the given integer number.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 897



def hincrby(key, field, increment)
  node_for(key).hincrby(key, field, increment)
end


  








  

    #hincrbyfloat(key, field, increment)  
  



  

    
Increment the numeric value of a hash field by the given float number.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 902



def hincrbyfloat(key, field, increment)
  node_for(key).hincrbyfloat(key, field, increment)
end


  








  

    #hkeys(key)  
  



  

    
Get all the fields in a hash.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 907



def hkeys(key)
  node_for(key).hkeys(key)
end


  








  

    #hlen(key)  
  



  

    
Get the number of fields in a hash.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 842



def hlen(key)
  node_for(key).hlen(key)
end


  








  

    #hmget(key, *fields)  
  



  

    
Get the values of all the given hash fields.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 871



def hmget(key, *fields)
  fields.flatten!(1)
  node_for(key).hmget(key, fields)
end


  








  

    #hmset(key, *attrs)  
  



  

    
Set multiple hash fields to multiple values.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 857



def hmset(key, *attrs)
  node_for(key).hmset(key, *attrs)
end


  








  

    #hrandfield(key, count = nil, **options)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 881



def hrandfield(key, count = nil, **options)
  node_for(key).hrandfield(key, count, **options)
end


  








  

    #hset(key, *attrs)  
  



  

    
Set multiple hash fields to multiple values.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 847



def hset(key, *attrs)
  node_for(key).hset(key, *attrs)
end


  








  

    #hsetnx(key, field, value)  
  



  

    
Set the value of a hash field, only if the field does not exist.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 852



def hsetnx(key, field, value)
  node_for(key).hsetnx(key, field, value)
end


  








  

    #hvals(key)  
  



  

    
Get all the values in a hash.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 912



def hvals(key)
  node_for(key).hvals(key)
end


  








  

    #incr(key)  
  



  

    
Increment the integer value of a key by one.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 276



def incr(key)
  node_for(key).incr(key)
end


  








  

    #incrby(key, increment)  
  



  

    
Increment the integer value of a key by the given integer number.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 281



def incrby(key, increment)
  node_for(key).incrby(key, increment)
end


  








  

    #incrbyfloat(key, increment)  
  



  

    
Increment the numeric value of a key by the given float number.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 286



def incrbyfloat(key, increment)
  node_for(key).incrbyfloat(key, increment)
end


  








  

    #info(cmd = nil)  
  



  

    
Get information and statistics about the server.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 94



def info(cmd = nil)
  on_each_node :info, cmd
end


  








  

    #inspect  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1065



def inspect
  "#<Redis client v#{Redis::VERSION} for #{nodes.map(&:id).join(', ')}>"
end


  








  

    #key_tag(key)   (protected)
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1085



def key_tag(key)
  key = key.to_s
  key[@tag, 1] if key.match?(@tag)
end


  








  

    #keys(glob = "*")  
  



  

    
Find all keys matching the given pattern.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 216



def keys(glob = "*")
  on_each_node(:keys, glob).flatten
end


  








  

    #lastsave  
  



  

    
Get the UNIX time stamp of the last successful save to disk.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 99



def lastsave
  on_each_node :lastsave
end


  








  

    #lindex(key, index)  
  



  

    
Get an element from a list by its index.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 526



def lindex(key, index)
  node_for(key).lindex(key, index)
end


  








  

    #linsert(key, where, pivot, value)  
  



  

    
Insert an element before or after another element in a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 531



def linsert(key, where, pivot, value)
  node_for(key).linsert(key, where, pivot, value)
end


  








  

    #llen(key)  
  



  

    
Get the length of a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 419



def llen(key)
  node_for(key).llen(key)
end


  








  

    #lmove(source, destination, where_source, where_destination)  
  



  

    
Remove the first/last element in a list, append/prepend it to another list and return it.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 424



def lmove(source, destination, where_source, where_destination)
  ensure_same_node(:lmove, [source, destination]) do |node|
    node.lmove(source, destination, where_source, where_destination)
  end
end


  








  

    #lmpop(*keys, modifier: "LEFT", count: nil)  
  



  

    
Iterate over keys, removing elements from the first non list found.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 563



def lmpop(*keys, modifier: "LEFT", count: nil)
  ensure_same_node(:lmpop, keys) do |node|
    node.lmpop(*keys, modifier: modifier, count: count)
  end
end


  








  

    #lpop(key, count = nil)  
  



  

    
Remove and get the first elements in a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 459



def lpop(key, count = nil)
  node_for(key).lpop(key, count)
end


  








  

    #lpush(key, value)  
  



  

    
Prepend one or more values to a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 439



def lpush(key, value)
  node_for(key).lpush(key, value)
end


  








  

    #lpushx(key, value)  
  



  

    
Prepend a value to a list, only if the list exists.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 444



def lpushx(key, value)
  node_for(key).lpushx(key, value)
end


  








  

    #lrange(key, start, stop)  
  



  

    
Get a range of elements from a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 536



def lrange(key, start, stop)
  node_for(key).lrange(key, start, stop)
end


  








  

    #lrem(key, count, value)  
  



  

    
Remove elements from a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 541



def lrem(key, count, value)
  node_for(key).lrem(key, count, value)
end


  








  

    #lset(key, index, value)  
  



  

    
Set the value of an element in a list by its index.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 546



def lset(key, index, value)
  node_for(key).lset(key, index, value)
end


  








  

    #ltrim(key, start, stop)  
  



  

    
Trim a list to the specified range.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 551



def ltrim(key, start, stop)
  node_for(key).ltrim(key, start, stop)
end


  








  

    #mapped_hmget(key, *fields)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 876



def mapped_hmget(key, *fields)
  fields.flatten!(1)
  node_for(key).mapped_hmget(key, fields)
end


  








  

    #mapped_hmset(key, hash)  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 861



def mapped_hmset(key, hash)
  node_for(key).hmset(key, hash)
end


  








  

    #mapped_mget(*keys)  
  



  

    
Get the values of all the given keys as a Hash.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 350



def mapped_mget(*keys)
  keys.flatten!(1)
  keys.group_by { |k| node_for k }.inject({}) do |results, (node, subkeys)|
    results.merge! node.mapped_mget(*subkeys)
  end
end


  








  

    #mapped_mset(_hash)  
  



  

    
  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 315



def mapped_mset(_hash)
  raise CannotDistribute, :mapped_mset
end


  








  

    #mapped_msetnx(_hash)  
  



  

    
  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 324



def mapped_msetnx(_hash)
  raise CannotDistribute, :mapped_msetnx
end


  








  

    #mget(*keys)  
  



  

    
Get the values of all the given keys as an Array.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 344



def mget(*keys)
  keys.flatten!(1)
  mapped_mget(*keys).values_at(*keys)
end


  








  

    #migrate(_key, _options)  
  



  

    
Transfer a key from the connected instance to another instance.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 174



def migrate(_key, _options)
  raise CannotDistribute, :migrate
end


  








  

    #monitor  
  



  

    
Listen for all requests received by the server in real time.


  





  
Raises:


    
  
  • 
    (NotImplementedError)
  
    • 





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 104



def monitor
  raise NotImplementedError
end


  








  

    #move(key, db)  
  



  

    
Move a key to another database.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 221



def move(key, db)
  node_for(key).move(key, db)
end


  








  

    #mset  
  



  

    
Set multiple keys to multiple values.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 311



def mset(*)
  raise CannotDistribute, :mset
end


  








  

    #msetnx  
  



  

    
Set multiple keys to multiple values, only if none of the keys exist.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 320



def msetnx(*)
  raise CannotDistribute, :msetnx
end


  








  

    #multi(&block)  
  



  

    
Mark the start of a transaction block.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 993



def multi(&block)
  raise CannotDistribute, :multi unless @watch_key

  node_for(@watch_key).multi(&block)
end


  








  

    #node_for(key)  
  



  

    
  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 30



def node_for(key)
  key = key_tag(key.to_s) || key.to_s
  raise CannotDistribute, :watch if @watch_key && @watch_key != key

  @ring.get_node(key)
end


  








  

    #node_index_for(key)   (protected)
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1081



def node_index_for(key)
  nodes.index(node_for(key))
end


  








  

    #nodes  
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 37



def nodes
  @ring.nodes
end


  








  

    #on_each_node(command, *args)   (protected)
  

  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1075



def on_each_node(command, *args)
  nodes.map do |node|
    node.send(command, *args)
  end
end


  








  

    #persist(key)  
  



  

    
Remove the expiration from a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 119



def persist(key)
  node_for(key).persist(key)
end


  








  

    #pexpire(key, milliseconds, **kwarg)  
  



  

    
Set a key's time to live in milliseconds.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 144



def pexpire(key, milliseconds, **kwarg)
  node_for(key).pexpire(key, milliseconds, **kwarg)
end


  








  

    #pexpireat(key, ms_unix_time, **kwarg)  
  



  

    
Set the expiration for a key as number of milliseconds from UNIX Epoch.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 149



def pexpireat(key, ms_unix_time, **kwarg)
  node_for(key).pexpireat(key, ms_unix_time, **kwarg)
end


  








  

    #pexpiretime(key)  
  



  

    
Get the expiration for a key as number of milliseconds from UNIX Epoch.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 154



def pexpiretime(key)
  node_for(key).pexpiretime(key)
end


  








  

    #pfadd(key, member)  
  



  

    
Add one or more members to a HyperLogLog structure.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1023



def pfadd(key, member)
  node_for(key).pfadd(key, member)
end


  








  

    #pfcount(*keys)  
  



  

    
Get the approximate cardinality of members added to HyperLogLog structure.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1028



def pfcount(*keys)
  ensure_same_node(:pfcount, keys.flatten(1)) do |node|
    node.pfcount(keys)
  end
end


  








  

    #pfmerge(dest_key, *source_key)  
  



  

    
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.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1036



def pfmerge(dest_key, *source_key)
  ensure_same_node(:pfmerge, [dest_key, *source_key]) do |node|
    node.pfmerge(dest_key, *source_key)
  end
end


  








  

    #ping  
  



  

    
Ping the server.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 55



def ping
  on_each_node :ping
end


  








  

    #pipelined  
  



  

    
  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 988



def pipelined
  raise CannotDistribute, :pipelined
end


  








  

    #psetex(key, ttl, value)  
  



  

    
Set the time to live in milliseconds of a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 301



def psetex(key, ttl, value)
  node_for(key).psetex(key, ttl, value)
end


  








  

    #psubscribe(*channels, &block)  
  



  

    
Listen for messages published to channels matching the given patterns.
See the Redis Server PSUBSCRIBE documentation
for further details


  





  
Raises:


    
  
  • 
    (NotImplementedError)
  
    • 





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 953



def psubscribe(*channels, &block)
  raise NotImplementedError
end


  








  

    #pttl(key)  
  



  

    
Get the time to live (in milliseconds) for a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 159



def pttl(key)
  node_for(key).pttl(key)
end


  








  

    #publish(channel, message)  
  



  

    
Post a message to a channel.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 922



def publish(channel, message)
  node_for(channel).publish(channel, message)
end


  








  

    #punsubscribe(*channels)  
  



  

    
Stop listening for messages posted to channels matching the given
patterns.
See the Redis Server PUNSUBSCRIBE documentation
for further details


  





  
Raises:


    
  
  • 
    (NotImplementedError)
  
    • 





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 961



def punsubscribe(*channels)
  raise NotImplementedError
end


  








  

    #quit  
  



  

    
Close the connection.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 65



def quit
  on_each_node :quit
end


  








  

    #randomkey  
  



  

    
Return a random key from the keyspace.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 233



def randomkey
  raise CannotDistribute, :randomkey
end


  








  

    #rename(old_name, new_name)  
  



  

    
Rename a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 238



def rename(old_name, new_name)
  ensure_same_node(:rename, [old_name, new_name]) do |node|
    node.rename(old_name, new_name)
  end
end


  








  

    #renamenx(old_name, new_name)  
  



  

    
Rename a key, only if the new key does not exist.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 245



def renamenx(old_name, new_name)
  ensure_same_node(:renamenx, [old_name, new_name]) do |node|
    node.renamenx(old_name, new_name)
  end
end


  








  

    #restore(key, ttl, serialized_value, **options)  
  



  

    
Create a key using the serialized value, previously obtained using DUMP.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 169



def restore(key, ttl, serialized_value, **options)
  node_for(key).restore(key, ttl, serialized_value, **options)
end


  








  

    #rpop(key, count = nil)  
  



  

    
Remove and get the last elements in a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 464



def rpop(key, count = nil)
  node_for(key).rpop(key, count)
end


  








  

    #rpoplpush(source, destination)  
  



  

    
Remove the last element in a list, append it to another list and return
it.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 470



def rpoplpush(source, destination)
  ensure_same_node(:rpoplpush, [source, destination]) do |node|
    node.rpoplpush(source, destination)
  end
end


  








  

    #rpush(key, value)  
  



  

    
Append one or more values to a list.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 449



def rpush(key, value)
  node_for(key).rpush(key, value)
end


  








  

    #rpushx(key, value)  
  



  

    
Append a value to a list, only if the list exists.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 454



def rpushx(key, value)
  node_for(key).rpushx(key, value)
end


  








  

    #sadd(key, *members)  
  



  

    
Add one or more members to a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 575



def sadd(key, *members)
  node_for(key).sadd(key, *members)
end


  








  

    #sadd?(key, *members)  ⇒ Boolean 
  



  

    
Add one or more members to a set.


  





  


  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 580



def sadd?(key, *members)
  node_for(key).sadd?(key, *members)
end


  








  

    #save  
  



  

    
Synchronously save the dataset to disk.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 109



def save
  on_each_node :save
end


  








  

    #scard(key)  
  



  

    
Get the number of members in a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 570



def scard(key)
  node_for(key).scard(key)
end


  








  

    #script(subcommand, *args)  
  



  

    
Control remote script registry.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 1018



def script(subcommand, *args)
  on_each_node(:script, subcommand, *args)
end


  








  

    #sdiff(*keys)  
  



  

    
Subtract multiple sets.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 637



def sdiff(*keys)
  keys.flatten!(1)
  ensure_same_node(:sdiff, keys) do |node|
    node.sdiff(keys)
  end
end


  








  

    #sdiffstore(destination, *keys)  
  



  

    
Subtract multiple sets and store the resulting set in a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 645



def sdiffstore(destination, *keys)
  keys.flatten!(1)
  ensure_same_node(:sdiffstore, [destination].concat(keys)) do |node|
    node.sdiffstore(destination, keys)
  end
end


  








  

    #select(db)  
  



  

    
Change the selected database for the current connection.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 50



def select(db)
  on_each_node :select, db
end


  








  

    #set(key, value, **options)  
  



  

    
Set the string value of a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 291



def set(key, value, **options)
  node_for(key).set(key, value, **options)
end


  








  

    #setbit(key, offset, value)  
  



  

    
Sets or clears the bit at offset in the string value stored at key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 368



def setbit(key, offset, value)
  node_for(key).setbit(key, offset, value)
end


  








  

    #setex(key, ttl, value)  
  



  

    
Set the time to live in seconds of a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 296



def setex(key, ttl, value)
  node_for(key).setex(key, ttl, value)
end


  








  

    #setnx(key, value)  
  



  

    
Set the value of a key, only if the key does not exist.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 306



def setnx(key, value)
  node_for(key).setnx(key, value)
end


  








  

    #setrange(key, offset, value)  
  



  

    
Overwrite part of a string at key starting at the specified offset.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 358



def setrange(key, offset, value)
  node_for(key).setrange(key, offset, value)
end


  








  

    #sinter(*keys)  
  



  

    
Intersect multiple sets.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 653



def sinter(*keys)
  keys.flatten!(1)
  ensure_same_node(:sinter, keys) do |node|
    node.sinter(keys)
  end
end


  








  

    #sinterstore(destination, *keys)  
  



  

    
Intersect multiple sets and store the resulting set in a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 661



def sinterstore(destination, *keys)
  keys.flatten!(1)
  ensure_same_node(:sinterstore, [destination].concat(keys)) do |node|
    node.sinterstore(destination, keys)
  end
end


  








  

    #sismember(key, member)  
  



  

    
Determine if a given value is a member of a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 612



def sismember(key, member)
  node_for(key).sismember(key, member)
end


  








  

    #smembers(key)  
  



  

    
Get all the members in a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 622



def smembers(key)
  node_for(key).smembers(key)
end


  








  

    #smismember(key, *members)  
  



  

    
Determine if multiple values are members of a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 617



def smismember(key, *members)
  node_for(key).smismember(key, *members)
end


  








  

    #smove(source, destination, member)  
  



  

    
Move a member from one set to another.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 605



def smove(source, destination, member)
  ensure_same_node(:smove, [source, destination]) do |node|
    node.smove(source, destination, member)
  end
end


  








  

    #sort(key, **options)  
  



  

    
Sort the elements in a list, set or sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 252



def sort(key, **options)
  keys = [key, options[:by], options[:store], *Array(options[:get])].compact

  ensure_same_node(:sort, keys) do |node|
    node.sort(key, **options)
  end
end


  








  

    #spop(key, count = nil)  
  



  

    
Remove and return a random member from a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 595



def spop(key, count = nil)
  node_for(key).spop(key, count)
end


  








  

    #srandmember(key, count = nil)  
  



  

    
Get a random member from a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 600



def srandmember(key, count = nil)
  node_for(key).srandmember(key, count)
end


  








  

    #srem(key, *members)  
  



  

    
Remove one or more members from a set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 585



def srem(key, *members)
  node_for(key).srem(key, *members)
end


  








  

    #srem?(key, *members)  ⇒ Boolean 
  



  

    
Remove one or more members from a set.


  





  


  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 590



def srem?(key, *members)
  node_for(key).srem?(key, *members)
end


  








  

    #sscan(key, cursor, **options)  
  



  

    
Scan a set


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 627



def sscan(key, cursor, **options)
  node_for(key).sscan(key, cursor, **options)
end


  








  

    #sscan_each(key, **options, &block)  
  



  

    
Scan a set and return an enumerator


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 632



def sscan_each(key, **options, &block)
  node_for(key).sscan_each(key, **options, &block)
end


  








  

    #strlen(key)  
  



  

    
Get the length of the value stored in a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 406



def strlen(key)
  node_for(key).strlen(key)
end


  








  

    #subscribe(channel, *channels, &block)  
  



  

    
Listen for messages published to the given channels.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 931



def subscribe(channel, *channels, &block)
  if channels.empty?
    @subscribed_node = node_for(channel)
    @subscribed_node.subscribe(channel, &block)
  else
    ensure_same_node(:subscribe, [channel] + channels) do |node|
      @subscribed_node = node
      node.subscribe(channel, *channels, &block)
    end
  end
end


  








  

    #sunion(*keys)  
  



  

    
Add multiple sets.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 669



def sunion(*keys)
  keys.flatten!(1)
  ensure_same_node(:sunion, keys) do |node|
    node.sunion(keys)
  end
end


  








  

    #sunionstore(destination, *keys)  
  



  

    
Add multiple sets and store the resulting set in a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 677



def sunionstore(destination, *keys)
  keys.flatten!(1)
  ensure_same_node(:sunionstore, [destination].concat(keys)) do |node|
    node.sunionstore(destination, keys)
  end
end


  








  

    #time  
  



  

    
Get server time: an UNIX timestamp and the elapsed microseconds in the current second.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 114



def time
  on_each_node :time
end


  








  

    #ttl(key)  
  



  

    
Get the time to live (in seconds) for a key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 139



def ttl(key)
  node_for(key).ttl(key)
end


  








  

    #type(key)  
  



  

    
Determine the type stored at key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 261



def type(key)
  node_for(key).type(key)
end


  










  

    #unsubscribe(*channels)  
  



  

    
Stop listening for messages posted to the given channels.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 944



def unsubscribe(*channels)
  raise SubscriptionError, "Can't unsubscribe if not subscribed." unless subscribed?

  @subscribed_node.unsubscribe(*channels)
end


  








  

    #unwatch  
  



  

    
Forget about all watched keys.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 980



def unwatch
  raise CannotDistribute, :unwatch unless @watch_key

  result = node_for(@watch_key).unwatch
  @watch_key = nil
  result
end


  








  

    #watch(*keys, &block)  
  



  

    
Watch the given keys to determine execution of the MULTI/EXEC block.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 966



def watch(*keys, &block)
  ensure_same_node(:watch, keys) do |node|
    @watch_key = key_tag(keys.first) || keys.first.to_s

    begin
      node.watch(*keys, &block)
    rescue StandardError
      @watch_key = nil
      raise
    end
  end
end


  








  

    #zadd(key, *args)  
  



  

    
Add one or more members to a sorted set, or update the score for members
that already exist.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 691



def zadd(key, *args)
  node_for(key).zadd(key, *args)
end


  








  

    #zcard(key)  
  



  

    
Get the number of members in a sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 685



def zcard(key)
  node_for(key).zcard(key)
end


  








  

    #zcount(key, min, max)  
  



  

    
Get the number of members in a particular score range.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 787



def zcount(key, min, max)
  node_for(key).zcount(key, min, max)
end


  








  

    #zdiff(*keys, **options)  
  



  

    
Return the difference between the first and all successive input sorted sets.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 825



def zdiff(*keys, **options)
  keys.flatten!(1)
  ensure_same_node(:zdiff, keys) do |node|
    node.zdiff(keys, **options)
  end
end


  








  

    #zdiffstore(destination, *keys, **options)  
  



  

    
Compute the difference between the first and all successive input sorted sets
and store the resulting sorted set in a new key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 834



def zdiffstore(destination, *keys, **options)
  keys.flatten!(1)
  ensure_same_node(:zdiffstore, [destination] + keys) do |node|
    node.zdiffstore(destination, keys, **options)
  end
end


  








  

    #zincrby(key, increment, member)  
  



  

    
Increment the score of a member in a sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 697



def zincrby(key, increment, member)
  node_for(key).zincrby(key, increment, member)
end


  








  

    #zinter(*keys, **options)  
  



  

    
Get the intersection of multiple sorted sets


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 792



def zinter(*keys, **options)
  keys.flatten!(1)
  ensure_same_node(:zinter, keys) do |node|
    node.zinter(keys, **options)
  end
end


  








  

    #zinterstore(destination, *keys, **options)  
  



  

    
Intersect multiple sorted sets and store the resulting sorted set in a new
key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 801



def zinterstore(destination, *keys, **options)
  keys.flatten!(1)
  ensure_same_node(:zinterstore, [destination].concat(keys)) do |node|
    node.zinterstore(destination, keys, **options)
  end
end


  








  

    #zmpop(*keys, modifier: "MIN", count: nil)  
  



  

    
Iterate over keys, removing members from the first non empty sorted set found.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 729



def zmpop(*keys, modifier: "MIN", count: nil)
  ensure_same_node(:zmpop, keys) do |node|
    node.zmpop(*keys, modifier: modifier, count: count)
  end
end


  








  

    #zmscore(key, *members)  
  



  

    
Get the scores associated with the given members in a sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 717



def zmscore(key, *members)
  node_for(key).zmscore(key, *members)
end


  








  

    #zrandmember(key, count = nil, **options)  
  



  

    
Get one or more random members from a sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 712



def zrandmember(key, count = nil, **options)
  node_for(key).zrandmember(key, count, **options)
end


  








  

    #zrange(key, start, stop, **options)  
  



  

    
Return a range of members in a sorted set, by index, score or lexicographical ordering.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 736



def zrange(key, start, stop, **options)
  node_for(key).zrange(key, start, stop, **options)
end


  








  

    #zrangebyscore(key, min, max, **options)  
  



  

    
Return a range of members in a sorted set, by score.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 771



def zrangebyscore(key, min, max, **options)
  node_for(key).zrangebyscore(key, min, max, **options)
end


  








  

    #zrangestore(dest_key, src_key, start, stop, **options)  
  



  

    
Select a range of members in a sorted set, by index, score or lexicographical ordering
and store the resulting sorted set in a new key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 742



def zrangestore(dest_key, src_key, start, stop, **options)
  ensure_same_node(:zrangestore, [dest_key, src_key]) do |node|
    node.zrangestore(dest_key, src_key, start, stop, **options)
  end
end


  








  

    #zrank(key, member, **options)  
  



  

    
Determine the index of a member in a sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 755



def zrank(key, member, **options)
  node_for(key).zrank(key, member, **options)
end


  








  

    #zrem(key, member)  
  



  

    
Remove one or more members from a sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 702



def zrem(key, member)
  node_for(key).zrem(key, member)
end


  








  

    #zremrangebyrank(key, start, stop)  
  



  

    
Remove all members in a sorted set within the given indexes.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 766



def zremrangebyrank(key, start, stop)
  node_for(key).zremrangebyrank(key, start, stop)
end


  








  

    #zremrangebyscore(key, min, max)  
  



  

    
Remove all members in a sorted set within the given scores.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 782



def zremrangebyscore(key, min, max)
  node_for(key).zremrangebyscore(key, min, max)
end


  








  

    #zrevrange(key, start, stop, **options)  
  



  

    
Return a range of members in a sorted set, by index, with scores ordered
from high to low.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 750



def zrevrange(key, start, stop, **options)
  node_for(key).zrevrange(key, start, stop, **options)
end


  








  

    #zrevrangebyscore(key, max, min, **options)  
  



  

    
Return a range of members in a sorted set, by score, with scores ordered
from high to low.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 777



def zrevrangebyscore(key, max, min, **options)
  node_for(key).zrevrangebyscore(key, max, min, **options)
end


  








  

    #zrevrank(key, member, **options)  
  



  

    
Determine the index of a member in a sorted set, with scores ordered from
high to low.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 761



def zrevrank(key, member, **options)
  node_for(key).zrevrank(key, member, **options)
end


  








  

    #zscore(key, member)  
  



  

    
Get the score associated with the given member in a sorted set.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 707



def zscore(key, member)
  node_for(key).zscore(key, member)
end


  








  

    #zunion(*keys, **options)  
  



  

    
Return the union of multiple sorted sets.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 809



def zunion(*keys, **options)
  keys.flatten!(1)
  ensure_same_node(:zunion, keys) do |node|
    node.zunion(keys, **options)
  end
end


  








  

    #zunionstore(destination, *keys, **options)  
  



  

    
Add multiple sorted sets and store the resulting sorted set in a new key.


  



  [ GitHub ]


  

  


# File 'lib/redis/distributed.rb', line 817



def zunionstore(destination, *keys, **options)
  keys.flatten!(1)
  ensure_same_node(:zunionstore, [destination].concat(keys)) do |node|
    node.zunionstore(destination, keys, **options)
  end
end