redis 4.8.1 → 5.4.0

data/lib/redis/commands/sets.rb

@@ -15,56 +15,40 @@ class Redis
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean, Integer] `Boolean` when a single member is specified,
-      #   holding whether or not adding the member succeeded, or `Integer` when an
-      #   array of members is specified, holding the number of members that were
-      #   successfully added
-      def sadd(key, member)
-        block = if Redis.sadd_returns_boolean && !member.is_a?(Array)
-          ::Redis.deprecate!(
-            "Redis#sadd will always return an Integer in Redis 5.0.0. Use Redis#sadd? instead." \
-            "(called from: #{caller(1, 1).first})"
-          )
-          Boolify
-        end
-        send_command([:sadd, key, member], &block)
+      # @return [Integer] The number of members that were successfully added
+      def sadd(key, *members)
+        members.flatten!(1)
+        send_command([:sadd, key].concat(members))
       end
 
       # Add one or more members to a set.
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean] Whether or not at least one member was added.
-      def sadd?(key, member)
-        send_command([:sadd, key, member], &Boolify)
+      # @return [Boolean] Wether at least one member was successfully added.
+      def sadd?(key, *members)
+        members.flatten!(1)
+        send_command([:sadd, key].concat(members), &Boolify)
       end
 
       # Remove one or more members from a set.
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean, Integer] `Boolean` when a single member is specified,
-      #   holding whether or not removing the member succeeded, or `Integer` when an
-      #   array of members is specified, holding the number of members that were
-      #   successfully removed
-      def srem(key, member)
-        block = if Redis.sadd_returns_boolean && !member.is_a?(Array)
-          ::Redis.deprecate!(
-            "Redis#srem will always return an Integer in Redis 5.0.0. Use Redis#srem? instead." \
-            "(called from: #{caller(1, 1).first})"
-          )
-          Boolify
-        end
-        send_command([:srem, key, member], &block)
+      # @return [Integer] The number of members that were successfully removed
+      def srem(key, *members)
+        members.flatten!(1)
+        send_command([:srem, key].concat(members))
       end
 
       # Remove one or more members from a set.
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean] `Boolean` Whether or not a member was removed.
-      def srem?(key, member)
-        send_command([:srem, key, member], &Boolify)
+      # @return [Boolean] Wether at least one member was successfully removed.
+      def srem?(key, *members)
+        members.flatten!(1)
+        send_command([:srem, key].concat(members), &Boolify)
       end
 
       # Remove and return one or more random member from a set.
@@ -76,7 +60,7 @@ class Redis
         if count.nil?
           send_command([:spop, key])
         else
-          send_command([:spop, key, count])
+          send_command([:spop, key, Integer(count)])
         end
       end
 
@@ -118,7 +102,8 @@ class Redis
       # @param [String, Array<String>] members
       # @return [Array<Boolean>]
       def smismember(key, *members)
-        send_command([:smismember, key, *members]) do |reply|
+        members.flatten!(1)
+        send_command([:smismember, key].concat(members)) do |reply|
           reply.map(&Boolify)
         end
       end
@@ -136,7 +121,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to subtract
       # @return [Array<String>] members in the difference
       def sdiff(*keys)
-        send_command([:sdiff, *keys])
+        keys.flatten!(1)
+        send_command([:sdiff].concat(keys))
       end
 
       # Subtract multiple sets and store the resulting set in a key.
@@ -145,7 +131,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to subtract
       # @return [Integer] number of elements in the resulting set
       def sdiffstore(destination, *keys)
-        send_command([:sdiffstore, destination, *keys])
+        keys.flatten!(1)
+        send_command([:sdiffstore, destination].concat(keys))
       end
 
       # Intersect multiple sets.
@@ -153,7 +140,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to intersect
       # @return [Array<String>] members in the intersection
       def sinter(*keys)
-        send_command([:sinter, *keys])
+        keys.flatten!(1)
+        send_command([:sinter].concat(keys))
       end
 
       # Intersect multiple sets and store the resulting set in a key.
