redis 4.8.1 → 6.0.0

data/lib/redis/commands/bitmaps.rb

@@ -27,9 +27,13 @@ class Redis
       # @param [String] key
       # @param [Integer] start start index
       # @param [Integer] stop stop index
+      # @param [String, Symbol] scale the scale of the offset range
+      #     e.g. 'BYTE' - interpreted as a range of bytes, 'BIT' - interpreted as a range of bits
       # @return [Integer] the number of bits set to 1
-      def bitcount(key, start = 0, stop = -1)
-        send_command([:bitcount, key, start, stop])
+      def bitcount(key, start = 0, stop = -1, scale: nil)
+        command = [:bitcount, key, start, stop]
+        command << scale if scale
+        send_command(command)
       end
 
       # Perform a bitwise operation between strings and store the resulting string in a key.
@@ -39,7 +43,10 @@ class Redis
       # @param [String, Array<String>] keys one or more source keys to perform `operation`
       # @return [Integer] the length of the string stored in `destkey`
       def bitop(operation, destkey, *keys)
-        send_command([:bitop, operation, destkey, *keys])
+        keys.flatten!(1)
+        command = [:bitop, operation, destkey]
+        command.concat(keys)
+        send_command(command)
       end
 
       # Return the position of the first bit set to 1 or 0 in a string.
@@ -48,14 +55,17 @@ class Redis
       # @param [Integer] bit whether to look for the first 1 or 0 bit
       # @param [Integer] start start index
       # @param [Integer] stop stop index
+      # @param [String, Symbol] scale the scale of the offset range
+      #     e.g. 'BYTE' - interpreted as a range of bytes, 'BIT' - interpreted as a range of bits
       # @return [Integer] the position of the first 1/0 bit.
       #                  -1 if looking for 1 and it is not found or start and stop are given.
-      def bitpos(key, bit, start = nil, stop = nil)
+      def bitpos(key, bit, start = nil, stop = nil, scale: nil)
         raise(ArgumentError, 'stop parameter specified without start parameter') if stop && !start
 
         command = [:bitpos, key, bit]
         command << start if start
         command << stop if stop
+        command << scale if scale
         send_command(command)
       end
     end

data/lib/redis/commands/cluster.rb

@@ -12,24 +12,7 @@ class Redis
       #
       # @return [Object] depends on the subcommand
       def cluster(subcommand, *args)
-        subcommand = subcommand.to_s.downcase
-        block = case subcommand
-        when 'slots'
-          HashifyClusterSlots
-        when 'nodes'
-          HashifyClusterNodes
-        when 'slaves'
-          HashifyClusterSlaves
-        when 'info'
-          HashifyInfo
-        else
-          Noop
-        end
-
-        # @see https://github.com/antirez/redis/blob/unstable/src/redis-trib.rb#L127 raw reply expected
-        block = Noop unless @cluster_mode
-
-        send_command([:cluster, subcommand] + args, &block)
+        send_command([:cluster, subcommand] + args)
       end
 
       # Sends `ASKING` command to random node and returns its reply.

data/lib/redis/commands/connection.rb

@@ -34,10 +34,7 @@ class Redis
       # @param [Integer] db zero-based index of the DB to use (0 to 15)
       # @return [String] `OK`
       def select(db)
-        synchronize do |client|
-          client.db = db
-          client.call([:select, db])
-        end
+        send_command([:select, db])
       end
 
       # Close the connection.
@@ -45,12 +42,10 @@ class Redis
       # @return [String] `OK`
       def quit
         synchronize do |client|
-          begin
-            client.call([:quit])
-          rescue ConnectionError
-          ensure
-            client.disconnect
-          end
+          client.call_v([:quit])
+        rescue ConnectionError
+        ensure
+          client.close
         end
       end
     end

data/lib/redis/commands/geo.rb

@@ -7,9 +7,19 @@ class Redis
       #
       # @param [String] key
       # @param [Array] member arguemnts for member or members: longitude, latitude, name
-      # @return [Integer] number of elements added to the sorted set
-      def geoadd(key, *member)
-        send_command([:geoadd, key, *member])
+      # @param [Boolean] nx don't update already existing elements, always add new ones (since Redis 6.2)
+      # @param [Boolean] xx only update elements that already exist, never add new ones (since Redis 6.2)
+      # @param [Boolean] ch modify the return value to the number of changed elements (since Redis 6.2)
+      # @return [Integer] number of elements added to the sorted set, or changed when `ch` is set
+      def geoadd(key, *member, nx: false, xx: false, ch: false)
+        raise ArgumentError, "can't supply both nx and xx" if nx && xx
+
+        args = [:geoadd, key]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "CH" if ch
+        args.concat(member)
+        send_command(args)
       end
 
       # Returns geohash string representing position for specified members of the specified key.
