Feature: Support for hash field expiration

src/StackExchange.Redis/Enums/ExpireResult.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace StackExchange.Redis;
+
+/// <summary>
+/// Specifies the result of operation to set expire time.
+/// </summary>
+public enum ExpireResult
+{
+    /// <summary>
+    /// Field deleted because the specified expiration time is due,
+    /// </summary>
+    Due = 2,
+    /// <summary>
+    /// Expiration time/duration updated successfully
+    /// </summary>
+    Success = 1,
+    /// <summary>
+    /// Expiration not set because of a specified NX | XX | GT | LT condition not met
+    /// </summary>
+    ConditionNotMet = 0,
+    /// <summary>
+    /// No such field.
+    /// </summary>
+    NoSuchField = -2,
+
+}

src/StackExchange.Redis/Enums/PersistResult.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace StackExchange.Redis;
+
+/// <summary>
+/// Specifies the result of operation to remove the expire time.
+/// </summary>
+public enum PersistResult
+{
+    /// <summary>
+    /// Expiration removed successfully
+    /// </summary>
+    Success = 1,
+    /// <summary>
+    /// Expiration not removed because of a specified NX | XX | GT | LT condition not met
+    /// </summary>
+    ConditionNotMet = -1,
+    /// <summary>
+    /// No such field.
+    /// </summary>
+    NoSuchField = -2,
+}

src/StackExchange.Redis/Enums/RedisCommand.cs

@@ -66,6 +66,9 @@ internal enum RedisCommand
     HDEL,
     HELLO,
     HEXISTS,
+    HEXPIRE,
+    HEXPIREAT,
+    HEXPIRETIME,
     HGET,
     HGETALL,
     HINCRBY,
@@ -74,6 +77,11 @@ internal enum RedisCommand
     HLEN,
     HMGET,
     HMSET,
+    HPERSIST,
+    HPEXPIRE,
+    HPEXPIREAT,
+    HPEXPIRETIME,
+    HPTTL,
     HRANDFIELD,
     HSCAN,
     HSET,
@@ -279,9 +287,14 @@ internal static bool IsPrimaryOnly(this RedisCommand command)
             case RedisCommand.GETEX:
             case RedisCommand.GETSET:
             case RedisCommand.HDEL:
+            case RedisCommand.HEXPIRE:
+            case RedisCommand.HEXPIREAT:
             case RedisCommand.HINCRBY:
             case RedisCommand.HINCRBYFLOAT:
             case RedisCommand.HMSET:
+            case RedisCommand.HPERSIST:
+            case RedisCommand.HPEXPIRE:
+            case RedisCommand.HPEXPIREAT:
             case RedisCommand.HSET:
             case RedisCommand.HSETNX:
             case RedisCommand.INCR:
@@ -378,11 +391,14 @@ internal static bool IsPrimaryOnly(this RedisCommand command)
             case RedisCommand.GETRANGE:
             case RedisCommand.HELLO:
             case RedisCommand.HEXISTS:
+            case RedisCommand.HEXPIRETIME:
             case RedisCommand.HGET:
             case RedisCommand.HGETALL:
             case RedisCommand.HKEYS:
             case RedisCommand.HLEN:
             case RedisCommand.HMGET:
+            case RedisCommand.HPEXPIRETIME:
+            case RedisCommand.HPTTL:
             case RedisCommand.HRANDFIELD:
             case RedisCommand.HSCAN:
             case RedisCommand.HSTRLEN:

src/StackExchange.Redis/Interfaces/IDatabase.cs

