inst-jobs 2.2.1 → 2.4.0

data/db/migrate/20210809145804_add_n_strand_index.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddNStrandIndex < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def change
+    add_index :delayed_jobs, %i[strand next_in_strand id],
+              name: "n_strand_index",
+              where: "strand IS NOT NULL",
+              algorithm: :concurrently
+  end
+end

data/db/migrate/20210812210128_add_singleton_column.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+class AddSingletonColumn < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def change
+    add_column :delayed_jobs, :singleton, :string, if_not_exists: true
+    add_column :failed_jobs, :singleton, :string, if_not_exists: true
+    # only one job can be queued in a singleton
+    add_index :delayed_jobs,
+              :singleton,
+              where: "singleton IS NOT NULL AND locked_by IS NULL",
+              unique: true,
+              name: "index_delayed_jobs_on_singleton_not_running",
+              algorithm: :concurrently
+    # only one job can be running for a singleton
+    add_index :delayed_jobs,
+              :singleton,
+              where: "singleton IS NOT NULL AND locked_by IS NOT NULL",
+              unique: true,
+              name: "index_delayed_jobs_on_singleton_running",
+              algorithm: :concurrently
+
+    reversible do |direction|
+      direction.up do
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+          DECLARE
+            running_count integer;
+            should_lock boolean;
+            should_be_precise boolean;
+            update_query varchar;
+            skip_locked varchar;
+          BEGIN
+            IF OLD.strand IS NOT NULL THEN
+              should_lock := true;
+              should_be_precise := OLD.id % (OLD.max_concurrent * 4) = 0;
+
+              IF NOT should_be_precise AND OLD.max_concurrent > 16 THEN
+                running_count := (SELECT COUNT(*) FROM (
+                  SELECT 1 as one FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+                ) subquery_for_count);
+                should_lock := running_count < OLD.max_concurrent;
+              END IF;
+
+              IF should_lock THEN
+                PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+              END IF;
+
+              -- note that we don't really care if the row we're deleting has a singleton, or if it even
+              -- matches the row(s) we're going to update. we just need to make sure that whatever
+              -- singleton we grab isn't already running (which is a simple existence check, since
+              -- the unique indexes ensure there is at most one singleton running, and one queued)
+              update_query := 'UPDATE delayed_jobs SET next_in_strand=true WHERE id IN (
+                SELECT id FROM delayed_jobs j2
+                  WHERE next_in_strand=false AND
+                    j2.strand=$1.strand AND
+                    (j2.singleton IS NULL OR NOT EXISTS (SELECT 1 FROM delayed_jobs j3 WHERE j3.singleton=j2.singleton AND j3.id<>j2.id))
+                  ORDER BY j2.strand_order_override ASC, j2.id ASC
+                  LIMIT ';
+
+              IF should_be_precise THEN
+                running_count := (SELECT COUNT(*) FROM (
+                  SELECT 1 FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+                ) s);
+                IF running_count < OLD.max_concurrent THEN
+                  update_query := update_query || '($1.max_concurrent - $2)';
+                ELSE
+                  -- we have too many running already; just bail
+                  RETURN OLD;
+                END IF;
+              ELSE
+                update_query := update_query || '1';
+
+                -- n-strands don't require precise ordering; we can make this query more performant
+                IF OLD.max_concurrent > 1 THEN
+                  skip_locked := ' SKIP LOCKED';
+                END IF;
+              END IF;
+
+              update_query := update_query || ' FOR UPDATE' || COALESCE(skip_locked, '') || ')';
+              EXECUTE update_query USING OLD, running_count;
+            ELSIF OLD.singleton IS NOT NULL THEN
+              UPDATE delayed_jobs SET next_in_strand = 't' WHERE singleton=OLD.singleton AND next_in_strand=false;
+            END IF;
+            RETURN OLD;
+          END;
+          $$ LANGUAGE plpgsql;
+        SQL
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
+          BEGIN
+            RAISE NOTICE 'inserting job';
+            IF NEW.strand IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+              IF (SELECT COUNT(*) FROM (
+                  SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand AND next_in_strand=true LIMIT NEW.max_concurrent
+                ) s) = NEW.max_concurrent THEN
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            IF NEW.singleton IS NOT NULL THEN
+              RAISE NOTICE 'inserting job that is a singleton';
+              PERFORM 1 FROM delayed_jobs WHERE singleton = NEW.singleton;
+              IF FOUND THEN
+                RAISE NOTICE 'and not first';
+                NEW.next_in_strand := false;
+              END IF;
+            END IF;
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql;
+        SQL
+      end
+      direction.down do
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+          DECLARE
+            running_count integer;
+            should_lock boolean;
+            should_be_precise boolean;
+          BEGIN
+            IF OLD.strand IS NOT NULL THEN
+              should_lock := true;
+              should_be_precise := OLD.id % (OLD.max_concurrent * 4) = 0;
+
+              IF NOT should_be_precise AND OLD.max_concurrent > 16 THEN
+                running_count := (SELECT COUNT(*) FROM (
+                  SELECT 1 as one FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+                ) subquery_for_count);
+                should_lock := running_count < OLD.max_concurrent;
+              END IF;
+
+              IF should_lock THEN
+                PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+              END IF;
+
+              IF should_be_precise THEN
+                running_count := (SELECT COUNT(*) FROM (
+                  SELECT 1 as one FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't' LIMIT OLD.max_concurrent
+                ) subquery_for_count);
+                IF running_count < OLD.max_concurrent THEN
+                  UPDATE delayed_jobs SET next_in_strand = 't' WHERE id IN (
+                    SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                    j2.strand = OLD.strand ORDER BY j2.strand_order_override ASC, j2.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+                  );
+                END IF;
+              ELSE
+                -- n-strands don't require precise ordering; we can make this query more performant
+                IF OLD.max_concurrent > 1 THEN
+                  UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                  (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                    j2.strand = OLD.strand ORDER BY j2.strand_order_override ASC, j2.id ASC LIMIT 1 FOR UPDATE SKIP LOCKED);
+                ELSE
+                  UPDATE delayed_jobs SET next_in_strand = 't' WHERE id =
+                    (SELECT id FROM delayed_jobs j2 WHERE next_in_strand = 'f' AND
+                      j2.strand = OLD.strand ORDER BY j2.strand_order_override ASC, j2.id ASC LIMIT 1 FOR UPDATE);
+                END IF;
+              END IF;
+            END IF;
+            RETURN OLD;
+          END;
+          $$ LANGUAGE plpgsql;
+        SQL
+        execute(<<~SQL)
+          CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
+          BEGIN
+            IF NEW.strand IS NOT NULL THEN
+              PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+              IF (SELECT COUNT(*) FROM (
+                  SELECT 1 AS one FROM delayed_jobs WHERE strand = NEW.strand LIMIT NEW.max_concurrent
+                ) subquery_for_count) = NEW.max_concurrent THEN
+                NEW.next_in_strand := 'f';
+              END IF;
+            END IF;
+            RETURN NEW;
+          END;
+          $$ LANGUAGE plpgsql;
+        SQL
+      end
+    end
+
+    connection.transaction do
+      reversible do |direction|
+        direction.up do
+          drop_triggers
+          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON delayed_jobs FOR EACH ROW WHEN (NEW.strand IS NOT NULL OR NEW.singleton IS NOT NULL) EXECUTE PROCEDURE delayed_jobs_before_insert_row_tr_fn()")
+          execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON delayed_jobs FOR EACH ROW WHEN ((OLD.strand IS NOT NULL OR OLD.singleton IS NOT NULL) AND OLD.next_in_strand=true) EXECUTE PROCEDURE delayed_jobs_after_delete_row_tr_fn()")
+        end
+        direction.down do
+          drop_triggers
+          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON delayed_jobs FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE delayed_jobs_before_insert_row_tr_fn()")
+          execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON delayed_jobs FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE delayed_jobs_after_delete_row_tr_fn()")
+        end
+      end
+    end
+  end
+
+  def drop_triggers
+    execute("DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs")
+    execute("DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs")
+  end
+end

