with_advisory_lock 7.0.0 → 7.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2af1c67f9aa840ba30d4c1a280a74a02bd46e83cef6ee426a59e16d77afaf99f
-  data.tar.gz: 055c8a8f251605c01d91fb4ead5f5cd3ab31b4327ee1bdb2b5fbd7b24cd0e455
+  metadata.gz: 7a82d92e5b44f2cf65a9af5ac2d00baacab6d47b3b47be9fc2db82bd5677e4c7
+  data.tar.gz: 4a9b77cd24fad228812b9eff2f65079e6be7b95130a8e8d628d71525045ef902
 SHA512:
-  metadata.gz: 9ea47f0a89759ee4573b7c0bf7a481e48bf7e5e6feac6b132ee42a5441478bb0d02840f1e40d5963ebc5c5bc93af47a21e4f58337e33c42091d07160994a0821
-  data.tar.gz: b584c732c8fd97dd74cc6c92286d19ef9f79fbb9911a626c092c0197028cc99540f3af5dce34fbc9579fd1c01d207c7426e57b91c0928cbb4ff3620f62bd0995
+  metadata.gz: 77996aa445351903666828d916b8bd02ad4357496c2240ac847f937f7b3adff7af83993b10d6af8bcdb33825992dc6391cc211f97428c36b2bd102e65e5c26b2
+  data.tar.gz: 94ec70a26f7c336f9dba44a384bc16d9d680d7495e43cb0c9fc22fee2380317f5d5263f36d3998837ca21f3e05424c7fc0fdb37ed75daf441ce534f0b4d67339

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"7.0.0"}
+{".":"7.0.2"}

data/.tool-versions

@@ -1 +1 @@
-ruby 3.4.4
+ruby 3.4.6

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## Changelog
 
