pgbus 0.23.1 → 0.23.2

data/app/models/pgbus/batch_entry.rb

@@ -38,19 +38,55 @@ module Pgbus
         .update_all(["total_jobs = GREATEST(total_jobs - 1, 0)"])
     end
 
+    # Resolve a batch member and count it, in one statement and no
+    # transaction (issue #650): delete the job's execution row and add one to
+    # +column+ on the batch that row belonged to, RETURNING the batch row.
+    # Returns that row as a BatchEntry, or nil when the job had no execution
+    # row (already resolved, or a pre-migration in-flight job) or its batch
+    # is gone. +column+ is interpolated, so only COUNTER_COLUMNS pass.
+    def self.count_and_resolve!(job_id, column)
+      raise ArgumentError, "Invalid column: #{column}" unless COUNTER_COLUMNS.include?(column)
+
+      sql = <<~SQL.squish
+        WITH gone AS (
+          DELETE FROM #{BatchExecution.table_name} WHERE job_id = $1 RETURNING batch_id
+        )
+        UPDATE #{table_name} b
+           SET #{column} = b.#{column} + 1
+          FROM gone
+         WHERE b.batch_id = gone.batch_id
+        RETURNING b.*
+      SQL
+      row = connection_pool.with_connection do |conn|
+        conn.exec_query(sql, "Pgbus Batch Count", [job_id]).first
+      end
+      row && instantiate(row)
+    end
+
     # Single-winner finish: status is processing AND no execution rows remain.
-    # Join-free NOT EXISTS so the subquery stays in this UPDATE's WHERE.
-    # Returns the number of rows updated (0 or 1).
+    # Join-free NOT EXISTS so the subquery stays in this UPDATE's WHERE (it
+    # was a NOT IN before issue #650; the same rows, batch_id is NOT NULL on
+    # pgbus_batch_executions). Returns the finished row as a BatchEntry
+    # (RETURNING *), or nil when this call did not finish the batch.
     def self.finish_if_empty!(batch_id)
       # Counters must already be terminal so a pre-migration in-flight batch
       # (zero execution rows, total_jobs = N, counters short of N) is not
       # closed empty. total_jobs = 0 with zero counters IS terminal: that is a
       # batch whose enqueue block crashed before it enqueued anything, and
       # nothing else will ever close it.
-      where(batch_id: batch_id, status: "processing")
-        .without_executions
-        .where("completed_jobs + failed_jobs = total_jobs")
-        .update_all(status: "finished", finished_at: Time.current)
+      sql = <<~SQL.squish
+        UPDATE #{table_name} SET status = 'finished', finished_at = $2
+         WHERE batch_id = $1 AND status = 'processing'
+           AND completed_jobs + failed_jobs = total_jobs
+           AND NOT EXISTS (
+             SELECT 1 FROM #{BatchExecution.table_name} e WHERE e.batch_id = #{table_name}.batch_id
+           )
+        RETURNING *
+      SQL
+      row = connection_pool.with_connection do |conn|
+        conn.exec_query(sql, "Pgbus Batch Finish", [batch_id, Time.current]).first
+      end
+      row && instantiate(row)
     end
 
     # Finish the batch if every job already reached a terminal state. Used
@@ -60,16 +96,19 @@ module Pgbus
     # idempotent against concurrent completion signals.
     # Returns { just_finished:, record: } or nil if batch not found.
     def self.check_finished!(batch_id)
-      return Batch.try_finish!(batch_id) if Batch.executions_migrated?
-
-      transaction do
-        record = lock.find_by(batch_id: batch_id)
-        return nil unless record
-        return { record: record, just_finished: false } if record.status == "finished"
-        return { record: record, just_finished: false } unless record.completed_jobs + record.discarded_jobs == record.total_jobs
-
-        record.update!(status: "finished", finished_at: Time.current)
-        { record: record, just_finished: true }
+      connection_pool.with_connection do
+        # The schema probe inside the lease: its first call reads the table list.
+        return Batch.try_finish!(batch_id) if Batch.executions_migrated?
+
+        transaction do
+          record = lock.find_by(batch_id: batch_id)
+          return nil unless record
+          return { record: record, just_finished: false } if record.status == "finished"
+          return { record: record, just_finished: false } unless record.completed_jobs + record.discarded_jobs == record.total_jobs
+
+          record.update!(status: "finished", finished_at: Time.current)
+          { record: record, just_finished: true }
+        end
       end
     end
 