data/exe/inst_jobs

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require File.expand_path('config/environment')
-Delayed::CLI.new.run()
+require_relative "config/environment"
+Delayed::CLI.new.run

data/lib/delayed/backend/active_record.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-class ActiveRecord::Base
-  def self.load_for_delayed_job(id)
-    if id
-      find(id)
-    else
-      super
+module ActiveRecord
+  class Base
+    def self.load_for_delayed_job(id)
+      if id
+        find(id)
+      else
+        super
+      end
     end
   end
 end
@@ -13,9 +15,13 @@ end
 module Delayed
   module Backend
     module ActiveRecord
+      class AbstractJob < ::ActiveRecord::Base
+        self.abstract_class = true
+      end
+
       # A job object that is persisted to the database.
       # Contains the work object as a YAML field.
-      class Job < ::ActiveRecord::Base
+      class Job < AbstractJob
         include Delayed::Backend::Base
         self.table_name = :delayed_jobs
 
@@ -27,17 +33,15 @@ module Delayed
 
         class << self
           def create(attributes, &block)
-            return super if connection.prepared_statements || Rails.version < '5.2'
-
+            on_conflict = attributes.delete(:on_conflict)
             # modified from ActiveRecord::Persistence.create and ActiveRecord::Persistence#_insert_record
             job = new(attributes, &block)