@@ -28,6 +38,7 @@ class Redis
       # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest
       #   or the farthest to the nearest relative to the center
       # @param [Integer] count limit the results to the first N matching items
+      # @param [Boolean] count_any return as soon as enough matches found (only with count, since Redis 6.2)
       # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
       # @return [Array<String>] may be changed with `options`
       def georadius(*args, **geoptions)
@@ -43,6 +54,7 @@ class Redis
       # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest
       #   to the nearest relative to the center
       # @param [Integer] count limit the results to the first N matching items
+      # @param [Boolean] count_any return as soon as enough matches found (only with count, since Redis 6.2)
       # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
       # @return [Array<String>] may be changed with `options`
       def georadiusbymember(*args, **geoptions)
@@ -61,6 +73,93 @@ class Redis
         send_command([:geopos, key, member])
       end
 
+      # Return the members of a geospatial sorted set that are within the borders of the
+      # area specified by a given shape, either a circle (BYRADIUS) or a rectangle (BYBOX),
+      # starting from a center point given either by member (FROMMEMBER) or by longitude and
+      # latitude (FROMLONLAT). Available since Redis 6.2.
+      #
+      # @example Search by radius from longitude/latitude
+      #   redis.geosearch("Sicily", fromlonlat: [15, 37], byradius: [200, "km"], sort: "asc")
+      #     # => ["Catania", "Palermo"]
+      #
+      # @example Search by box from an existing member, with extras
+      #   redis.geosearch("Sicily", frommember: "Catania", bybox: [400, 400, "km"],
+      #                   sort: "asc", withcoord: true, withdist: true)
+      #     # => [["Catania", "0.0000", ["15.087...", "37.502..."]], ...]
+      #
+      # @param [String] key
+      # @param [String] frommember use the position of the given existing member as the center
+      # @param [Array<Numeric>] fromlonlat a [longitude, latitude] pair used as the center
+      # @param [Array] byradius a [radius, unit] pair where unit is one of 'm', 'km', 'ft', 'mi'
+      # @param [Array] bybox a [width, height, unit] triple where unit is one of 'm', 'km', 'ft', 'mi'
+      # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest, or vice versa
+      # @param [Integer] count limit the results to the first N matching items
+      # @param [Boolean] count_any return as soon as enough matches are found (only with count)
+      # @param [Boolean] withcoord also return the longitude and latitude of matching items
+      # @param [Boolean] withdist also return the distance from the center point
+      # @param [Boolean] withhash also return the raw geohash-encoded sorted set score of the item
+      # @return [Array<String>] may be changed with WITH* flags
+      def geosearch(key, frommember: nil, fromlonlat: nil, byradius: nil, bybox: nil,
+                    sort: nil, count: nil, count_any: false,
+                    withcoord: false, withdist: false, withhash: false)
+        args = [key]
+        args << "FROMMEMBER" << frommember if frommember
+        args << "FROMLONLAT" << fromlonlat[0] << fromlonlat[1] if fromlonlat
+        args << "BYRADIUS" << byradius[0] << byradius[1] if byradius
+        args << "BYBOX" << bybox[0] << bybox[1] << bybox[2] if bybox
+
+        options = []
+        options << "WITHCOORD" if withcoord
+        options << "WITHDIST" if withdist
+        options << "WITHHASH" if withhash
+
+        geoarguments = _geoarguments(*args, sort: sort, count: count, count_any: count_any, options: options)
+
+        send_command([:geosearch, *geoarguments])
+      end
+
+      # Like GEOSEARCH, but stores the result in a destination key. By default the destination
+      # is populated with the matching members and their geospatial scores; when STOREDIST is
+      # set, the members are stored with their distance from the center point as the score.
+      # Available since Redis 6.2.
+      #
+      # @example Store the three nearest members
+      #   redis.geosearchstore("nearest", "Sicily",
+      #                        fromlonlat: [15, 37], bybox: [400, 400, "km"], sort: "asc", count: 3)
+      #     # => 3
+      #
+      # @example Store distances as scores
+      #   redis.geosearchstore("distances", "Sicily",
+      #                        fromlonlat: [15, 37], bybox: [400, 400, "km"], storedist: true)
+      #     # => 3
+      #
+      # @param [String] destination key to store the result in
+      # @param [String] source geospatial sorted set to search
+      # @param [String] frommember use the position of the given existing member as the center
+      # @param [Array<Numeric>] fromlonlat a [longitude, latitude] pair used as the center
+      # @param [Array] byradius a [radius, unit] pair where unit is one of 'm', 'km', 'ft', 'mi'
+      # @param [Array] bybox a [width, height, unit] triple where unit is one of 'm', 'km', 'ft', 'mi'
+      # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest, or vice versa
+      # @param [Integer] count limit the results to the first N matching items
+      # @param [Boolean] count_any return as soon as enough matches are found (only with count)
+      # @param [Boolean] storedist store the distance from the center point as the score
+      # @return [Integer] number of elements stored in the destination key
+      def geosearchstore(destination, source, frommember: nil, fromlonlat: nil, byradius: nil, bybox: nil,
+                         sort: nil, count: nil, count_any: false, storedist: false)
+        args = [destination, source]
+        args << "FROMMEMBER" << frommember if frommember
+        args << "FROMLONLAT" << fromlonlat[0] << fromlonlat[1] if fromlonlat
+        args << "BYRADIUS" << byradius[0] << byradius[1] if byradius
+        args << "BYBOX" << bybox[0] << bybox[1] << bybox[2] if bybox
+
+        options = []
+        options << "STOREDIST" if storedist
+
+        geoarguments = _geoarguments(*args, sort: sort, count: count, count_any: count_any, options: options)
+
+        send_command([:geosearchstore, *geoarguments])
+      end
+
       # Returns the distance between two members of a geospatial index
       #
       # @param [String ]key
