redis 5.4.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d76a0d8a8a0361f991dc110219ffc77c12503148f9ece9586dd274321283265
-  data.tar.gz: fab1b1d4d3a5e22d2d952c98648a1412239f117a2c53bcbdf20ea7c43f456faa
+  metadata.gz: 10e2b37efa4ce556e0a412006412a027693dc20e5f45df8759d2571dec5008ab
+  data.tar.gz: 074126dd5ed435ac137b0b946129db11ef16020afd8a65dcbe94b181beaf9198
 SHA512:
-  metadata.gz: 042f0aa785647bb0e6f73ff50722ba5dcf440e3f5e817c7eec030b876b7d34ca8be42a7a5a5a1767eba66b7424a8d2e74fe8e7b9e0362eedefe4fb58878cdb57
-  data.tar.gz: 5bc22d99f3a77929f35c02072be18d663ca127c77055afadd55455d3f571f61bbd70853d6fd4414e0e11f601c20d68872e8f097fce109341e5bda39f6aadb9fe
+  metadata.gz: d5cc54f6d9f95a0d77c2f824569dc9d09506eabf593c9b9d18483bae897258daf1a1fa8e069b79388ac0f8948d288cfe4af3fcea9d3760a3074bc0c4b55cb2fb
+  data.tar.gz: a8137ff6826639d927179a78d0017604aa34f592bd9710a777a58db0618a8061eb71aa4ee402fae928b26dc6e43a19c4248181604db17b1a584760a806fedadf

data/CHANGELOG.md