@@ -162,7 +150,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to intersect
       # @return [Integer] number of elements in the resulting set
       def sinterstore(destination, *keys)
-        send_command([:sinterstore, destination, *keys])
+        keys.flatten!(1)
+        send_command([:sinterstore, destination].concat(keys))
       end
 
       # Add multiple sets.
@@ -170,7 +159,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to unify
       # @return [Array<String>] members in the union
       def sunion(*keys)
-        send_command([:sunion, *keys])
+        keys.flatten!(1)
+        send_command([:sunion].concat(keys))
       end
 
       # Add multiple sets and store the resulting set in a key.
@@ -179,7 +169,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to unify
       # @return [Integer] number of elements in the resulting set
       def sunionstore(destination, *keys)
-        send_command([:sunionstore, destination, *keys])
+        keys.flatten!(1)
+        send_command([:sunionstore, destination].concat(keys))
       end
 
       # Scan a set
@@ -193,6 +184,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [String, Array<String>] the next cursor and all found members
+      #
+      # See the [Redis Server SSCAN documentation](https://redis.io/docs/latest/commands/sscan/) for further details
       def sscan(key, cursor, **options)
         _scan(:sscan, cursor, [key], **options)
       end
@@ -208,6 +201,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [Enumerator] an enumerator for all keys in the set
+      #
+      # See the [Redis Server SSCAN documentation](https://redis.io/docs/latest/commands/sscan/) for further details
       def sscan_each(key, **options, &block)
         return to_enum(:sscan_each, key, **options) unless block_given?
 

data/lib/redis/commands/sorted_sets.rb

@@ -136,7 +136,9 @@ class Redis
       # @return [Array<String, Float>] element and score pair if count is not specified
       # @return [Array<Array<String, Float>>] list of popped elements and scores
       def zpopmax(key, count = nil)
-        send_command([:zpopmax, key, count].compact) do |members|
+        command = [:zpopmax, key]
+        command << Integer(count) if count
+        send_command(command) do |members|
           members = FloatifyPairs.call(members)
           count.to_i > 1 ? members : members.first
         end
@@ -157,12 +159,80 @@ class Redis
       # @return [Array<String, Float>] element and score pair if count is not specified
       # @return [Array<Array<String, Float>>] list of popped elements and scores
       def zpopmin(key, count = nil)
-        send_command([:zpopmin, key, count].compact) do |members|
+        command = [:zpopmin, key]
+        command << Integer(count) if count
+        send_command(command) do |members|
           members = FloatifyPairs.call(members)
           count.to_i > 1 ? members : members.first
         end
       end
 
