inst-jobs 2.2.1 → 2.4.0

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -24,8 +24,8 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   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}
+    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
 
   def readd_triggers
@@ -35,6 +35,7 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
 
   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

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
+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)
+    # 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;
@@ -36,10 +35,10 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      # don't need the full count on insert
-      execute(<<-CODE)
+    # don't need the full count on insert
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -53,13 +52,11 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       DECLARE
         running_count integer;
@@ -77,9 +74,9 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -91,7 +88,6 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -9,19 +9,19 @@ class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
 
   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"
+    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, [:priority, :run_at, :queue],
-      algorithm: :concurrently,
-      where: "locked_at IS NULL AND next_in_strand",
-      name: "get_delayed_jobs_index"
+    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

@@ -6,92 +6,87 @@ class SpeedUpMaxConcurrentDeleteTrigger < ActiveRecord::Migration[4.2]
   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));
+    # 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;
-        
-            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
-              -- 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 =
+              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;
+                  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 IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
   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);
+    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;
-          RETURN OLD;
-        END;
-        $$ LANGUAGE plpgsql;
-      SQL
-    end
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
   end
 end
-

data/db/migrate/20200825011002_add_strand_order_override.rb

@@ -10,119 +10,115 @@ class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
   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"
+    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 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));
+    # 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;
-        
-            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
-              -- 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 =
+              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;
+                  j2.strand = OLD.strand ORDER BY j2.strand_order_override ASC, j2.id ASC LIMIT 1 FOR UPDATE);
             END IF;
           END IF;
-          RETURN OLD;
-        END;
-        $$ LANGUAGE plpgsql;
-      SQL
-    end
+        END IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
   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));
+    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;
-        
-            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
-              -- 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 =
+              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;
+                  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 IF;
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
   end
 end