@@ -80,23 +119,25 @@ module Pgbus
     def self.increment_counter!(batch_id, column)
       raise ArgumentError, "Invalid column: #{column}" unless COUNTER_COLUMNS.include?(column)
 
-      transaction do
-        record = lock.find_by(batch_id: batch_id)
-        return nil unless record
+      connection_pool.with_connection do
+        transaction do
+          record = lock.find_by(batch_id: batch_id)
+          return nil unless record
 
-        record.increment!(column)
+          record.increment!(column)
 
-        return { record: record, just_finished: false } if Batch.executions_migrated?
+          return { record: record, just_finished: false } if Batch.executions_migrated?
 
-        # total_jobs grows per job while the block is still open (issue #423),
-        # so completed == total can be momentarily true on a pending batch.
-        # Only a processing batch may auto-finish; check_finished! at the end
-        # of the block covers the pending case.
-        counters_match = record.completed_jobs + record.discarded_jobs == record.total_jobs
-        just_finished = counters_match && record.status == "processing"
-        record.update!(status: "finished", finished_at: Time.current) if just_finished
+          # total_jobs grows per job while the block is still open (issue #423),
+          # so completed == total can be momentarily true on a pending batch.
+          # Only a processing batch may auto-finish; check_finished! at the end
+          # of the block covers the pending case.
+          counters_match = record.completed_jobs + record.discarded_jobs == record.total_jobs
+          just_finished = counters_match && record.status == "processing"
+          record.update!(status: "finished", finished_at: Time.current) if just_finished
 
-        { record: record, just_finished: just_finished }
+          { record: record, just_finished: just_finished }
+        end
       end
     end
   end

data/app/models/pgbus/batch_execution.rb

@@ -13,12 +13,14 @@ module Pgbus
     # live message before the msg_id backfill lands); backfill! overwrites it
     # with the physical target after send.
     def self.insert_for!(batch_id:, job_id:, queue_name: nil)
-      connection.exec_query(
-        "INSERT INTO #{table_name} (batch_id, job_id, queue_name, created_at) " \
-        "VALUES ($1, $2, $3, $4) ON CONFLICT (job_id) DO NOTHING",
-        "BatchExecution Insert",
-        [batch_id, job_id, queue_name, Time.current]
-      )
+      connection_pool.with_connection do |conn|
+        conn.exec_query(
+          "INSERT INTO #{table_name} (batch_id, job_id, queue_name, created_at) " \
+          "VALUES ($1, $2, $3, $4) ON CONFLICT (job_id) DO NOTHING",
+          "BatchExecution Insert",
+          [batch_id, job_id, queue_name, Time.current]
+        )
+      end
     end
 
     def self.backfill!(job_id, msg_id:, queue_name:)

data/app/models/pgbus/blocked_execution.rb

@@ -10,21 +10,23 @@ module Pgbus
     # A parked job never ages out — `expires_at` orders the sweep, nothing more.
     # Returns { queue_name:, payload:, priority: } or nil.
     def self.release_next!(concurrency_key)
-      result = connection.exec_query(
-        <<~SQL,
-          DELETE FROM pgbus_blocked_executions
-          WHERE id = (
-            SELECT id FROM pgbus_blocked_executions
-            WHERE concurrency_key = $1
-            ORDER BY priority ASC, created_at ASC
-            LIMIT 1
-            FOR UPDATE SKIP LOCKED
-          )
-          RETURNING queue_name, payload, priority
-        SQL
-        "Pgbus Blocked Release",
-        [concurrency_key]
-      )
+      result = connection_pool.with_connection do |conn|
+        conn.exec_query(
+          <<~SQL,
+            DELETE FROM pgbus_blocked_executions
+            WHERE id = (
+              SELECT id FROM pgbus_blocked_executions
+              WHERE concurrency_key = $1
+              ORDER BY priority ASC, created_at ASC
+              LIMIT 1
+              FOR UPDATE SKIP LOCKED
+            )
+            RETURNING queue_name, payload, priority
+          SQL
+          "Pgbus Blocked Release",
+          [concurrency_key]
+        )
+      end
 
       row = result.first
       return nil unless row

data/app/models/pgbus/job_stat.rb

