Remove BG migrations jobs for defunct helpers

Remove dangling background migration job classes which are no longer
needed, because the migration helpers that used them were deleted.

lib/gitlab/background_migration/cleanup_concurrent_rename.rb

-# frozen_string_literal: true
-
-module Gitlab
-  module BackgroundMigration
-    # Background migration for cleaning up a concurrent column rename.
-    class CleanupConcurrentRename < CleanupConcurrentSchemaChange
-      RESCHEDULE_DELAY = 10.minutes
-
-      def cleanup_concurrent_schema_change(table, old_column, new_column)
-        cleanup_concurrent_column_rename(table, old_column, new_column)
-      end
-    end
-  end
-end

lib/gitlab/background_migration/cleanup_concurrent_schema_change.rb

-# frozen_string_literal: true
-
-module Gitlab
-  module BackgroundMigration
-    # Base class for background migration for rename/type changes.
-    class CleanupConcurrentSchemaChange
-      include Database::MigrationHelpers
-
-      # table - The name of the table the migration is performed for.
-      # old_column - The name of the old (to drop) column.
-      # new_column - The name of the new column.
-      def perform(table, old_column, new_column)
-        return unless column_exists?(table, new_column) && column_exists?(table, old_column)
-
-        rows_to_migrate = define_model_for(table)
-          .where(new_column => nil)
-          .where
-          .not(old_column => nil)
-
-        if rows_to_migrate.any?
-          BackgroundMigrationWorker.perform_in(
-            RESCHEDULE_DELAY,
-            self.class.name,
-            [table, old_column, new_column]
-          )
-        else
-          cleanup_concurrent_schema_change(table, old_column, new_column)
-        end
-      end
-
-      def cleanup_concurrent_schema_change(_table, _old_column, _new_column)
-        raise NotImplementedError
-      end
-
-      # These methods are necessary so we can re-use the migration helpers in
-      # this class.
-      def connection
-        ActiveRecord::Base.connection
-      end
-
-      def method_missing(name, *args, &block)
-        connection.__send__(name, *args, &block) # rubocop: disable GitlabSecurity/PublicSend
-      end
-
-      def respond_to_missing?(*args)
-        connection.respond_to?(*args) || super
-      end
-
-      def define_model_for(table)
-        Class.new(ActiveRecord::Base) do
-          self.table_name = table
-        end
-      end
-    end
-  end
-end

lib/gitlab/background_migration/cleanup_concurrent_type_change.rb

-# frozen_string_literal: true
-
-module Gitlab
-  module BackgroundMigration
-    # Background migration for cleaning up a concurrent column type changeb.
-    class CleanupConcurrentTypeChange < CleanupConcurrentSchemaChange
-      RESCHEDULE_DELAY = 10.minutes
-
-      def cleanup_concurrent_schema_change(table, old_column, new_column)
-        cleanup_concurrent_column_type_change(table, old_column)
-      end
-    end
-  end
-end

lib/gitlab/background_migration/copy_column.rb

-# frozen_string_literal: true
-
-module Gitlab
-  module BackgroundMigration
-    # CopyColumn is a simple (reusable) background migration that can be used to
-    # update the value of a column based on the value of another column in the
-    # same table.
-    #
-    # For this background migration to work the table that is migrated _has_ to
-    # have an `id` column as the primary key.
-    class CopyColumn
-      # table - The name of the table that contains the columns.
-      # copy_from - The column containing the data to copy.
-      # copy_to - The column to copy the data to.
-      # start_id - The start ID of the range of rows to update.
-      # end_id - The end ID of the range of rows to update.
-      def perform(table, copy_from, copy_to, start_id, end_id)
-        return unless connection.column_exists?(table, copy_to)
-
-        quoted_table = connection.quote_table_name(table)
-        quoted_copy_from = connection.quote_column_name(copy_from)
-        quoted_copy_to = connection.quote_column_name(copy_to)
-
-        # We're using raw SQL here since this job may be frequently executed. As
-        # a result dynamically defining models would lead to many unnecessary
-        # schema information queries.
-        connection.execute <<-SQL.strip_heredoc
-        UPDATE #{quoted_table}
-        SET #{quoted_copy_to} = #{quoted_copy_from}
-        WHERE id BETWEEN #{start_id} AND #{end_id}
-        AND #{quoted_copy_from} IS NOT NULL
-        AND #{quoted_copy_to} IS NULL
-        SQL
-      end
-
-      def connection
-        ActiveRecord::Base.connection
-      end
-    end
-  end
-end

spec/lib/gitlab/background_migration/cleanup_concurrent_schema_change_spec.rb

-# frozen_string_literal: true
-require 'spec_helper'
-
-RSpec.describe Gitlab::BackgroundMigration::CleanupConcurrentSchemaChange do
-  describe '#perform' do
-    it 'new column does not exist' do
-      expect(subject).to receive(:column_exists?).with(:issues, :closed_at_timestamp).and_return(false)
-      expect(subject).not_to receive(:column_exists?).with(:issues, :closed_at)
-      expect(subject).not_to receive(:define_model_for)
-
-      expect(subject.perform(:issues, :closed_at, :closed_at_timestamp)).to be_nil
-    end
-
-    it 'old column does not exist' do
-      expect(subject).to receive(:column_exists?).with(:issues, :closed_at_timestamp).and_return(true)
-      expect(subject).to receive(:column_exists?).with(:issues, :closed_at).and_return(false)
-      expect(subject).not_to receive(:define_model_for)
-
-      expect(subject.perform(:issues, :closed_at, :closed_at_timestamp)).to be_nil
-    end
-
-    it 'has both old and new columns' do
-      expect(subject).to receive(:column_exists?).twice.and_return(true)
-
-      expect { subject.perform('issues', :closed_at, :created_at) }.to raise_error(NotImplementedError)
-    end
-  end
-end