@@ -73,10 +172,13 @@ class Redis
 
       private
 
-      def _geoarguments(*args, options: nil, sort: nil, count: nil)
-        args.push sort if sort
-        args.push 'count', count if count
-        args.push options if options
+      def _geoarguments(*args, options: nil, sort: nil, count: nil, count_any: false)
+        args << sort if sort
+        if count
+          args << 'COUNT' << Integer(count)
+          args << 'ANY' if count_any
+        end
+        args.concat(Array(options))
         args
       end
     end

data/lib/redis/commands/hashes.rb

@@ -63,7 +63,7 @@ class Redis
       #
       # @see #hmset
       def mapped_hmset(key, hash)
-        hmset(key, hash.to_a.flatten)
+        hmset(key, hash.flatten)
       end
 
       # Get the value of a hash field.
@@ -87,7 +87,8 @@ class Redis
       #
       # @see #mapped_hmget
       def hmget(key, *fields, &blk)
-        send_command([:hmget, key] + fields, &blk)
+        fields.flatten!(1)
+        send_command([:hmget, key].concat(fields), &blk)
       end
 
       # Get the values of all the given hash fields.
@@ -102,7 +103,8 @@ class Redis
       #
       # @see #hmget
       def mapped_hmget(key, *fields)
-        hmget(key, *fields) do |reply|
+        fields.flatten!(1)
+        hmget(key, fields) do |reply|
           if reply.is_a?(Array)
             Hash[fields.zip(reply)]
           else
@@ -152,7 +154,8 @@ class Redis
       # @param [String, Array<String>] field
       # @return [Integer] the number of fields that were removed from the hash
       def hdel(key, *fields)
-        send_command([:hdel, key, *fields])
+        fields.flatten!(1)
+        send_command([:hdel, key].concat(fields))
       end
 
       # Determine if a hash field exists.
@@ -171,7 +174,7 @@ class Redis
       # @param [Integer] increment
       # @return [Integer] value of the field after incrementing it
       def hincrby(key, field, increment)
-        send_command([:hincrby, key, field, increment])
+        send_command([:hincrby, key, field, Integer(increment)])
       end
 
       # Increment the numeric value of a hash field by the given float number.
@@ -181,7 +184,7 @@ class Redis
       # @param [Float] increment
       # @return [Float] value of the field after incrementing it
       def hincrbyfloat(key, field, increment)
-        send_command([:hincrbyfloat, key, field, increment], &Floatify)
+        send_command([:hincrbyfloat, key, field, Float(increment)], &Floatify)
       end
 
       # Get all the fields in a hash.