-            job.single_step_create
+            job.single_step_create(on_conflict: on_conflict)
           end
         end
 
-        def single_step_create
+        def single_step_create(on_conflict: nil)
           connection = self.class.connection
-          return save if connection.prepared_statements || Rails.version < '5.2'
 
           # a before_save callback that we're skipping
           initialize_defaults
@@ -45,12 +49,10 @@ module Delayed
           current_time = current_time_from_proper_timezone
 
           all_timestamp_attributes_in_model.each do |column|
-            if !attribute_present?(column)
-              _write_attribute(column, current_time)
-            end
+            _write_attribute(column, current_time) unless attribute_present?(column)
           end
 
-          if Rails.version >= '6'
+          if Rails.version >= "6"
             attribute_names = attribute_names_for_partial_writes
             attribute_names = attributes_for_create(attribute_names)
             values = attributes_with_values(attribute_names)
@@ -58,20 +60,57 @@ module Delayed
             attribute_names = partial_writes? ? keys_for_partial_write : self.attribute_names
             values = attributes_with_values_for_create(attribute_names)
           end
+
           im = self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
-          sql, _binds = connection.send(:to_sql_and_binds, im, [])
+
+          lock_and_insert = values["strand"] && instance_of?(Job)
+          # can't use prepared statements if we're combining multiple statemenets
+          sql, binds = if lock_and_insert
+                         connection.unprepared_statement do
+                           connection.send(:to_sql_and_binds, im)
+                         end
+                       else
+                         connection.send(:to_sql_and_binds, im)
+                       end
+          sql = +sql
+
+          if singleton && instance_of?(Job)
+            sql << " ON CONFLICT (singleton) WHERE singleton IS NOT NULL AND locked_by IS NULL DO "
+            sql << case on_conflict
+                   when :patient, :loose
+                     "NOTHING"
+                   when :overwrite
+                     "UPDATE SET run_at=EXCLUDED.run_at, handler=EXCLUDED.handler"
+                   else # :use_earliest
+                     "UPDATE SET run_at=EXCLUDED.run_at WHERE EXCLUDED.run_at<delayed_jobs.run_at"
+                   end
+          end
 
           # https://www.postgresql.org/docs/9.5/libpq-exec.html
