redis 3.3.3 → 5.0.5

data/lib/redis/commands/streams.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Streams
+      # Returns the stream information each subcommand.
+      #
+      # @example stream
+      #   redis.xinfo(:stream, 'mystream')
+      # @example groups
+      #   redis.xinfo(:groups, 'mystream')
+      # @example consumers
+      #   redis.xinfo(:consumers, 'mystream', 'mygroup')
+      #
+      # @param subcommand [String] e.g. `stream` `groups` `consumers`
+      # @param key        [String] the stream key
+      # @param group      [String] the consumer group name, required if subcommand is `consumers`
+      #
+      # @return [Hash]        information of the stream if subcommand is `stream`
+      # @return [Array<Hash>] information of the consumer groups if subcommand is `groups`
+      # @return [Array<Hash>] information of the consumers if subcommand is `consumers`
+      def xinfo(subcommand, key, group = nil)
+        args = [:xinfo, subcommand, key, group].compact
+        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.
+      #
+      # @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)
+      #
+      # @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
+      #
+      # @return [String] the entry id
+      def xadd(key, entry, approximate: nil, maxlen: nil, id: '*')
+        args = [:xadd, key]
+        if maxlen
+          args << "MAXLEN"
+          args << "~" if approximate
+          args << maxlen
+        end
+        args << id
+        args.concat(entry.flatten)
+        send_command(args)
+      end
+
+      # Trims older entries of the stream if needed.
+      #
+      # @example Without options
+      #   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
+      #
+      # @return [Integer] the number of entries actually deleted
+      def xtrim(key, maxlen, approximate: false)
+        args = [:xtrim, key, 'MAXLEN', (approximate ? '~' : nil), maxlen].compact
+        send_command(args)
+      end
+
+      # Delete entries by entry ids.
+      #
+      # @example With splatted entry ids
+      #   redis.xdel('mystream', '0-1', '0-2')
+      # @example With arrayed entry ids
+      #   redis.xdel('mystream', ['0-1', '0-2'])
+      #
+      # @param key [String]        the stream key
+      # @param ids [Array<String>] one or multiple entry ids
+      #
+      # @return [Integer] the number of entries actually deleted
+      def xdel(key, *ids)
+        args = [:xdel, key].concat(ids.flatten)
+        send_command(args)
+      end
+
+      # Fetches entries of the stream in ascending order.
+      #
+      # @example Without options
+      #   redis.xrange('mystream')
+      # @example With a specific start
+      #   redis.xrange('mystream', '0-1')
+      # @example With a specific start and end
+      #   redis.xrange('mystream', '0-1', '0-3')
+      # @example With count options
+      #   redis.xrange('mystream', count: 10)
+      #
+      # @param key [String]  the stream key
+      # @param start [String]  first entry id of range, default value is `-`
+      # @param end [String]  last entry id of range, default value is `+`
+      # @param count [Integer] the number of entries as limit
+      #
+      # @return [Array<Array<String, Hash>>] the ids and entries pairs
+      def xrange(key, start = '-', range_end = '+', count: nil)
+        args = [:xrange, key, start, range_end]
+        args.concat(['COUNT', count]) if count
+        send_command(args, &HashifyStreamEntries)
+      end
+
+      # Fetches entries of the stream in descending order.
+      #
+      # @example Without options
+      #   redis.xrevrange('mystream')
+      # @example With a specific end
+      #   redis.xrevrange('mystream', '0-3')
+      # @example With a specific end and start
+      #   redis.xrevrange('mystream', '0-3', '0-1')
+      # @example With count options
+      #   redis.xrevrange('mystream', count: 10)
+      #
+      # @param key [String]  the stream key
+      # @param end [String]  first entry id of range, default value is `+`
+      # @param start [String]  last entry id of range, default value is `-`
+      # @params count [Integer] the number of entries as limit
+      #
+      # @return [Array<Array<String, Hash>>] the ids and entries pairs
+      def xrevrange(key, range_end = '+', start = '-', count: nil)
+        args = [:xrevrange, key, range_end, start]
+        args.concat(['COUNT', count]) if count
+        send_command(args, &HashifyStreamEntries)
+      end
+
+      # Returns the number of entries inside a stream.
+      #
+      # @example With key
+      #   redis.xlen('mystream')
+      #
+      # @param key [String] the stream key
+      #
+      # @return [Integer] the number of entries
+      def xlen(key)
+        send_command([:xlen, key])
+      end
+
+      # Fetches entries from one or multiple streams. Optionally blocking.
+      #
+      # @example With a key
+      #   redis.xread('mystream', '0-0')
+      # @example With multiple keys
+      #   redis.xread(%w[mystream1 mystream2], %w[0-0 0-0])
+      # @example With count option
+      #   redis.xread('mystream', '0-0', count: 2)
+      # @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
+      #
+      # @return [Hash{String => Hash{String => Hash}}] the entries
+      def xread(keys, ids, count: nil, block: nil)
+        args = [:xread]
+        args << 'COUNT' << count if count
+        args << 'BLOCK' << block.to_i if block
+        _xread(args, keys, ids, block)
+      end
+
+      # Manages the consumer group of the stream.
+      #
+      # @example With `create` subcommand
+      #   redis.xgroup(:create, 'mystream', 'mygroup', '$')
+      # @example With `setid` subcommand
+      #   redis.xgroup(:setid, 'mystream', 'mygroup', '$')
+      # @example With `destroy` subcommand
+      #   redis.xgroup(:destroy, 'mystream', 'mygroup')
+      # @example With `delconsumer` subcommand
+      #   redis.xgroup(:delconsumer, 'mystream', 'mygroup', 'consumer1')
+      #
+      # @param subcommand     [String] `create` `setid` `destroy` `delconsumer`
+      # @param key            [String] the stream key
+      # @param group          [String] the consumer group name
+      # @param id_or_consumer [String]
+      #   * the entry id or `$`, required if subcommand is `create` or `setid`
+      #   * the consumer name, required if subcommand is `delconsumer`
+      # @param mkstream [Boolean] whether to create an empty stream automatically or not
+      #
+      # @return [String] `OK` if subcommand is `create` or `setid`
+      # @return [Integer] effected count if subcommand is `destroy` or `delconsumer`
+      def xgroup(subcommand, key, group, id_or_consumer = nil, mkstream: false)
+        args = [:xgroup, subcommand, key, group, id_or_consumer, (mkstream ? 'MKSTREAM' : nil)].compact
+        send_command(args)
+      end
+
+      # Fetches a subset of the entries from one or multiple streams related with the consumer group.
+      # Optionally blocking.
+      #
+      # @example With a key
+      #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>')
+      # @example With multiple keys
+      #   redis.xreadgroup('mygroup', 'consumer1', %w[mystream1 mystream2], %w[> >])
+      # @example With count option
+      #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>', count: 2)
+      # @example With block option
+      #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>', block: 1000)
+      # @example With noack option
+      #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>', noack: true)
+      #
+      # @param group    [String]        the consumer group name
+      # @param consumer [String]        the consumer name
+      # @param keys     [Array<String>] one or multiple stream keys
+      # @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] :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)
+        args = [:xreadgroup, 'GROUP', group, consumer]
+        args << 'COUNT' << count if count
+        args << 'BLOCK' << block.to_i if block
+        args << 'NOACK' if noack
+        _xread(args, keys, ids, block)
+      end
+
+      # Removes one or multiple entries from the pending entries list of a stream consumer group.
+      #
+      # @example With a entry id
+      #   redis.xack('mystream', 'mygroup', '1526569495631-0')
+      # @example With splatted entry ids
+      #   redis.xack('mystream', 'mygroup', '0-1', '0-2')
+      # @example With arrayed entry ids
+      #   redis.xack('mystream', 'mygroup', %w[0-1 0-2])
+      #
+      # @param key   [String]        the stream key
+      # @param group [String]        the consumer group name
+      # @param ids   [Array<String>] one or multiple entry ids
+      #
+      # @return [Integer] the number of entries successfully acknowledged
+      def xack(key, group, *ids)
+        args = [:xack, key, group].concat(ids.flatten)
+        send_command(args)
+      end
+
+      # Changes the ownership of a pending entry
+      #
+      # @example With splatted entry ids
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-1', '0-2')
+      # @example With arrayed entry ids
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2])
+      # @example With idle option
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], idle: 1000)
+      # @example With time option
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], time: 1542866959000)
+      # @example With retrycount option
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], retrycount: 10)
+      # @example With force option
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], force: true)
+      # @example With justid option
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], justid: true)
+      #
+      # @param key           [String]        the stream key
+      # @param group         [String]        the consumer group name
+      # @param consumer      [String]        the consumer name
+      # @param min_idle_time [Integer]       the number of milliseconds
+      # @param ids           [Array<String>] one or multiple entry ids
+      # @param opts          [Hash]          several options for `XCLAIM` command
+      #
+      # @option opts [Integer] :idle       the number of milliseconds as last time it was delivered of the entry
+      # @option opts [Integer] :time       the number of milliseconds as a specific Unix Epoch time
+      # @option opts [Integer] :retrycount the number of retry counter
+      # @option opts [Boolean] :force      whether to create the pending entry to the pending entries list or not
+      # @option opts [Boolean] :justid     whether to fetch just an array of entry ids or not
+      #
+      # @return [Hash{String => Hash}] the entries successfully claimed
+      # @return [Array<String>]        the entry ids successfully claimed if justid option is `true`
+      def xclaim(key, group, consumer, min_idle_time, *ids, **opts)
+        args = [:xclaim, key, group, consumer, min_idle_time].concat(ids.flatten)
+        args.concat(['IDLE',       opts[:idle].to_i])  if opts[:idle]
+        args.concat(['TIME',       opts[:time].to_i])  if opts[:time]
+        args.concat(['RETRYCOUNT', opts[:retrycount]]) if opts[:retrycount]
+        args << 'FORCE'                                if opts[:force]
+        args << 'JUSTID'                               if opts[:justid]
+        blk = opts[:justid] ? Noop : HashifyStreamEntries
+        send_command(args, &blk)
+      end
+
+      # Transfers ownership of pending stream entries that match the specified criteria.
+      #
+      # @example Claim next pending message stuck > 5 minutes  and mark as retry
+      #   redis.xautoclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0')
+      # @example Claim 50 next pending messages stuck > 5 minutes  and mark as retry
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0', count: 50)
+      # @example Claim next pending message stuck > 5 minutes and don't mark as retry
+      #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0', justid: true)
+      # @example Claim next pending message after this id stuck > 5 minutes  and mark as retry
+      #   redis.xautoclaim('mystream', 'mygroup', 'consumer1', 3600000, '1641321233-0')
+      #
+      # @param key           [String]        the stream key
+      # @param group         [String]        the consumer group name
+      # @param consumer      [String]        the consumer name
+      # @param min_idle_time [Integer]       the number of milliseconds
+      # @param start         [String]        entry id to start scanning from or 0-0 for everything
+      # @param count         [Integer]       number of messages to claim (default 1)
+      # @param justid        [Boolean]       whether to fetch just an array of entry ids or not.
+      #                                      Does not increment retry count when true
+      #
+      # @return [Hash{String => Hash}] the entries successfully claimed
+      # @return [Array<String>]        the entry ids successfully claimed if justid option is `true`
+      def xautoclaim(key, group, consumer, min_idle_time, start, count: nil, justid: false)
+        args = [:xautoclaim, key, group, consumer, min_idle_time, start]
+        if count
+          args << 'COUNT' << count.to_s
+        end
+        args << 'JUSTID' if justid
+        blk = justid ? HashifyStreamAutoclaimJustId : HashifyStreamAutoclaim
+        send_command(args, &blk)
+      end
+
+      # Fetches not acknowledging pending entries
+      #
+      # @example With key and group
+      #   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')
+      #
+      # @param key      [String]  the stream key
+      # @param group    [String]  the consumer group name
+      # @param start    [String]  start first entry id of range
+      # @param end      [String]  end   last entry id of range
+      # @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, 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)
+        else
+          raise ArgumentError, "wrong number of arguments (given #{args.size + 2}, expected 2, 5 or 6)"
+        end
+
+        summary_needed = args.empty?
+        blk = summary_needed ? HashifyStreamPendings : HashifyStreamPendingDetails
+        send_command(command_args, &blk)
+      end
+
+      private
+
+      def _xread(args, keys, ids, blocking_timeout_msec)
+        keys = keys.is_a?(Array) ? keys : [keys]
+        ids = ids.is_a?(Array) ? ids : [ids]
+        args << 'STREAMS'
+        args.concat(keys)
+        args.concat(ids)
+
+        if blocking_timeout_msec.nil?
+          send_command(args, &HashifyStreams)
+        elsif blocking_timeout_msec.to_f.zero?
+          send_blocking_command(args, 0, &HashifyStreams)
+        else
+          send_blocking_command(args, blocking_timeout_msec.to_f / 1_000, &HashifyStreams)
+        end
+      end
+    end
+  end
+end