@@ -217,11 +220,20 @@ class Redis
       # @param [Hash] options
       #   - `:match => String`: only return keys matching the pattern
       #   - `:count => Integer`: return count keys at most per iteration
+      #   - `:novalues => Boolean`: whether or not to include values in the output (default: false)
       #
-      # @return [String, Array<[String, String]>] the next cursor and all found keys
+      # @return [String, Array<[String, String]>, Array<String>] the next cursor and all found keys
+      #   - when `:novalues` is false: [cursor, [[field1, value1], [field2, value2], ...]]
+      #   - when `:novalues` is true: [cursor, [field1, field2, ...]]
+      #
+      # See the [Redis Server HSCAN documentation](https://redis.io/docs/latest/commands/hscan/) for further details
       def hscan(key, cursor, **options)
         _scan(:hscan, cursor, [key], **options) do |reply|
-          [reply[0], reply[1].each_slice(2).to_a]
+          if options[:novalues]
+            reply
+          else
+            [reply[0], reply[1].each_slice(2).to_a]
+          end
         end
       end
 
@@ -234,8 +246,11 @@ class Redis
       # @param [Hash] options
       #   - `:match => String`: only return keys matching the pattern
       #   - `:count => Integer`: return count keys at most per iteration
+      #   - `:novalues => Boolean`: whether or not to include values in the output (default: false)
       #
       # @return [Enumerator] an enumerator for all found keys
+      #
+      # See the [Redis Server HSCAN documentation](https://redis.io/docs/latest/commands/hscan/) for further details
       def hscan_each(key, **options, &block)
         return to_enum(:hscan_each, key, **options) unless block_given?
 
@@ -246,6 +261,162 @@ class Redis
           break if cursor == "0"
         end
       end