-          sql = "#{sql} RETURNING id"
-          # > Multiple queries sent in a single PQexec call are processed in a single transaction,
-          # unless there are explicit BEGIN/COMMIT commands included in the query string to divide
-          # it into multiple transactions.
-          sql = "SELECT pg_advisory_xact_lock(#{connection.quote_table_name('half_md5_as_bigint')}(#{connection.quote(values['strand'])})); #{sql}" if values["strand"]
-          result = connection.execute(sql, "#{self} Create")
-          self.id = result.values.first.first
-          result.clear
-          @new_record = false
-          changes_applied
+          sql << " RETURNING id"
+
+          if lock_and_insert
+            # > Multiple queries sent in a single PQexec call are processed in a single transaction,
+            # unless there are explicit BEGIN/COMMIT commands included in the query string to divide
+            # it into multiple transactions.
+            # but we don't need to lock when inserting into Delayed::Failed
+            if values["strand"] && instance_of?(Job)
+              fn_name = connection.quote_table_name("half_md5_as_bigint")
+              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{connection.quote(values['strand'])})); #{sql}"
+            end
+            result = connection.execute(sql, "#{self} Create")
+            self.id = result.values.first.first
+            result.clear
+          else
+            result = connection.exec_query(sql, "#{self} Create", binds)
+            self.id = connection.send(:last_inserted_id, result)
+          end
+
+          # it might not get set if there was an existing record, and we didn't update it
+          if id
+            @new_record = false
+            changes_applied
+          end
 
           self
         end
@@ -98,9 +137,11 @@ module Delayed
         # to raise the lock level
         before_create :lock_strand_on_create
         def lock_strand_on_create
-          if strand.present?
-            self.class.connection.execute("SELECT pg_advisory_xact_lock(#{self.class.connection.quote_table_name('half_md5_as_bigint')}(#{self.class.connection.quote(strand)}))")
-          end
+          return unless strand.present? && instance_of?(Job)
+
+          fn_name = self.class.connection.quote_table_name("half_md5_as_bigint")
+          quoted_strand_name = self.class.connection.quote(strand)
+          self.class.connection.execute("SELECT pg_advisory_xact_lock(#{fn_name}(#{quoted_strand_name}))")
         end
 
         # This overwrites the previous behavior
@@ -119,7 +160,7 @@ module Delayed
         end
 
         def self.failed
-          where("failed_at IS NOT NULL")
+          where.not(failed_at: nil)
         end
 
         def self.running
@@ -127,51 +168,54 @@ module Delayed
         end
 
         # a nice stress test:
-        # 10_000.times { |i| Kernel.delay(strand: 's1', run_at: (24.hours.ago + (rand(24.hours.to_i))).system("echo #{i} >> test1.txt") }
+        # 10_000.times do |i|
+        #   Kernel.delay(strand: 's1', run_at: (24.hours.ago + (rand(24.hours.to_i))).system("echo #{i} >> test1.txt")
+        # end
         # 500.times { |i| "ohai".delay(run_at: (12.hours.ago + (rand(24.hours.to_i))).reverse }
         # then fire up your workers
         # you can check out strand correctness: diff test1.txt <(sort -n test1.txt)
-         def self.ready_to_run(forced_latency: nil)
-           now = db_time_now
-           now -= forced_latency if forced_latency
-           where("run_at<=? AND locked_at IS NULL AND next_in_strand=?", now, true)
-         end
+        def self.ready_to_run(forced_latency: nil)
+          now = db_time_now
+          now -= forced_latency if forced_latency
+          where("run_at<=? AND locked_at IS NULL AND next_in_strand=?", now, true)
+        end
+
         def self.by_priority
           order(:priority, :run_at, :id)
         end
 
         # When a worker is exiting, make sure we don't have any locked jobs.
         def self.clear_locks!(worker_name)
-          where(:locked_by => worker_name).update_all(:locked_by => nil, :locked_at => nil)
+          where(locked_by: worker_name).update_all(locked_by: nil, locked_at: nil)
         end
 
         def self.strand_size(strand)
-          self.where(:strand => strand).count
+          where(strand: strand).count
         end
 