+## [7.0.2](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v7.0.1...with_advisory_lock/v7.0.2) (2025-09-20)
+
+
+### Bug Fixes
+
+* Replace connection.select_value with connection.query_value ([#131](https://github.com/ClosureTree/with_advisory_lock/issues/131)) ([dc01977](https://github.com/ClosureTree/with_advisory_lock/commit/dc01977e5e3a120843b19a5e6befd538c6e36516))
+
+## [7.0.1](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v7.0.0...with_advisory_lock/v7.0.1) (2025-07-21)
+
+
+### Bug Fixes
+
+* handle ActiveRecord's release_advisory_lock signature for Rails 7.2+ ([#127](https://github.com/ClosureTree/with_advisory_lock/issues/127)) ([94253ca](https://github.com/ClosureTree/with_advisory_lock/commit/94253ca2af7f684a3c99645765853546c3da8e02)), closes [#126](https://github.com/ClosureTree/with_advisory_lock/issues/126)
+
 ## [7.0.0](https://github.com/ClosureTree/with_advisory_lock/compare/with_advisory_lock/v6.0.0...with_advisory_lock/v7.0.0) (2025-07-05)
 
 

data/lib/with_advisory_lock/mysql_advisory.rb

@@ -25,8 +25,17 @@ module WithAdvisoryLock
       execute_successful?("GET_LOCK(#{quote(lock_keys.first)}, #{mysql_timeout})")
     end
 
-    def release_advisory_lock(lock_keys, lock_name:, **)
-      execute_successful?("RELEASE_LOCK(#{quote(lock_keys.first)})")
+    def release_advisory_lock(*args, **kwargs)
+      # Handle both signatures - ActiveRecord's built-in and ours
+      if args.length == 1 && kwargs.empty?
+        # ActiveRecord's signature: release_advisory_lock(lock_id)
+        # Called by Rails migrations with a single positional argument
+        super
+      else
+        # Our signature: release_advisory_lock(lock_keys, lock_name:, **)
+        lock_keys = args.first
+        execute_successful?("RELEASE_LOCK(#{quote(lock_keys.first)})")
+      end
     rescue ActiveRecord::StatementInvalid => e
       # If the connection is broken, the lock is automatically released by MySQL
       # No need to fail the release operation
@@ -56,7 +65,7 @@ module WithAdvisoryLock
     private
 
     def execute_successful?(mysql_function)
-      select_value("SELECT #{mysql_function}") == 1
+      query_value("SELECT #{mysql_function}") == 1
     end
   end
 end

data/lib/with_advisory_lock/postgresql_advisory.rb

@@ -71,7 +71,7 @@ module WithAdvisoryLock
         LIMIT 1
       SQL
 
-      select_value(query).present?
+      query_value(query).present?
     rescue ActiveRecord::StatementInvalid
       # If pg_locks is not accessible, fall back to nil to indicate we should use the default method
       nil
@@ -96,7 +96,7 @@ module WithAdvisoryLock
     end
 
     def execute_advisory(function, lock_keys, lock_name)
-      result = select_value(prepare_sql(function, lock_keys, lock_name))
+      result = query_value(prepare_sql(function, lock_keys, lock_name))
       LOCK_RESULT_VALUES.include?(result)
     end
 

data/lib/with_advisory_lock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WithAdvisoryLock
-  VERSION = Gem::Version.new('7.0.0')
+  VERSION = Gem::Version.new('7.0.2')
 end

data/test/with_advisory_lock/lock_test.rb

@@ -133,6 +133,25 @@ module LockTestCases
       # After the block, current_advisory_lock should be nil regardless
       assert_nil model_class.current_advisory_lock
     end
+
+    test 'does not write and read lock queries from the query cache' do
+      model_class.connection.cache do
+        model_class.with_advisory_lock!("lock", timeout_seconds: 0) {}
+        assert_nil model_class.connection.query_cache["SELECT GET_LOCK('lock', 0)"]
+
+        # Blocker thread uses a different connection
+        blocker = Thread.new do
+          model_class.with_advisory_lock("lock", timeout_seconds: 0) { sleep 1 }
+        end
+        # blocker should get the lock and not release it in time
+        sleep 0.5
+        lock_result = model_class.with_advisory_lock_result("lock", timeout_seconds: 0) do
+          raise "Successfully entered critical region while lock was held by other thread"
+        end
+        blocker.join
+        assert_not(lock_result.lock_was_acquired?)
+      end
+    end
   end
 end
 
@@ -177,7 +196,7 @@ class MySQLLockTest < GemTestCase
     # Hold a lock in another connection - need to use the same prefixed name as the gem
     other_conn = model_class.connection_pool.checkout
     lock_keys = other_conn.lock_keys_for(lock_name)
-    other_conn.select_value("SELECT GET_LOCK(#{other_conn.quote(lock_keys.first)}, 0)")
+    other_conn.query_value("SELECT GET_LOCK(#{other_conn.quote(lock_keys.first)}, 0)")
 
     begin
       # Attempt to acquire with a short timeout - should fail quickly
@@ -190,7 +209,7 @@ class MySQLLockTest < GemTestCase
       assert_not result
       assert elapsed < 3.0, "Expected quick timeout, but took #{elapsed} seconds"
     ensure
-      other_conn.select_value("SELECT RELEASE_LOCK(#{other_conn.quote(lock_keys.first)})")
+      other_conn.query_value("SELECT RELEASE_LOCK(#{other_conn.quote(lock_keys.first)})")
       model_class.connection_pool.checkin(other_conn)
     end
   end

data/test/with_advisory_lock/mysql_release_lock_test.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class MySQLReleaseLockTest < GemTestCase
+  self.use_transactional_tests = false
+
+  def model_class
+    MysqlTag
+  end
+
+  def setup
+    super
+    begin
+      skip unless model_class.connection.adapter_name =~ /mysql/i
+      MysqlTag.delete_all
+    rescue ActiveRecord::NoDatabaseError
+      skip "MySQL database not available. Please create the database first."
+    rescue StandardError => e
+      skip "MySQL connection failed: #{e.message}"
+    end
+  end
+
+  test 'release_advisory_lock handles gem signature with lock_keys' do
+    lock_name = 'test_gem_signature'
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+
+    # Acquire the lock
+    result = model_class.connection.try_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert result, 'Failed to acquire lock'
+
+    # Release using gem signature
+    released = model_class.connection.release_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert released, 'Failed to release lock using gem signature'
+
+    # Verify lock is released by trying to acquire it again
+    result = model_class.connection.try_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert result, 'Lock was not properly released'
+
+    # Clean up
+    model_class.connection.release_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+  end
+
+  test 'release_advisory_lock handles ActiveRecord signature' do
+    # Rails calls release_advisory_lock with a positional argument (lock_id)
+    # This test ensures our override doesn't break Rails' migration locking
+
+    lock_name = 'test_rails_signature'
+
+    # Acquire lock using SQL (ActiveRecord doesn't provide get_advisory_lock method)
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+    result = model_class.connection.query_value("SELECT GET_LOCK(#{model_class.connection.quote(lock_keys.first)}, 0)")
+    assert_equal 1, result, 'Failed to acquire lock using SQL'
+
+    # Release using ActiveRecord signature (positional argument, as Rails does)
+    released = model_class.connection.release_advisory_lock(lock_keys.first)
+    assert released, 'Failed to release lock using ActiveRecord signature'
+
+    # Verify lock is released
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+    result = model_class.connection.query_value("SELECT GET_LOCK(#{model_class.connection.quote(lock_keys.first)}, 0)")
+    assert_equal 1, result, 'Lock was not properly released'
+
+    # Clean up
+    model_class.connection.query_value("SELECT RELEASE_LOCK(#{model_class.connection.quote(lock_keys.first)})")
+  end
+
+  test 'release_advisory_lock handles connection errors gracefully' do
+    lock_name = 'test_connection_error'
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+
+    # Acquire the lock
+    result = model_class.connection.try_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert result, 'Failed to acquire lock'
+
+    # Simulate connection error handling
+    # The method should handle various connection error types without raising
+    begin
+      # Try to release - even if we can't simulate a real connection error,
+      # the code path exists and should work
+      model_class.connection.release_advisory_lock(
+        lock_keys,
+        lock_name: lock_name,
+        shared: false,
+        transaction: false
+      )
+    rescue StandardError => e
+      # Should not raise connection-related errors
+      refute_match(/Lost connection|MySQL server has gone away|Connection refused/i, e.message)
+      raise
+    end
+  end
+end

data/test/with_advisory_lock/transaction_test.rb

@@ -7,8 +7,8 @@ class PostgreSQLTransactionScopingTest < GemTestCase
 
   setup do
     @pg_lock_count = lambda do
-      backend_pid = Tag.connection.select_value('SELECT pg_backend_pid()')
-      Tag.connection.select_value("SELECT COUNT(*) FROM pg_locks WHERE locktype = 'advisory' AND pid = #{backend_pid};").to_i
+      backend_pid = Tag.connection.query_value('SELECT pg_backend_pid()')
+      Tag.connection.query_value("SELECT COUNT(*) FROM pg_locks WHERE locktype = 'advisory' AND pid = #{backend_pid};").to_i
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.0.2
 platform: ruby
 authors:
 - Matthew McEachen
@@ -157,6 +157,7 @@ files:
 - test/with_advisory_lock/concern_test.rb
 - test/with_advisory_lock/lock_test.rb
 - test/with_advisory_lock/multi_adapter_test.rb
+- test/with_advisory_lock/mysql_release_lock_test.rb
 - test/with_advisory_lock/parallelism_test.rb
 - test/with_advisory_lock/postgresql_race_condition_test.rb
 - test/with_advisory_lock/shared_test.rb