inst-jobs 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cfef8fa3325ff17a355286bf43ea4df18f817ac3ce6d5ca938fa551c117897c
-  data.tar.gz: 02cecf31bd9e6629cd9f15552a29578e916239f7c1dab7d7bec93274ffb38478
+  metadata.gz: d1547b62f3c5fd86703cc209ec4b0feb6954db3c6fb4b58f4bcdbcf58dc9a9eb
+  data.tar.gz: 95ad1cacd71ac4511ee29eb0d3fda780037768234c232302b6fc10084de9e351
 SHA512:
-  metadata.gz: ec8936d4c32b74eae509897903c3ed86d639883554ea647f611f635191df8858df9734ba9c2931c43cba8adab26c24973108610798df29ded204d3f5e612b2b2
-  data.tar.gz: acc42e02a347d8c16ccb06967a3feb1a965a2a8746e801df7488ccc0f84e00dee334fff352885e0400bf52a2ac764e02af9757967773131f7db7f8da23613d9e
+  metadata.gz: bd27fc7e6c0ca5a613ba98ea0928d7947f2344d05c57ab14f588ff615c69bab60a0b6f08e60d1b610b6746ad8a467d151237f1469129f6144d5e93ce20ea71ef
+  data.tar.gz: 25ce44b9f6eeedae9605c4bc2077a9e9b51a4b7df94ba4d68be1e78f70801af65273c332caba780c11bf523cff31daed9c44d8f068f697a8910781b09a2daf88

data/db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb

@@ -0,0 +1,95 @@
+class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    if connection.adapter_name == 'PostgreSQL'
+      # tl;dr sacrifice some responsiveness to max_concurrent changes for faster performance
+      # don't get the count every single time - it's usually safe to just set the next one in line
+      # since the max_concurrent doesn't change all that often for a strand
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      DECLARE
+        running_count integer;
+      BEGIN
+        IF OLD.strand IS NOT NULL THEN
+          PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+          IF OLD.id % 20 = 0 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.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+              );
+            END IF;
+          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.id ASC LIMIT 1 FOR UPDATE);
+          END IF;
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+      CODE
+
+      # don't need the full count on insert
+      execute(<<-CODE)
+      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;
+      CODE
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      DECLARE
+        running_count integer;
+      BEGIN
+        IF OLD.strand IS NOT NULL THEN
+          PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+          running_count := (SELECT COUNT(*) FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't');
+          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.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+            );
+          END IF;
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+      CODE
+
+      execute(<<-CODE)
+      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 delayed_jobs WHERE strand = NEW.strand) >= NEW.max_concurrent THEN
+            NEW.next_in_strand := 'f';
+          END IF;
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+      CODE
+    end
+  end
+end

data/db/migrate/20190726154743_make_critical_columns_not_null.rb

@@ -0,0 +1,15 @@
+class MakeCriticalColumnsNotNull < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    change_column_null :delayed_jobs, :run_at, false
+    change_column_null :delayed_jobs, :queue, false
+  end
+
+  def down
+    change_column_null :delayed_jobs, :run_at, true
+    change_column_null :delayed_jobs, :queue, true
+  end
+end

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -0,0 +1,25 @@
+class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
+  disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
+
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
+    add_index :delayed_jobs, [:queue, :priority, :run_at, :id],
+      algorithm: :concurrently,
+      where: "locked_at IS NULL AND next_in_strand",
+      name: "get_delayed_jobs_index"
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index_old"
+  end
+
+  def down
+    rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
+    add_index :delayed_jobs, [:priority, :run_at, :queue],
+      algorithm: :concurrently,
+      where: "locked_at IS NULL AND next_in_strand",
+      name: "get_delayed_jobs_index"
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index_old"
+  end
+end

data/db/migrate/20200824222232_speed_up_max_concurrent_delete_trigger.rb

@@ -0,0 +1,95 @@
+class SpeedUpMaxConcurrentDeleteTrigger < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    if connection.adapter_name == 'PostgreSQL'
+      # tl;dr sacrifice some responsiveness to max_concurrent changes for faster performance
+      # don't get the count every single time - it's usually safe to just set the next one in line
+      # since the max_concurrent doesn't change all that often for a strand
+      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.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.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.id ASC LIMIT 1 FOR UPDATE);
+              END IF;
+            END IF;
+          END IF;
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-SQL)
+        CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+        DECLARE
+          running_count integer;
+        BEGIN
+          IF OLD.strand IS NOT NULL THEN
+            PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+            IF OLD.id % 20 = 0 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.id ASC LIMIT (OLD.max_concurrent - running_count) FOR UPDATE
+                );
+              END IF;
+            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.id ASC LIMIT 1 FOR UPDATE);
+            END IF;
+          END IF;
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
+  end
+end
+

data/db/migrate/20200825011002_add_strand_order_override.rb

@@ -0,0 +1,126 @@
+class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
+  disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
+
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :strand_order_override, :integer, default: 0, null: false
+    add_column :failed_jobs, :strand_order_override, :integer, default: 0, null: false
+    add_index :delayed_jobs, [:strand, :strand_order_override, :id],
+      algorithm: :concurrently,
+      where: "strand IS NOT NULL",
+      name: "next_in_strand_index"
+
+    if connection.adapter_name == 'PostgreSQL'
+      # Use the strand_order_override as the primary sorting mechanism (useful when moving between jobs queues without preserving ID ordering)
+      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
+    end
+  end
+
+  def down
+    remove_column :delayed_jobs, :strand_order_override, :integer
+    remove_column :failed_jobs, :strand_order_override, :integer
+
+    if connection.adapter_name == 'PostgreSQL'
+      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.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.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.id ASC LIMIT 1 FOR UPDATE);
+              END IF;
+            END IF;
+          END IF;
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
+  end
+end