-        def self.running_jobs()
-          self.running.order(:locked_at)
+        def self.running_jobs
+          running.order(:locked_at)
         end
 
         def self.scope_for_flavor(flavor, query)
           scope = case flavor.to_s
-          when 'current'
-            self.current
-          when 'future'
-            self.future
-          when 'failed'
-            Delayed::Job::Failed
-          when 'strand'
-            self.where(:strand => query)
-          when 'tag'
-            self.where(:tag => query)
-          else
-            raise ArgumentError, "invalid flavor: #{flavor.inspect}"
-          end
-
-          if %w(current future).include?(flavor.to_s)
+                  when "current"
+                    current
+                  when "future"
+                    future
+                  when "failed"
+                    Delayed::Job::Failed
+                  when "strand"
+                    where(strand: query)
+                  when "tag"
+                    where(tag: query)
+                  else
+                    raise ArgumentError, "invalid flavor: #{flavor.inspect}"
+                  end
+
+          if %w[current future].include?(flavor.to_s)
             queue = query.presence || Delayed::Settings.queue
-            scope = scope.where(:queue => queue)
+            scope = scope.where(queue: queue)
           end
 
           scope
@@ -188,8 +232,8 @@ module Delayed
                            limit,
                            offset = 0,
                            query = nil)
-          scope = self.scope_for_flavor(flavor, query)
-          order = flavor.to_s == 'future' ? 'run_at' : 'id desc'
+          scope = scope_for_flavor(flavor, query)
+          order = flavor.to_s == "future" ? "run_at" : "id desc"
           scope.order(order).limit(limit).offset(offset).to_a
         end
 
@@ -197,7 +241,7 @@ module Delayed
         # see list_jobs for documentation on arguments
         def self.jobs_count(flavor,
                             query = nil)
-          scope = self.scope_for_flavor(flavor, query)
+          scope = scope_for_flavor(flavor, query)
           scope.count
         end
 
@@ -206,30 +250,33 @@ module Delayed
         # to specify the jobs to act on, either pass opts[:ids] = [list of job ids]
         # or opts[:flavor] = <some flavor> to perform on all jobs of that flavor
         def self.bulk_update(action, opts)
-          raise("Can't #{action.to_s} failed jobs") if opts[:flavor].to_s == 'failed' && action.to_s != 'destroy'
+          raise("Can't #{action} failed jobs") if opts[:flavor].to_s == "failed" && action.to_s != "destroy"
+
           scope = if opts[:ids]
-            if opts[:flavor] == 'failed'
-              Delayed::Job::Failed.where(:id => opts[:ids])
-            else
-              self.where(:id => opts[:ids])
-            end
-          elsif opts[:flavor]
+                    if opts[:flavor] == "failed"
+                      Delayed::Job::Failed.where(id: opts[:ids])
+                    else
+                      where(id: opts[:ids])
+                    end
+                  elsif opts[:flavor]
 
-            self.scope_for_flavor(opts[:flavor], opts[:query])
-          end
+                    scope_for_flavor(opts[:flavor], opts[:query])
+                  end
 
           return 0 unless scope
 
           case action.to_s
-          when 'hold'
+          when "hold"
             scope = scope.where(locked_by: nil)
-            scope.update_all(:locked_by => ON_HOLD_LOCKED_BY, :locked_at => db_time_now, :attempts => ON_HOLD_COUNT)
-          when 'unhold'
+            scope.update_all(locked_by: ON_HOLD_LOCKED_BY, locked_at: db_time_now, attempts: ON_HOLD_COUNT)
+          when "unhold"
             now = db_time_now
             scope = scope.where(locked_by: ON_HOLD_LOCKED_BY)
