redis 4.8.1 → 6.0.0

data/lib/redis/distributed.rb

@@ -20,8 +20,12 @@ class Redis
     def initialize(node_configs, options = {})
       @tag = options[:tag] || /^\{(.+?)\}/
       @ring = options[:ring] || HashRing.new
-      @node_configs = node_configs.dup
+      @node_configs = node_configs.map(&:dup)
       @default_options = options.dup
+      # Schemas registered via himport_prepare, replayed to nodes that join the ring later (see
+      # #add_node) so ring membership changes don't leave nodes without the fieldsets that
+      # key-routed himport_set calls expect. Initialized before the add_node loop below.
+      @himport_fieldsets = {}
       node_configs.each { |node_config| add_node(node_config) }
       @subscribed_node = nil
       @watch_key = nil
@@ -41,7 +45,14 @@ class Redis
     def add_node(options)
       options = { url: options } if options.is_a?(String)
       options = @default_options.merge(options)
-      @ring.add_node Redis.new(options)
+      options.delete(:tag)
+      options.delete(:ring)
+      node = Redis.new(options)
+      # Replay registered fieldsets before the node can receive key-routed himport_set calls:
+      # a node joining after a himport_prepare fan-out has neither the server-side fieldset nor
+      # a populated registry to self-recover from "no such fieldset".
+      @himport_fieldsets.each { |name, fields| node.himport_prepare(name, fields) }
+      @ring.add_node node
     end
 
     # Change the selected database for the current connection.
@@ -64,6 +75,10 @@ class Redis
       on_each_node :quit
     end
 
+    def close
+      on_each_node :close
+    end
+
     # Asynchronously save the dataset to disk.
     def bgsave
       on_each_node :bgsave
@@ -124,6 +139,11 @@ class Redis
       node_for(key).expireat(key, unix_time, **kwargs)
     end
 
+    # Get the expiration for a key as a UNIX timestamp.
+    def expiretime(key)
+      node_for(key).expiretime(key)
+    end
+
     # Get the time to live (in seconds) for a key.
     def ttl(key)
       node_for(key).ttl(key)
@@ -139,6 +159,11 @@ class Redis
       node_for(key).pexpireat(key, ms_unix_time, **kwarg)
     end
 
+    # Get the expiration for a key as number of milliseconds from UNIX Epoch.
+    def pexpiretime(key)
+      node_for(key).pexpiretime(key)
+    end
+
     # Get the time to live (in milliseconds) for a key.
     def pttl(key)
       node_for(key).pttl(key)
@@ -161,6 +186,7 @@ class Redis
 
     # Delete a key.
     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)
@@ -169,6 +195,7 @@ class Redis
 
     # Unlink keys.
     def unlink(*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.unlink(*keys)
@@ -177,23 +204,16 @@ class Redis
 
     # Determine if a key exists.
     def exists(*args)
-      if !Redis.exists_returns_integer && args.size == 1
-        ::Redis.deprecate!(
-          "`Redis#exists(key)` will return an Integer in redis-rb 4.3, if you want to keep the old behavior, " \
-          "use `exists?` instead. To opt-in to the new behavior now you can set Redis.exists_returns_integer = true. " \
-          "(#{::Kernel.caller(1, 1).first})\n"
-        )
-        exists?(*args)
-      else
-        keys_per_node = args.group_by { |key| node_for(key) }
-        keys_per_node.inject(0) do |sum, (node, keys)|
-          sum + node._exists(*keys)
-        end
+      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
 
     # Determine if any of the keys exists.
     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)
@@ -297,7 +317,7 @@ class Redis
     end
 
     # Set multiple keys to multiple values.
-    def mset(*_args)
+    def mset(*)
       raise CannotDistribute, :mset
     end
 
@@ -306,7 +326,7 @@ class Redis
     end
 
     # Set multiple keys to multiple values, only if none of the keys exist.
-    def msetnx(*_args)
+    def msetnx(*)
       raise CannotDistribute, :msetnx
     end
 
@@ -329,13 +349,133 @@ class Redis
       node_for(key).getex(key, **options)
     end
 