+      # Removes and returns up to count members with scores in the sorted set stored at key.
+      #
+      # @example Popping a member
+      #   redis.bzmpop('zset')
+      #   #=> ['zset', ['a', 1.0]]
+      # @example With count option
+      #   redis.bzmpop('zset', count: 2)
+      #   #=> ['zset', [['a', 1.0], ['b', 2.0]]
+      #
+      # @params timeout [Float] a float value specifying the maximum number of seconds to block) elapses.
+      #   A timeout of zero can be used to block indefinitely.
+      # @params key [String, Array<String>] one or more keys with sorted sets
+      # @params modifier [String]
+      #  - when `"MIN"` - the elements popped are those with lowest scores
+      #  - when `"MAX"` - the elements popped are those with the highest scores
+      # @params count [Integer] a number of members to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements and scores
+      def bzmpop(timeout, *keys, modifier: "MIN", count: nil)
+        raise ArgumentError, "Pick either MIN or MAX" unless modifier == "MIN" || modifier == "MAX"
+
+        args = [:bzmpop, timeout, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_blocking_command(args, timeout) do |response|
+          response&.map do |entry|
+            case entry
+            when String then entry
+            when Array then entry.map { |pair| FloatifyPairs.call(pair) }.flatten(1)
+            end
+          end
+        end
+      end
+
+      # Removes and returns up to count members with scores in the sorted set stored at key.
+      #
+      # @example Popping a member
+      #   redis.zmpop('zset')
+      #   #=> ['zset', ['a', 1.0]]
+      # @example With count option
+      #   redis.zmpop('zset', count: 2)
+      #   #=> ['zset', [['a', 1.0], ['b', 2.0]]
+      #
+      # @params key [String, Array<String>] one or more keys with sorted sets
+      # @params modifier [String]
+      #  - when `"MIN"` - the elements popped are those with lowest scores
+      #  - when `"MAX"` - the elements popped are those with the highest scores
+      # @params count [Integer] a number of members to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements and scores
+      def zmpop(*keys, modifier: "MIN", count: nil)
+        raise ArgumentError, "Pick either MIN or MAX" unless modifier == "MIN" || modifier == "MAX"
+
+        args = [:zmpop, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_command(args) do |response|
+          response&.map do |entry|
+            case entry
+            when String then entry
+            when Array then entry.map { |pair| FloatifyPairs.call(pair) }.flatten(1)
+            end
+          end
+        end
+      end
+
       # Removes and returns up to count members with the highest scores in the sorted set stored at keys,
       #   or block until one is available.
       #
@@ -261,7 +331,7 @@ class Redis
         end
 
         args = [:zrandmember, key]
-        args << count if count
+        args << Integer(count) if count
 
         if with_scores
           args << "WITHSCORES"
@@ -313,7 +383,7 @@ class Redis
 
         if limit
           args << "LIMIT"
-          args.concat(limit)
+          args.concat(limit.map { |l| Integer(l) })
         end
 
         if with_scores
@@ -354,7 +424,7 @@ class Redis
 
         if limit
           args << "LIMIT"
-          args.concat(limit)
+          args.concat(limit.map { |l| Integer(l) })
         end
 
         send_command(args)
@@ -372,7 +442,7 @@ class Redis
       #
       # @see #zrange
       def zrevrange(key, start, stop, withscores: false, with_scores: withscores)
-        args = [:zrevrange, key, start, stop]
+        args = [:zrevrange, key, Integer(start), Integer(stop)]
 
         if with_scores
           args << "WITHSCORES"
@@ -384,21 +454,55 @@ class Redis
 
       # Determine the index of a member in a sorted set.
       #
+      # @example Retrieve member rank
+      #   redis.zrank("zset", "a")
+      #     # => 3
+      # @example Retrieve member rank with their score
+      #   redis.zrank("zset", "a", :with_score => true)
+      #     # => [3, 32.0]
+      #
       # @param [String] key
       # @param [String] member
-      # @return [Integer]
-      def zrank(key, member)
-        send_command([:zrank, key, member])
+      #
+      # @return [Integer, [Integer, Float]]
+      #   - when `:with_score` is not specified, an Integer
+      #   - when `:with_score` is specified, a `[rank, score]` pair
+      def zrank(key, member, withscore: false, with_score: withscore)
+        args = [:zrank, key, member]
+
+        if with_score
+          args << "WITHSCORE"
+          block = FloatifyPair
+        end
+
+        send_command(args, &block)
       end
 
       # Determine the index of a member in a sorted set, with scores ordered from
       # high to low.
       #
+      # @example Retrieve member rank
+      #   redis.zrevrank("zset", "a")
+      #     # => 3
+      # @example Retrieve member rank with their score
+      #   redis.zrevrank("zset", "a", :with_score => true)
+      #     # => [3, 32.0]
+      #
       # @param [String] key
       # @param [String] member
-      # @return [Integer]
-      def zrevrank(key, member)
-        send_command([:zrevrank, key, member])
+      #
+      # @return [Integer, [Integer, Float]]
+      #   - when `:with_score` is not specified, an Integer
+      #   - when `:with_score` is specified, a `[rank, score]` pair
+      def zrevrank(key, member, withscore: false, with_score: withscore)
+        args = [:zrevrank, key, member]
+
+        if with_score
+          args << "WITHSCORE"
+          block = FloatifyPair
+        end
+
+        send_command(args, &block)
       end
 
       # Remove all members in a sorted set within the given indexes.
@@ -466,7 +570,7 @@ class Redis
 
         if limit
           args << "LIMIT"
-          args.concat(limit)
+          args.concat(limit.map { |l| Integer(l) })
         end
 
         send_command(args)
@@ -488,7 +592,7 @@ class Redis
 
         if limit
           args << "LIMIT"
-          args.concat(limit)
+          args.concat(limit.map { |l| Integer(l) })
         end
 
         send_command(args)
@@ -531,7 +635,7 @@ class Redis
 
         if limit
           args << "LIMIT"
-          args.concat(limit)
+          args.concat(limit.map { |l| Integer(l) })
         end
 
         send_command(args, &block)
@@ -561,7 +665,7 @@ class Redis
 
         if limit
           args << "LIMIT"
-          args.concat(limit)
+          args.concat(limit.map { |l| Integer(l) })
         end
 
         send_command(args, &block)
@@ -747,6 +851,8 @@ class Redis
       #
       # @return [String, Array<[String, Float]>] the next cursor and all found
       #   members and scores
+      #
+      # See the [Redis Server ZSCAN documentation](https://redis.io/docs/latest/commands/zscan/) for further details
       def zscan(key, cursor, **options)
         _scan(:zscan, cursor, [key], **options) do |reply|
           [reply[0], FloatifyPairs.call(reply[1])]
@@ -764,6 +870,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [Enumerator] an enumerator for all found scores and members
+      #
+      # See the [Redis Server ZSCAN documentation](https://redis.io/docs/latest/commands/zscan/) for further details
       def zscan_each(key, **options, &block)
         return to_enum(:zscan_each, key, **options) unless block_given?
 
@@ -778,7 +886,8 @@ class Redis
       private
 
       def _zsets_operation(cmd, *keys, weights: nil, aggregate: nil, with_scores: false)
-        command = [cmd, keys.size, *keys]
+        keys.flatten!(1)
+        command = [cmd, keys.size].concat(keys)
 
         if weights
           command << "WEIGHTS"
@@ -796,7 +905,8 @@ class Redis
       end
 
       def _zsets_operation_store(cmd, destination, keys, weights: nil, aggregate: nil)
-        command = [cmd, destination, keys.size, *keys]
+        keys.flatten!(1)
+        command = [cmd, destination, keys.size].concat(keys)
 
         if weights
           command << "WEIGHTS"

data/lib/redis/commands/streams.rb

@@ -21,15 +21,12 @@ class Redis
       # @return [Array<Hash>] information of the consumers if subcommand is `consumers`
       def xinfo(subcommand, key, group = nil)
         args = [:xinfo, subcommand, key, group].compact
-        synchronize do |client|
-          client.call(args) do |reply|
-            case subcommand.to_s.downcase
-            when 'stream'              then Hashify.call(reply)
-            when 'groups', 'consumers' then reply.map { |arr| Hashify.call(arr) }
-            else reply
-            end
-          end
+        block = case subcommand.to_s.downcase
+        when 'stream'              then Hashify
+        when 'groups', 'consumers' then proc { |r| r.map(&Hashify) }
         end
+
+        send_command(args, &block)
       end
 
       # Add new entry to the stream.
@@ -37,26 +34,35 @@ class Redis
       # @example Without options
       #   redis.xadd('mystream', f1: 'v1', f2: 'v2')
       # @example With options
-      #   redis.xadd('mystream', { f1: 'v1', f2: 'v2' }, id: '0-0', maxlen: 1000, approximate: true)
+      #   redis.xadd('mystream', { f1: 'v1', f2: 'v2' }, id: '0-0', maxlen: 1000, approximate: true, nomkstream: true)
       #
       # @param key   [String] the stream key
       # @param entry [Hash]   one or multiple field-value pairs
       # @param opts  [Hash]   several options for `XADD` command
       #
       # @option opts [String]  :id          the entry id, default value is `*`, it means auto generation
-      # @option opts [Integer] :maxlen      max length of entries
-      # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen or not
+      # @option opts [Integer] :maxlen      max length of entries to keep
+      # @option opts [Integer] :minid       min id of entries to keep
+      # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen/minid or not
+      # @option opts [Boolean] :nomkstream  whether to add NOMKSTREAM, default is not to add
       #
       # @return [String] the entry id
-      def xadd(key, entry, approximate: nil, maxlen: nil, id: '*')
+      def xadd(key, entry, approximate: nil, maxlen: nil, minid: nil, nomkstream: nil, id: '*')
         args = [:xadd, key]
+        args << 'NOMKSTREAM' if nomkstream
         if maxlen
+          raise ArgumentError, "can't supply both maxlen and minid" if minid
+
           args << "MAXLEN"
           args << "~" if approximate
           args << maxlen
+        elsif minid
+          args << "MINID"
+          args << "~" if approximate
+          args << minid
         end
         args << id
-        args.concat(entry.to_a.flatten)
+        args.concat(entry.flatten)
         send_command(args)
       end
 
@@ -66,14 +72,30 @@ class Redis
       #   redis.xtrim('mystream', 1000)
       # @example With options
       #   redis.xtrim('mystream', 1000, approximate: true)
-      #
-      # @param key         [String]  the stream key
-      # @param mexlen      [Integer] max length of entries
-      # @param approximate [Boolean] whether to add `~` modifier of maxlen or not
+      # @example With strategy
+      #   redis.xtrim('mystream', '1-0', strategy: 'MINID')
+      #
+      # @overload xtrim(key, maxlen, strategy: 'MAXLEN', approximate: true)
+      #   @param key         [String]  the stream key
+      #   @param maxlen      [Integer] max length of entries
+      #   @param strategy    [String]  the limit strategy, must be MAXLEN
+      #   @param approximate [Boolean] whether to add `~` modifier of maxlen or not
+      #   @param limit       [Integer] maximum count of entries to be evicted
+      # @overload xtrim(key, minid, strategy: 'MINID', approximate: true)
+      #   @param key         [String]  the stream key
+      #   @param minid       [String]  minimum id of entries
+      #   @param strategy    [String]  the limit strategy, must be MINID
+      #   @param approximate [Boolean] whether to add `~` modifier of minid or not
+      #   @param limit       [Integer] maximum count of entries to be evicted
       #
       # @return [Integer] the number of entries actually deleted
-      def xtrim(key, maxlen, approximate: false)
-        args = [:xtrim, key, 'MAXLEN', (approximate ? '~' : nil), maxlen].compact
+      def xtrim(key, len_or_id, strategy: 'MAXLEN', approximate: false, limit: nil)
+        strategy = strategy.to_s.upcase
+
+        args = [:xtrim, key, strategy]
+        args << '~' if approximate
+        args << len_or_id
+        args.concat(['LIMIT', limit]) if limit
         send_command(args)
       end
 
@@ -113,7 +135,7 @@ class Redis
       def xrange(key, start = '-', range_end = '+', count: nil)
         args = [:xrange, key, start, range_end]
         args.concat(['COUNT', count]) if count
-        synchronize { |client| client.call(args, &HashifyStreamEntries) }
+        send_command(args, &HashifyStreamEntries)
       end
 
       # Fetches entries of the stream in descending order.
@@ -334,6 +356,8 @@ class Redis
       #   redis.xpending('mystream', 'mygroup')
       # @example With range options
       #   redis.xpending('mystream', 'mygroup', '-', '+', 10)
+      # @example With range and idle time options
+      #   redis.xpending('mystream', 'mygroup', '-', '+', 10, idle: 9000)
       # @example With range and consumer options
       #   redis.xpending('mystream', 'mygroup', '-', '+', 10, 'consumer1')
       #
@@ -344,10 +368,13 @@ class Redis
       # @param count    [Integer] count the number of entries as limit
       # @param consumer [String]  the consumer name
       #
+      # @option opts [Integer] :idle       pending message minimum idle time in milliseconds
+      #
       # @return [Hash]        the summary of pending entries
       # @return [Array<Hash>] the pending entries details if options were specified
-      def xpending(key, group, *args)
+      def xpending(key, group, *args, idle: nil)
         command_args = [:xpending, key, group]
+        command_args << 'IDLE' << Integer(idle) if idle
         case args.size
         when 0, 3, 4
           command_args.concat(args)

data/lib/redis/commands/strings.rb

@@ -25,7 +25,7 @@ class Redis
       # @param [Integer] decrement
       # @return [Integer] value after decrementing it
       def decrby(key, decrement)
-        send_command([:decrby, key, decrement])
+        send_command([:decrby, key, Integer(decrement)])
       end
 
       # Increment the integer value of a key by one.
@@ -50,7 +50,7 @@ class Redis
       # @param [Integer] increment
       # @return [Integer] value after incrementing it
       def incrby(key, increment)
-        send_command([:incrby, key, increment])
+        send_command([:incrby, key, Integer(increment)])
       end
 
       # Increment the numeric value of a key by the given float number.
@@ -63,7 +63,7 @@ class Redis
       # @param [Float] increment
       # @return [Float] value after incrementing it
       def incrbyfloat(key, increment)
-        send_command([:incrbyfloat, key, increment], &Floatify)
+        send_command([:incrbyfloat, key, Float(increment)], &Floatify)
       end
 
       # Set the string value of a key.
@@ -82,10 +82,10 @@ class Redis
       # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`
       def set(key, value, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil, keepttl: nil, get: nil)
         args = [:set, key, value.to_s]
-        args << "EX" << ex if ex
-        args << "PX" << px if px
-        args << "EXAT" << exat if exat
-        args << "PXAT" << pxat if pxat
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
         args << "NX" if nx
         args << "XX" if xx
         args << "KEEPTTL" if keepttl
@@ -105,7 +105,7 @@ class Redis
       # @param [String] value
       # @return [String] `"OK"`
       def setex(key, ttl, value)
-        send_command([:setex, key, ttl, value.to_s])
+        send_command([:setex, key, Integer(ttl), value.to_s])
       end
 
       # Set the time to live in milliseconds of a key.
@@ -115,7 +115,7 @@ class Redis
       # @param [String] value
       # @return [String] `"OK"`
       def psetex(key, ttl, value)
-        send_command([:psetex, key, ttl, value.to_s])
+        send_command([:psetex, key, Integer(ttl), value.to_s])
       end
 
       # Set the value of a key, only if the key does not exist.
@@ -152,7 +152,7 @@ class Redis
       #
       # @see #mset
       def mapped_mset(hash)
-        mset(hash.to_a.flatten)
+        mset(hash.flatten)
       end
 
       # Set one or more values, only if none of the keys exist.
@@ -180,7 +180,7 @@ class Redis
       #
       # @see #msetnx
       def mapped_msetnx(hash)
-        msetnx(hash.to_a.flatten)
+        msetnx(hash.flatten)
       end
 
       # Get the value of a key.
@@ -202,6 +202,7 @@ class Redis
       #
       # @see #mapped_mget
       def mget(*keys, &blk)
+        keys.flatten!(1)
         send_command([:mget, *keys], &blk)
       end
 
@@ -232,7 +233,7 @@ class Redis
       # @param [String] value
       # @return [Integer] length of the string after it was modified
       def setrange(key, offset, value)
-        send_command([:setrange, key, offset, value.to_s])
+        send_command([:setrange, key, Integer(offset), value.to_s])
       end
 
       # Get a substring of the string stored at a key.
@@ -243,7 +244,7 @@ class Redis
       #   the end of the string
       # @return [Integer] `0` or `1`
       def getrange(key, start, stop)
-        send_command([:getrange, key, start, stop])
+        send_command([:getrange, key, Integer(start), Integer(stop)])
       end
 
       # Append a value to a key.
@@ -291,10 +292,10 @@ class Redis
       # @return [String] The value of key, or nil when key does not exist.
       def getex(key, ex: nil, px: nil, exat: nil, pxat: nil, persist: false)
         args = [:getex, key]
-        args << "EX" << ex if ex
-        args << "PX" << px if px
-        args << "EXAT" << exat if exat
-        args << "PXAT" << pxat if pxat
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
         args << "PERSIST" if persist
 
         send_command(args)