@@ -10,19 +10,22 @@ module Pgbus
     scope :dead_lettered, -> { where(status: "dead_lettered") }
 
     # Record a job execution stat. Called by the executor after each job.
+    # One lease for the probe and the insert, returned at the end (issue #649).
     def self.record!(job_class:, queue_name:, status:, duration_ms:, enqueue_latency_ms: nil, retry_count: 0)
-      return unless table_exists?
-
-      attrs = {
-        job_class: job_class,
-        queue_name: queue_name,
-        status: status,
-        duration_ms: duration_ms
-      }
-      attrs[:enqueue_latency_ms] = enqueue_latency_ms if latency_columns?
-      attrs[:retry_count] = retry_count if latency_columns?
-
-      create!(attrs)
+      connection_pool.with_connection do
+        next unless table_exists?
+
+        attrs = {
+          job_class: job_class,
+          queue_name: queue_name,
+          status: status,
+          duration_ms: duration_ms
+        }
+        attrs[:enqueue_latency_ms] = enqueue_latency_ms if latency_columns?
+        attrs[:retry_count] = retry_count if latency_columns?
+
+        create!(attrs)
+      end
     rescue StandardError => e
       Pgbus.logger.debug { "[Pgbus] Failed to record job stat: #{e.message}" }
     end
@@ -43,7 +46,7 @@ module Pgbus
     def self.table_exists?
       return @table_exists if defined?(@table_exists)
 
-      @table_exists = connection.table_exists?(table_name)
+      @table_exists = connection_pool.with_connection { |conn| conn.table_exists?(table_name) }
     rescue StandardError => e
       Pgbus.logger.debug { "[Pgbus] Failed to check job stat table: #{e.message}" }
       false

data/app/models/pgbus/semaphore.rb

@@ -13,20 +13,22 @@ module Pgbus
     # promotion is judged against the real limit rather than a guessed 1.
     # On a fresh row there is no recorded limit, so nil falls back to 1.
     def self.acquire!(key, max_value, expires_at)
-      result = connection.exec_query(
-        <<~SQL,
-          INSERT INTO pgbus_semaphores (key, value, max_value, expires_at)
-          VALUES ($1, 1, COALESCE($2, 1), $3)
-          ON CONFLICT (key) DO UPDATE
-            SET value = pgbus_semaphores.value + 1,
-                max_value = COALESCE($2, pgbus_semaphores.max_value),
-                expires_at = GREATEST(pgbus_semaphores.expires_at, EXCLUDED.expires_at)
-            WHERE pgbus_semaphores.value < COALESCE($2, pgbus_semaphores.max_value)
-          RETURNING value
-        SQL
-        "Pgbus Semaphore Acquire",
-        [key, max_value, expires_at]
-      )
+      result = connection_pool.with_connection do |conn|
+        conn.exec_query(
+          <<~SQL,
+            INSERT INTO pgbus_semaphores (key, value, max_value, expires_at)
+            VALUES ($1, 1, COALESCE($2, 1), $3)
+            ON CONFLICT (key) DO UPDATE
+              SET value = pgbus_semaphores.value + 1,
+                  max_value = COALESCE($2, pgbus_semaphores.max_value),
+                  expires_at = GREATEST(pgbus_semaphores.expires_at, EXCLUDED.expires_at)
+              WHERE pgbus_semaphores.value < COALESCE($2, pgbus_semaphores.max_value)
+            RETURNING value
+          SQL
+          "Pgbus Semaphore Acquire",
+          [key, max_value, expires_at]
+        )
+      end
 
       result.any? ? :acquired : :blocked
     end

data/app/models/pgbus/uniqueness_key.rb

@@ -21,11 +21,13 @@ module Pgbus
                     else
                       "DO NOTHING"
                     end
-      result = connection.exec_query(
-        "INSERT INTO #{table_name} (lock_key, queue_name, msg_id) " \
-        "VALUES ($1, $2, $3) ON CONFLICT (lock_key) #{on_conflict} RETURNING lock_key, created_at",
-        "UniquenessKey Acquire", [lock_key, queue_name, msg_id]
-      )
+      result = connection_pool.with_connection do |conn|
+        conn.exec_query(
+          "INSERT INTO #{table_name} (lock_key, queue_name, msg_id) " \
+          "VALUES ($1, $2, $3) ON CONFLICT (lock_key) #{on_conflict} RETURNING lock_key, created_at",
+          "UniquenessKey Acquire", [lock_key, queue_name, msg_id]
+        )
+      end
       row = result.rows.first
       return false unless row
 
