Add Lease and non-boxing versions of Execute(Async)

src/StackExchange.Redis/Interfaces/IDatabase.cs

@@ -1437,6 +1437,51 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
         RedisResult Execute(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Execute an arbitrary command against the server; this is primarily intended for executing modules,
+        /// but may also be used to provide access to new features that lack a direct API.
+        ///
+        /// Response must be represented as a RESP simple string, bulk string, or integer.  Other response will
+        /// result in an error.
+        /// </summary>
+        /// <param name="command">The command to run.</param>
+        /// <param name="args">The arguments to pass for the command.</param>
+        /// <returns>A dynamic representation of the command's result.</returns>
+        /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
+        Lease<byte>? ExecuteLease(string command, params object[] args);
+
+        /// <summary>
+        /// Execute an arbitrary command against the server; this is primarily intended for executing modules,
+        /// but may also be used to provide access to new features that lack a direct API.
+        ///
+        /// Response must be represented as a RESP simple string, bulk string, or integer.  Other response will
+        /// result in an error.
+        /// </summary>
+        /// <param name="command">The command to run.</param>
+        /// <param name="args">The arguments to pass for the command.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A dynamic representation of the command's result.</returns>
+        /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
+        Lease<byte>? ExecuteLease(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Execute an arbitrary command against the server; this is primarily intended for
+        /// executing modules, but may also be used to provide access to new features that lack
+        /// a direct API.
+        ///
+        /// Response must be represented as a RESP simple string, bulk string, or integer.  Other response will
+        /// result in an error.
+        ///
+        /// This breaks out keys and args so collection can be reused, and avoid boxing.
+        /// <param name="command">The command to run.</param>
+        /// <param name="keys">The keys to use to chose slots in cluster mode.  These are NOT passed as part of the command</param>
+        /// <param name="args">The arguments to pass for the command.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A dynamic representation of the command's result.</returns>
+        /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
+        /// </summary>
+        Lease<byte>? ExecuteLeaseExplicit(string command, ICollection<RedisKey> keys, ICollection<RedisValue> args, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Execute a Lua script against the server.
         /// </summary>

src/StackExchange.Redis/Interfaces/IDatabaseAsync.cs

@@ -338,6 +338,15 @@ public interface IDatabaseAsync : IRedisAsync
         /// <inheritdoc cref="IDatabase.Execute(string, ICollection{object}, CommandFlags)"/>
         Task<RedisResult> ExecuteAsync(string command, ICollection<object>? args, CommandFlags flags = CommandFlags.None);
 
+        /// <inheritdoc cref="IDatabase.ExecuteLease(string, object[])"/>
+        Task<Lease<byte>?> ExecuteLeaseAsync(string command, params object[] args);
+
+        /// <inheritdoc cref="IDatabase.ExecuteLease(string, ICollection{object}, CommandFlags)"/>
+        Task<Lease<byte>?> ExecuteLeaseAsync(string command, ICollection<object>? args, CommandFlags flags = CommandFlags.None);
+
+        /// <inheritdoc cref="IDatabase.ExecuteLeaseExplicit(string, ICollection{RedisKey}, ICollection{RedisValue}, CommandFlags)"/>
+        Task<Lease<byte>?> ExecuteLeaseExplicitAsync(string command, ICollection<RedisKey> keys, ICollection<RedisValue> args, CommandFlags flags = CommandFlags.None);
+
         /// <inheritdoc cref="IDatabase.ScriptEvaluate(string, RedisKey[], RedisValue[], CommandFlags)"/>
         Task<RedisResult> ScriptEvaluateAsync(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None);
 

src/StackExchange.Redis/Interfaces/IServer.cs

@@ -263,9 +263,26 @@ public partial interface IServer : IRedis
         /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
         RedisResult Execute(string command, params object[] args);
 
+        /// <summary>
+        /// Execute an arbitrary command against the server; this is primarily intended for
+        /// executing modules, but may also be used to provide access to new features that lack
+        /// a direct API.
+        ///
+        /// Response must be represented as a RESP simple string, bulk string, or integer.  Other response will
+        /// result in an error.
+        /// </summary>
+        /// <param name="command">The command to run.</param>
+        /// <param name="args">The arguments to pass for the command.</param>
+        /// <returns>A dynamic representation of the command's result.</returns>
+        /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
+        Lease<byte>? ExecuteLease(string command, params object[] args);
+
         /// <inheritdoc cref="Execute(string, object[])"/>
         Task<RedisResult> ExecuteAsync(string command, params object[] args);
 
+        /// <inheritdoc cref="ExecuteLease(string, object[])"/>
+        Task<Lease<byte>?> ExecuteLeaseAsync(string command, params object[] args);
+
         /// <summary>
         /// Execute an arbitrary command against the server; this is primarily intended for
         /// executing modules, but may also be used to provide access to new features that lack
@@ -278,9 +295,48 @@ public partial interface IServer : IRedis
         /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
         RedisResult Execute(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Execute an arbitrary command against the server; this is primarily intended for
+        /// executing modules, but may also be used to provide access to new features that lack
+        /// a direct API.
+        ///
+        /// Response must be represented as a RESP simple string, bulk string, or integer.  Other response will
+        /// result in an error.
+        /// </summary>
+        /// <param name="command">The command to run.</param>
+        /// <param name="args">The arguments to pass for the command.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A dynamic representation of the command's result.</returns>
+        /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
+        Lease<byte>? ExecuteLease(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None);
+
         /// <inheritdoc cref="Execute(string, ICollection{object}, CommandFlags)"/>
         Task<RedisResult> ExecuteAsync(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None);
 
+        /// <inheritdoc cref="ExecuteLease(string, ICollection{object}, CommandFlags)"/>
+        Task<Lease<byte>?> ExecuteLeaseAsync(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// Execute an arbitrary command against the server; this is primarily intended for
+        /// executing modules, but may also be used to provide access to new features that lack
+        /// a direct API.
+        ///
+        /// Response must be represented as a RESP simple string, bulk string, or integer.  Other response will
+        /// result in an error.
+        ///
+        /// This breaks out keys and args so collection can be reused, and avoid boxing.
+        /// <param name="command">The command to run.</param>
+        /// <param name="keys">The keys to use to chose slots in cluster mode.  These are NOT passed as part of the command</param>
+        /// <param name="args">The arguments to pass for the command.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>A dynamic representation of the command's result.</returns>
+        /// <remarks>This API should be considered an advanced feature; inappropriate use can be harmful.</remarks>
+        /// </summary>
+        Lease<byte>? ExecuteLeaseExplicit(string command, ICollection<RedisKey> keys, ICollection<RedisValue> args, CommandFlags flags = CommandFlags.None);
+
+        /// <inheritdoc cref="ExecuteLeaseExplicit(string, ICollection{RedisKey}, ICollection{RedisValue}, CommandFlags)"/>
+        Task<Lease<byte>?> ExecuteLeaseExplicitAsync(string command, ICollection<RedisKey> keys, ICollection<RedisValue> args, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Delete all the keys of all databases on the server.
         /// </summary>

src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.cs

@@ -345,6 +345,15 @@ public Task<RedisResult> ExecuteAsync(string command, params object[] args) =>
         public Task<RedisResult> ExecuteAsync(string command, ICollection<object>? args, CommandFlags flags = CommandFlags.None) =>
             Inner.ExecuteAsync(command, ToInner(args), flags);
 
+        public Task<Lease<byte>?> ExecuteLeaseAsync(string command, params object[] args) =>
+            Inner.ExecuteLeaseAsync(command, ToInner(args), CommandFlags.None);
+
+        public Task<Lease<byte>?> ExecuteLeaseAsync(string command, ICollection<object>? args, CommandFlags flags = CommandFlags.None) =>
+            Inner.ExecuteLeaseAsync(command, ToInner(args), flags);
+
+        public Task<Lease<byte>?> ExecuteLeaseExplicitAsync(string command, ICollection<RedisKey> keys, ICollection<RedisValue> args, CommandFlags flags = CommandFlags.None) =>
+            throw new NotSupportedException($"{nameof(ExecuteLeaseExplicitAsync)} is not supported with key prefixes");
+
         public Task<RedisResult> ScriptEvaluateAsync(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) =>
             // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those?
             Inner.ScriptEvaluateAsync(hash, ToInner(keys), values, flags);

src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixedDatabase.cs

@@ -332,6 +332,15 @@ public RedisResult Execute(string command, params object[] args)
         public RedisResult Execute(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None)
             => Inner.Execute(command, ToInner(args), flags);
 
+        public Lease<byte>? ExecuteLease(string command, params object[] args)
+            => Inner.ExecuteLease(command, ToInner(args), CommandFlags.None);
+
+        public Lease<byte>? ExecuteLease(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None)
+            => Inner.ExecuteLease(command, ToInner(args), flags);
+
+        public Lease<byte>? ExecuteLeaseExplicit(string command, ICollection<RedisKey> keys, ICollection<RedisValue> args, CommandFlags flags = CommandFlags.None)
+            => throw new NotSupportedException($"{nameof(ExecuteLeaseExplicit)} is not supported with key prefixes");
+
         public RedisResult ScriptEvaluate(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None) =>
             // TODO: The return value could contain prefixed keys. It might make sense to 'unprefix' those?
             Inner.ScriptEvaluate(hash, ToInner(keys), values, flags);

src/StackExchange.Redis/PublicAPI/PublicAPI.Unshipped.txt

@@ -1 +1,13 @@
-#nullable enable
+#nullable enable
+StackExchange.Redis.IDatabase.ExecuteLease(string! command, params object![]! args) -> StackExchange.Redis.Lease<byte>?
+StackExchange.Redis.IDatabase.ExecuteLease(string! command, System.Collections.Generic.ICollection<object!>! args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> StackExchange.Redis.Lease<byte>?
+StackExchange.Redis.IDatabase.ExecuteLeaseExplicit(string! command, System.Collections.Generic.ICollection<StackExchange.Redis.RedisKey>! keys, System.Collections.Generic.ICollection<StackExchange.Redis.RedisValue>! args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> StackExchange.Redis.Lease<byte>?
+StackExchange.Redis.IDatabaseAsync.ExecuteLeaseAsync(string! command, params object![]! args) -> System.Threading.Tasks.Task<StackExchange.Redis.Lease<byte>?>!
+StackExchange.Redis.IDatabaseAsync.ExecuteLeaseAsync(string! command, System.Collections.Generic.ICollection<object!>? args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> System.Threading.Tasks.Task<StackExchange.Redis.Lease<byte>?>!
+StackExchange.Redis.IDatabaseAsync.ExecuteLeaseExplicitAsync(string! command, System.Collections.Generic.ICollection<StackExchange.Redis.RedisKey>! keys, System.Collections.Generic.ICollection<StackExchange.Redis.RedisValue>! args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> System.Threading.Tasks.Task<StackExchange.Redis.Lease<byte>?>!
+StackExchange.Redis.IServer.ExecuteLease(string! command, params object![]! args) -> StackExchange.Redis.Lease<byte>?
+StackExchange.Redis.IServer.ExecuteLease(string! command, System.Collections.Generic.ICollection<object!>! args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> StackExchange.Redis.Lease<byte>?
+StackExchange.Redis.IServer.ExecuteLeaseAsync(string! command, params object![]! args) -> System.Threading.Tasks.Task<StackExchange.Redis.Lease<byte>?>!
+StackExchange.Redis.IServer.ExecuteLeaseAsync(string! command, System.Collections.Generic.ICollection<object!>! args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> System.Threading.Tasks.Task<StackExchange.Redis.Lease<byte>?>!
+StackExchange.Redis.IServer.ExecuteLeaseExplicit(string! command, System.Collections.Generic.ICollection<StackExchange.Redis.RedisKey>! keys, System.Collections.Generic.ICollection<StackExchange.Redis.RedisValue>! args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> StackExchange.Redis.Lease<byte>?
+StackExchange.Redis.IServer.ExecuteLeaseExplicitAsync(string! command, System.Collections.Generic.ICollection<StackExchange.Redis.RedisKey>! keys, System.Collections.Generic.ICollection<StackExchange.Redis.RedisValue>! args, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> System.Threading.Tasks.Task<StackExchange.Redis.Lease<byte>?>!

src/StackExchange.Redis/RedisDatabase.cs

@@ -1595,6 +1595,21 @@ public RedisResult Execute(string command, ICollection<object> args, CommandFlag
             return ExecuteSync(msg, ResultProcessor.ScriptResult)!;
         }
 
+        public Lease<byte>? ExecuteLease(string command, params object[] args)
+            => ExecuteLease(command, args, CommandFlags.None);
+
+        public Lease<byte>? ExecuteLease(string command, ICollection<object> args, CommandFlags flags = CommandFlags.None)
+        {
+            var msg = new ExecuteMessage(multiplexer?.CommandMap, Database, flags, command, args);
+            return ExecuteSync(msg, ResultProcessor.Lease);
+        }
+
+        public Lease<byte>? ExecuteLeaseExplicit(string command, ICollection<RedisKey> keys, ICollection<RedisValue> args, CommandFlags flags = CommandFlags.None)
+        {
+            var msg = new ExecuteExplicitMessage(multiplexer?.CommandMap, Database, flags, command, keys, args);
+            return ExecuteSync(msg, ResultProcessor.Lease);
+        }
+
         public Task<RedisResult> ExecuteAsync(string command, params object[] args)
             => ExecuteAsync(command, args, CommandFlags.None);
 
@@ -1604,6 +1619,21 @@ public Task<RedisResult> ExecuteAsync(string command, ICollection<object>? args,
             return ExecuteAsync(msg, ResultProcessor.ScriptResult, defaultValue: RedisResult.NullSingle);
         }
 
+        public Task<Lease<byte>?> ExecuteLeaseAsync(string command, params object[] args)
+            => ExecuteLeaseAsync(command, args, CommandFlags.None);
+
+        public Task<Lease<byte>?> ExecuteLeaseAsync(string command, ICollection<object>? args, CommandFlags flags = CommandFlags.None)
+        {
+            var msg = new ExecuteMessage(multiplexer?.CommandMap, Database, flags, command, args);
+            return ExecuteAsync<Lease<byte>?>(msg, ResultProcessor.Lease!, defaultValue: null);
+        }
+
+        public Task<Lease<byte>?> ExecuteLeaseExplicitAsync(string command, ICollection<RedisKey>? keys, ICollection<RedisValue>? args, CommandFlags flags = CommandFlags.None)
+        {
+            var msg = new ExecuteExplicitMessage(multiplexer?.CommandMap, Database, flags, command, keys, args);
+            return ExecuteAsync<Lease<byte>?>(msg, ResultProcessor.Lease!, defaultValue: null);
+        }
+
         public RedisResult ScriptEvaluate(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None)
         {
             var command = ResultProcessor.ScriptLoadProcessor.IsSHA1(script) ? RedisCommand.EVALSHA : RedisCommand.EVAL;
@@ -4968,6 +4998,48 @@ public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy)
             public override int ArgCount => _args.Count;
         }
 
+        internal sealed class ExecuteExplicitMessage : Message
+        {
+            private readonly ICollection<RedisKey> _keys;
+            private readonly ICollection<RedisValue> _args;
+            public new CommandBytes Command { get; }
+
+            public ExecuteExplicitMessage(CommandMap? map, int db, CommandFlags flags, string command, ICollection<RedisKey>? keys, ICollection<RedisValue>? args) : base(db, flags, RedisCommand.UNKNOWN)
+            {
+                if (args != null && args.Count >= PhysicalConnection.REDIS_MAX_ARGS) // using >= here because we will be adding 1 for the command itself (which is an arg for the purposes of the multi-bulk protocol)
+                {
+                    throw ExceptionFactory.TooManyArgs(command, args.Count);
+                }
+                Command = map?.GetBytes(command) ?? default;
+                if (Command.IsEmpty) throw ExceptionFactory.CommandDisabled(command);
+                _keys = keys ?? Array.Empty<RedisKey>();
+                _args = args ?? Array.Empty<RedisValue>();
+            }
+
+            protected override void WriteImpl(PhysicalConnection physical)
+            {
+                physical.WriteHeader(RedisCommand.UNKNOWN, _args.Count, Command);
+                foreach (var arg in _args)
+                {
+                    physical.WriteBulkString(arg);
+                }
+            }
+
+            public override string CommandString => Command.ToString();
+            public override string CommandAndKey => Command.ToString();
+
+            public override int GetHashSlot(ServerSelectionStrategy serverSelectionStrategy)
+            {
+                int slot = ServerSelectionStrategy.NoSlot;
+                foreach (var key in _keys)
+                {
+                    slot = serverSelectionStrategy.CombineSlot(slot, key);
+                }
+                return slot;
+            }
+            public override int ArgCount => _args.Count;
+        }
+
         private sealed class ScriptEvalMessage : Message, IMultiMessage
         {
             private readonly RedisKey[] keys;