@@ -1,4 +1,55 @@
-# Unreleased
+# 6.0.0
+
+## Breaking changes
+
+- Use RESP3 (`HELLO 3`) by default; pass `protocol: 2` to keep RESP2. `GEOPOS` and
+  `GEOSEARCH`/`GEORADIUS` with `WITHCOORD` now return coordinates as `Float` instead of `String`.
+  See [specs/migration-resp3.md](specs/migration-resp3.md). (#1351)
+- Require Ruby 3.2+. (#1353, #1365)
+
+## New features
+
+- Add support for the Redis Query Engine (RediSearch, `FT.*`): `ft_create`, `ft_alter`,
+  `ft_dropindex`, `ft_info`, `ft_search`, `ft_aggregate`, vector and hybrid search, suggestions,
+  dictionaries, synonyms, aliases, and spellcheck. Not supported by `Redis::Distributed`.
+  (#1356, #1359, #1360, #1361)
+- Add support for the JSON module: `json_set`, `json_get`, `json_mset`, `json_mget`, `json_del`,
+  `json_forget`, `json_clear`, `json_merge`, `json_arr*`, `json_obj*`, `json_str*`,
+  `json_numincrby`, `json_toggle`, `json_type`, `json_debug_memory`. (#1346, #1347, #1348, #1349)
+- Add `lmovem` and `blmovem` (Redis 8.10). (#1363)
+- Add `sunioncard` and `sdiffcard` (Redis 8.10). (#1357)
+- `xread` and `xreadgroup` now accept `max_count:` and `max_size:` (Redis 8.10). (#1358)
+- Add `hexpire`, `hpexpire`, `httl` and `hpttl` (Redis 7.4). (#1324, #1325, #1331)
+- `hscan` and `hscan_each` now accept `novalues: true` (Redis 7.4). (#1327)
+- Add `geosearch` and `geosearchstore` (Redis 6.2); geo commands are now available on
+  `Redis::Distributed`. (#1342)
+- `geoadd` now accepts `nx:`, `xx:` and `ch:`; geo radius searches accept `count_any:`; `xadd`
+  accepts `limit:` (Redis 6.2). (#1345)
+- `Redis::Distributed` now implements `hscan`, `hscan_each` and `hstrlen`. (#1319)
+- Identify the client to the server via `CLIENT SETINFO` (`lib-name=redis-rb`,
+  `lib-ver=<version>`). Extend the reported name with `driver_info:`, or disable with
+  `driver_info: false`. See the README "Client identification" section. (#1369)
+
+## Experimental
+
+- Add `himport_prepare`, `himport_set`, `himport_discard` and `himport_discard_all`
+  (Redis 8.10 `HIMPORT`). Lost fieldsets are re-prepared and retried automatically; disable with
+  `himport_auto_prepare: false`. The API may change in a future minor release. See the README
+  "Bulk hash ingestion (HIMPORT)" section. (#1364)
+
+## Bug fixes
+
+- Fix `FloatifyPairs` to not re-transform already transformed replies. (#1354)
+- `unlink` now returns `0` for an empty keyset, consistent with `del`. (#1316)
+
+## Maintenance
+
+- Pin `redis-client` to the exact version `0.30.1` (previously `>= 0.22.0`); includes the
+  reply-desynchronization fix from 0.26.4. (#1350, #1352)
+- Maintainership change: `redis-rb` is now maintained by the Redis Ltd company.
+- Run the test suite against prebuilt `redislabs/client-libs-test` Docker images; CI now covers
+  MRI 3.2/3.3/3.4/4.0 and TruffleRuby against Redis 7.2–8.10; JRuby removed. (#1317, #1318, #1344)
+- Drop the unused `executables` config from the gemspec. (#1322)
 
 # 5.4.1
 

data/README.md

@@ -71,6 +71,97 @@ redis.get("mykey")
 All commands, their arguments, and return values are documented and
 available on [RubyDoc.info][rubydoc].
 
+## Language and server support
+
+redis-rb targets actively supported runtimes on both the language and the server side:
+
+- **Ruby:** Ruby 3.2 and newer. See the [Ruby maintenance branches][ruby-branches] page for
+  each version's status and dates.
+- **Redis server:** the versions designated for support by Redis. See 
+[Supported Redis database versions][redis-versions].
+
+## Protocol (RESP3)
+
+Starting in 6.0, the client negotiates the [RESP3 protocol][resp3] (`HELLO 3`)
+by default. Command return values are unchanged from 5.x, with one exception:
+`GEOPOS` and `GEOSEARCH`/`GEORADIUS` with `WITHCOORD` now return coordinates as
+`Float` instead of `String`.
+
+To keep the previous RESP2 behavior, pass `protocol: 2`:
+
+```ruby
+redis = Redis.new(protocol: 2)
+```
+
+Servers without RESP3 support (Redis < 6.0, or anything replying `NOPROTO`) are
+detected on connect and the client transparently falls back to RESP2, so no
+configuration is needed for older servers.
+
+### Why RESP3 is the default
+
+RESP3's richer wire types let the parser deliver replies already in their final
+Ruby shape. Under RESP2, structured replies arrive as flat arrays of bulk
+strings and the client re-shapes them in Ruby: `HGETALL` turns a flat
+`[field, value, field, value, ...]` array into a `Hash`, and sorted-set scores
+are converted from `String` to `Float` pair by pair. Under RESP3 the server
+tags these replies as native maps and doubles, so the final `Hash` and `Float`
+values come straight out of the parser and the Ruby-side re-shaping pass
+disappears entirely.
+
+How much that saves depends on where parsing happens. In our benchmarks
+([bench/resp_comparison.rb](bench/resp_comparison.rb), Ruby 3.4, 100-element
+replies), hash reads (`HGETALL`) consistently use ~10–25% less client CPU per
+call on both drivers. With the [hiredis driver](#hiredis-binding), where
+parsing runs in C, sorted-set reads with scores gain up to 16% throughput and
+~20% less CPU per call on top of that; with the pure-Ruby driver they are
+unchanged, since the parser then spends in Ruby roughly what the re-shaping
+pass used to cost. Simple string commands and stream commands are unaffected
+either way — their reply shapes are the same in both protocols. In short:
+RESP3 is never slower where it matters, and it pairs best with hiredis — that
+combination moves all reply construction out of Ruby and into C.
+
+Beyond performance, RESP3 unlocks protocol capabilities RESP2 simply doesn't
+have. The most important is out-of-band **push messages**: the server can send
+notifications on a connection without the client asking, which is the
+foundation for server-assisted client-side caching (`CLIENT TRACKING`
+invalidation events), pub/sub messages delivered over the regular command
+connection instead of a dedicated one, and other server-initiated
+notifications. Defaulting to RESP3 in 6.0 lays the groundwork for building
+these features in future releases without another protocol migration.
+
+See [the RESP3 migration guide](specs/migration-resp3.md) for full details.
+
+## Client identification
+
+On connect the client identifies itself to the server with `CLIENT SETINFO`, so
+`redis-rb` and its version are visible in `CLIENT LIST` and `CLIENT INFO`:
+
+```
+lib-name=redis-rb lib-ver=<Redis::VERSION>
+```
+
+Libraries built on top of `redis-rb` can add their own identity with
+`driver_info:`, which is reported alongside it. The recommended suffix format
+is `<name>_v<version>`, following the convention used by the official client
+libraries:
+
+```ruby
+Redis.new(driver_info: "my-gem_v#{MyGem::VERSION}")
+# reported as: lib-name=redis-rb(my-gem_v1.0.0) lib-ver=<Redis::VERSION>
+```
+
+`driver_info:` also accepts an array, joined with `;` (the conventional
+delimiter for multiple suffixes). It extends the reported name rather than
+replacing it, so `redis-rb` stays identifiable either way. Runs of characters
+the server would reject (spaces, non-printable bytes) and of the parentheses
+that delimit the suffix are each replaced with a single `_`, or dropped at the
+edges of the value.
+
+Servers older than 7.2 don't support `CLIENT SETINFO`; they reject it, the error
+is ignored, and the connection is used as normal. If a proxy or server can't
+tolerate the command at all, pass `driver_info: false` to disable client
+identification entirely.
+
 ## Connection Pooling and Thread safety
 
 The client does not provide connection pooling. Each `Redis` instance
@@ -94,7 +185,7 @@ MyApp.redis.incr("some-counter")
 ## Sentinel support
 
 The client is able to perform automatic failover by using [Redis
-Sentinel](http://redis.io/topics/sentinel).  Make sure to run Redis 2.8+
+Sentinel](http://redis.io/topics/sentinel). Make sure to run Redis 2.8+
 if you want to use this feature.
 
 To connect using Sentinel, use:
@@ -114,13 +205,13 @@ and `slave`. When the role is `slave`, the client will try to connect to a
 random slave of the specified master. If a role is not specified, the client
 will connect to the master.
 
-* When using the Sentinel support you need to specify a list of sentinels to
+* When using Sentinel support, you need to specify a list of sentinels to
 connect to. The list does not need to enumerate all your Sentinel instances,
 but a few so that if one is down the client will try the next one. The client
 is able to remember the last Sentinel that was able to reply correctly and will
-use it for the next requests.
+use it for the next request.
 
-To [authenticate](https://redis.io/docs/management/sentinel/#configuring-sentinel-instances-with-authentication) Sentinel itself, you can specify the `sentinel_username` and `sentinel_password`. Exclude the `sentinel_username` option if you're using password-only authentication.
+To [authenticate](https://redis.io/docs/management/sentinel/#configuring-sentinel-instances-with-authentication) with Sentinel itself, you can specify the `sentinel_username` and `sentinel_password`. Exclude the `sentinel_username` option if you're using password-only authentication.
 
 ```ruby
 SENTINELS = [{ host: '127.0.0.1', port: 26380},
@@ -129,7 +220,7 @@ SENTINELS = [{ host: '127.0.0.1', port: 26380},
 redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, sentinel_username: 'appuser', sentinel_password: 'mysecret', role: :master)
 ```
 
-If you specify a username and/or password at the top level for your main Redis instance, Sentinel *will not* using thouse credentials
+If you specify a username and/or password at the top level for your main Redis instance, Sentinel *will not* use those credentials.
 
 ```ruby
 # Use 'mysecret' to authenticate against the mymaster instance, but skip authentication for the sentinels:
@@ -139,7 +230,7 @@ SENTINELS = [{ host: '127.0.0.1', port: 26380 },
 redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret')
 ```
 
-So you have to provide Sentinel credential and Redis explicitly even they are the same
+So you have to provide Sentinel credentials and Redis explicitly even if they are the same.
 
 ```ruby
 # Use 'mysecret' to authenticate against the mymaster instance and sentinel
@@ -149,7 +240,7 @@ SENTINELS = [{ host: '127.0.0.1', port: 26380 },
 redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret', sentinel_password: 'mysecret')
 ```
 
-Also the `name`, `password`, `username` and `db` for Redis instance can be passed as an url:
+Also, the `name`, `password`, `username`, and `db` for the Redis instance can be passed as a URL:
 
 ```ruby
 redis = Redis.new(url: "redis://appuser:mysecret@mymaster/10", sentinels: SENTINELS, role: :master)
@@ -251,6 +342,70 @@ incr.value
 # => 1
 ```
 
+## Bulk hash ingestion (HIMPORT)
+
+> **Experimental:** HIMPORT support is experimental. The client API (method
+> signatures, reply aggregation on cluster, and the automatic re-prepare
+> behavior) may change in a future minor release without a major version bump.
+
+Redis 8.10 adds the `HIMPORT` command family for loading many hashes that share
+the same set of field names: register the field names once with
+`himport_prepare`, then create each hash by sending only its values. Keys
+written this way are regular hashes — every hash command works on them.
+
+```ruby
+redis.himport_prepare("users", ["name", "email", "age"])
+redis.himport_set("user:1", "users", ["alice", "alice@example.com", "25"])
+redis.himport_set("user:2", "users", ["bob", "bob@example.com", "30"])
+redis.himport_discard("users") # => 1
+```
+
+Values pair positionally with the prepared fields. Note that hash enumeration
+order (`HGETALL`, `HKEYS`) is not guaranteed to match the prepare order.
+
+### Fieldsets are connection state
+
+A prepared fieldset lives in the server-side session of the physical connection
+that prepared it: it is invisible to other connections and destroyed by a
+disconnect or `RESET`. A `himport_set` on a connection without the fieldset
+fails with `ERR no such fieldset`.
+
+Because a `Redis` instance transparently replaces a dead connection (see
+[Reconnections](#reconnections)), the client keeps the last schema prepared for
+each fieldset name and, when a `himport_set` reports the fieldset is gone,
+re-prepares it and retries the command once. Explicitly discarded fieldsets are
+never restored. To keep the fieldset lifecycle fully explicit instead, disable
+the recovery:
+
+```ruby
+redis = Redis.new(himport_auto_prepare: false)
+```
+
+For the highest ingestion throughput, send the `PREPARE` and its `SET`s as one
+pipeline — a single batch always executes on a single connection:
+
+```ruby
+redis.pipelined do |pipeline|
+  pipeline.himport_prepare("users", ["name", "email", "age"])
+  rows.each { |id, row| pipeline.himport_set("user:#{id}", "users", row) }
+end
+```
+
+If the `PREPARE` in a batch fails, every `SET` in it fails with
+`no such fieldset` — the `PREPARE` error is the root cause. Note that the
+automatic re-prepare applies to direct calls only, not to commands inside
+`pipelined`/`multi` blocks.
+
+When using the `connection_pool` gem, each checkout may hand you a different
+underlying connection: run `himport_prepare` and its `himport_set` calls within
+one checkout (`pool.with { |redis| ... }`), ideally as one pipelined block.
+
+With `Redis::Distributed`, `himport_prepare`, `himport_discard` and
+`himport_discard_all` fan out to every ring node and return an array with one
+reply per node; `himport_set` routes by key. With `Redis::Cluster`, the same
+commands fan out to every master node and return a single aggregated reply,
+matching the standalone API.
+
 ## Error Handling
 
 In general, if something goes wrong you'll get an exception. For example, if
@@ -421,11 +576,6 @@ the client object, specify hiredis:
 redis = Redis.new(driver: :hiredis)
 ```
 
-## Testing
-
-This library is tested against recent Ruby and Redis versions.
-Check [Github Actions][gh-actions-link] for the exact versions supported.
-
 ## See Also
 
 - [async-redis](https://github.com/socketry/async-redis) — An [async](https://github.com/socketry/async) compatible Redis client.
@@ -451,3 +601,6 @@ requests.
 [gh-actions-image]:  https://github.com/redis/redis-rb/workflows/Test/badge.svg
 [gh-actions-link]:   https://github.com/redis/redis-rb/actions
 [rubydoc]:           https://rubydoc.info/gems/redis
+[resp3]:             https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md
+[ruby-branches]:     https://www.ruby-lang.org/en/downloads/branches/
+[redis-versions]:    https://redis.io/docs/latest/operate/rc/databases/version-management/#supported-database-versions

data/lib/redis/client.rb

@@ -20,12 +20,15 @@ class Redis
     end
 
     class << self
-      def config(**kwargs)
-        super(protocol: 2, **kwargs)
+      def config(protocol: 3, **kwargs)
+        super(protocol: protocol, **kwargs,
+              driver_info: Redis::LibIdentity.driver_info(kwargs[:driver_info]))
       end
 
-      def sentinel(**kwargs)
-        super(protocol: 2, **kwargs, client_implementation: ::RedisClient)
+      def sentinel(protocol: 3, **kwargs)
+        super(protocol: protocol, **kwargs,
+              driver_info: Redis::LibIdentity.driver_info(kwargs[:driver_info]),
+              client_implementation: ::RedisClient)
       end
 
       def translate_error!(error, mapping: ERROR_MAPPING)
@@ -33,6 +36,24 @@ class Redis
         raise redis_error, error.message, error.backtrace
       end
 
+      # Whether +error+ raised during the connection handshake means the server can't speak RESP3
+      # (so we should retry the connection as RESP2). Covers Redis < 6 (no HELLO command, surfaced
+      # by redis-client as UnsupportedServer) and any server replying NOPROTO to `HELLO 3`.
+      def resp3_unsupported?(error)
+        return true if error.is_a?(::RedisClient::UnsupportedServer)
+        return true if error.is_a?(::RedisClient::CommandError) && error.message.include?("NOPROTO")
+
+        # Redis::Cluster discovers its topology by connecting to each startup node. When those nodes
+        # don't speak RESP3, redis-cluster-client collects the per-node failures and re-raises them
+        # wrapped in an InitialSetupError, discarding the original error classes (see
+        # RedisClient::Cluster::InitialSetupError.from_errors). Only the concatenated message
+        # survives, so match it to still trigger the RESP2 fallback for pre-6.0 clusters. Guarded by
+        # defined? because the cluster error class is only loaded with the redis-clustering gem.
+        defined?(::RedisClient::Cluster::InitialSetupError) &&
+          error.is_a?(::RedisClient::Cluster::InitialSetupError) &&
+          (error.message.include?("NOPROTO") || error.message.include?("HELLO command"))
+      end
+
       private
 
       def translate_error_class(error_class, mapping: ERROR_MAPPING)
@@ -62,6 +83,10 @@ class Redis
       config.db
     end
 
+    def protocol
+      config.protocol
+    end
+
     def host
       config.host unless config.path
     end
@@ -87,15 +112,16 @@ class Redis
     undef_method :call_once_v
     undef_method :blocking_call
 
-    def ensure_connected(retryable: true, &block)
-      super(retryable: retryable, &block)
-    rescue ::RedisClient::Error => error
-      Client.translate_error!(error)
-    end
-
+    # We default to RESP3. Servers that can't speak it reject the `HELLO 3` handshake (Redis < 6.0
+    # has no HELLO at all; others answer NOPROTO). Re-raise those errors untranslated so they reach
+    # Redis#with_protocol_fallback as RedisClient::Error and trigger a transparent rebuild as RESP2 —
+    # the same path the sentinel and cluster clients already use. Everything else is translated to
+    # the matching Redis::* error.
     def call_v(command, &block)
       super(command, &block)
     rescue ::RedisClient::Error => error
+      raise if Client.resp3_unsupported?(error)
+
       Client.translate_error!(error)
     end
 
@@ -109,18 +135,24 @@ class Redis
 
       super(timeout, command, &block)
     rescue ::RedisClient::Error => error
+      raise if Client.resp3_unsupported?(error)
+
       Client.translate_error!(error)
     end
 
     def pipelined(exception: true)
       super
     rescue ::RedisClient::Error => error
+      raise if Client.resp3_unsupported?(error)
+
       Client.translate_error!(error)
     end
 
     def multi(watch: nil)
       super
     rescue ::RedisClient::Error => error
+      raise if Client.resp3_unsupported?(error)
+
       Client.translate_error!(error)
     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)
+      def _geoarguments(*args, options: nil, sort: nil, count: nil, count_any: false)
         args << sort if sort
-        args << 'COUNT' << Integer(count) if count
-        args << options if options
+        if count
+          args << 'COUNT' << Integer(count)
+          args << 'ANY' if count_any
+        end
+        args.concat(Array(options))
         args
       end
     end