@@ -52,7 +54,7 @@ module Pgbus
         sql += " AND created_at = $4"
         binds << created_at
       end
-      connection.exec_update(sql, "UniquenessKey Bind", binds)
+      connection_pool.with_connection { |conn| conn.exec_update(sql, "UniquenessKey Bind", binds) }
     end
 
     # Drop the bind ownership stamp without touching the lock row. Used when
@@ -65,10 +67,9 @@ module Pgbus
     # Release a uniqueness lock after job completion or DLQ.
     def self.release!(lock_key)
       Thread.current[:pgbus_uniqueness_created_at]&.delete(lock_key)
-      connection.exec_delete(
-        "DELETE FROM #{table_name} WHERE lock_key = $1",
-        "UniquenessKey Release", [lock_key]
-      )
+      connection_pool.with_connection do |conn|
+        conn.exec_delete("DELETE FROM #{table_name} WHERE lock_key = $1", "UniquenessKey Release", [lock_key])
+      end
     end
 
     # Release a lock only while it still points at this message. Used by the
@@ -81,10 +82,12 @@ module Pgbus
     # queue. The queue is part of the match.
     def self.release_if_bound!(lock_key, queue_name:, msg_id:)
       Thread.current[:pgbus_uniqueness_created_at]&.delete(lock_key)
-      connection.exec_delete(
-        "DELETE FROM #{table_name} WHERE lock_key = $1 AND queue_name = $2 AND msg_id = $3",
-        "UniquenessKey Release If Bound", [lock_key, queue_name.to_s, msg_id.to_i]
-      )
+      connection_pool.with_connection do |conn|
+        conn.exec_delete(
+          "DELETE FROM #{table_name} WHERE lock_key = $1 AND queue_name = $2 AND msg_id = $3",
+          "UniquenessKey Release If Bound", [lock_key, queue_name.to_s, msg_id.to_i]
+        )
+      end
     end
 
     # The row a message holds: bound to that message (queue + msg_id, see
@@ -109,10 +112,10 @@ module Pgbus
     # be a retry's it handed over), and the reaper takes an orphan.
     def self.release_held_by!(lock_key, queue_name:, msg_id:, enqueued_at:)
       Thread.current[:pgbus_uniqueness_created_at]&.delete(lock_key)
-      connection.exec_delete(
-        "DELETE FROM #{table_name} WHERE #{HELD_BY_CONDITION}",
-        "UniquenessKey Release Held By", held_by_binds(lock_key, queue_name, msg_id, sent_at_literal(enqueued_at))
-      )
+      binds = held_by_binds(lock_key, queue_name, msg_id, sent_at_literal(enqueued_at))
+      connection_pool.with_connection do |conn|
+        conn.exec_delete("DELETE FROM #{table_name} WHERE #{HELD_BY_CONDITION}", "UniquenessKey Release Held By", binds)
+      end
     end
 
     # Hand the running attempt's lock to its retry, which goes out through the
@@ -126,11 +129,13 @@ module Pgbus
     # attempt's enqueued_at only a row bound to it is taken.
     def self.unbind!(lock_key, from_queue_name:, from_msg_id:, from_enqueued_at:, queue_name:)
       binds = held_by_binds(lock_key, from_queue_name, from_msg_id, sent_at_literal(from_enqueued_at))
-      result = connection.exec_query(
-        "UPDATE #{table_name} SET queue_name = $5, msg_id = 0, created_at = CURRENT_TIMESTAMP " \
-        "WHERE #{HELD_BY_CONDITION} RETURNING created_at",
-        "UniquenessKey Unbind", binds + [queue_name.to_s]
-      )
+      result = connection_pool.with_connection do |conn|
+        conn.exec_query(
+          "UPDATE #{table_name} SET queue_name = $5, msg_id = 0, created_at = CURRENT_TIMESTAMP " \
+          "WHERE #{HELD_BY_CONDITION} RETURNING created_at",
+          "UniquenessKey Unbind", binds + [queue_name.to_s]
+        )
+      end
       result.rows.first&.first
     end
 
@@ -138,17 +143,21 @@ module Pgbus
     # discards and queue purges — as [lock_key, queue_name, msg_id,
     # enqueued_at] tuples, one statement per thousand.
     def self.release_all_held_by!(holders)
