switchman-inst-jobs 4.0.13 → 4.0.14

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -1,46 +1,48 @@
+# frozen_string_literal: true
+
 class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
   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
-            );
+    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));
+            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;
-        END IF;
-        RETURN OLD;
-      END;
-      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
-      CODE
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
     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
-            );
+    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 $$
+        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;
-        END IF;
-        RETURN OLD;
-      END;
-      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
-      CODE
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
     end
   end
 end

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   def up
     drop_triggers
@@ -23,8 +25,8 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   end
 
   def readd_triggers
-    execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.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 #{connection.quote_table_name(::Delayed::Job.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("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.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 #{connection.quote_table_name(::Delayed::Job.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)

data/db/migrate/20170308045400_add_shard_id_to_delayed_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddShardIdToDelayedJobs < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 

data/db/migrate/20170308045401_add_delayed_jobs_shard_id_to_switchman_shards.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsShardIdToSwitchmanShards < ActiveRecord::Migration[5.2]
   def change
     add_reference :switchman_shards, :delayed_jobs_shard, foreign_key: { to_table: :switchman_shards }, index: false, if_not_exists: true

data/db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb

@@ -1,91 +1,93 @@
+# frozen_string_literal: true
+
 class SpeedUpMaxConcurrentTriggers < ActiveRecord::Migration[4.2]
   def up
-    if connection.adapter_name == 'PostgreSQL'
+    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
-              );
+      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;
-          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
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
 
       # 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';
+      execute(<<~SQL)
+        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;
-        END IF;
-        RETURN NEW;
-      END;
-      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
-      CODE
+          RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
     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
-            );
+    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));
+            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;
-        END IF;
-        RETURN OLD;
-      END;
-      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
-      CODE
+          RETURN OLD;
+        END;
+        $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
 
-      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';
+      execute(<<~SQL)
+        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;
-        END IF;
-        RETURN NEW;
-      END;
-      $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
-      CODE
+          RETURN NEW;
+        END;
+        $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
+      SQL
     end
   end
 end

data/db/migrate/20190726154743_make_critical_columns_not_null.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MakeCriticalColumnsNotNull < ActiveRecord::Migration[4.2]
   def up
     change_column_null :delayed_jobs, :run_at, false

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -1,21 +1,25 @@
+# frozen_string_literal: true
+
 class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
   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],
+    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'
+              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],
+    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'
+              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/20200818130101_add_on_hold_to_switchman_shards.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddOnHoldToSwitchmanShards < ActiveRecord::Migration[5.2]
   def change
     add_column :switchman_shards, :jobs_held, :bool, default: false

data/db/migrate/20200822014259_add_block_stranded_to_switchman_shards.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddBlockStrandedToSwitchmanShards < ActiveRecord::Migration[5.2]
   def change
     add_column :switchman_shards, :block_stranded, :bool, default: false

data/db/migrate/20200824222232_speed_up_max_concurrent_delete_trigger.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 class SpeedUpMaxConcurrentDeleteTrigger < ActiveRecord::Migration[4.2]
   def up
-    if connection.adapter_name == 'PostgreSQL'
+    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 $$
+        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;
@@ -57,9 +59,9 @@ class SpeedUpMaxConcurrentDeleteTrigger < ActiveRecord::Migration[4.2]
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
+    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 $$
+        CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_after_delete_row_tr_fn")} () RETURNS trigger AS $$
         DECLARE
           running_count integer;
         BEGIN

data/db/migrate/20200825011002_add_strand_order_override.rb

@@ -1,18 +1,21 @@
+# frozen_string_literal: true
+
 class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
   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],
+    add_index :delayed_jobs,
+              %i[strand strand_order_override id],
               algorithm: :concurrently,
-              where: 'strand IS NOT NULL',
-              name: 'next_in_strand_index'
+              where: "strand IS NOT NULL",
+              name: "next_in_strand_index"
 