@@ -325,6 +325,79 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// <remarks><seealso href="https://redis.io/commands/hexists"/></remarks>
         bool HashExists(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Set the remaining time to live in milliseconds for the given set of fields of hash
+        /// After the timeout has expired, the field of the hash will automatically be deleted.
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to set expire time.</param>
+        /// <param name="expiry">The timeout to set.</param>
+        /// <param name="when">under which condition the expiration will be set using <see cref="ExpireWhen"/>.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns> Empty array if the key does not exist. Otherwise returns an array where each item is the result of operation for given fields;
+        ///		2: field deleted because the specified expiration time is due
+        ///		1: expiration time set/updated
+        /// 	0: expiration time is not set/update (a specified ExpireWhen condition is not met)
+        ///		-2 : no such field
+        /// </returns>
+        ExpireResult[] HashFieldExpire(RedisKey key, RedisValue[] hashFields, TimeSpan expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        ///	Set the time out on a field of the given set of fields of hash
+        /// After the timeout has expired, the field of the hash will automatically be deleted.
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to set expire time.</param>
+        /// <param name="expiry">The exact date to expiry to set.</param>
+        /// <param name="when">under which condition the expiration will be set using <see cref="ExpireWhen"/>.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns> Empty array if the key does not exist. Otherwise returns an array where each item is the result of operation for given fields;
+        ///		2: field deleted because the specified expiration time is due
+        ///		1: expiration time set/updated
+        /// 	0: expiration time is not set/update (a specified ExpireWhen condition is not met)
+        ///		-2 : no such field
+        /// </returns>
+        ExpireResult[] HashFieldExpire(RedisKey key, RedisValue[] hashFields, DateTime expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// For each specified field, it gets the expiration time as a Unix timestamp in milliseconds (milliseconds since the Unix epoch)
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to get expire time.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>Empty array if the key does not exist. Otherwise returns the result of operation for given fields
+        ///     expiration time: as a UNIX timestamp in milliseconds
+        ///     -1: if field has no associated expiration time 
+        ///     -2: no such field
+        /// </returns>
+        long[] HashFieldGetExpireDateTime(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// For each specified field, it removes the expiration time
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to remove expire time.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>Empty array if the key does not exist. Otherwise returns the result of operation for given fields
+        ///     1: if the expiration time was removed
+        ///     -1: if field has no associated expiration time 
+        ///     -2: no such field
+        /// </returns>
+        PersistResult[] HashFieldPersist(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// For each specified field, it gets the remaining time to live in milliseconds
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to get expire time.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>Empty array if the key does not exist. Otherwise returns the result of operation for given fields
+        ///      time to live: in milliseconds
+        ///     -1: if field has no associated expiration time 
+        ///     -2: no such field
+        /// </returns>
+        long[] HashFieldGetTimeToLive(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Returns the value associated with field in the hash stored at key.
         /// </summary>
@@ -1628,7 +1701,7 @@ public interface IDatabase : IRedis, IDatabaseAsync
 
         /// <inheritdoc cref="SortedSetAdd(RedisKey, RedisValue, double, SortedSetWhen, CommandFlags)" />
         [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
-        bool SortedSetAdd(RedisKey key, RedisValue member, double score, When when, CommandFlags flags= CommandFlags.None);
+        bool SortedSetAdd(RedisKey key, RedisValue member, double score, When when, CommandFlags flags = CommandFlags.None);
 
         /// <summary>
         /// Adds the specified member with the specified score to the sorted set stored at key.

src/StackExchange.Redis/Interfaces/IDatabaseAsync.cs

@@ -312,6 +312,79 @@ public interface IDatabaseAsync : IRedisAsync
         /// <remarks><seealso href="https://redis.io/commands/hexists"/></remarks>
         Task<bool> HashExistsAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None);
 
+        /// <summary>
+        /// Set the remaining time to live in milliseconds for the given set of fields of hash
+        /// After the timeout has expired, the field of the hash will automatically be deleted.
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to set expire time.</param>
+        /// <param name="expiry">The timeout to set.</param>
+        /// <param name="when">under which condition the expiration will be set using <see cref="ExpireWhen"/>.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns> Empty array if the key does not exist. Otherwise returns an array where each item is the result of operation for given fields;
+        ///		2: field deleted because the specified expiration time is due
+        ///		1: expiration time set/updated
+        /// 	0: expiration time is not set/update (a specified ExpireWhen condition is not met)
+        ///		-2 : no such field
+        /// </returns>
+        Task<ExpireResult[]> HashFieldExpireAsync(RedisKey key, RedisValue[] hashFields, TimeSpan expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        ///	Set the time out on a field of the given set of fields of hash
+        /// After the timeout has expired, the field of the hash will automatically be deleted.
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to set expire time.</param>
+        /// <param name="expiry">The exact date to expiry to set.</param>
+        /// <param name="when">under which condition the expiration will be set using <see cref="ExpireWhen"/>.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns> Empty array if the key does not exist. Otherwise returns an array where each item is the result of operation for given fields;
+        ///		2: field deleted because the specified expiration time is due
+        ///		1: expiration time set/updated
+        /// 	0: expiration time is not set/update (a specified ExpireWhen condition is not met)
+        ///		-2 : no such field
+        /// </returns>
+        Task<ExpireResult[]> HashFieldExpireAsync(RedisKey key, RedisValue[] hashFields, DateTime expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// For each specified field, it gets the expiration time as a Unix timestamp in milliseconds (milliseconds since the Unix epoch)
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to get expire time.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>Empty array if the key does not exist. Otherwise returns the result of operation for given fields
+        ///     expiration time: as a UNIX timestamp in milliseconds
+        ///     -1: if field has no associated expiration time 
+        ///     -2: no such field
+        /// </returns>
+        Task<long[]> HashFieldGetExpireDateTimeAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// For each specified field, it removes the expiration time
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to remove expire time.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>Empty array if the key does not exist. Otherwise returns the result of operation for given fields
+        ///     1: if the expiration time was removed
+        ///     -1: if field has no associated expiration time 
+        ///     -2: no such field
+        /// </returns>
+        Task<PersistResult[]> HashFieldPersistAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None);
+
+        /// <summary>
+        /// For each specified field, it gets the remaining time to live in milliseconds
+        /// </summary>
+        /// <param name="key">The key of the hash.</param>
+        /// <param name="hashFields">The fields in the hash to get expire time.</param>
+        /// <param name="flags">The flags to use for this operation.</param>
+        /// <returns>Empty array if the key does not exist. Otherwise returns the result of operation for given fields
+        ///      time to live: in milliseconds
+        ///     -1: if field has no associated expiration time 
+        ///     -2: no such field
+        /// </returns>
+        Task<long[]> HashFieldGetTimeToLiveAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags = CommandFlags.None);
+
         /// <summary>
         /// Returns the value associated with field in the hash stored at key.
         /// </summary>

src/StackExchange.Redis/KeyspaceIsolation/KeyPrefixed.cs

@@ -84,6 +84,21 @@ public Task<bool> HashDeleteAsync(RedisKey key, RedisValue hashField, CommandFla
         public Task<bool> HashExistsAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) =>
             Inner.HashExistsAsync(ToInner(key), hashField, flags);
 
+        public Task<ExpireResult[]> HashFieldExpireAsync(RedisKey key, RedisValue[] hashFields, TimeSpan expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) =>
+            Inner.HashFieldExpireAsync(ToInner(key), hashFields, expiry, when, flags);
+
+        public Task<ExpireResult[]> HashFieldExpireAsync(RedisKey key, RedisValue[] hashFields, DateTime expiry, ExpireWhen when = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) =>
+            Inner.HashFieldExpireAsync(ToInner(key), hashFields, expiry, when, flags);
+
+        public Task<long[]> HashFieldGetExpireDateTimeAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags) =>
+            Inner.HashFieldGetExpireDateTimeAsync(ToInner(key), hashFields, flags);
+
+        public Task<PersistResult[]> HashFieldPersistAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags) =>
+            Inner.HashFieldPersistAsync(ToInner(key), hashFields, flags);
+
+        public Task<long[]> HashFieldGetTimeToLiveAsync(RedisKey key, RedisValue[] hashFields, CommandFlags flags) =>
+            Inner.HashFieldGetTimeToLiveAsync(ToInner(key), hashFields, flags);
+
         public Task<HashEntry[]> HashGetAllAsync(RedisKey key, CommandFlags flags = CommandFlags.None) =>
             Inner.HashGetAllAsync(ToInner(key), flags);