Add support for SORT_RO

docs/ReleaseNotes.md

@@ -27,6 +27,7 @@
 - Adds: Support for `ZMPOP` with `.SortedSetPop()`/`.SortedSetPopAsync()` ([#2094 by slorello89](https://github.com/StackExchange/StackExchange.Redis/pull/2094))
 - Adds: Support for `XAUTOCLAIM` with `.StreamAutoClaim()`/.`StreamAutoClaimAsync()` and `.StreamAutoClaimIdsOnly()`/.`StreamAutoClaimIdsOnlyAsync()` ([#2095 by ttingen](https://github.com/StackExchange/StackExchange.Redis/pull/2095))
 - Adds: Support for `OBJECT FREQ` with `.KeyFrequency()`/`.KeyFrequencyAsync()` ([#2105 by Avital-Fine](https://github.com/StackExchange/StackExchange.Redis/pull/2105))
+- Adds: Support for `SORT_RO` with `.Sort()`/`.SortAsync()` ([#2111 by slorello89](https://github.com/StackExchange/StackExchange.Redis/pull/2111))
 
 ## 2.5.61
 

src/StackExchange.Redis/Enums/RedisCommand.cs

@@ -166,6 +166,7 @@ internal enum RedisCommand
  SMISMEMBER,
  SMOVE,
  SORT,
+ SORT_RO,
  SPOP,
  SRANDMEMBER,
  SREM,
@@ -320,6 +321,7 @@ internal static bool IsPrimaryOnly(this RedisCommand command)
  case RedisCommand.SETRANGE:
  case RedisCommand.SINTERSTORE:
  case RedisCommand.SMOVE:
+ case RedisCommand.SORT:
  case RedisCommand.SPOP:
  case RedisCommand.SREM:
  case RedisCommand.SUNIONSTORE:
@@ -428,7 +430,7 @@ internal static bool IsPrimaryOnly(this RedisCommand command)
  case RedisCommand.SLOWLOG:
  case RedisCommand.SMEMBERS:
  case RedisCommand.SMISMEMBER:
- case RedisCommand.SORT:
+ case RedisCommand.SORT_RO:
  case RedisCommand.SRANDMEMBER:
  case RedisCommand.STRLEN:
  case RedisCommand.SUBSCRIBE:

src/StackExchange.Redis/Interfaces/IDatabase.cs

@@ -1551,6 +1551,7 @@ public interface IDatabase : IRedis, IDatabaseAsync
  /// the <c>get</c> parameter (note that <c>#</c> specifies the element itself, when used in <c>get</c>).
  /// Referring to the <a href="https://redis.io/commands/sort">redis SORT documentation </a> for examples is recommended.
  /// When used in hashes, <c>by</c> and <c>get</c> can be used to specify fields using <c>-&gt;</c> notation (again, refer to redis documentation).
+ /// Uses <a href="https://redis.io/commands/sort_ro">SORT_RO</a> when possible.
  /// </summary>
  /// <param name="key">The key of the list, set, or sorted set.</param>
  /// <param name="skip">How many entries to skip on the return.</param>
@@ -1562,6 +1563,7 @@ public interface IDatabase : IRedis, IDatabaseAsync
  /// <param name="flags">The flags to use for this operation.</param>
  /// <returns>The sorted elements, or the external values if <c>get</c> is specified.</returns>
  /// <remarks><seealso href="https://redis.io/commands/sort"/></remarks>
+ /// <remarks><seealso href="https://redis.io/commands/sort_ro"/></remarks>
  RedisValue[] Sort(RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None);
 
  /// <summary>

src/StackExchange.Redis/Interfaces/IDatabaseAsync.cs

@@ -1516,6 +1516,7 @@ public interface IDatabaseAsync : IRedisAsync
  /// the <c>get</c> parameter (note that <c>#</c> specifies the element itself, when used in <c>get</c>).
  /// Referring to the <a href="https://redis.io/commands/sort">redis SORT documentation </a> for examples is recommended.
  /// When used in hashes, <c>by</c> and <c>get</c> can be used to specify fields using <c>-&gt;</c> notation (again, refer to redis documentation).
+ /// Uses <a href="https://redis.io/commands/sort_ro">SORT_RO</a> when possible.
  /// </summary>
  /// <param name="key">The key of the list, set, or sorted set.</param>
  /// <param name="skip">How many entries to skip on the return.</param>

src/StackExchange.Redis/RedisDatabase.cs

@@ -1775,26 +1775,26 @@ private CursorEnumerable<RedisValue> SetScanAsync(RedisKey key, RedisValue patte
 
  public RedisValue[] Sort(RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None)
  {
- var msg = GetSortedSetAddMessage(default(RedisKey), key, skip, take, order, sortType, by, get, flags);
- return ExecuteSync(msg, ResultProcessor.RedisValueArray, defaultValue: Array.Empty<RedisValue>());
+ var msg = GetSortMessage(RedisKey.Null, key, skip, take, order, sortType, by, get, flags, out var server);
+ return ExecuteSync(msg, ResultProcessor.RedisValueArray, server: server, defaultValue: Array.Empty<RedisValue>());
  }
 
  public long SortAndStore(RedisKey destination, RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None)
  {
- var msg = GetSortedSetAddMessage(destination, key, skip, take, order, sortType, by, get, flags);
- return ExecuteSync(msg, ResultProcessor.Int64);
+ var msg = GetSortMessage(destination, key, skip, take, order, sortType, by, get, flags, out var server);
+ return ExecuteSync(msg, ResultProcessor.Int64, server);
  }
 
  public Task<long> SortAndStoreAsync(RedisKey destination, RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None)
  {
- var msg = GetSortedSetAddMessage(destination, key, skip, take, order, sortType, by, get, flags);
- return ExecuteAsync(msg, ResultProcessor.Int64);
+ var msg = GetSortMessage(destination, key, skip, take, order, sortType, by, get, flags, out var server);
+ return ExecuteAsync(msg, ResultProcessor.Int64, server);
  }
 
  public Task<RedisValue[]> SortAsync(RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None)
  {
- var msg = GetSortedSetAddMessage(default(RedisKey), key, skip, take, order, sortType, by, get, flags);
- return ExecuteAsync(msg, ResultProcessor.RedisValueArray, defaultValue: Array.Empty<RedisValue>());
+ var msg = GetSortMessage(RedisKey.Null, key, skip, take, order, sortType, by, get, flags, out var server);
+ return ExecuteAsync(msg, ResultProcessor.RedisValueArray, defaultValue: Array.Empty<RedisValue>(), server: server);
  }
 
  public bool SortedSetAdd(RedisKey key, RedisValue member, double score, CommandFlags flags)
@@ -3513,28 +3513,25 @@ private Message GetSortedSetAddMessage(RedisKey key, RedisValue member, double s
  }
  }
 
- private Message GetSortedSetAddMessage(RedisKey destination, RedisKey key, long skip, long take, Order order, SortType sortType, RedisValue by, RedisValue[]? get, CommandFlags flags)
+ private Message GetSortMessage(RedisKey destination, RedisKey key, long skip, long take, Order order, SortType sortType, RedisValue by, RedisValue[]? get, CommandFlags flags, out ServerEndPoint? server)
  {
+ server = null;
+ var command = destination.IsNull && GetFeatures(key, flags, out server).ReadOnlySort
+ ? RedisCommand.SORT_RO
+ : RedisCommand.SORT;
+
  // most common cases; no "get", no "by", no "destination", no "skip", no "take"
  if (destination.IsNull && skip == 0 && take == -1 && by.IsNull && (get == null || get.Length == 0))
  {
- switch (order)
+ return order switch
  {
- case Order.Ascending:
- switch (sortType)
- {
- case SortType.Numeric: return Message.Create(Database, flags, RedisCommand.SORT, key);
- case SortType.Alphabetic: return Message.Create(Database, flags, RedisCommand.SORT, key, RedisLiterals.ALPHA);
- }
- break;
- case Order.Descending:
- switch (sortType)
- {
- case SortType.Numeric: return Message.Create(Database, flags, RedisCommand.SORT, key, RedisLiterals.DESC);
- case SortType.Alphabetic: return Message.Create(Database, flags, RedisCommand.SORT, key, RedisLiterals.DESC, RedisLiterals.ALPHA);
- }
- break;
- }
+ Order.Ascending when sortType == SortType.Numeric => Message.Create(Database, flags, command, key),
+ Order.Ascending when sortType == SortType.Alphabetic => Message.Create(Database, flags, command, key, RedisLiterals.ALPHA),
+ Order.Descending when sortType == SortType.Numeric => Message.Create(Database, flags, command, key, RedisLiterals.DESC),
+ Order.Descending when sortType == SortType.Alphabetic => Message.Create(Database, flags, command, key, RedisLiterals.DESC, RedisLiterals.ALPHA),
+ Order.Ascending or Order.Descending => throw new ArgumentOutOfRangeException(nameof(sortType)),
+ _ => throw new ArgumentOutOfRangeException(nameof(order)),
+ };
  }
 
  // and now: more complicated scenarios...
@@ -3578,7 +3575,7 @@ private Message GetSortedSetAddMessage(RedisKey destination, RedisKey key, long
  values.Add(item);
  }
  }
- if (destination.IsNull) return Message.Create(Database, flags, RedisCommand.SORT, key, values.ToArray());
+ if (destination.IsNull) return Message.Create(Database, flags, command, key, values.ToArray());
 
  // Because we are using STORE, we need to push this to a primary
  if (Message.GetPrimaryReplicaFlags(flags) == CommandFlags.DemandReplica)

src/StackExchange.Redis/RedisFeatures.cs

@@ -132,6 +132,11 @@ public RedisFeatures(Version version)
  /// </summary>
  public bool PushIfNotExists => Version >= v2_1_1;
 
+ /// <summary>
+ /// Does this support <see href="https://redis.io/commands/sort_ro">SORT_RO</see>?
+ /// </summary>
+ internal bool ReadOnlySort => Version >= v7_0_0_rc1;
+
  /// <summary>
  /// Is <see href="https://redis.io/commands/scan/">SCAN</see> (cursor-based scanning) available?
  /// </summary>

tests/StackExchange.Redis.Tests/Sets.cs

@@ -343,4 +343,50 @@ public void SetPopMulti_Nil()
  var arr = db.SetPop(key, 1);
  Assert.Empty(arr);
  }
+
+ [Fact]
+ public async Task TestSortReadonlyPrimary()
+ {
+ using var conn = Create();
+
+ var db = conn.GetDatabase();
+ var key = Me();
+ await db.KeyDeleteAsync(key);
+
+ var random = new Random();
+ var items = Enumerable.Repeat(0, 200).Select(_ => random.Next()).ToList();
+ await db.SetAddAsync(key, items.Select(x=>(RedisValue)x).ToArray());
+ items.Sort();
+
+ var result = db.Sort(key).Select(x=>(int)x);
+ Assert.Equal(items, result);
+
+ result = (await db.SortAsync(key)).Select(x => (int)x);
+ Assert.Equal(items, result);
+ }
+
+ [Fact]
+ public async Task TestSortReadonlyReplica()
+ {
+ using var conn = Create(require: RedisFeatures.v7_0_0_rc1);
+
+ var db = conn.GetDatabase();
+ var key = Me();
+ await db.KeyDeleteAsync(key);
+
+ var random = new Random();
+ var items = Enumerable.Repeat(0, 200).Select(_ => random.Next()).ToList();
+ await db.SetAddAsync(key, items.Select(x=>(RedisValue)x).ToArray());
+
+ using var readonlyConn = Create(configuration: TestConfig.Current.ReplicaServerAndPort, require: RedisFeatures.v7_0_0_rc1);
+ var readonlyDb = conn.GetDatabase();
+
+ items.Sort();
+
+ var result = readonlyDb.Sort(key).Select(x => (int)x);
+ Assert.Equal(items, result);
+
+ result = (await readonlyDb.SortAsync(key)).Select(x => (int)x);
+ Assert.Equal(items, result);
+ }
 }