-            scope.update_all(["locked_by = NULL, locked_at = NULL, attempts = 0, run_at = (CASE WHEN run_at > ? THEN run_at ELSE ? END), failed_at = NULL", now, now])
-          when 'destroy'
-            scope = scope.where("locked_by IS NULL OR locked_by=?", ON_HOLD_LOCKED_BY) unless opts[:flavor] == 'failed'
+            scope.update_all([<<~SQL.squish, now, now])
+              locked_by=NULL, locked_at=NULL, attempts=0, run_at=(CASE WHEN run_at > ? THEN run_at ELSE ? END), failed_at=NULL
+            SQL
+          when "destroy"
+            scope = scope.where("locked_by IS NULL OR locked_by=?", ON_HOLD_LOCKED_BY) unless opts[:flavor] == "failed"
             scope.delete_all
           end
         end
@@ -240,16 +287,17 @@ module Delayed
         def self.tag_counts(flavor,
                             limit,
                             offset = 0)
-          raise(ArgumentError, "invalid flavor: #{flavor}") unless %w(current all).include?(flavor.to_s)
+          raise(ArgumentError, "invalid flavor: #{flavor}") unless %w[current all].include?(flavor.to_s)
+
           scope = case flavor.to_s
-            when 'current'
-              self.current
-            when 'all'
-              self
-            end
+                  when "current"
+                    current
+                  when "all"
+                    self
+                  end
 
           scope = scope.group(:tag).offset(offset).limit(limit)
-          scope.order(Arel.sql("COUNT(tag) DESC")).count.map { |t,c| { :tag => t, :count => c } }
+          scope.order(Arel.sql("COUNT(tag) DESC")).count.map { |t, c| { tag: t, count: c } }
         end
 
         def self.maybe_silence_periodic_log(&block)
@@ -273,7 +321,7 @@ module Delayed
 
           loop do
             jobs = maybe_silence_periodic_log do
-              if connection.adapter_name == 'PostgreSQL' && !Settings.select_random_from_batch
+              if connection.adapter_name == "PostgreSQL" && !Settings.select_random_from_batch
                 # In Postgres, we can lock a job and return which row was locked in a single
                 # query by using RETURNING. Combine that with the ROW_NUMBER() window function
                 # to assign a distinct locked_at value to each job locked, when doing multiple
@@ -281,22 +329,20 @@ module Delayed
                 effective_worker_names = Array(worker_names)
 
                 lock = nil
-                lock = "FOR UPDATE SKIP LOCKED" if connection.postgresql_version >= 90500
+                lock = "FOR UPDATE SKIP LOCKED" if connection.postgresql_version >= 90_500
                 target_jobs = all_available(queue,
                                             min_priority,
                                             max_priority,
-                                            forced_latency: forced_latency).
-                    limit(effective_worker_names.length + prefetch).
-                    lock(lock)
-                jobs_with_row_number = all.from(target_jobs).
-                    select("id, ROW_NUMBER() OVER () AS row_number")
+                                            forced_latency: forced_latency)
+                              .limit(effective_worker_names.length + prefetch)
+                              .lock(lock)
+                jobs_with_row_number = all.from(target_jobs)
+                                          .select("id, ROW_NUMBER() OVER () AS row_number")
                 updates = +"locked_by = CASE row_number "
                 effective_worker_names.each_with_index do |worker, i|
                   updates << "WHEN #{i + 1} THEN #{connection.quote(worker)} "
                 end
-                if prefetch_owner
-                  updates << "ELSE #{connection.quote(prefetch_owner)} "
-                end
+                updates << "ELSE #{connection.quote(prefetch_owner)} " if prefetch_owner
                 updates << "END, locked_at = #{connection.quote(db_time_now)}"
 
                 # Originally this was done with a subquery, but this allows the query planner to
@@ -306,22 +352,22 @@ module Delayed
                 # For more details, see:
                 #  * https://dba.stackexchange.com/a/69497/55285
                 #  * https://github.com/feikesteenbergen/demos/blob/b7ecee8b2a79bf04cbcd74972e6bfb81903aee5d/bugs/update_limit_bug.txt