-    if connection.adapter_name == 'PostgreSQL'
+    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 $$
+        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;
@@ -67,9 +70,9 @@ class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
     remove_column :delayed_jobs, :strand_order_override, :integer
     remove_column :failed_jobs, :strand_order_override, :integer
 
-    if connection.adapter_name == 'PostgreSQL'
+    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 $$
+        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;

data/db/migrate/20210809145804_add_n_strand_index.rb

@@ -4,9 +4,10 @@ class AddNStrandIndex < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def change
-    add_index :delayed_jobs, %i[strand next_in_strand id],
-              name: 'n_strand_index',
-              where: 'strand IS NOT NULL',
+    add_index :delayed_jobs,
+              %i[strand next_in_strand id],
+              name: "n_strand_index",
+              where: "strand IS NOT NULL",
               algorithm: :concurrently
   end
 end

data/db/migrate/20210812210128_add_singleton_column.rb

@@ -9,22 +9,22 @@ class AddSingletonColumn < ActiveRecord::Migration[5.2]
     # only one job can be queued in a singleton
     add_index :delayed_jobs,
               :singleton,
-              where: 'singleton IS NOT NULL AND locked_by IS NULL',
+              where: "singleton IS NOT NULL AND locked_by IS NULL",
               unique: true,
-              name: 'index_delayed_jobs_on_singleton_not_running',
+              name: "index_delayed_jobs_on_singleton_not_running",
               algorithm: :concurrently
     # only one job can be running for a singleton
     add_index :delayed_jobs,
               :singleton,
-              where: 'singleton IS NOT NULL AND locked_by IS NOT NULL',
+              where: "singleton IS NOT NULL AND locked_by IS NOT NULL",
               unique: true,
-              name: 'index_delayed_jobs_on_singleton_running',
+              name: "index_delayed_jobs_on_singleton_running",
               algorithm: :concurrently
 
     reversible do |direction|
       direction.up do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+          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;
@@ -88,7 +88,7 @@ class AddSingletonColumn < ActiveRecord::Migration[5.2]
           $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
         SQL
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          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));
@@ -111,7 +111,7 @@ class AddSingletonColumn < ActiveRecord::Migration[5.2]
       end
       direction.down do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+          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;
@@ -160,7 +160,7 @@ class AddSingletonColumn < ActiveRecord::Migration[5.2]
           $$ LANGUAGE plpgsql SET search_path TO #{::Switchman::Shard.current.name};
         SQL
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          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));
@@ -181,13 +181,13 @@ class AddSingletonColumn < ActiveRecord::Migration[5.2]
       reversible do |direction|
         direction.up do
           drop_triggers
-          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (NEW.strand IS NOT NULL OR NEW.singleton 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 #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN ((OLD.strand IS NOT NULL OR OLD.singleton IS NOT NULL) AND OLD.next_in_strand=true) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')}()")
+          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN (NEW.strand IS NOT NULL OR NEW.singleton 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 #{connection.quote_table_name(::Delayed::Job.table_name)} FOR EACH ROW WHEN ((OLD.strand IS NOT NULL OR OLD.singleton IS NOT NULL) AND OLD.next_in_strand=true) EXECUTE PROCEDURE #{connection.quote_table_name("delayed_jobs_after_delete_row_tr_fn")}()")
         end
         direction.down do
           drop_triggers
-          execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.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 #{connection.quote_table_name(::Delayed::Job.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("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON #{connection.quote_table_name(::Delayed::Job.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 #{connection.quote_table_name(::Delayed::Job.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
       end
     end

data/db/migrate/20210917232626_add_delete_conflicting_singletons_before_unlock_trigger.rb

@@ -3,7 +3,7 @@
 class AddDeleteConflictingSingletonsBeforeUnlockTrigger < ActiveRecord::Migration[5.2]
   def up
     execute(<<~SQL)
-      CREATE FUNCTION #{connection.quote_table_name('delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn')} () RETURNS trigger AS $$
+      CREATE FUNCTION #{connection.quote_table_name("delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn")} () RETURNS trigger AS $$
       BEGIN
         IF EXISTS (SELECT 1 FROM delayed_jobs j2 WHERE j2.singleton=OLD.singleton) THEN
           DELETE FROM delayed_jobs WHERE id<>OLD.id AND singleton=OLD.singleton;
@@ -17,11 +17,11 @@ class AddDeleteConflictingSingletonsBeforeUnlockTrigger < ActiveRecord::Migratio
         OLD.singleton IS NOT NULL AND
         OLD.singleton=NEW.singleton AND
         OLD.locked_by IS NOT NULL AND
-        NEW.locked_by IS NULL) EXECUTE PROCEDURE #{connection.quote_table_name('delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn')}();
+        NEW.locked_by IS NULL) EXECUTE PROCEDURE #{connection.quote_table_name("delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn")}();
     SQL
   end
 
   def down