+    # Set the JSON value at a path in the document stored under a key.
+    def json_set(key, path, value, **options)
+      node_for(key).json_set(key, path, value, **options)
+    end
+
+    # Get the JSON value(s) at one or more paths in the document stored under a key.
+    def json_get(key, *paths, **options)
+      node_for(key).json_get(key, *paths, **options)
+    end
+
+    # Set one or more JSON values. The keys may live on different nodes and the operation must be
+    # atomic, so it cannot be distributed.
+    def json_mset(*)
+      raise CannotDistribute, :json_mset
+    end
+
+    # Get the values at a path from several keys. Keys are grouped by node, queried per node, and
+    # reassembled in the original key order.
+    def json_mget(*keys, path, **options)
+      keys.flatten!(1)
+      values = keys.group_by { |key| node_for(key) }.each_with_object({}) do |(node, subkeys), acc|
+        node.json_mget(*subkeys, path, **options).each_with_index do |value, i|
+          acc[subkeys[i]] = value
+        end
+      end
+      keys.map { |key| values[key] }
+    end
+
+    # Delete the JSON value(s) at a path in the document stored under a key.
+    def json_del(key, path = nil)
+      node_for(key).json_del(key, path)
+    end
+
+    # Delete the JSON value(s) at a path in the document stored under a key (alias of json_del).
+    def json_forget(key, path = nil)
+      node_for(key).json_forget(key, path)
+    end
+
+    # Clear the container and numeric JSON value(s) at a path in the document stored under a key.
+    def json_clear(key, path = nil)
+      node_for(key).json_clear(key, path)
+    end
+
+    # Merge a JSON value into the document stored under a key at a path.
+    def json_merge(key, path, value, **options)
+      node_for(key).json_merge(key, path, value, **options)
+    end
+
+    # Append one or more values to the JSON array at a path in the document stored under a key.
+    def json_arrappend(key, path, *values, **options)
+      node_for(key).json_arrappend(key, path, *values, **options)
+    end
+
+    # Return the index of the first occurrence of a scalar in the JSON array at a path.
+    def json_arrindex(key, path, value, **options)
+      node_for(key).json_arrindex(key, path, value, **options)
+    end
+
+    # Insert one or more values into the JSON array at a path in the document stored under a key.
+    def json_arrinsert(key, path, index, *values, **options)
+      node_for(key).json_arrinsert(key, path, index, *values, **options)
+    end
+
+    # Return the length of the JSON array at a path in the document stored under a key.
+    def json_arrlen(key, path = nil)
+      node_for(key).json_arrlen(key, path)
+    end
+
+    # Remove and return an element from the JSON array at a path in the document stored under a key.
+    def json_arrpop(key, path = nil, index = nil, **options)
+      node_for(key).json_arrpop(key, path, index, **options)
+    end
+
+    # Trim the JSON array at a path in the document stored under a key to an inclusive range.
+    def json_arrtrim(key, path, start, stop)
+      node_for(key).json_arrtrim(key, path, start, stop)
+    end
+
+    # Increment the numeric JSON value(s) at a path in the document stored under a key.
+    def json_numincrby(key, path, number)
+      node_for(key).json_numincrby(key, path, number)
+    end
+
+    # Return the type name(s) of the JSON value(s) at a path in the document stored under a key.
+    def json_type(key, path = nil)
+      node_for(key).json_type(key, path)
+    end
+
+    # Return the key names of the JSON object(s) at a path in the document stored under a key.
+    def json_objkeys(key, path = nil)
+      node_for(key).json_objkeys(key, path)
+    end
+
+    # Return the number of keys in the JSON object(s) at a path in the document stored under a key.
+    def json_objlen(key, path = nil)
+      node_for(key).json_objlen(key, path)
+    end
+
+    # Return the length of the JSON string(s) at a path in the document stored under a key.
+    def json_strlen(key, path = nil)
+      node_for(key).json_strlen(key, path)
+    end
+
+    # Append a string to the JSON string(s) at a path in the document stored under a key.
+    def json_strappend(key, path, value, **options)
+      node_for(key).json_strappend(key, path, value, **options)
+    end
+
+    # Toggle the boolean JSON value(s) at a path in the document stored under a key.
+    def json_toggle(key, path)
+      node_for(key).json_toggle(key, path)
+    end
+
+    # Report the size in bytes of the JSON value(s) at a path in the document stored under a key.
+    def json_debug_memory(key, path = nil)
+      node_for(key).json_debug_memory(key, path)
+    end
+
     # Get the values of all the given keys as an Array.
     def mget(*keys)
+      keys.flatten!(1)
       mapped_mget(*keys).values_at(*keys)
     end
 
     # Get the values of all the given keys as a Hash.
     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
@@ -367,20 +507,21 @@ class Redis
     end
 
     # Count the number of set bits in a range of the string value stored at key.