-      holders.each_slice(1000).sum do |slice|
-        values = slice.map do |lock_key, queue_name, msg_id, enqueued_at|
-          "(#{connection.quote(lock_key.to_s)}, #{connection.quote(queue_name.to_s)}, #{msg_id.to_i}, " \
-            "#{connection.quote(sent_at_literal(enqueued_at))}::timestamptz)"
+      return 0 if holders.empty?
+
+      connection_pool.with_connection do |conn|
+        holders.each_slice(1000).sum do |slice|
+          values = slice.map do |lock_key, queue_name, msg_id, enqueued_at|
+            "(#{conn.quote(lock_key.to_s)}, #{conn.quote(queue_name.to_s)}, #{msg_id.to_i}, " \
+              "#{conn.quote(sent_at_literal(enqueued_at))}::timestamptz)"
+          end
+          conn.exec_delete(
+            "DELETE FROM #{table_name} AS u USING (VALUES #{values.join(", ")}) AS m(lock_key, queue_name, msg_id, sent_at) " \
+            "WHERE u.lock_key = m.lock_key AND ((u.queue_name = m.queue_name AND u.msg_id = m.msg_id AND u.msg_id > 0) OR " \
+            "(u.msg_id <= 0 AND u.created_at <= m.sent_at))",
+            "UniquenessKey Release All Held By"
+          )
         end
-        connection.exec_delete(
-          "DELETE FROM #{table_name} AS u USING (VALUES #{values.join(", ")}) AS m(lock_key, queue_name, msg_id, sent_at) " \
-          "WHERE u.lock_key = m.lock_key AND ((u.queue_name = m.queue_name AND u.msg_id = m.msg_id AND u.msg_id > 0) OR " \
-          "(u.msg_id <= 0 AND u.created_at <= m.sent_at))",
-          "UniquenessKey Release All Held By"
-        )
       end
     end
 
@@ -185,10 +194,12 @@ module Pgbus
     # belong to it — pass the parked row's created_at as the ceiling.
     def self.release_if_unbound!(lock_key, acquired_before:)
       Thread.current[:pgbus_uniqueness_created_at]&.delete(lock_key)
-      connection.exec_delete(
-        "DELETE FROM #{table_name} WHERE lock_key = $1 AND msg_id = 0 AND created_at <= $2",
-        "UniquenessKey Release If Unbound", [lock_key, acquired_before]
-      )
+      connection_pool.with_connection do |conn|
+        conn.exec_delete(
+          "DELETE FROM #{table_name} WHERE lock_key = $1 AND msg_id = 0 AND created_at <= $2",
+          "UniquenessKey Release If Unbound", [lock_key, acquired_before]
+        )
+      end
     end
 
     # True when the key's row is bound to this message (queue + msg_id): its
@@ -196,18 +207,20 @@ module Pgbus
     # this when it dead-letters a :while_executing message that never failed
     # (issue #629): a crash loop, not a uniqueness conflict.
     def self.bound_to?(lock_key, queue_name:, msg_id:)
-      !connection.select_value(
-        "SELECT 1 FROM #{table_name} WHERE lock_key = $1 AND queue_name = $2 AND msg_id = $3 LIMIT 1",
-        "UniquenessKey Bound To", [lock_key, queue_name.to_s, msg_id.to_i]
-      ).nil?
+      row = connection_pool.with_connection do |conn|
+        conn.select_value(
+          "SELECT 1 FROM #{table_name} WHERE lock_key = $1 AND queue_name = $2 AND msg_id = $3 LIMIT 1",
+          "UniquenessKey Bound To", [lock_key, queue_name.to_s, msg_id.to_i]
+        )
+      end
+      !row.nil?
     end
 
     # Check if a key is currently locked.
     def self.locked?(lock_key)
-      result = connection.select_value(
-        "SELECT 1 FROM #{table_name} WHERE lock_key = $1 LIMIT 1",
-        "UniquenessKey Check", [lock_key]
-      )
+      result = connection_pool.with_connection do |conn|
+        conn.select_value("SELECT 1 FROM #{table_name} WHERE lock_key = $1 LIMIT 1", "UniquenessKey Check", [lock_key])
+      end
       !result.nil?
     end
   end

data/lib/pgbus/active_job/adapter.rb