+
+      # Sets the time to live in seconds for one or more fields.
+      #
+      # @example
+      #   redis.hset("hash", "f1", "v1")
+      #   redis.hexpire("hash", 10, "f1", "f2") # => [1, -2]
+      #
+      # @param [String] key
+      # @param [Integer] ttl
+      # @param [Array<String>] fields
+      # @return [Array<Integer>] Feedback on if the fields have been updated.
+      #
+      # See https://redis.io/docs/latest/commands/hexpire/#return-information for array reply.
+      def hexpire(key, ttl, *fields)
+        send_command([:hexpire, key, ttl, 'FIELDS', fields.length, *fields])
+      end
+
+      # Returns the time to live in seconds for one or more fields.
+      #
+      # @example
+      #   redis.hset("hash", "f1", "v1", "f2", "v2")
+      #   redis.hexpire("hash", 10, "f1") # => [1]
+      #   redis.httl("hash", "f1", "f2", "f3") # => [10, -1, -2]
+      #
+      # @param [String] key
+      # @param [Array<String>] fields
+      # @return [Array<Integer>] Feedback on the TTL of the fields.
+      #
+      # See https://redis.io/docs/latest/commands/httl/#return-information for array reply.
+      def httl(key, *fields)
+        send_command([:httl, key, 'FIELDS', fields.length, *fields])
+      end
+
+      # Sets the time to live in milliseconds for one or more fields.
+      #
+      # @example
+      #   redis.hset("hash", "f1", "v1")
+      #   redis.hpexpire("hash", 500, "f1", "f2") # => [1, -2]
+      #   redis.hpexpire("hash", 500, "f1", "f2", nx: true) # => [0, -2]
+      #
+      # @param [String] key
+      # @param [Integer] ttl
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
+      # @param [Array<String>] fields
+      # @return [Array<Integer>] Feedback on if the fields have been updated.
+      #
+      # See https://redis.io/docs/latest/commands/hpexpire/#return-information for array reply.
+      def hpexpire(key, ttl, *fields, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:hpexpire, key, ttl]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+        args.concat(['FIELDS', fields.length, *fields])
+
+        send_command(args)
+      end
+
+      # Returns the time to live in milliseconds for one or more fields.
+      #
+      # @example
+      #   redis.hset("hash", "f1", "v1", "f2", "v2")
+      #   redis.hpexpire("hash", 500, "f1") # => [1]
+      #   redis.hpttl("hash", "f1", "f2", "f3") # => [500, -1, -2]
+      #
+      # @param [String] key
+      # @param [Array<String>] fields
+      # @return [Array<Integer>] Feedback on the TTL of the fields.
+      #
+      # See https://redis.io/docs/latest/commands/hpttl/#return-information for array reply.
+      def hpttl(key, *fields)
+        send_command([:hpttl, key, 'FIELDS', fields.length, *fields])
+      end
+
+      # Register an ordered list of hash field names under +fieldset_name+ for
+      # use by subsequent #himport_set calls on the same connection.
+      #
+      # Fieldsets are server-side session state scoped to the current physical
+      # connection: they vanish on disconnect or RESET and are invisible to
+      # other connections. See the README "Bulk hash ingestion (HIMPORT)"
+      # section for connection-scoping guidance. Re-preparing an existing
+      # +fieldset_name+ silently replaces it. Field order is preserved as
+      # given; it defines the positional pairing used by #himport_set.
+      #
+      # @note HIMPORT support is experimental: the client API may change in a
+      #   future minor release without a major version bump.
+      #
+      # @example
+      #   redis.himport_prepare("shared", ["name", "email", "age"])
+      #     # => "OK"
+      #
+      # @param [String] fieldset_name name used by later SET and DISCARD calls
+      # @param [String, Array<String>] fields one or more field names
+      # @return [String] `"OK"`
+      # @api experimental
+      def himport_prepare(fieldset_name, *fields)
+        fields.flatten!(1)
+        raise ArgumentError, "fields must not be empty" if fields.empty?
+
+        send_command([:himport, "PREPARE", fieldset_name].concat(fields))
+      end
+
+      # Create or fully replace the hash at +key+ using the field list
+      # registered under +fieldset_name+ on this connection. Values pair
+      # positionally with the fields given to #himport_prepare; the value
+      # count must equal the field count.
+      #
+      # The fieldset must exist on the executing connection, otherwise the
+      # server replies with a "no such fieldset" error.
+      #
+      # @note HIMPORT support is experimental: the client API may change in a
+      #   future minor release without a major version bump.
+      #
+      # @example
+      #   redis.himport_set("shared:1", "shared", ["alice", "alice@example.com", "25"])
+      #     # => "OK"
+      #
+      # @param [String] key hash key to create or overwrite
+      # @param [String] fieldset_name fieldset previously prepared on this connection
+      # @param [String, Array<String>] values one or more values, order preserved
+      # @return [String] `"OK"`
+      # @api experimental
+      def himport_set(key, fieldset_name, *values)
+        values.flatten!(1)
+        raise ArgumentError, "values must not be empty" if values.empty?
+
+        send_command([:himport, "SET", key, fieldset_name].concat(values))
+      end
+
+      # Remove +fieldset_name+ from this connection's session. Keys already
+      # written through the fieldset are not affected.
+      #
+      # @note HIMPORT support is experimental: the client API may change in a
+      #   future minor release without a major version bump.
+      #
+      # @param [String] fieldset_name
+      # @return [Integer] `1` if the fieldset was removed, `0` if it did not exist
+      # @api experimental
+      def himport_discard(fieldset_name)
+        send_command([:himport, "DISCARD", fieldset_name])
+      end
+
+      # Remove all fieldsets from this connection's session.
+      #
+      # @note HIMPORT support is experimental: the client API may change in a
+      #   future minor release without a major version bump.
+      #
+      # @return [Integer] number of fieldsets removed
+      # @api experimental
+      def himport_discard_all
+        send_command([:himport, "DISCARDALL"])
+      end
     end
   end
 end

data/lib/redis/commands/hyper_log_log.rb

@@ -20,7 +20,7 @@ class Redis
       # @param [String, Array<String>] keys
       # @return [Integer]
       def pfcount(*keys)
-        send_command([:pfcount] + keys)
+        send_command([:pfcount] + keys.flatten(1))
       end
 
       # Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of

data/lib/redis/commands/keys.rb

@@ -22,6 +22,8 @@ class Redis
       #   - `:type => String`: return keys only of the given type
       #
       # @return [String, Array<String>] the next cursor and all found keys
+      #
+      # See the [Redis Server SCAN documentation](https://redis.io/docs/latest/commands/scan/) for further details
       def scan(cursor, **options)
         _scan(:scan, cursor, [], **options)
       end
@@ -46,6 +48,8 @@ class Redis
       #   - `:type => String`: return keys only of the given type
       #
       # @return [Enumerator] an enumerator for all found keys
+      #
+      # See the [Redis Server SCAN documentation](https://redis.io/docs/latest/commands/scan/) for further details
       def scan_each(**options, &block)
         return to_enum(:scan_each, **options) unless block_given?
 