-    def bitcount(key, start = 0, stop = -1)
-      node_for(key).bitcount(key, start, stop)
+    def bitcount(key, start = 0, stop = -1, scale: nil)
+      node_for(key).bitcount(key, start, stop, scale: scale)
     end
 
     # Perform a bitwise operation between strings and store the resulting string in a key.
     def bitop(operation, destkey, *keys)
+      keys.flatten!(1)
       ensure_same_node(:bitop, [destkey] + keys) do |node|
-        node.bitop(operation, destkey, *keys)
+        node.bitop(operation, destkey, keys)
       end
     end
 
     # Return the position of the first bit set to 1 or 0 in a string.
-    def bitpos(key, bit, start = nil, stop = nil)
-      node_for(key).bitpos(key, bit, start, stop)
+    def bitpos(key, bit, start = nil, stop = nil, scale: nil)
+      node_for(key).bitpos(key, bit, start, stop, scale: scale)
     end
 
     # Set the string value of a key and return its old value.
@@ -413,6 +554,15 @@ class Redis
       end
     end
 
+    # Remove multiple elements from the head/tail of a list, append/prepend
+    # them to another list and return them.
+    def lmovem(source, destination, where_source, where_destination, count: nil, exactly: nil, order: nil)
+      ensure_same_node(:lmovem, [source, destination]) do |node|
+        node.lmovem(source, destination, where_source, where_destination,
+                    count: count, exactly: exactly, order: order)
+      end
+    end
+
     # Remove the first/last element in a list and append/prepend it
     # to another list and return it, or block until one is available.
     def blmove(source, destination, where_source, where_destination, timeout: 0)
@@ -421,6 +571,17 @@ class Redis
       end
     end
 
+    # Remove multiple elements from the head/tail of a list, append/prepend
+    # them to another list and return them; or block until the request can
+    # be satisfied or the timeout expires.
+    def blmovem(source, destination, where_source, where_destination, timeout: 0, count: nil, exactly: nil,
+                order: nil)
+      ensure_same_node(:blmovem, [source, destination]) do |node|
+        node.blmovem(source, destination, where_source, where_destination,
+                     timeout: timeout, count: count, exactly: exactly, order: order)
+      end
+    end
+
     # Prepend one or more values to a list.
     def lpush(key, value)
       node_for(key).lpush(key, value)
@@ -463,23 +624,15 @@ class Redis
       timeout = if args.last.is_a?(Hash)
         options = args.pop
         options[:timeout]
-      elsif args.last.respond_to?(:to_int)
-        last_arg = args.pop
-        ::Redis.deprecate!(
-          "Passing the timeout as a positional argument is deprecated, it should be passed as a keyword argument:\n" \
-          "  redis.#{cmd}(#{args.map(&:inspect).join(', ')}, timeout: #{last_arg.to_int})" \
-          "(called from: #{caller(2, 1).first})"
-        )
-        last_arg.to_int
       end
 
-      keys = args.flatten
+      args.flatten!(1)
 
-      ensure_same_node(cmd, keys) do |node|
+      ensure_same_node(cmd, args) do |node|
         if timeout
-          node.__send__(cmd, keys, timeout: timeout)
+          node.__send__(cmd, args, timeout: timeout)
         else
-          node.__send__(cmd, keys)
+          node.__send__(cmd, args)
         end
       end
     end
@@ -490,6 +643,18 @@ class Redis
       _bpop(:blpop, args)
     end
 
+    def bzpopmax(*args)
+      _bpop(:bzpopmax, args) do |reply|
+        reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
+      end
+    end
+
+    def bzpopmin(*args)
+      _bpop(:bzpopmin, args) do |reply|
+        reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
+      end
+    end
+
     # Remove and get the last element in a list, or block until one is
     # available.
     def brpop(*args)
@@ -498,9 +663,9 @@ class Redis
 
     # Pop a value from a list, push it to another list and return it; or block
     # until one is available.
-    def brpoplpush(source, destination, deprecated_timeout = 0, **options)
+    def brpoplpush(source, destination, **options)
       ensure_same_node(:brpoplpush, [source, destination]) do |node|
-        node.brpoplpush(source, destination, deprecated_timeout, **options)
+        node.brpoplpush(source, destination, **options)
       end
     end
 
@@ -534,29 +699,43 @@ class Redis
       node_for(key).ltrim(key, start, stop)
     end
 