@@ -88,11 +88,13 @@ module Pgbus
           # signalling right now waits and then sees the parked row instead
           # of stranding it (rails/solid_queue#712).
           acquired = false
-          Pgbus::Semaphore.transaction(requires_new: true) do
-            acquired = Concurrency::Semaphore.acquire(key, concurrency[:limit], slot_lease(concurrency, delay)) ==
-                       :acquired
-            blocked = handle_conflict(concurrency, active_job, key, queue, payload_hash, priority: priority) unless
-              acquired
+          Pgbus::Semaphore.connection_pool.with_connection do
+            Pgbus::Semaphore.transaction(requires_new: true) do
+              acquired = Concurrency::Semaphore.acquire(key, concurrency[:limit], slot_lease(concurrency, delay)) ==
+                         :acquired
+              blocked = handle_conflict(concurrency, active_job, key, queue, payload_hash, priority: priority) unless
+                acquired
+            end
           end
 
           if acquired

data/lib/pgbus/batch.rb

@@ -198,20 +198,26 @@ module Pgbus
     end
 
     # Record a completed job. Returns the batch row after update.
+    # One lease for the whole signal, returned at its end (issue #649): the
+    # executor calls this after the job's own lease went back.
     def self.job_completed(batch_id, job_id: nil)
-      if executions_migrated?
-        job_id ? resolve_execution(batch_id, job_id, "completed_jobs") : signal_without_row(batch_id, "completed_jobs")
-      else
-        update_counter(batch_id, "completed_jobs")
+      BatchEntry.connection_pool.with_connection do
+        if executions_migrated?
+          job_id ? resolve_execution(batch_id, job_id, "completed_jobs") : signal_without_row(batch_id, "completed_jobs")
+        else
+          update_counter(batch_id, "completed_jobs")
+        end
       end
     end
 
     # Record a discarded/dead-lettered job. Returns the batch row after update.
     def self.job_discarded(batch_id, job_id: nil)
-      if executions_migrated?
-        job_id ? resolve_execution(batch_id, job_id, "failed_jobs") : signal_without_row(batch_id, "failed_jobs")
-      else
-        update_counter(batch_id, "discarded_jobs")
+      BatchEntry.connection_pool.with_connection do
+        if executions_migrated?
+          job_id ? resolve_execution(batch_id, job_id, "failed_jobs") : signal_without_row(batch_id, "failed_jobs")
+        else
+          update_counter(batch_id, "discarded_jobs")
+        end
       end
     end
 
@@ -353,16 +359,20 @@ module Pgbus
       batch_id = payloads.first&.fetch(METADATA_KEY, nil)
       return if payloads.empty? || batch_id.nil?
 
-      migrated = executions_migrated?
-      BatchEntry.transaction do
-        BatchEntry.increment_total_jobs!(batch_id, payloads.size)
-        next unless migrated
+      BatchEntry.connection_pool.with_connection do
+        # The schema probe inside the lease: its first call reads the table
+        # list through the connection.
+        migrated = executions_migrated?
+        BatchEntry.transaction do
+          BatchEntry.increment_total_jobs!(batch_id, payloads.size)
+          next unless migrated
 
-        payloads.each do |payload|
-          job_id = payload["job_id"]
-          next unless job_id
+          payloads.each do |payload|
+            job_id = payload["job_id"]
+            next unless job_id
 
-          BatchExecution.insert_for!(batch_id: batch_id, job_id: job_id, queue_name: payload["queue_name"])
+            BatchExecution.insert_for!(batch_id: batch_id, job_id: job_id, queue_name: payload["queue_name"])
+          end
         end
       end
     end
@@ -417,10 +427,12 @@ module Pgbus
       return unless batch_id
 
       job_id = payload["job_id"]
-      migrated = executions_migrated?
-      BatchEntry.transaction do
-        BatchEntry.decrement_total_jobs!(batch_id)
-        BatchExecution.where(job_id: job_id).delete_all if migrated && job_id
+      BatchEntry.connection_pool.with_connection do
+        migrated = executions_migrated?
+        BatchEntry.transaction do
+          BatchEntry.decrement_total_jobs!(batch_id)
+          BatchExecution.where(job_id: job_id).delete_all if migrated && job_id
+        end
       end
     end
 
@@ -429,30 +441,40 @@ module Pgbus
       # Only batch members have an execution row: without this, every plain
       # enqueue paid a no-op UPDATE round trip after the send (issue #603).
       return unless payload[METADATA_KEY]
