Don't override ActiveRecord::QueryMethods#lock but create a different method

Depending on the load order, it might end up skipping the override and using the original
one, leading to slow queries using SELECT ... FOR UPDATE.

Author: rosa

app/models/solid_queue/blocked_execution.rb

@@ -24,7 +24,7 @@ def release_many(concurrency_keys)
 
       def release_one(concurrency_key)
         transaction do
-          ordered.where(concurrency_key: concurrency_key).limit(1).lock.each(&:release)
+          ordered.where(concurrency_key: concurrency_key).limit(1).non_blocking_lock.each(&:release)
         end
       end
 

app/models/solid_queue/process/prunable.rb

@@ -9,7 +9,7 @@ module SolidQueue::Process::Prunable
 
   class_methods do
     def prune
-      prunable.lock.find_in_batches(batch_size: 50) do |batch|
+      prunable.non_blocking_lock.find_in_batches(batch_size: 50) do |batch|
         batch.each do |process|
           SolidQueue.logger.info("[SolidQueue] Pruning dead process #{process.id} - #{process.metadata}")
           process.deregister

app/models/solid_queue/ready_execution.rb

@@ -26,7 +26,7 @@ def select_and_lock(queue_relation, process_id, limit)
         end
 
         def select_candidates(queue_relation, limit)
-          queue_relation.ordered.limit(limit).lock.pluck(:job_id)
+          queue_relation.ordered.limit(limit).non_blocking_lock.pluck(:job_id)
         end
 
         def lock_candidates(job_ids, process_id)

app/models/solid_queue/record.rb

@@ -6,11 +6,11 @@ class Record < ActiveRecord::Base
 
     connects_to **SolidQueue.connects_to if SolidQueue.connects_to
 
-    def self.lock(...)
+    def self.non_blocking_lock
       if SolidQueue.use_skip_locked
-        super(Arel.sql("FOR UPDATE SKIP LOCKED"))
+        lock(Arel.sql("FOR UPDATE SKIP LOCKED"))
       else
-        super
+        lock
       end
     end
   end

app/models/solid_queue/scheduled_execution.rb

@@ -11,7 +11,7 @@ class ScheduledExecution < Execution
     class << self
       def dispatch_next_batch(batch_size)
         transaction do
-          job_ids = next_batch(batch_size).lock.pluck(:job_id)
+          job_ids = next_batch(batch_size).non_blocking_lock.pluck(:job_id)
           if job_ids.empty? then []
           else
             dispatch_batch(job_ids)