+    # Iterate over keys, blocking and removing elements from the first non empty liist found.
+    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
+
+    # Iterate over keys, removing elements from the first non list found.
+    def lmpop(*keys, modifier: "LEFT", count: nil)
+      ensure_same_node(:lmpop, keys) do |node|
+        node.lmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
     # Get the number of members in a set.
     def scard(key)
       node_for(key).scard(key)
     end
 
     # Add one or more members to a set.
-    def sadd(key, member)
-      node_for(key).sadd(key, member)
+    def sadd(key, *members)
+      node_for(key).sadd(key, *members)
     end
 
     # Add one or more members to a set.
-    def sadd?(key, member)
-      node_for(key).sadd?(key, member)
+    def sadd?(key, *members)
+      node_for(key).sadd?(key, *members)
     end
 
     # Remove one or more members from a set.
-    def srem(key, member)
-      node_for(key).srem(key, member)
+    def srem(key, *members)
+      node_for(key).srem(key, *members)
     end
 
     # Remove one or more members from a set.
-    def srem?(key, member)
-      node_for(key).srem?(key, member)
+    def srem?(key, *members)
+      node_for(key).srem?(key, *members)
     end
 
     # Remove and return a random member from a set.
@@ -603,43 +782,66 @@ class Redis
 
     # Subtract multiple sets.
     def sdiff(*keys)
+      keys.flatten!(1)
       ensure_same_node(:sdiff, keys) do |node|
-        node.sdiff(*keys)
+        node.sdiff(keys)
       end
     end
 
     # Subtract multiple sets and store the resulting set in a key.
     def sdiffstore(destination, *keys)
-      ensure_same_node(:sdiffstore, [destination] + keys) do |node|
-        node.sdiffstore(destination, *keys)
+      keys.flatten!(1)
+      ensure_same_node(:sdiffstore, [destination].concat(keys)) do |node|
+        node.sdiffstore(destination, keys)
+      end
+    end
+
+    # Get the number of members in the difference between the first set and
+    # all successive sets.
+    def sdiffcard(*keys, limit: nil)
+      keys.flatten!(1)
+      ensure_same_node(:sdiffcard, keys) do |node|
+        node.sdiffcard(keys, limit: limit)
       end
     end
 
     # Intersect multiple sets.
     def sinter(*keys)
+      keys.flatten!(1)
       ensure_same_node(:sinter, keys) do |node|
-        node.sinter(*keys)
+        node.sinter(keys)
       end
     end
 
     # Intersect multiple sets and store the resulting set in a key.
     def sinterstore(destination, *keys)
-      ensure_same_node(:sinterstore, [destination] + keys) do |node|
-        node.sinterstore(destination, *keys)
+      keys.flatten!(1)
+      ensure_same_node(:sinterstore, [destination].concat(keys)) do |node|
+        node.sinterstore(destination, keys)
       end
     end
 
     # Add multiple sets.
     def sunion(*keys)
+      keys.flatten!(1)
       ensure_same_node(:sunion, keys) do |node|
-        node.sunion(*keys)
+        node.sunion(keys)
       end
     end
 
     # Add multiple sets and store the resulting set in a key.
     def sunionstore(destination, *keys)
-      ensure_same_node(:sunionstore, [destination] + keys) do |node|
-        node.sunionstore(destination, *keys)
+      keys.flatten!(1)
+      ensure_same_node(:sunionstore, [destination].concat(keys)) do |node|
+        node.sunionstore(destination, keys)
+      end
+    end
+
+    # Get the number of distinct members in the union of multiple sets.
+    def sunioncard(*keys, approx: false, limit: nil)
+      keys.flatten!(1)
+      ensure_same_node(:sunioncard, keys) do |node|
+        node.sunioncard(keys, approx: approx, limit: limit)
       end
     end
 
@@ -680,6 +882,20 @@ class Redis
       node_for(key).zmscore(key, *members)
     end
 
+    # Iterate over keys, blocking and removing members from the first non empty sorted set found.
+    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
+
+    # Iterate over keys, removing members from the first non empty sorted set found.
+    def zmpop(*keys, modifier: "MIN", count: nil)
+      ensure_same_node(:zmpop, keys) do |node|
+        node.zmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
     # Return a range of members in a sorted set, by index, score or lexicographical ordering.
     def zrange(key, start, stop, **options)
       node_for(key).zrange(key, start, stop, **options)
@@ -700,14 +916,14 @@ class Redis
     end
 
     # Determine the index of a member in a sorted set.
-    def zrank(key, member)
-      node_for(key).zrank(key, member)
+    def zrank(key, member, **options)
+      node_for(key).zrank(key, member, **options)
     end
 
     # Determine the index of a member in a sorted set, with scores ordered from
     # high to low.