-                query = "WITH limited_jobs AS (#{jobs_with_row_number.to_sql}) " \
-                        "UPDATE #{quoted_table_name} SET #{updates} FROM limited_jobs WHERE limited_jobs.id=#{quoted_table_name}.id " \
-                        "RETURNING #{quoted_table_name}.*"
+                query = <<~SQL.squish
+                  WITH limited_jobs AS (#{jobs_with_row_number.to_sql})
+                  UPDATE #{quoted_table_name} SET #{updates} FROM limited_jobs WHERE limited_jobs.id=#{quoted_table_name}.id
+                  RETURNING #{quoted_table_name}.*
+                SQL
 
                 jobs = find_by_sql(query)
                 # because this is an atomic query, we don't have to return more jobs than we needed
                 # to try and lock them, nor is there a possibility we need to try again because
                 # all of the jobs we tried to lock had already been locked by someone else
-                if worker_names.is_a?(Array)
-                  result = jobs.index_by(&:locked_by)
-                  # all of the prefetched jobs can come back as an array
-                  result[prefetch_owner] = jobs.select { |j| j.locked_by == prefetch_owner } if prefetch_owner
-                  return result
-                else
-                  return jobs.first
-                end
+                return jobs.first unless worker_names.is_a?(Array)
+
+                result = jobs.index_by(&:locked_by)
+                # all of the prefetched jobs can come back as an array
+                result[prefetch_owner] = jobs.select { |j| j.locked_by == prefetch_owner } if prefetch_owner
+                return result
               else
                 batch_size = Settings.fetch_batch_size
                 batch_size *= worker_names.length if worker_names.is_a?(Array)
@@ -331,13 +377,13 @@ module Delayed
             if jobs.empty?
               return worker_names.is_a?(Array) ? {} : nil
             end
-            if Settings.select_random_from_batch
-              jobs = jobs.sort_by { rand }
-            end
+
+            jobs = jobs.sort_by { rand } if Settings.select_random_from_batch
             if worker_names.is_a?(Array)
               result = {}
               jobs.each do |job|
                 break if worker_names.empty?
+
                 worker_name = worker_names.first
                 if job.send(:lock_exclusively!, worker_name)
                   result[worker_name] = job
@@ -346,10 +392,10 @@ module Delayed
               end
               return result
             else
-              job = jobs.detect do |job|
+              locked_job = jobs.detect do |job|
                 job.send(:lock_exclusively!, worker_names)
               end
-              return job if job
+              return locked_job if locked_job
             end
           end
         end
@@ -371,27 +417,9 @@ module Delayed
           check_queue(queue)
           check_priorities(min_priority, max_priority)
 
-          self.ready_to_run(forced_latency: forced_latency).
-              where(:priority => min_priority..max_priority, :queue => queue).
-              by_priority
-        end
-
-        # used internally by create_singleton to take the appropriate lock
-        # depending on the db driver
-        def self.transaction_for_singleton(strand, on_conflict)
-          return yield if on_conflict == :loose
-          self.transaction do
-            if on_conflict == :patient
-              pg_function = 'pg_try_advisory_xact_lock'
-              execute_method = :select_value
-            else
-              pg_function = 'pg_advisory_xact_lock'
-              execute_method = :execute
-            end
-            result = connection.send(execute_method, sanitize_sql(["SELECT #{pg_function}(#{connection.quote_table_name('half_md5_as_bigint')}(?))", strand]))
-            return if result == false && on_conflict == :patient
-            yield
-          end
+          ready_to_run(forced_latency: forced_latency)
+            .where(priority: min_priority..max_priority, queue: queue)
+            .by_priority
         end
 
         # Create the job on the specified strand, but only if there aren't any
@@ -399,10 +427,11 @@ module Delayed
         # (in other words, the job will still be created if there's another job
         # on the strand but it's already running)
         def self.create_singleton(options)
-          strand = options[:strand]
+          strand = options[:singleton]
           on_conflict = options.delete(:on_conflict) || :use_earliest
-          transaction_for_singleton(strand, on_conflict) do
-            job = self.where(:strand => strand, :locked_at => nil).next_in_strand_order.first
+
+          transaction_for_singleton(singleton, on_conflict) do
+            job = where(strand: strand, locked_at: nil).next_in_strand_order.first
             new_job = new(options)
             if job
               new_job.initialize_defaults
@@ -426,7 +455,7 @@ module Delayed
 
         def self.processes_locked_locally(name: nil)
           name ||= Socket.gethostname rescue x
-          where("locked_by LIKE ?", "#{name}:%").pluck(:locked_by).map{|locked_by| locked_by.split(":").last.to_i}
+          where("locked_by LIKE ?", "#{name}:%").pluck(:locked_by).map { |locked_by| locked_by.split(":").last.to_i }
         end
 
         def self.unlock_orphaned_prefetched_jobs
@@ -449,12 +478,14 @@ module Delayed
         def lock_exclusively!(worker)
           now = self.class.db_time_now
           # We don't own this job so we will update the locked_by name and the locked_at
-          affected_rows = self.class.where("id=? AND locked_at IS NULL AND run_at<=?", self, now).update_all(:locked_at => now, :locked_by => worker)
+          affected_rows = self.class.where("id=? AND locked_at IS NULL AND run_at<=?", self, now).update_all(
+            locked_at: now, locked_by: worker
+          )
           if affected_rows == 1
             mark_as_locked!(now, worker)
-            return true
+            true
           else
-            return false
+            false
           end
         end
 
@@ -464,9 +495,9 @@ module Delayed
           affected_rows = self.class.where(id: self, locked_by: from).update_all(locked_at: now, locked_by: to)
           if affected_rows == 1
             mark_as_locked!(now, to)
-            return true
+            true
           else
-            return false
+            false
           end
         end
 
@@ -478,34 +509,43 @@ module Delayed
           if respond_to?(:changes_applied)
             changes_applied
           else
-            changed_attributes['locked_at'] = time
-            changed_attributes['locked_by'] = worker
+            changed_attributes["locked_at"] = time
+            changed_attributes["locked_by"] = worker
           end
         end
         protected :lock_exclusively!, :mark_as_locked!
 
         def create_and_lock!(worker)
           raise "job already exists" unless new_record?
+
+          # we don't want to process unique constraint violations of
+          # running singleton jobs; always do it as two steps
+          if singleton
+            single_step_create
+            lock_exclusively!(worker)
+            return
+          end
+
           self.locked_at = Delayed::Job.db_time_now
           self.locked_by = worker
           single_step_create
         end
 
         def fail!
-          attrs = self.attributes
-          attrs['original_job_id'] = attrs.delete('id')
-          attrs['failed_at'] ||= self.class.db_time_now
-          attrs.delete('next_in_strand')
-          attrs.delete('max_concurrent')
+          attrs = attributes
+          attrs["original_job_id"] = attrs.delete("id")
+          attrs["failed_at"] ||= self.class.db_time_now
+          attrs.delete("next_in_strand")
+          attrs.delete("max_concurrent")
           self.class.transaction do
             failed_job = Failed.create(attrs)
-            self.destroy
+            destroy
             failed_job
           end
         rescue
           # we got an error while failing the job -- we need to at least get
           # the job out of the queue
-          self.destroy
+          destroy
           # re-raise so the worker logs the error, at least
           raise
         end
@@ -513,20 +553,8 @@ module Delayed
         class Failed < Job
           include Delayed::Backend::Base
           self.table_name = :failed_jobs
-          # Rails hasn't completely loaded yet, and setting the table name will cache some stuff
-          # so reset that cache so that it will load correctly after Rails is all loaded
-          # It's fixed in Rails 5 to not cache anything when you set the table_name
-          if Rails.version < '5' && Rails.version >= '4.2'
-            @arel_engine = nil
-            @arel_table = nil
-          end
-        end
-        if Rails.version < '5' && Rails.version >= '4.2'
-          @arel_engine = nil
-          @arel_table = nil
         end
       end
-
     end
   end
 end