redis 4.8.1 → 6.0.0

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,37 @@ 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 [Integer] :limit       maximum count of entries to be evicted, requires approximate trimming
+      # @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, limit: 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.concat(['LIMIT', limit]) if limit
         args << id
-        args.concat(entry.to_a.flatten)
+        args.concat(entry.flatten)
         send_command(args)
       end
 
@@ -66,14 +74,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 +137,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.
@@ -159,18 +183,28 @@ class Redis
       #   redis.xread(%w[mystream1 mystream2], %w[0-0 0-0])
       # @example With count option
       #   redis.xread('mystream', '0-0', count: 2)
+      # @example With max_count option
+      #   redis.xread(%w[mystream1 mystream2], %w[0-0 0-0], max_count: 10)
       # @example With block option
       #   redis.xread('mystream', '$', block: 1000)
       #
-      # @param keys  [Array<String>] one or multiple stream keys
-      # @param ids   [Array<String>] one or multiple entry ids
-      # @param count [Integer]       the number of entries as limit per stream
-      # @param block [Integer]       the number of milliseconds as blocking timeout
+      # @param keys      [Array<String>] one or multiple stream keys
+      # @param ids       [Array<String>] one or multiple entry ids
+      # @param count     [Integer]       the number of entries as limit per stream
+      # @param max_count [Integer]       the total number of entries as limit across all streams
+      #   combined, must be greater than or equal to `count` when both are given (Redis 8.10+).
+      #   Defaults to unlimited.
+      # @param max_size  [Integer]       soft cap on the total reply size in bytes across all
+      #   streams combined, measured on the serialized server reply including protocol overhead;
+      #   a single oversized first entry can still be returned (Redis 8.10+). Defaults to unlimited.
+      # @param block     [Integer]       the number of milliseconds as blocking timeout
       #
       # @return [Hash{String => Hash{String => Hash}}] the entries
-      def xread(keys, ids, count: nil, block: nil)
+      def xread(keys, ids, count: nil, max_count: nil, max_size: nil, block: nil)
         args = [:xread]
         args << 'COUNT' << count if count
+        args << 'MAXCOUNT' << Integer(max_count) if max_count
+        args << 'MAXSIZE' << Integer(max_size) if max_size
         args << 'BLOCK' << block.to_i if block
         _xread(args, keys, ids, block)
       end
@@ -221,14 +255,22 @@ class Redis
       # @param ids      [Array<String>] one or multiple entry ids
       # @param opts     [Hash]          several options for `XREADGROUP` command
       #
-      # @option opts [Integer] :count the number of entries as limit
+      # @option opts [Integer] :count the number of entries as limit per stream
+      # @option opts [Integer] :max_count the total number of entries as limit across all streams
+      #   combined, must be greater than or equal to `count` when both are given (Redis 8.10+).
+      #   Defaults to unlimited.
+      # @option opts [Integer] :max_size soft cap on the total reply size in bytes across all
+      #   streams combined, measured on the serialized server reply including protocol overhead;
+      #   a single oversized first entry can still be returned (Redis 8.10+). Defaults to unlimited.
       # @option opts [Integer] :block the number of milliseconds as blocking timeout
       # @option opts [Boolean] :noack whether message loss is acceptable or not
       #
       # @return [Hash{String => Hash{String => Hash}}] the entries
-      def xreadgroup(group, consumer, keys, ids, count: nil, block: nil, noack: nil)
+      def xreadgroup(group, consumer, keys, ids, count: nil, max_count: nil, max_size: nil, block: nil, noack: nil)
         args = [:xreadgroup, 'GROUP', group, consumer]
         args << 'COUNT' << count if count
+        args << 'MAXCOUNT' << Integer(max_count) if max_count
+        args << 'MAXSIZE' << Integer(max_size) if max_size
         args << 'BLOCK' << block.to_i if block
         args << 'NOACK' if noack
         _xread(args, keys, ids, block)
@@ -334,6 +376,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 +388,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)

data/lib/redis/commands/transactions.rb

@@ -5,48 +5,26 @@ class Redis
     module Transactions
       # Mark the start of a transaction block.
       #
-      # Passing a block is optional.
-      #
       # @example With a block
       #   redis.multi do |multi|
       #     multi.set("key", "value")
       #     multi.incr("counter")
       #   end # => ["OK", 6]
       #
-      # @example Without a block
-      #   redis.multi
-      #     # => "OK"
-      #   redis.set("key", "value")
-      #     # => "QUEUED"
-      #   redis.incr("counter")
-      #     # => "QUEUED"
-      #   redis.exec
-      #     # => ["OK", 6]
-      #
       # @yield [multi] the commands that are called inside this block are cached
       #   and written to the server upon returning from it
       # @yieldparam [Redis] multi `self`
       #
-      # @return [String, Array<...>]
-      #   - when a block is not given, `OK`
-      #   - when a block is given, an array with replies
+      # @return [Array<...>]
+      #   - an array with replies
       #
       # @see #watch
       # @see #unwatch