data/lib/redis/commands/strings.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Strings
+      # Decrement the integer value of a key by one.
+      #
+      # @example
+      #   redis.decr("value")
+      #     # => 4
+      #
+      # @param [String] key
+      # @return [Integer] value after decrementing it
+      def decr(key)
+        send_command([:decr, key])
+      end
+
+      # Decrement the integer value of a key by the given number.
+      #
+      # @example
+      #   redis.decrby("value", 5)
+      #     # => 0
+      #
+      # @param [String] key
+      # @param [Integer] decrement
+      # @return [Integer] value after decrementing it
+      def decrby(key, decrement)
+        send_command([:decrby, key, Integer(decrement)])
+      end
+
+      # Increment the integer value of a key by one.
+      #
+      # @example
+      #   redis.incr("value")
+      #     # => 6
+      #
+      # @param [String] key
+      # @return [Integer] value after incrementing it
+      def incr(key)
+        send_command([:incr, key])
+      end
+
+      # Increment the integer value of a key by the given integer number.
+      #
+      # @example
+      #   redis.incrby("value", 5)
+      #     # => 10
+      #
+      # @param [String] key
+      # @param [Integer] increment
+      # @return [Integer] value after incrementing it
+      def incrby(key, increment)
+        send_command([:incrby, key, Integer(increment)])
+      end
+
+      # Increment the numeric value of a key by the given float number.
+      #
+      # @example
+      #   redis.incrbyfloat("value", 1.23)
+      #     # => 1.23
+      #
+      # @param [String] key
+      # @param [Float] increment
+      # @return [Float] value after incrementing it
+      def incrbyfloat(key, increment)
+        send_command([:incrbyfloat, key, Float(increment)], &Floatify)
+      end
+
+      # Set the string value of a key.
+      #
+      # @param [String] key
+      # @param [String] value
+      # @param [Hash] options
+      #   - `:ex => Integer`: Set the specified expire time, in seconds.
+      #   - `:px => Integer`: Set the specified expire time, in milliseconds.
+      #   - `:exat => Integer` : Set the specified Unix time at which the key will expire, in seconds.
+      #   - `:pxat => Integer` : Set the specified Unix time at which the key will expire, in milliseconds.
+      #   - `:nx => true`: Only set the key if it does not already exist.
+      #   - `:xx => true`: Only set the key if it already exist.
+      #   - `:keepttl => true`: Retain the time to live associated with the key.
+      #   - `:get => true`: Return the old string stored at key, or nil if key did not exist.
+      # @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" << 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
+        args << "GET" if get
+
+        if nx || xx
+          send_command(args, &BoolifySet)
+        else
+          send_command(args)
+        end
+      end
+
+      # Set the time to live in seconds of a key.
+      #
+      # @param [String] key
+      # @param [Integer] ttl
+      # @param [String] value
+      # @return [String] `"OK"`
+      def setex(key, ttl, value)
+        send_command([:setex, key, Integer(ttl), value.to_s])
+      end
+
+      # Set the time to live in milliseconds of a key.
+      #
+      # @param [String] key
+      # @param [Integer] ttl
+      # @param [String] value
+      # @return [String] `"OK"`
+      def psetex(key, ttl, value)
+        send_command([:psetex, key, Integer(ttl), value.to_s])
+      end
+
+      # Set the value of a key, only if the key does not exist.
+      #
+      # @param [String] key
+      # @param [String] value
+      # @return [Boolean] whether the key was set or not
+      def setnx(key, value)
+        send_command([:setnx, key, value.to_s], &Boolify)
+      end
+
+      # Set one or more values.
+      #
+      # @example
+      #   redis.mset("key1", "v1", "key2", "v2")
+      #     # => "OK"
+      #
+      # @param [Array<String>] args array of keys and values
+      # @return [String] `"OK"`
+      #
+      # @see #mapped_mset
+      def mset(*args)
+        send_command([:mset] + args)
+      end
+
+      # Set one or more values.
+      #
+      # @example
+      #   redis.mapped_mset({ "f1" => "v1", "f2" => "v2" })
+      #     # => "OK"
+      #
+      # @param [Hash] hash keys mapping to values
+      # @return [String] `"OK"`
+      #
+      # @see #mset
+      def mapped_mset(hash)
+        mset(hash.flatten)
+      end
+
+      # Set one or more values, only if none of the keys exist.
+      #
+      # @example
+      #   redis.msetnx("key1", "v1", "key2", "v2")
+      #     # => true
+      #
+      # @param [Array<String>] args array of keys and values
+      # @return [Boolean] whether or not all values were set
+      #
+      # @see #mapped_msetnx
+      def msetnx(*args)
+        send_command([:msetnx, *args], &Boolify)
+      end
+
+      # Set one or more values, only if none of the keys exist.
+      #
+      # @example
+      #   redis.mapped_msetnx({ "key1" => "v1", "key2" => "v2" })
+      #     # => true
+      #
+      # @param [Hash] hash keys mapping to values
+      # @return [Boolean] whether or not all values were set
+      #
+      # @see #msetnx
+      def mapped_msetnx(hash)
+        msetnx(hash.flatten)
+      end
+
+      # Get the value of a key.
+      #
+      # @param [String] key
+      # @return [String]
+      def get(key)
+        send_command([:get, key])
+      end
+
+      # Get the values of all the given keys.
+      #
+      # @example
+      #   redis.mget("key1", "key2")
+      #     # => ["v1", "v2"]
+      #
+      # @param [Array<String>] keys
+      # @return [Array<String>] an array of values for the specified keys
+      #
+      # @see #mapped_mget
+      def mget(*keys, &blk)
+        keys.flatten!(1)
+        send_command([:mget, *keys], &blk)
+      end
+
+      # Get the values of all the given keys.
+      #
+      # @example
+      #   redis.mapped_mget("key1", "key2")
+      #     # => { "key1" => "v1", "key2" => "v2" }
+      #
+      # @param [Array<String>] keys array of keys
+      # @return [Hash] a hash mapping the specified keys to their values
+      #
+      # @see #mget
+      def mapped_mget(*keys)
+        mget(*keys) do |reply|
+          if reply.is_a?(Array)
+            Hash[keys.zip(reply)]
+          else
+            reply
+          end
+        end
+      end
+
+      # Overwrite part of a string at key starting at the specified offset.
+      #
+      # @param [String] key
+      # @param [Integer] offset byte offset
+      # @param [String] value
+      # @return [Integer] length of the string after it was modified
+      def setrange(key, offset, value)
+        send_command([:setrange, key, Integer(offset), value.to_s])
+      end
+
+      # Get a substring of the string stored at a key.
+      #
+      # @param [String] key
+      # @param [Integer] start zero-based start offset
+      # @param [Integer] stop zero-based end offset. Use -1 for representing
+      #   the end of the string
+      # @return [Integer] `0` or `1`
+      def getrange(key, start, stop)
+        send_command([:getrange, key, Integer(start), Integer(stop)])
+      end
+
+      # Append a value to a key.
+      #
+      # @param [String] key
+      # @param [String] value value to append
+      # @return [Integer] length of the string after appending
+      def append(key, value)
+        send_command([:append, key, value])
+      end
+
+      # Set the string value of a key and return its old value.
+      #
+      # @param [String] key
+      # @param [String] value value to replace the current value with
+      # @return [String] the old value stored in the key, or `nil` if the key
+      #   did not exist
+      def getset(key, value)
+        send_command([:getset, key, value.to_s])
+      end
+
+      # Get the value of key and delete the key. This command is similar to GET,
+      # except for the fact that it also deletes the key on success.
+      #
+      # @param [String] key
+      # @return [String] the old value stored in the key, or `nil` if the key
+      #   did not exist
+      def getdel(key)
+        send_command([:getdel, key])
+      end
+
+      # Get the value of key and optionally set its expiration. GETEX is similar to
+      # GET, but is a write command with additional options. When no options are
+      # provided, GETEX behaves like GET.
+      #
+      # @param [String] key
+      # @param [Hash] options
+      #   - `:ex => Integer`: Set the specified expire time, in seconds.
+      #   - `:px => Integer`: Set the specified expire time, in milliseconds.
+      #   - `:exat => true`: Set the specified Unix time at which the key will
+      #      expire, in seconds.
+      #   - `:pxat => true`: Set the specified Unix time at which the key will
+      #      expire, in milliseconds.
+      #   - `:persist => true`: Remove the time to live associated with the key.
+      # @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" << 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)
+      end
+
+      # Get the length of the value stored in a key.
+      #
+      # @param [String] key
+      # @return [Integer] the length of the value stored in the key, or 0
+      #   if the key does not exist
+      def strlen(key)
+        send_command([:strlen, key])
+      end
+    end
+  end
+end