Merge pull request #1090 from araishikeiwai/expire-options

Add support for EXPIRE command group options (NX/XX/GT/LT)

Author: byroot

lib/redis/commands/keys.rb

@@ -69,18 +69,40 @@ def persist(key)
       #
       # @param [String] key
       # @param [Integer] seconds time to live
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def expire(key, seconds)
-        send_command([:expire, key, seconds], &Boolify)
+      def expire(key, seconds, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:expire, key, seconds]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Set the expiration for a key as a UNIX timestamp.
       #
       # @param [String] key
       # @param [Integer] unix_time expiry time specified as a UNIX timestamp
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def expireat(key, unix_time)
-        send_command([:expireat, key, unix_time], &Boolify)
+      def expireat(key, unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:expireat, key, unix_time]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Get the time to live (in seconds) for a key.
@@ -103,18 +125,40 @@ def ttl(key)
       #
       # @param [String] key
       # @param [Integer] milliseconds time to live
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def pexpire(key, milliseconds)
-        send_command([:pexpire, key, milliseconds], &Boolify)
+      def pexpire(key, milliseconds, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:pexpire, key, milliseconds]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Set the expiration for a key as number of milliseconds from UNIX Epoch.
       #
       # @param [String] key
       # @param [Integer] ms_unix_time expiry time specified as number of milliseconds from UNIX Epoch.
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def pexpireat(key, ms_unix_time)
-        send_command([:pexpireat, key, ms_unix_time], &Boolify)
+      def pexpireat(key, ms_unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:pexpireat, key, ms_unix_time]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Get the time to live (in milliseconds) for a key.

test/lint/value_types.rb

@@ -66,6 +66,20 @@ def test_expire
       r.set("foo", "s1")
       assert r.expire("foo", 2)
       assert_in_range 0..2, r.ttl("foo")
+
+      target_version "7.0.0" do
+        r.set("bar", "s2")
+        refute r.expire("bar", 5, xx: true)
+        assert r.expire("bar", 5, nx: true)
+        refute r.expire("bar", 5, nx: true)
+        assert r.expire("bar", 5, xx: true)
+
+        r.expire("bar", 10)
+        refute r.expire("bar", 15, lt: true)
+        refute r.expire("bar", 5, gt: true)
+        assert r.expire("bar", 15, gt: true)
+        assert r.expire("bar", 5, lt: true)
+      end
     end
 
     def test_pexpire
@@ -74,12 +88,40 @@ def test_pexpire
         assert r.pexpire("foo", 2000)
         assert_in_range 0..2, r.ttl("foo")
       end
+
+      target_version "7.0.0" do
+        r.set("bar", "s2")
+        refute r.pexpire("bar", 5_000, xx: true)
+        assert r.pexpire("bar", 5_000, nx: true)
+        refute r.pexpire("bar", 5_000, nx: true)
+        assert r.pexpire("bar", 5_000, xx: true)
+
+        r.pexpire("bar", 10_000)
+        refute r.pexpire("bar", 15_000, lt: true)
+        refute r.pexpire("bar", 5_000, gt: true)
+        assert r.pexpire("bar", 15_000, gt: true)
+        assert r.pexpire("bar", 5_000, lt: true)
+      end
     end
 
     def test_expireat
       r.set("foo", "s1")
       assert r.expireat("foo", (Time.now + 2).to_i)
       assert_in_range 0..2, r.ttl("foo")
+
+      target_version "7.0.0" do
+        r.set("bar", "s2")
+        refute r.expire_at("bar", (Time.now + 5).to_i, xx: true)
+        assert r.expire_at("bar", (Time.now + 5).to_i, nx: true)
+        refute r.expire_at("bar", (Time.now + 5).to_i, nx: true)
+        assert r.expire_at("bar", (Time.now + 5).to_i, xx: true)
+
+        r.expire_at("bar", 10)
+        refute r.expire_at("bar", (Time.now + 15).to_i, lt: true)
+        refute r.expire_at("bar", (Time.now + 5).to_i, gt: true)
+        assert r.expire_at("bar", (Time.now + 15).to_i, gt: true)
+        assert r.expire_at("bar", (Time.now + 5).to_i, lt: true)
+      end
     end
 
     def test_pexpireat
@@ -88,6 +130,20 @@ def test_pexpireat
         assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
         assert_in_range 0..2, r.ttl("foo")
       end
+
+      target_version "7.0.0" do
+        r.set("bar", "s2")
+        refute r.expire_at("bar", (Time.now + 5).to_i * 1_000, xx: true)
+        assert r.expire_at("bar", (Time.now + 5).to_i * 1_000, nx: true)
+        refute r.expire_at("bar", (Time.now + 5).to_i * 1_000, nx: true)
+        assert r.expire_at("bar", (Time.now + 5).to_i * 1_000, xx: true)
+
+        r.expire_at("bar", 10)
+        refute r.expire_at("bar", (Time.now + 15).to_i * 1_000, lt: true)
+        refute r.expire_at("bar", (Time.now + 5).to_i * 1_000, gt: true)
+        assert r.expire_at("bar", (Time.now + 15).to_i * 1_000, gt: true)
+        assert r.expire_at("bar", (Time.now + 5).to_i * 1_000, lt: true)
+      end
     end
 
     def test_persist