-      def multi(&block) # :nodoc:
-        if block_given?
-          if block&.arity == 0
-            Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
-          end
-
-          synchronize do |prior_client|
-            pipeline = Pipeline::Multi.new(prior_client)
-            pipelined_connection = PipelinedConnection.new(pipeline)
-            yield pipelined_connection
-            prior_client.call_pipeline(pipeline)
+      def multi
+        synchronize do |client|
+          client.multi do |raw_transaction|
+            yield MultiConnection.new(raw_transaction)
           end
-        else
-          send_command([:multi])
         end
       end
 
@@ -82,7 +60,7 @@ class Redis
       # @see #multi
       def watch(*keys)
         synchronize do |client|
-          res = client.call([:watch, *keys])
+          res = client.call_v([:watch] + keys)
 
           if block_given?
             begin
@@ -125,8 +103,6 @@ class Redis
 
       # Discard all commands issued after MULTI.
       #
-      # Only call this method when `#multi` was called **without** a block.
-      #
       # @return [String] `"OK"`
       #
       # @see #multi

data/lib/redis/commands.rb

@@ -8,8 +8,10 @@ require "redis/commands/hashes"
 require "redis/commands/hyper_log_log"
 require "redis/commands/keys"
 require "redis/commands/lists"
+require "redis/commands/modules/json"
 require "redis/commands/pubsub"
 require "redis/commands/scripting"
+require "redis/commands/modules/search"
 require "redis/commands/server"
 require "redis/commands/sets"
 require "redis/commands/sorted_sets"
@@ -27,8 +29,10 @@ class Redis
     include HyperLogLog
     include Keys
     include Lists
+    include Json
     include Pubsub
     include Scripting
+    include Search
     include Server
     include Sets
     include SortedSets
@@ -40,12 +44,7 @@ class Redis
     # where the method call will return nil. Propagate the nil instead of falsely
     # returning false.
     Boolify = lambda { |value|
-      case value
-      when Integer
-        value > 0
-      else
-        value
-      end
+      value != 0 unless value.nil?
     }
 
     BoolifySet = lambda { |value|
@@ -60,7 +59,9 @@ class Redis
     }
 
     Hashify = lambda { |value|
-      if value.respond_to?(:each_slice)
+      if value.is_a?(Hash) # RESP3 already returns a map
+        value
+      elsif value.respond_to?(:each_slice) # RESP2 flat [k, v, k, v, ...]
         value.each_slice(2).to_h
       else
         value
@@ -68,10 +69,12 @@ class Redis
     }
 
     Pairify = lambda { |value|
-      if value.respond_to?(:each_slice)
-        value.each_slice(2).to_a
-      else
+      return value unless value.respond_to?(:each_slice)
+
+      if value.first.is_a?(Array) # RESP3 already returns [[k, v], ...]
         value
+      else # RESP2 flat [k, v, k, v, ...]
+        value.each_slice(2).to_a
       end
     }
 
@@ -88,11 +91,20 @@ class Redis
       end
     }
 
+    FloatifyPair = lambda { |(first, score)|
+      [first, Floatify.call(score)]
+    }
+
     FloatifyPairs = lambda { |value|
       return value unless value.respond_to?(:each_slice)
 
-      value.each_slice(2).map do |member, score|
-        [member, Floatify.call(score)]
+      if value.first.is_a?(Array) # RESP3 already returns [[member, score], ...]
+        # Scores arrive as native doubles, so the pairs are already in the final shape and
+        # re-mapping would only re-allocate identical arrays. Floatify only transforms Strings, so
+        # unless a score came back as one (it shouldn't under RESP3) return the parser's array as-is.
+        value.first.last.is_a?(String) ? value.map(&FloatifyPair) : value
+      else # RESP2 flat [member, score, member, score, ...]
+        value.each_slice(2).map(&FloatifyPair)
       end
     }
 
@@ -124,7 +136,9 @@ class Redis
     HashifyStreamAutoclaim = lambda { |reply|
       {
         'next' => reply[0],
-        'entries' => reply[1].map { |entry| [entry[0], entry[1].each_slice(2).to_h] }
+        'entries' => reply[1].compact.map do |entry, values|
+          [entry, values.each_slice(2)&.to_h]
+        end
       }
     }
 
@@ -202,8 +216,8 @@ class Redis
     # hash, are up to consumers.
     #
     # Redis error replies are raised as Ruby exceptions.
-    def call(*command)
-      send_command(command)
+    def call(*command, &block)
+      send_command(command, &block)
     end
 
     # Interact with the sentinel command (masters, master, slaves, failover)
@@ -218,14 +232,19 @@ class Redis
         when "get-master-addr-by-name"
           reply
         else
-          if reply.is_a?(Array)
-            if reply[0].is_a?(Array)
-              reply.map(&Hashify)
+          case reply
+          when Array
+            if reply.empty?
+              reply # empty list (e.g. sentinels/slaves with no entries) stays []; don't Hashify to {}
             else
-              Hashify.call(reply)
+              case reply[0]
+              when Array then reply.map(&Hashify) # RESP2: list of flat [k, v, ...] arrays
+              when Hash then reply                 # RESP3: list of maps (already hashes)
+              else Hashify.call(reply)             # RESP2: a single flat [k, v, ...] array
+              end
             end
           else
-            reply
+            reply # RESP3 single map, or a scalar reply
           end
         end
       end