-    def zrevrank(key, member)
-      node_for(key).zrevrank(key, member)
+    def zrevrank(key, member, **options)
+      node_for(key).zrevrank(key, member, **options)
     end
 
     # Remove all members in a sorted set within the given indexes.
@@ -738,43 +954,49 @@ class Redis
 
     # Get the intersection of multiple sorted sets
     def zinter(*keys, **options)
+      keys.flatten!(1)
       ensure_same_node(:zinter, keys) do |node|
-        node.zinter(*keys, **options)
+        node.zinter(keys, **options)
       end
     end
 
     # Intersect multiple sorted sets and store the resulting sorted set in a new
     # key.
-    def zinterstore(destination, keys, **options)
-      ensure_same_node(:zinterstore, [destination] + keys) do |node|
+    def zinterstore(destination, *keys, **options)
+      keys.flatten!(1)
+      ensure_same_node(:zinterstore, [destination].concat(keys)) do |node|
         node.zinterstore(destination, keys, **options)
       end
     end
 
     # Return the union of multiple sorted sets.
     def zunion(*keys, **options)
+      keys.flatten!(1)
       ensure_same_node(:zunion, keys) do |node|
-        node.zunion(*keys, **options)
+        node.zunion(keys, **options)
       end
     end
 
     # Add multiple sorted sets and store the resulting sorted set in a new key.
-    def zunionstore(destination, keys, **options)
-      ensure_same_node(:zunionstore, [destination] + keys) do |node|
+    def zunionstore(destination, *keys, **options)
+      keys.flatten!(1)
+      ensure_same_node(:zunionstore, [destination].concat(keys)) do |node|
         node.zunionstore(destination, keys, **options)
       end
     end
 
     # Return the difference between the first and all successive input sorted sets.
     def zdiff(*keys, **options)
+      keys.flatten!(1)
       ensure_same_node(:zdiff, keys) do |node|
-        node.zdiff(*keys, **options)
+        node.zdiff(keys, **options)
       end
     end
 
     # Compute the difference between the first and all successive input sorted sets
     # and store the resulting sorted set in a new key.
-    def zdiffstore(destination, keys, **options)
+    def zdiffstore(destination, *keys, **options)
+      keys.flatten!(1)
       ensure_same_node(:zdiffstore, [destination] + keys) do |node|
         node.zdiffstore(destination, keys, **options)
       end
@@ -801,7 +1023,7 @@ class Redis
     end
 
     def mapped_hmset(key, hash)
-      node_for(key).hmset(key, *hash.to_a.flatten)
+      node_for(key).hmset(key, hash)
     end
 
     # Get the value of a hash field.
@@ -811,11 +1033,13 @@ class Redis
 
     # Get the values of all the given hash fields.
     def hmget(key, *fields)
-      node_for(key).hmget(key, *fields)
+      fields.flatten!(1)
+      node_for(key).hmget(key, fields)
     end
 
     def mapped_hmget(key, *fields)
-      Hash[*fields.zip(hmget(key, *fields)).flatten]
+      fields.flatten!(1)
+      node_for(key).mapped_hmget(key, fields)
     end
 
     def hrandfield(key, count = nil, **options)
@@ -824,7 +1048,8 @@ class Redis
 
     # Delete one or more hash fields.
     def hdel(key, *fields)
-      node_for(key).hdel(key, *fields)
+      fields.flatten!(1)
+      node_for(key).hdel(key, fields)
     end
 
     # Determine if a hash field exists.
@@ -857,6 +1082,112 @@ class Redis
       node_for(key).hgetall(key)
     end
 
