ZMPOP and LMPOP

src/StackExchange.Redis/Enums/RedisCommand.cs

@@ -87,6 +87,7 @@ internal enum RedisCommand
         LINSERT,
         LLEN,
         LMOVE,
+        LMPOP,
         LPOP,
         LPOS,
         LPUSH,
@@ -207,6 +208,7 @@ internal enum RedisCommand
         ZINTERCARD,
         ZINTERSTORE,
         ZLEXCOUNT,
+        ZMPOP,
         ZMSCORE,
         ZPOPMAX,
         ZPOPMIN,

src/StackExchange.Redis/Interfaces/IDatabase.cs

@@ -836,6 +836,19 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// <remarks>https://redis.io/commands/lpop</remarks>
         RedisValue[] ListLeftPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Removes and returns at most specified <paramref name="count"/> of elements from the first non-empty list
+        /// within the set of <paramref name="keys"/> passed into it.
+        /// Starts on the left side of the list.
+        /// If the length of the first non-empty list is less than <paramref name="count"/>, only the elements within that list are returned.
+        /// </summary>
+        /// <param name="keys">The keys to look through for elements to pop.</param>
+        /// <param name="count">The maximum number of elements to pop from the list.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A span of contiguous elements from the list, or <see cref="ListPopResult.Null"/> if no non-empty lists are found.</returns>
+        /// <remarks>https://redis.io/commands/lmpop</remarks>
+        ListPopResult ListLeftPop(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Scans through the list stored at <paramref name="key"/> looking for <paramref name="element"/>, returning the 0-based
         /// index of the first matching element.
@@ -973,6 +986,19 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// <remarks>https://redis.io/commands/rpop</remarks>
         RedisValue[] ListRightPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Removes and returns at most specified <paramref name="count"/> of elements from the first non-empty list
+        /// within the set of <paramref name="keys"/> passed into it.
+        /// Starts on the right side of the list.
+        /// If the length of the first non-empty list is less than <paramref name="count"/>, only the elements within that list are returned.
+        /// </summary>
+        /// <param name="keys">The keys to look through for elements to pop.</param>
+        /// <param name="count">The maximum number of elements to pop from the list.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A span of contiguous elements from the list, or <see cref="ListPopResult.Null"/> if no non-empty lists are found.</returns>
+        /// <remarks>https://redis.io/commands/lmpop</remarks>
+        ListPopResult ListRightPop(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Atomically returns and removes the last element (tail) of the list stored at source, and pushes the element at the first element (head) of the list stored at destination.
         /// </summary>
@@ -1981,6 +2007,18 @@ IEnumerable<SortedSetEntry> SortedSetScan(RedisKey key,
         /// <remarks>https://redis.io/commands/zpopmax</remarks>
         SortedSetEntry[] SortedSetPop(RedisKey key, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Removes and returns up to <paramref name="count"/> entries from the first non-empty sorted set in <paramref name="keys"/>.
+        /// Returns <see cref="SortedSetPopResult.Null"/> if none of the sets exist or contain any elements.
+        /// </summary>
+        /// <param name="keys">The keys to check.</param>
+        /// <param name="count">The maximum number of records to pop out of the sorted set.</param>
+        /// <param name="order">The order to sort by when popping items out of the set.</param>
+        /// <param name="flags">The flags to use for the operation.</param>
+        /// <returns>A contiguous collection of sorted set entries with the key they were popped from, or <see cref="SortedSetPopResult.Null"/> if no non-empty sorted sets are found.</returns>
+        /// <remarks>https://redis.io/commands/zmpop</remarks>
+        SortedSetPopResult SortedSetPop(RedisKey[] keys, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Allow the consumer to mark a pending message as correctly processed. Returns the number of messages acknowledged.
         /// </summary>

src/StackExchange.Redis/Interfaces/IDatabaseAsync.cs

@@ -812,6 +812,19 @@ public interface IDatabaseAsync : IRedisAsync
         /// <remarks>https://redis.io/commands/lpop</remarks>
         Task<RedisValue[]> ListLeftPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Removes and returns at most specified <paramref name="count"/> of elements from the first non-empty list
+        /// within the set of <paramref name="keys"/> passed into it.
+        /// Starts on the left side of the list.
+        /// If the length of the first non-empty list is less than <paramref name="count"/>, only the elements within that list are returned.
+        /// </summary>
+        /// <param name="keys">The keys to look through for elements to pop.</param>
+        /// <param name="count">The maximum number of elements to pop from the list.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A span of contiguous elements from the list, or <see cref="ListPopResult.Null"/> if no non-empty lists are found.</returns>
+        /// <remarks>https://redis.io/commands/lmpop</remarks>
+        Task<ListPopResult> ListLeftPopAsync(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Scans through the list stored at <paramref name="key"/> looking for <paramref name="element"/>, returning the 0-based
         /// index of the first matching element.
@@ -949,6 +962,19 @@ public interface IDatabaseAsync : IRedisAsync
         /// <remarks>https://redis.io/commands/rpop</remarks>
         Task<RedisValue[]> ListRightPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Removes and returns at most specified <paramref name="count"/> of elements from the first non-empty list
+        /// within the set of <paramref name="keys"/> passed into it.
+        /// Starts on the right side of the list.
+        /// If the length of the first non-empty list is less than <paramref name="count"/>, only the elements within that list are returned.
+        /// </summary>
+        /// <param name="keys">The keys to look through for elements to pop.</param>
+        /// <param name="count">The maximum number of elements to pop from the list.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A span of contiguous elements from the list, or <see cref="ListPopResult.Null"/> if no non-empty lists are found.</returns>
+        /// <remarks>https://redis.io/commands/lmpop</remarks>
+        Task<ListPopResult> ListRightPopAsync(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Atomically returns and removes the last element (tail) of the list stored at source, and pushes the element at the first element (head) of the list stored at destination.
         /// </summary>
@@ -1933,6 +1959,18 @@ IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(RedisKey key,
         /// <remarks>https://redis.io/commands/zpopmax</remarks>
         Task<SortedSetEntry[]> SortedSetPopAsync(RedisKey key, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Removes and returns up to <paramref name="count"/> entries from the first non-empty sorted set in <paramref name="keys"/>.
+        /// Returns <see cref="SortedSetPopResult.Null"/> if none of the sets exist or contain any elements.
+        /// </summary>
+        /// <param name="keys">The keys to check.</param>
+        /// <param name="count">The maximum number of records to pop out of the sorted set.</param>
+        /// <param name="order">The order to sort by when popping items out of the set.</param>
+        /// <param name="flags">The flags to use for the operation.</param>
+        /// <returns>A contiguous collection of sorted set entries with the key they were popped from, or <see cref="SortedSetPopResult.Null"/> if no non-empty sorted sets are found.</returns>
+        /// <remarks>https://redis.io/commands/zmpop</remarks>
+        Task<SortedSetPopResult> SortedSetPopAsync(RedisKey[] keys, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Allow the consumer to mark a pending message as correctly processed. Returns the number of messages acknowledged.
         /// </summary>

src/StackExchange.Redis/KeyspaceIsolation/DatabaseWrapper.cs

@@ -218,6 +218,9 @@ public RedisValue ListLeftPop(RedisKey key, CommandFlags flags = CommandFlags.No
         public RedisValue[] ListLeftPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) =>
             Inner.ListLeftPop(ToInner(key), count, flags);
 
+        public ListPopResult ListLeftPop(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) =>
+            Inner.ListLeftPop(ToInner(keys), count, flags);
+
         public long ListPosition(RedisKey key, RedisValue element, long rank = 1, long maxLength = 0, CommandFlags flags = CommandFlags.None) =>
             Inner.ListPosition(ToInner(key), element, rank, maxLength, flags);
 
@@ -251,6 +254,9 @@ public RedisValue ListRightPop(RedisKey key, CommandFlags flags = CommandFlags.N
         public RedisValue[] ListRightPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) =>
             Inner.ListRightPop(ToInner(key), count, flags);
 
+        public ListPopResult ListRightPop(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) =>
+            Inner.ListRightPop(ToInner(keys), count, flags);
+
         public RedisValue ListRightPopLeftPush(RedisKey source, RedisKey destination, CommandFlags flags = CommandFlags.None) =>
             Inner.ListRightPopLeftPush(ToInner(source), ToInner(destination), flags);
 
@@ -475,6 +481,9 @@ public long SortedSetRemoveRangeByValue(RedisKey key, RedisValue min, RedisValue
         public SortedSetEntry[] SortedSetPop(RedisKey key, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) =>
             Inner.SortedSetPop(ToInner(key), count, order, flags);
 
+        public SortedSetPopResult SortedSetPop(RedisKey[] keys, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) =>
+            Inner.SortedSetPop(ToInner(keys), count, order, flags);
+
         public long StreamAcknowledge(RedisKey key, RedisValue groupName, RedisValue messageId, CommandFlags flags = CommandFlags.None) =>
             Inner.StreamAcknowledge(ToInner(key), groupName, messageId, flags);
 

src/StackExchange.Redis/KeyspaceIsolation/WrapperBase.cs

@@ -229,6 +229,9 @@ public Task<RedisValue> ListLeftPopAsync(RedisKey key, CommandFlags flags = Comm
         public Task<RedisValue[]> ListLeftPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) =>
             Inner.ListLeftPopAsync(ToInner(key), count, flags);
 
+        public Task<ListPopResult> ListLeftPopAsync(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) =>
+            Inner.ListLeftPopAsync(ToInner(keys), count, flags);
+
         public Task<long> ListPositionAsync(RedisKey key, RedisValue element, long rank = 1, long maxLength = 0, CommandFlags flags = CommandFlags.None) =>
             Inner.ListPositionAsync(ToInner(key), element, rank, maxLength, flags);
 
@@ -262,6 +265,9 @@ public Task<RedisValue> ListRightPopAsync(RedisKey key, CommandFlags flags = Com
         public Task<RedisValue[]> ListRightPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) =>
             Inner.ListRightPopAsync(ToInner(key), count, flags);
 
+        public Task<ListPopResult> ListRightPopAsync(RedisKey[] keys, long count, CommandFlags flags = CommandFlags.None) =>
+            Inner.ListRightPopAsync(ToInner(keys), count, flags);
+
         public Task<RedisValue> ListRightPopLeftPushAsync(RedisKey source, RedisKey destination, CommandFlags flags = CommandFlags.None) =>
             Inner.ListRightPopLeftPushAsync(ToInner(source), ToInner(destination), flags);
 
@@ -492,6 +498,9 @@ public IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(RedisKey key, RedisVa
         public Task<SortedSetEntry[]> SortedSetPopAsync(RedisKey key, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) =>
             Inner.SortedSetPopAsync(ToInner(key), count, order, flags);
 
+        public Task<SortedSetPopResult> SortedSetPopAsync(RedisKey[] keys, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) =>
+            Inner.SortedSetPopAsync(ToInner(keys), count, order, flags);
+
         public Task<long> StreamAcknowledgeAsync(RedisKey key, RedisValue groupName, RedisValue messageId, CommandFlags flags = CommandFlags.None) =>
             Inner.StreamAcknowledgeAsync(ToInner(key), groupName, messageId, flags);
 

src/StackExchange.Redis/ListPopResult.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace StackExchange.Redis;
+
+/// <summary>
+/// A contiguous portion of a redis list.
+/// </summary>
+public readonly struct ListPopResult
+{
+    /// <summary>
+    /// A null ListPopResult, indicating no results.
+    /// </summary>
+    public static ListPopResult Null { get; } = new ListPopResult(RedisKey.Null, Array.Empty<RedisValue>());
+
+    /// <summary>
+    /// Whether this object is null/empty.
+    /// </summary>
+    public bool IsNull => Key.IsNull && Values == Array.Empty<RedisValue>();
+
+    /// <summary>
+    /// The key of the list that this set of entries came form.
+    /// </summary>
+    public RedisKey Key { get; }
+
+    /// <summary>
+    /// The values from the list.
+    /// </summary>
+    public RedisValue[] Values { get; }
+
+    internal ListPopResult(RedisKey key, RedisValue[] values)
+    {
+        Key = key;
+        Values = values;
+    }
+}