-    execute("DROP FUNCTION #{connection.quote_table_name('delayed_jobs_before_unlock_delete_conflicting_singletons_row_tr_fn')}() CASCADE")
+    execute("DROP FUNCTION #{connection.quote_table_name("delayed_jobs_before_unlock_delete_conflicting_singletons_row_tr_fn")}() CASCADE")
   end
 end

data/db/migrate/20210928174754_fix_singleton_condition_in_before_insert.rb

@@ -5,7 +5,7 @@ class FixSingletonConditionInBeforeInsert < ActiveRecord::Migration[5.2]
     reversible do |direction|
       direction.up do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          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));
@@ -30,7 +30,7 @@ class FixSingletonConditionInBeforeInsert < ActiveRecord::Migration[5.2]
       end
       direction.down do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          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));

data/db/migrate/20210929204903_update_conflicting_singleton_function_to_use_index.rb

@@ -3,7 +3,7 @@
 class UpdateConflictingSingletonFunctionToUseIndex < ActiveRecord::Migration[5.2]
   def up
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn')} () RETURNS trigger AS $$
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn")} () RETURNS trigger AS $$
       BEGIN
         DELETE FROM delayed_jobs WHERE id<>OLD.id AND singleton=OLD.singleton AND locked_by IS NULL;
         RETURN NEW;
@@ -14,7 +14,7 @@ class UpdateConflictingSingletonFunctionToUseIndex < ActiveRecord::Migration[5.2
 
   def down
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn')} () RETURNS trigger AS $$
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_before_unlock_delete_conflicting_singletons_row_fn")} () RETURNS trigger AS $$
       BEGIN
         IF EXISTS (SELECT 1 FROM delayed_jobs j2 WHERE j2.singleton=OLD.singleton) THEN
           DELETE FROM delayed_jobs WHERE id<>OLD.id AND singleton=OLD.singleton;

data/db/migrate/20211101190934_update_after_delete_trigger_for_singleton_index.rb

@@ -3,7 +3,7 @@
 class UpdateAfterDeleteTriggerForSingletonIndex < ActiveRecord::Migration[5.2]
   def up
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      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;
@@ -70,7 +70,7 @@ class UpdateAfterDeleteTriggerForSingletonIndex < ActiveRecord::Migration[5.2]
 
   def down
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      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;

data/db/migrate/20211207094200_update_after_delete_trigger_for_singleton_transition_cases.rb

@@ -3,7 +3,7 @@
 class UpdateAfterDeleteTriggerForSingletonTransitionCases < ActiveRecord::Migration[5.2]
   def up
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_after_delete_row_tr_fn")} () RETURNS trigger AS $$
       DECLARE
         next_strand varchar;
         running_count integer;
@@ -104,7 +104,7 @@ class UpdateAfterDeleteTriggerForSingletonTransitionCases < ActiveRecord::Migrat
 
   def down
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      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;

data/db/migrate/20211220112800_fix_singleton_race_condition_insert.rb

@@ -5,7 +5,7 @@ class FixSingletonRaceConditionInsert < ActiveRecord::Migration[5.2]
     reversible do |direction|
       direction.up do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          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));
@@ -31,7 +31,7 @@ class FixSingletonRaceConditionInsert < ActiveRecord::Migration[5.2]
       end
       direction.down do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          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));