-      return unless executions_migrated?
 
       job_id = payload["job_id"]
       return unless job_id
 
-      BatchExecution.backfill!(job_id, msg_id: msg_id, queue_name: queue_name)
+      # The adapter calls this after its send, outside any lease of its own,
+      # so the schema probe stays fail-soft as it always was: a cold process
+      # that cannot get a connection skips the backfill rather than failing
+      # an enqueue whose message is already live.
+      return unless execution_rows_migrated_softly?
+
+      BatchExecution.connection_pool.with_connection do
+        BatchExecution.backfill!(job_id, msg_id: msg_id, queue_name: queue_name)
+      end
     end
 
     # Single-winner finish via execution-row absence. After a winning UPDATE,
     # re-check exists? in a fresh statement (Postgres READ COMMITTED can let a
     # blocked CAS win from a stale NOT EXISTS snapshot — solid_queue's finalize).
-    def self.try_finish!(batch_id)
-      result = BatchEntry.transaction do
-        updated = BatchEntry.finish_if_empty!(batch_id)
-        next { just_finished: false, record: BatchEntry.find_by(batch_id: batch_id) } unless updated.positive?
-
-        raise ActiveRecord::Rollback if BatchExecution.where(batch_id: batch_id).exists?
+    # The winner's record comes from the UPDATE's RETURNING; a loser hands back
+    # +record+ (the row a completion signal already holds, issue #650) and
+    # reads the row only when it has none (the sweep, check_finished!).
+    def self.try_finish!(batch_id, record: nil)
+      BatchEntry.connection_pool.with_connection do
+        result = BatchEntry.transaction do
+          finished = BatchEntry.finish_if_empty!(batch_id)
+          next { just_finished: false, record: record || BatchEntry.find_by(batch_id: batch_id) } unless finished
+
+          raise ActiveRecord::Rollback if BatchExecution.where(batch_id: batch_id).exists?
+
+          { just_finished: true, record: finished }
+        end
 
-        { just_finished: true, record: BatchEntry.find_by(batch_id: batch_id) }
+        result || { just_finished: false, record: record || BatchEntry.find_by(batch_id: batch_id) }
       end
-
-      return { just_finished: false, record: BatchEntry.find_by(batch_id: batch_id) } if result.nil?
-
-      result
     end
 
     def self.sweep_stalled(stalled_for: Pgbus.configuration.batch_stall_threshold, batch_size: 500, client: Pgbus.client)
@@ -462,11 +484,16 @@ module Pgbus
     class << self
       private
 
+      # Two statements and one short finish transaction per member (issue
+      # #650): count_and_resolve! deletes the execution row and counts it
+      # into the batch, RETURNING the row the finish and the callbacks use.
+      # No row back means the job had no execution row: an already-resolved
+      # signal, or a pre-migration in-flight batch counted the old way.
       def resolve_execution(batch_id, job_id, column)
-        BatchEntry.transaction do
-          deleted = BatchExecution.where(job_id: job_id).delete_all
-          BatchEntry.increment_counter!(batch_id, column) if deleted.positive? || legacy_untracked_batch?(batch_id)
-        end
+        record = BatchEntry.count_and_resolve!(job_id, column)
+        return finish_if_needed(try_finish!(record.batch_id, record: record)) if record
+
+        BatchEntry.increment_counter!(batch_id, column) if legacy_untracked_batch?(batch_id)
         finish_if_needed(try_finish!(batch_id))
       end
 
@@ -480,6 +507,18 @@ module Pgbus
         record && !counters_match_total?(record)
       end
 
+      # executions_migrated? with its first probe inside a lease it returns;
+      # false when no connection can be had (it already is false when the
+      # probe itself raises).
+      def execution_rows_migrated_softly?
+        # Memoized true: no lease for the probe, the backfill takes the one.
+        return true if @schema_lock.synchronize { @executions_migrated }
+
+        BatchExecution.connection_pool.with_connection { executions_migrated? }
+      rescue StandardError
+        false
+      end
+
       def counters_match_total?(record)
         failures = record.respond_to?(:discarded_jobs) ? record.discarded_jobs.to_i : record.failed_jobs.to_i
         record.total_jobs.positive? && (record.completed_jobs + failures) == record.total_jobs