@@ -76,7 +80,7 @@ class Redis
       #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
       def expire(key, seconds, nx: nil, xx: nil, gt: nil, lt: nil)
-        args = [:expire, key, seconds]
+        args = [:expire, key, Integer(seconds)]
         args << "NX" if nx
         args << "XX" if xx
         args << "GT" if gt
@@ -96,7 +100,7 @@ class Redis
       #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
       def expireat(key, unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
-        args = [:expireat, key, unix_time]
+        args = [:expireat, key, Integer(unix_time)]
         args << "NX" if nx
         args << "XX" if xx
         args << "GT" if gt
@@ -105,6 +109,14 @@ class Redis
         send_command(args, &Boolify)
       end
 
+      # Get a key's expiry time specified as number of seconds from UNIX Epoch
+      #
+      # @param  [String] key
+      # @return [Integer] expiry time specified as number of seconds from UNIX Epoch
+      def expiretime(key)
+        send_command([:expiretime, key])
+      end
+
       # Get the time to live (in seconds) for a key.
       #
       # @param [String] key
@@ -132,7 +144,7 @@ class Redis
       #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
       def pexpire(key, milliseconds, nx: nil, xx: nil, gt: nil, lt: nil)
-        args = [:pexpire, key, milliseconds]
+        args = [:pexpire, key, Integer(milliseconds)]
         args << "NX" if nx
         args << "XX" if xx
         args << "GT" if gt
@@ -152,7 +164,7 @@ class Redis
       #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
       def pexpireat(key, ms_unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
-        args = [:pexpireat, key, ms_unix_time]
+        args = [:pexpireat, key, Integer(ms_unix_time)]
         args << "NX" if nx
         args << "XX" if xx
         args << "GT" if gt
@@ -161,6 +173,14 @@ class Redis
         send_command(args, &Boolify)
       end
 
+      # Get a key's expiry time specified as number of milliseconds from UNIX Epoch
+      #
+      # @param  [String] key
+      # @return [Integer] expiry time specified as number of milliseconds from UNIX Epoch
+      def pexpiretime(key)
+        send_command([:pexpiretime, key])
+      end
+
       # Get the time to live (in milliseconds) for a key.
       #
       # @param [String] key
@@ -241,6 +261,9 @@ class Redis
       # @param [String, Array<String>] keys
       # @return [Integer] number of keys that were unlinked
       def unlink(*keys)
+        keys.flatten!(1)
+        return 0 if keys.empty?
+
         send_command([:unlink] + keys)
       end
 
@@ -249,24 +272,6 @@ class Redis
       # @param [String, Array<String>] keys
       # @return [Integer]
       def exists(*keys)
-        if !Redis.exists_returns_integer && keys.size == 1
-          if Redis.exists_returns_integer.nil?
-            message = "`Redis#exists(key)` will return an Integer in redis-rb 4.3. `exists?` returns a boolean, you " \
-              "should use it instead. To opt-in to the new behavior now you can set Redis.exists_returns_integer =  " \
-              "true. To disable this message and keep the current (boolean) behaviour of 'exists' you can set " \
-              "`Redis.exists_returns_integer = false`, but this option will be removed in 5.0.0. " \
-              "(#{::Kernel.caller(1, 1).first})\n"
-
-            ::Redis.deprecate!(message)
-          end
-
-          exists?(*keys)
-        else
-          _exists(*keys)
-        end
-      end
-
-      def _exists(*keys)
         send_command([:exists, *keys])
       end
 
@@ -284,6 +289,8 @@ class Redis
       #
       # @param [String] pattern
       # @return [Array<String>]
+      #
+      # See the [Redis Server KEYS documentation](https://redis.io/docs/latest/commands/keys/) for further details
       def keys(pattern = "*")
         send_command([:keys, pattern]) do |reply|
           if reply.is_a?(String)
@@ -440,13 +447,14 @@ class Redis
 
       private
 
-      def _scan(command, cursor, args, match: nil, count: nil, type: nil, &block)
+      def _scan(command, cursor, args, match: nil, count: nil, type: nil, novalues: false, &block)
         # SSCAN/ZSCAN/HSCAN already prepend the key to +args+.
 
         args << cursor
         args << "MATCH" << match if match
-        args << "COUNT" << count if count
+        args << "COUNT" << Integer(count) if count
         args << "TYPE" << type if type
+        args << "NOVALUES" if novalues
 
         send_command([command] + args, &block)
       end