switchman-inst-jobs 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99fc38ce3e38711c3ebb2d35f6e6eccb62f5d9388e6fbec9b9ba40830b3b4df7
-  data.tar.gz: 12501153af5a11a2c4d958cbe60d2185d684d92794081b1bbffe6f3394a6b257
+  metadata.gz: 8e4c1c0421945fc0c823b2b1e452801565ac1c3e5ad9aae77d52fd8a36d83d0d
+  data.tar.gz: 87d5a191c8dd7c1918d1bae1d8b05ffdfee1146e462e9adab0869f2b2210f681
 SHA512:
-  metadata.gz: 236773fe9bc45914fc1e78fe45ba8e16793259a93c2e58fe3a6603d04f03d4a748c8fd51171bbcb1440dd39e56a5b016bf9864668f540b8322f2b7f354ae68fa
-  data.tar.gz: 42d222e8d2660833010b731295cf76984e5e8cff9097c911260ab4ea0491771088685f73c0a9e05d335a38af79efdf34ad71296f7017297cdd9d382f8163f2e9
+  metadata.gz: a6c0abc940a6f4a7dc73923e9e020b853f23d29551bb19efa67338ae1e0da0af9065cde8f6a9f60e212f9514dd95c73b242512f1e21e53147601ff7f8cde30c1
+  data.tar.gz: 4caad338666dcfbb83967c007a28443a45f86aa813b8fa4f8d81f6354beb9e9f3b68ae7b4118afa5d40c6e2da77e34f7982c8e28a6c1de2e9cdcc99942acd2c4

data/db/migrate/20101216224513_create_delayed_jobs.rb

@@ -0,0 +1,42 @@
+class CreateDelayedJobs < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    unless connection.adapter_name == 'PostgreSQL'
+      raise("#{connection.adapter_name} is not supported for delayed jobs queue")
+    end
+
+    create_table :delayed_jobs do |table|
+      # Allows some jobs to jump to the front of the queue
+      table.integer  :priority, default: 0
+      # Provides for retries, but still fail eventually.
+      table.integer  :attempts, default: 0
+      # YAML-encoded string of the object that will do work
+      table.text     :handler, limit: (500 * 1024)
+      # reason for last failure (See Note below)
+      table.text     :last_error
+      # The queue that this job is in
+      table.string   :queue, default: nil
+      # When to run.
+      # Could be Time.zone.now for immediately, or sometime in the future.
+      table.datetime :run_at
+      # Set when a client is working on this object
+      table.datetime :locked_at
+      # Set when all retries have failed
+      table.datetime :failed_at
+      # Who is working on this object (if locked)
+      table.string   :locked_by
+
+      table.timestamps
+    end
+
+    add_index :delayed_jobs, %i[priority run_at], name: 'delayed_jobs_priority'
+    add_index :delayed_jobs, [:queue], name: 'delayed_jobs_queue'
+  end
+
+  def down
+    drop_table :delayed_jobs
+  end
+end

data/db/migrate/20110208031356_add_delayed_jobs_tag.rb

@@ -0,0 +1,14 @@
+class AddDelayedJobsTag < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :tag, :string
+    add_index :delayed_jobs, [:tag]
+  end
+
+  def down
+    remove_column :delayed_jobs, :tag
+  end
+end

data/db/migrate/20110426161613_add_delayed_jobs_max_attempts.rb

@@ -0,0 +1,13 @@
+class AddDelayedJobsMaxAttempts < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :max_attempts, :integer
+  end
+
+  def down
+    remove_column :delayed_jobs, :max_attempts
+  end
+end

data/db/migrate/20110516225834_add_delayed_jobs_strand.rb

@@ -0,0 +1,14 @@
+class AddDelayedJobsStrand < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :strand, :string
+    add_index :delayed_jobs, :strand
+  end
+
+  def down
+    remove_column :delayed_jobs, :strand
+  end
+end

data/db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb

@@ -0,0 +1,26 @@
+class CleanupDelayedJobsIndexes < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    case connection.adapter_name
+    when 'PostgreSQL'
+      # "nulls first" syntax is postgresql specific, and allows for more
+      # efficient querying for the next job
+      connection.execute("CREATE INDEX get_delayed_jobs_index ON #{::Delayed::Job.quoted_table_name} (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
+    else
+      add_index :delayed_jobs, %w[priority run_at locked_at failed_at queue], name: 'get_delayed_jobs_index'
+    end
+
+    # unused indexes
+    remove_index :delayed_jobs, name: 'delayed_jobs_queue'
+    remove_index :delayed_jobs, name: 'delayed_jobs_priority'
+  end
+
+  def down
+    remove_index :delayed_jobs, name: 'get_delayed_jobs_index'
+    add_index :delayed_jobs, %i[priority run_at], name: 'delayed_jobs_priority'
+    add_index :delayed_jobs, [:queue], name: 'delayed_jobs_queue'
+  end
+end

data/db/migrate/20110610213249_optimize_delayed_jobs.rb

@@ -0,0 +1,40 @@
+class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    create_table :failed_jobs do |t|
+      t.integer  'priority',    default: 0
+      t.integer  'attempts',    default: 0
+      t.string   'handler',     limit: 512_000
+      t.integer  'original_id', limit: 8
+      t.text     'last_error'
+      t.string   'queue'
+      t.datetime 'run_at'
+      t.datetime 'locked_at'
+      t.datetime 'failed_at'
+      t.string   'locked_by'
+      t.datetime 'created_at'
+      t.datetime 'updated_at'
+      t.string   'tag'
+      t.integer  'max_attempts'
+      t.string   'strand'
+    end
+
+    remove_index :delayed_jobs, name: 'get_delayed_jobs_index'
+    remove_index :delayed_jobs, [:strand]
+
+    add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: 'index_delayed_jobs_for_get_next'
+    add_index :delayed_jobs, %w[strand id], name: 'index_delayed_jobs_on_strand'
+
+    # move all failed jobs to the new failed table
+    Delayed::Backend::ActiveRecord::Job.where('failed_at IS NOT NULL').find_each do |job|
+      job.fail! unless job.on_hold?
+    end
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration
+  end
+end

data/db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb

@@ -0,0 +1,52 @@
+class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    remove_index :delayed_jobs, name: 'index_delayed_jobs_for_get_next'
+
+    add_column :delayed_jobs, :next_in_strand, :boolean, default: true, null: false
+
+    # create the new index
+    connection.execute("CREATE INDEX get_delayed_jobs_index ON #{::Delayed::Job.quoted_table_name} (priority, run_at, queue) WHERE locked_at IS NULL AND next_in_strand = 't'")
+
+    # create the insert trigger
+    execute(<<-CODE)
+    CREATE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+    BEGIN
+      LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
+      IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
+        NEW.next_in_strand := 'f';
+      END IF;
+      RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+    CODE
+    execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
+
+    # create the delete trigger
+    execute(<<-CODE)
+    CREATE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+    BEGIN
+      UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
+      RETURN OLD;
+    END;
+    $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+    CODE
+    execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} ()")
+
+    execute(%{UPDATE #{::Delayed::Job.quoted_table_name} SET next_in_strand = 'f' WHERE strand IS NOT NULL AND id <> (SELECT id FROM #{::Delayed::Job.quoted_table_name} j2 WHERE j2.strand = delayed_jobs.strand ORDER BY j2.strand, j2.id ASC LIMIT 1)})
+  end
+
+  def down
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{::Delayed::Job.quoted_table_name})
+    execute %{DROP FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} ()}
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{::Delayed::Job.quoted_table_name})
+    execute %{DROP FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} ()}
+
+    remove_column :delayed_jobs, :next_in_strand
+    remove_index :delayed_jobs, name: 'get_delayed_jobs_index'
+    add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: 'index_delayed_jobs_for_get_next'
+  end
+end

data/db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb

@@ -0,0 +1,31 @@
+class DelayedJobsDeleteTriggerLockForUpdate < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+end

data/db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb

@@ -0,0 +1,15 @@
+class DropPsqlJobsPopFn < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    if connection.adapter_name == 'PostgreSQL'
+      connection.execute('DROP FUNCTION IF EXISTS pop_from_delayed_jobs(varchar, varchar, integer, integer, timestamp without time zone)')
+    end
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration
+  end
+end

data/db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb

@@ -0,0 +1,80 @@
+class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    # use an advisory lock based on the name of the strand, instead of locking the whole table
+    # note that we're using half of the md5, so collisions are possible, but we don't really
+    # care because that would just be the old behavior, whereas for the most part locking will
+    # be much smaller
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE FUNCTION #{connection.quote_table_name('half_md5_as_bigint')}(strand varchar) RETURNS bigint AS $$
+      DECLARE
+        strand_md5 bytea;
+      BEGIN
+        strand_md5 := decode(md5(strand), 'hex');
+        RETURN (CAST(get_byte(strand_md5, 0) AS bigint) << 56) +
+                                  (CAST(get_byte(strand_md5, 1) AS bigint) << 48) +
+                                  (CAST(get_byte(strand_md5, 2) AS bigint) << 40) +
+                                  (CAST(get_byte(strand_md5, 3) AS bigint) << 32) +
+                                  (CAST(get_byte(strand_md5, 4) AS bigint) << 24) +
+                                  (get_byte(strand_md5, 5) << 16) +
+                                  (get_byte(strand_md5, 6) << 8) +
+                                   get_byte(strand_md5, 7);
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+        IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
+          NEW.next_in_strand := 'f';
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
+        IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
+          NEW.next_in_strand := 'f';
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      execute("DROP FUNCTION #{connection.quote_table_name('half_md5_as_bigint')}(varchar)")
+    end
+  end
+end

data/db/migrate/20120607181141_index_jobs_on_locked_by.rb

@@ -0,0 +1,15 @@
+class IndexJobsOnLockedBy < ActiveRecord::Migration[4.2]
+  disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
+
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    add_index :delayed_jobs, :locked_by, algorithm: :concurrently, where: 'locked_by IS NOT NULL'
+  end
+
+  def down
+    remove_index :delayed_jobs, :locked_by
+  end
+end

data/db/migrate/20120608191051_add_jobs_run_at_index.rb

@@ -0,0 +1,15 @@
+class AddJobsRunAtIndex < ActiveRecord::Migration[4.2]
+  disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
+
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    add_index :delayed_jobs, %w[run_at tag], algorithm: :concurrently
+  end
+
+  def down
+    remove_index :delayed_jobs, name: 'index_delayed_jobs_on_run_at_and_tag'
+  end
+end

data/db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb

@@ -0,0 +1,13 @@
+class ChangeDelayedJobsHandlerToText < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    change_column :delayed_jobs, :handler, :text
+  end
+
+  def down
+    change_column :delayed_jobs, :handler, :string, limit: 500.kilobytes
+  end
+end

data/db/migrate/20140505215131_add_failed_jobs_original_job_id.rb

@@ -0,0 +1,13 @@
+class AddFailedJobsOriginalJobId < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    add_column :failed_jobs, :original_job_id, :integer, limit: 8
+  end
+
+  def down
+    remove_column :failed_jobs, :original_job_id
+  end
+end

data/db/migrate/20140505215510_copy_failed_jobs_original_id.rb

@@ -0,0 +1,12 @@
+class CopyFailedJobsOriginalId < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    # this is a smaller, less frequently accessed table, so we just update all at once
+    Delayed::Backend::ActiveRecord::Job::Failed.where('original_job_id is null').update_all('original_job_id = original_id')
+  end
+
+  def down; end
+end

data/db/migrate/20140505223637_drop_failed_jobs_original_id.rb

@@ -0,0 +1,13 @@
+class DropFailedJobsOriginalId < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Backend::ActiveRecord::Job.connection
+  end
+
+  def up
+    remove_column :failed_jobs, :original_id
+  end
+
+  def down
+    add_column :failed_jobs, :original_id, :integer, limit: 8
+  end
+end

data/db/migrate/20140512213941_add_source_to_jobs.rb

@@ -0,0 +1,15 @@
+class AddSourceToJobs < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :source, :string
+    add_column :failed_jobs, :source, :string
+  end
+
+  def down
+    remove_column :delayed_jobs, :source
+    remove_column :failed_jobs, :source
+  end
+end

data/db/migrate/20150807133223_add_max_concurrent_to_jobs.rb

@@ -0,0 +1,70 @@
+class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :max_concurrent, :integer, default: 1, null: false
+
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        IF OLD.strand IS NOT NULL THEN
+          PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+          IF (SELECT COUNT(*) FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't') < OLD.max_concurrent 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
+            );
+          END IF;
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+
+  def down
+    remove_column :delayed_jobs, :max_concurrent
+
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
+        IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
+          NEW.next_in_strand := 'f';
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+end