data/lib/delayed/backend/active_record.rb

@@ -17,10 +17,68 @@ module Delayed
         include Delayed::Backend::Base
         self.table_name = :delayed_jobs
 
+        scope :next_in_strand_order, -> { order(:strand_order_override, :id) }
+
         def self.reconnect!
           clear_all_connections!
         end
 
+        class << self
+          def create(attributes, &block)
+            return super if connection.prepared_statements || Rails.version < '5.2'
+
+            # modified from ActiveRecord::Persistence.create and ActiveRecord::Persistence#_insert_record
+            job = new(attributes, &block)
+            job.single_step_create
+          end
+        end
+
+        def single_step_create
+          connection = self.class.connection
+          return save if connection.prepared_statements || Rails.version < '5.2'
+
+          # a before_save callback that we're skipping
+          initialize_defaults
+
+          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
+          end
+
+          if Rails.version >= '6'
+            attribute_names = attribute_names_for_partial_writes
+            attribute_names = attributes_for_create(attribute_names)
+            values = attributes_with_values(attribute_names)
+          else
+            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, [])
+
+          # 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
+
+          self
+        end
+
+        def destroy
+          # skip transaction and callbacks
+          destroy_row
+        end
+
         # be aware that some strand functionality is controlled by triggers on
         # the database. see
         # db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb
@@ -71,8 +129,10 @@ module Delayed
         # 500.times { |i| "ohai".send_later_enqueue_args(:reverse, { :run_at => (12.hours.ago + (rand(24.hours.to_i))) }) }
         # then fire up your workers
         # you can check out strand correctness: diff test1.txt <(sort -n test1.txt)
-         def self.ready_to_run
-           where("run_at<=? AND locked_at IS NULL AND next_in_strand=?", db_time_now, true)
+         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)
@@ -187,7 +247,7 @@ module Delayed
             end
 
           scope = scope.group(:tag).offset(offset).limit(limit)
-          scope.order("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)
@@ -203,7 +263,8 @@ module Delayed
                                              min_priority = nil,
                                              max_priority = nil,
                                              prefetch: 0,
-                                             prefetch_owner: nil)
+                                             prefetch_owner: nil,
+                                             forced_latency: nil)
 
           check_queue(queue)
           check_priorities(min_priority, max_priority)
@@ -217,9 +278,14 @@ module Delayed
                 # jobs in a single query.
                 effective_worker_names = Array(worker_names)
 
-                target_jobs = all_available(queue, min_priority, max_priority).
+                lock = nil
+                lock = "FOR UPDATE SKIP LOCKED" if connection.postgresql_version >= 90500
+                target_jobs = all_available(queue,
+                                            min_priority,
+                                            max_priority,
+                                            forced_latency: forced_latency).
                     limit(effective_worker_names.length + prefetch).
-                    lock
+                    lock(lock)
                 jobs_with_row_number = all.from(target_jobs).
                     select("id, ROW_NUMBER() OVER () AS row_number")
                 updates = "locked_by = CASE row_number "
@@ -295,23 +361,33 @@ module Delayed
 
         def self.all_available(queue = Delayed::Settings.queue,
                                min_priority = nil,
-                               max_priority = nil)
+                               max_priority = nil,
+                               forced_latency: nil)
           min_priority ||= Delayed::MIN_PRIORITY
           max_priority ||= Delayed::MAX_PRIORITY
 
           check_queue(queue)
           check_priorities(min_priority, max_priority)
 
-          self.ready_to_run.
+          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)
+        def self.transaction_for_singleton(strand, on_conflict)
+          return yield if on_conflict == :loose
           self.transaction do
-            connection.execute(sanitize_sql(["SELECT pg_advisory_xact_lock(#{connection.quote_table_name('half_md5_as_bigint')}(?))", strand]))
+            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
         end
@@ -323,18 +399,21 @@ module Delayed
         def self.create_singleton(options)
           strand = options[:strand]
           on_conflict = options.delete(:on_conflict) || :use_earliest
-          transaction_for_singleton(strand) do
-            job = self.where(:strand => strand, :locked_at => nil).order(:id).first
+          transaction_for_singleton(strand, on_conflict) do
+            job = self.where(:strand => strand, :locked_at => nil).next_in_strand_order.first
             new_job = new(options)
             if job
               new_job.initialize_defaults
               job.run_at =
                 case on_conflict
-                when :use_earliest
+                when :use_earliest, :patient
                   [job.run_at, new_job.run_at].min
                 when :overwrite
                   new_job.run_at
+                when :loose
+                  job.run_at
                 end
+              job.handler = new_job.handler if on_conflict == :overwrite
               job.save! if job.changed?
             else
               new_job.save!
@@ -407,7 +486,7 @@ module Delayed
           raise "job already exists" unless new_record?
           self.locked_at = Delayed::Job.db_time_now
           self.locked_by = worker
-          save!
+          single_step_create
         end
 
         def fail!