+    def hexpire(key, ttl, *fields)
+      node_for(key).hexpire(key, ttl, *fields)
+    end
+
+    def httl(key, *fields)
+      node_for(key).httl(key, *fields)
+    end
+
+    # Scan a hash
+    def hscan(key, cursor, **options)
+      node_for(key).hscan(key, cursor, **options)
+    end
+
+    # Scan a hash and return an enumerator
+    def hscan_each(key, **options, &block)
+      node_for(key).hscan_each(key, **options, &block)
+    end
+
+    # Get the length of the value stored in a hash field
+    def hstrlen(key, field)
+      node_for(key).hstrlen(key, field)
+    end
+
+    def hpexpire(key, ttl, *fields, nx: nil, xx: nil, gt: nil, lt: nil)
+      node_for(key).hpexpire(key, ttl, *fields, nx: nx, xx: xx, gt: gt, lt: lt)
+    end
+
+    def hpttl(key, *fields)
+      node_for(key).hpttl(key, *fields)
+    end
+
+    # Register a fieldset on every ring node. Fieldsets are scoped to a physical
+    # connection, so every node that may receive an `himport_set` for a key it
+    # owns needs the fieldset on its own connection.
+    def himport_prepare(fieldset_name, *fields)
+      fields.flatten!(1)
+      results = on_each_node(:himport_prepare, fieldset_name, fields)
+      @himport_fieldsets[fieldset_name.to_s] = fields.dup.freeze
+      results
+    end
+
+    # Create or fully replace a hash from a fieldset prepared on the key's node.
+    def himport_set(key, fieldset_name, *values)
+      values.flatten!(1)
+      node_for(key).himport_set(key, fieldset_name, values)
+    end
+
+    # Remove a fieldset from every ring node.
+    def himport_discard(fieldset_name)
+      results = on_each_node(:himport_discard, fieldset_name)
+      @himport_fieldsets.delete(fieldset_name.to_s)
+      results
+    end
+
+    # Remove all fieldsets from every ring node.
+    def himport_discard_all
+      results = on_each_node(:himport_discard_all)
+      @himport_fieldsets.clear
+      results
+    end
+
+    # Add one or more geospatial items to a sorted set.
+    def geoadd(key, *member, **options)
+      node_for(key).geoadd(key, *member, **options)
+    end
+
+    # Get geohash strings representing the position of one or more members.
+    def geohash(key, member)
+      node_for(key).geohash(key, member)
+    end
+
+    # Get longitude and latitude of one or more members of a geospatial index.
+    def geopos(key, member)
+      node_for(key).geopos(key, member)
+    end
+
+    # Get the distance between two members of a geospatial index.
+    def geodist(key, member1, member2, unit = 'm')
+      node_for(key).geodist(key, member1, member2, unit)
+    end
+
+    # Query a geospatial index for members within a given radius from a point.
+    def georadius(*args, **geoptions)
+      key = args.first
+      node_for(key).georadius(*args, **geoptions)
+    end
+
+    # Query a geospatial index for members within a given radius from an existing member.
+    def georadiusbymember(*args, **geoptions)
+      key = args.first
+      node_for(key).georadiusbymember(*args, **geoptions)
+    end
+
+    # Search a geospatial index for members within a given shape from a center point.
+    def geosearch(key, **options)
+      node_for(key).geosearch(key, **options)
+    end
+
+    # Like #geosearch, but stores the result in a destination key.
+    # Destination and source must hash to the same node; use a key tag to ensure that.
+    def geosearchstore(destination, source, **options)
+      ensure_same_node(:geosearchstore, [destination, source]) do |node|
+        node.geosearchstore(destination, source, **options)
+      end
+    end
+
     # Post a message to a channel.
     def publish(channel, message)
       node_for(channel).publish(channel, message)
@@ -881,18 +1212,22 @@ class Redis
 
     # Stop listening for messages posted to the given channels.
     def unsubscribe(*channels)
-      raise "Can't unsubscribe if not subscribed." unless subscribed?
+      raise SubscriptionError, "Can't unsubscribe if not subscribed." unless subscribed?
 
       @subscribed_node.unsubscribe(*channels)
     end
 
     # Listen for messages published to channels matching the given patterns.
+    # See the [Redis Server PSUBSCRIBE documentation](https://redis.io/docs/latest/commands/psubscribe/)
+    # for further details
     def psubscribe(*channels, &block)
       raise NotImplementedError
     end
 
     # Stop listening for messages posted to channels matching the given
     # patterns.
+    # See the [Redis Server PUNSUBSCRIBE documentation](https://redis.io/docs/latest/commands/punsubscribe/)
+    # for further details
     def punsubscribe(*channels)
       raise NotImplementedError
     end
@@ -928,9 +1263,7 @@ class Redis
     def multi(&block)
       raise CannotDistribute, :multi unless @watch_key
 
-      result = node_for(@watch_key).multi(&block)
-      @watch_key = nil if block_given?
-      result
+      node_for(@watch_key).multi(&block)
     end
 
     # Execute all commands issued after MULTI.
@@ -1020,7 +1353,8 @@ class Redis
     end
 
     def key_tag(key)
-      key.to_s[@tag, 1] if @tag
+      key = key.to_s
+      key[@tag, 1] if key.match?(@tag)
     end
 
     def ensure_same_node(command, keys)