data/db/migrate/20151123210429_add_expires_at_to_jobs.rb

@@ -0,0 +1,15 @@
+class AddExpiresAtToJobs < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    add_column :delayed_jobs, :expires_at, :datetime
+    add_column :failed_jobs, :expires_at, :datetime
+  end
+
+  def down
+    remove_column :delayed_jobs, :expires_at
+    remove_column :failed_jobs, :expires_at
+  end
+end

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -0,0 +1,50 @@
+class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      BEGIN
+        IF OLD.strand IS NOT NULL THEN
+          PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
+          IF (SELECT COUNT(*) FROM delayed_jobs WHERE strand = OLD.strand AND next_in_strand = 't') < OLD.max_concurrent 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
+            );
+          END IF;
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+end

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -0,0 +1,39 @@
+class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
+  def connection
+    Delayed::Job.connection
+  end
+
+  def up
+    drop_triggers
+
+    add_string_limit_if_missing :delayed_jobs, :queue
+    add_string_limit_if_missing :delayed_jobs, :locked_by
+    add_string_limit_if_missing :delayed_jobs, :tag
+    add_string_limit_if_missing :delayed_jobs, :strand
+    add_string_limit_if_missing :delayed_jobs, :source
+
+    add_string_limit_if_missing :failed_jobs, :queue
+    add_string_limit_if_missing :failed_jobs, :locked_by
+    add_string_limit_if_missing :failed_jobs, :tag
+    add_string_limit_if_missing :failed_jobs, :strand
+    add_string_limit_if_missing :failed_jobs, :source
+
+    readd_triggers
+  end
+
+  def drop_triggers
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON #{::Delayed::Job.quoted_table_name})
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON #{::Delayed::Job.quoted_table_name})
+  end
+
+  def readd_triggers
+    execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')}()")
+    execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON #{::Delayed::Job.quoted_table_name} FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')}()")
+  end
+
+  def add_string_limit_if_missing(table, column)
+    return if column_exists?(table, column, :string, limit: 255)
+
+    change_column table, column, :string, limit: 255
+  end
+end

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 #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      # don't need the full count on insert
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      CODE
+
+      execute(<<-CODE)
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      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, %i[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, %i[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,94 @@
+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 #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
+    end
+  end
+
+  def down
+    if connection.adapter_name == 'PostgreSQL'
+      execute(<<-SQL)
+        CREATE OR REPLACE FUNCTION #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      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, %i[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 #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      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 #{connection.quote_table_name('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 SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
+    end
+  end
+end

data/lib/switchman_inst_jobs/active_record/migration.rb

@@ -17,6 +17,16 @@ module SwitchmanInstJobs
       ensure
         ::ActiveRecord::Migration.open_migrations -= 1
       end
+
+      def copy(destination, sources, options = {})
+        if sources.delete('delayed_engine')
+          # rubocop:disable Rails/Output
+          puts 'NOTE: Not installing delayed_engine migrations in an application using switchman-inst-jobs'
+          puts '(use rake switchman_inst_jobs:install:migrations instead)'
+          # rubocop:enable Rails/Output
+        end
+        super
+      end
     end
   end
 end

data/lib/switchman_inst_jobs/jobs_migrator.rb

@@ -183,12 +183,14 @@ module SwitchmanInstJobs
           # Adapted from get_and_lock_next_available in delayed/backend/active_record.rb
           target_jobs = scope.limit(1000).lock('FOR UPDATE SKIP LOCKED')
 
-          query = "WITH limited_jobs AS (#{target_jobs.to_sql}) " \
-                  "UPDATE #{::Delayed::Job.quoted_table_name} " \
-                  "SET locked_by = #{::Delayed::Job.connection.quote(::Delayed::Backend::Base::ON_HOLD_LOCKED_BY)}, " \
-                  "locked_at = #{::Delayed::Job.connection.quote(::Delayed::Job.db_time_now)} "\
-                  "FROM limited_jobs WHERE limited_jobs.id=#{::Delayed::Job.quoted_table_name}.id " \
-                  "RETURNING #{::Delayed::Job.quoted_table_name}.*"
+          query = source_shard.activate(:delayed_jobs) do
+            "WITH limited_jobs AS (#{target_jobs.to_sql}) " \
+            "UPDATE #{::Delayed::Job.quoted_table_name} " \
+            "SET locked_by = #{::Delayed::Job.connection.quote(::Delayed::Backend::Base::ON_HOLD_LOCKED_BY)}, " \
+            "locked_at = #{::Delayed::Job.connection.quote(::Delayed::Job.db_time_now)} "\
+            "FROM limited_jobs WHERE limited_jobs.id=#{::Delayed::Job.quoted_table_name}.id " \
+            "RETURNING #{::Delayed::Job.quoted_table_name}.*"
+          end
 
           jobs = source_shard.activate(:delayed_jobs) { ::Delayed::Job.find_by_sql(query) }
           new_jobs = jobs.map do |job|

data/lib/switchman_inst_jobs/version.rb

@@ -1,3 +1,3 @@
 module SwitchmanInstJobs
-  VERSION = '1.5.2'.freeze
+  VERSION = '1.6.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: switchman-inst-jobs
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Bryan Petty
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-27 00:00:00.000000000 Z
+date: 2020-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inst-jobs
@@ -70,20 +70,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '1.16'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '1.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '1.16'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -266,17 +266,42 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-description: 
+description:
 email:
 - bpetty@instructure.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- db/migrate/20101216224513_create_delayed_jobs.rb
+- db/migrate/20110208031356_add_delayed_jobs_tag.rb
+- db/migrate/20110426161613_add_delayed_jobs_max_attempts.rb
+- db/migrate/20110516225834_add_delayed_jobs_strand.rb
+- db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb
+- db/migrate/20110610213249_optimize_delayed_jobs.rb
+- db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb
+- db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb
+- db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb
+- db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb
+- db/migrate/20120607181141_index_jobs_on_locked_by.rb
+- db/migrate/20120608191051_add_jobs_run_at_index.rb
+- db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb
+- db/migrate/20140505215131_add_failed_jobs_original_job_id.rb
+- db/migrate/20140505215510_copy_failed_jobs_original_id.rb
+- db/migrate/20140505223637_drop_failed_jobs_original_id.rb
+- db/migrate/20140512213941_add_source_to_jobs.rb
+- db/migrate/20150807133223_add_max_concurrent_to_jobs.rb
+- db/migrate/20151123210429_add_expires_at_to_jobs.rb
+- db/migrate/20151210162949_improve_max_concurrent.rb
+- db/migrate/20161206323555_add_back_default_string_limits_jobs.rb
 - db/migrate/20170308045400_add_shard_id_to_delayed_jobs.rb
-- db/migrate/20180628153808_set_search_paths_on_functions.rb
+- db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb
+- db/migrate/20190726154743_make_critical_columns_not_null.rb
+- db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb
 - db/migrate/20200818130101_add_on_hold_to_switchman_shards.rb
 - db/migrate/20200822014259_add_block_stranded_to_switchman_shards.rb
+- db/migrate/20200824222232_speed_up_max_concurrent_delete_trigger.rb
+- db/migrate/20200825011002_add_strand_order_override.rb
 - lib/switchman-inst-jobs.rb
 - lib/switchman_inst_jobs.rb
 - lib/switchman_inst_jobs/active_record/connection_adapters/postgresql_adapter.rb
@@ -300,7 +325,7 @@ homepage: https://github.com/instructure/switchman-inst-jobs
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -316,7 +341,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Switchman and Instructure Jobs compatibility gem.
 test_files: []

data/db/migrate/20180628153808_set_search_paths_on_functions.rb

@@ -1,15 +0,0 @@
-class SetSearchPathsOnFunctions < ActiveRecord::Migration[4.2]
-  disable_ddl_transaction!
-
-  def up
-    set_search_path('delayed_jobs_after_delete_row_tr_fn', '()')
-    set_search_path('delayed_jobs_before_insert_row_tr_fn', '()')
-    set_search_path('half_md5_as_bigint', '(varchar)')
-  end
-
-  def down
-    set_search_path('delayed_jobs_after_delete_row_tr_fn', '()', 'DEFAULT')
-    set_search_path('delayed_jobs_before_insert_row_tr_fn', '()', 'DEFAULT')
-    set_search_path('half_md5_as_bigint', '(varchar)', 'DEFAULT')
-  end
-end