online_migrations 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87bf9f8f917c2d14e8a2e5584a2710dec5ccd66051730b8bb1b5a0b765b70ccb
-  data.tar.gz: 0cbf86b34c7d62f1466c877df231c2d39f3f4d5c2bd4f4dbef080f56e3254a74
+  metadata.gz: 95f3b31c9fe8edb868fade7dbdaed0ebf78d53da7a1ff52786a748663bc93bf5
+  data.tar.gz: 94c2fed042d39993d85f6641db3b4a86c3a360b3c858f48aeb2da052bb2c52cc
 SHA512:
-  metadata.gz: 3184f370a4cb3a3fa150ff24644355bc6c928eaa88331a0e18ee6f2c2448917898f5165675381162701f49881018516533b97e2364204a5a6ebd8bb19b3063cc
-  data.tar.gz: 954f9d33eba0e94020e0c9de77fd47097cd192915ad60a6c08aff8ab6d7a54b06a6938a50191c6b75596ae06b427076809472098b90a633549f2208ca358c656
+  metadata.gz: f844aa5e502a91739923039a8fb84d10ae9682404bd14bd4b92352400c6dae82963b21166178c72c47ea4ecbd0792b6f46da151d92ce205e217a5788c9a8b27a
+  data.tar.gz: 2db40b6b3cf81f923251f16a023aedbb18f8f24d28abb9e6b638090030c013c24dd6a41942df3e4f4cd1264c84c997eaaeb6adcb1c2d8d8844bc4934406f9ebc

data/BACKGROUND_MIGRATIONS.md

@@ -116,9 +116,12 @@ enqueue_background_migration("MyMigrationWithArgs", arg1, arg2, ...)
 
 ## Predefined background migrations
 
-* `BackfillColumn` - backfills column(s) with scalar values
-* `CopyColumn` - copies data from one column(s) to other(s)
-* `ResetCounters` - resets one or more counter caches to their correct value
+* `BackfillColumn` - backfills column(s) with scalar values (enqueue using `backfill_column_in_background`)
+* `CopyColumn` - copies data from one column(s) to other(s) (enqueue using `copy_column_in_background`)
+* `DeleteAssociatedRecords` - deletes records associated with a parent object (enqueue using `delete_associated_records_in_background`)
+* `DeleteOrphanedRecords` - deletes records with one or more missing relations (enqueue using `delete_orphaned_records_in_background`)
+* `PerformActionOnRelation` - performs specific action on a relation or indvidual records (enqueue using `perform_action_on_relation_in_background`)
+* `ResetCounters` - resets one or more counter caches to their correct value (enqueue using `reset_counters_in_background`)
 
 ## Testing
 
@@ -262,8 +265,6 @@ The error handler should be a lambda that accepts 2 arguments:
 
 * `error`: The exception that was raised.
 * `errored_job`: An `OnlineMigrations::BackgroundMigrations::MigrationJob` object that represents a failed batch.
-* `errored_element`: The `OnlineMigrations::BackgroundMigrations::MigrationJob` object representing a batch,
-  that was being processed when the Background Migration raised an exception.
 
 ### Customizing the background migrations module
 

data/CHANGELOG.md

@@ -1,5 +1,86 @@
 ## master (unreleased)
 
+## 0.5.1 (2022-07-19)
+
+- Raise for possible index corruption in all environments (previously, the check was made only
+  in the production environment)
+
+## 0.5.0 (2022-06-23)
+
+- Added check for index corruption with PostgreSQL 14.0 to 14.3
+
+- No need to separately remove indexes when removing a column from the small table
+
+- Add ability to perform specific action on a relation or individual records using background migrations
+
+    Example, assuming you have lots and lots of fraud likes:
+
+    ```ruby
+    class DeleteFraudLikes < ActiveRecord::Migration[7.0]
+      def up
+        perform_action_on_relation_in_background("Like", { fraud: true }, :delete_all)
+      end
+    end
+    ```
+
+    Example, assuming you added a new column to the users and want to populate it:
+
+    ```ruby
+    class User < ApplicationRecord
+      def generate_invite_token
+        self.invite_token = # some complex logic
+      end
+    end
+
+    perform_action_on_relation_in_background("User", { invite_token: nil }, :generate_invite_token)
+    ```
+
+    You can use `delete_all`/`destroy_all`/`update_all` for the whole relation or run specific methods on individual records.
+
+- Add ability to delete records associated with a parent object using background migrations
+
+    ```ruby
+      class Link < ActiveRecord::Base
+        has_many :clicks
+      end
+
+      class Click < ActiveRecord::Base
+        belongs_to :link
+      end
+
+      class DeleteSomeLinkClicks < ActiveRecord::Migration[7.0]
+        def up
+          some_link = ...
+          delete_associated_records_in_background("Link", some_link.id, :clicks)
+        end
+      end
+    ```
+
+- Add ability to delete orphaned records using background migrations
+
+    ```ruby
+      class User < ApplicationRecord
+        has_many :posts
+      end
+
+      class Post < ApplicationRecord
+        belongs_to :author, class_name: 'User'
+      end
+
+      class DeleteOrphanedPosts < ActiveRecord::Migration[7.0]
+        def up
+          delete_orphaned_records_in_background("Post", :author)
+        end
+      end
+    ```
+
+## 0.4.1 (2022-03-21)
+
+- Fix missing options in suggested command for columns removal
+- Fix retrieving raw postgresql connection
+
+## 0.4.0 (2022-03-17)
+
 - Lazy load this gem
 
 - Add ability to reset counter caches using background migrations

data/README.md

@@ -351,7 +351,7 @@ A safer approach can be accomplished in several steps:
   ```ruby
   class CleanupChangeFilesSizeType < ActiveRecord::Migration[7.0]
     def up
-      cleanup_change_column_type_concurrently :files, :size
+      cleanup_column_type_change :files, :size
     end
 
     def down

data/lib/online_migrations/background_migrations/delete_associated_records.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module OnlineMigrations
+  module BackgroundMigrations
+    # @private
+    class DeleteAssociatedRecords < BackgroundMigration
+      attr_reader :record, :association
+
+      def initialize(model_name, record_id, association, _options = {})
+        model = Object.const_get(model_name, false)
+        @record = model.find(record_id)
+        @association = association
+      end
+
+      def relation
+        unless @record.respond_to?(association)
+          raise ArgumentError, "'#{@record.class.name}' has no association called '#{association}'"
+        end
+
+        record.public_send(association)
+      end
+
+      def process_batch(relation)
+        relation.delete_all(:delete_all)
+      end
+    end
+  end
+end

data/lib/online_migrations/background_migrations/delete_orphaned_records.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OnlineMigrations
+  module BackgroundMigrations
+    # @private
+    class DeleteOrphanedRecords < BackgroundMigration
+      attr_reader :model, :associations
+
+      def initialize(model_name, associations, _options = {})
+        @model = Object.const_get(model_name, false)
+        @associations = associations.map(&:to_sym)
+      end
+
+      def relation
+        # For ActiveRecord 6.1+ we can use `where.missing`
+        # https://github.com/rails/rails/pull/34727
+        associations.inject(model.unscoped) do |relation, association|
+          reflection = model.reflect_on_association(association)
+          unless reflection
+            raise ArgumentError, "'#{model.name}' has no association called '#{association}'"
+          end
+
+          # left_joins was added in ActiveRecord 5.0 - https://github.com/rails/rails/pull/12071
+          relation
+            .left_joins(association)
+            .where(reflection.table_name => { reflection.association_primary_key => nil })
+        end
+      end
+
+      def process_batch(relation)
+        if Utils.ar_version > 5.0
+          relation.delete_all
+        else
+          # Older ActiveRecord generates incorrect query when running delete_all
+          primary_key = model.primary_key
+          model.unscoped.where(primary_key => relation.select(primary_key)).delete_all
+        end
+      end
+
+      def count
+        Utils.estimated_count(model.connection, model.table_name)
+      end
+    end
+  end
+end

data/lib/online_migrations/background_migrations/migration_helpers.rb

@@ -21,7 +21,7 @@ module OnlineMigrations
       # @example Additional background migration options
       #   backfill_column_in_background(:users, :admin, false, batch_size: 10_000)
       #
-      # @note This method is better suited for extra large tables (100s of millions of records).
+      # @note This method is better suited for large tables (10/100s of millions of records).
       #     For smaller tables it is probably better and easier to use more flexible `update_column_in_batches`.
       #
       # @note Consider `backfill_columns_in_background` when backfilling multiple columns
@@ -76,7 +76,7 @@ module OnlineMigrations
       # @example Additional background migration options
       #   backfill_column_for_type_change_in_background(:files, :size, batch_size: 10_000)
       #
-      # @note This method is better suited for extra large tables (100s of millions of records).
+      # @note This method is better suited for large tables (10/100s of millions of records).
       #     For smaller tables it is probably better and easier to use more flexible `backfill_column_for_type_change`.
       #
       def backfill_column_for_type_change_in_background(table_name, column_name, model_name: nil,
@@ -131,7 +131,7 @@ module OnlineMigrations
       # @example
       #   copy_column_in_background(:users, :id, :id_for_type_change)
       #
-      # @note This method is better suited for extra large tables (100s of millions of records).
+      # @note This method is better suited for large tables (10/100s of millions of records).
       #     For smaller tables it is probably better and easier to use more flexible `update_column_in_batches`.
       #
       def copy_column_in_background(table_name, copy_from, copy_to, model_name: nil, type_cast_function: nil, **options)
@@ -190,7 +190,7 @@ module OnlineMigrations
       #
       # @see https://api.rubyonrails.org/classes/ActiveRecord/CounterCache/ClassMethods.html#method-i-reset_counters
       #
-      # @note This method is better suited for extra large tables (100s of millions of records).
+      # @note This method is better suited for large tables (10/100s of millions of records).
       #     For smaller tables it is probably better and easier to use `reset_counters` from the ActiveRecord.
       #
       def reset_counters_in_background(model_name, *counters, touch: nil, **options)
@@ -205,6 +205,115 @@ module OnlineMigrations
         )
       end
 
+      # Deletes records with one or more missing relations using background migrations.
+      # This is useful when some referential integrity in the database is broken and
+      # you want to delete orphaned records.
+      #
+      # @param model_name [String]
+      # @param associations [Array]
+      # @param options [Hash] used to control the behavior of background migration.
+      #     See `#enqueue_background_migration`
+      #
+      # @return [OnlineMigrations::BackgroundMigrations::Migration]
+      #
+      # @example
+      #     delete_orphaned_records_in_background("Post", :author)
+      #
+      # @note This method is better suited for large tables (10/100s of millions of records).
+      #     For smaller tables it is probably better and easier to directly find and delete orpahed records.
+      #
+      def delete_orphaned_records_in_background(model_name, *associations, **options)
+        if Utils.ar_version <= 4.2
+          raise "#{__method__} does not support ActiveRecord <= 4.2 yet"
+        end
+
+        model_name = model_name.name if model_name.is_a?(Class)
+
+        enqueue_background_migration(
+          "DeleteOrphanedRecords",
+          model_name,
+          associations,
+          **options
+        )
+      end
+
+      # Deletes associated records for a specific parent record using background migrations.
+      # This is useful when you are planning to remove a parent object (user, account etc)
+      # and needs to remove lots of its associated objects.
+      #
+      # @param model_name [String]
+      # @param record_id [Integer, String] parent record primary key's value
+      # @param association [String, Symbol] association name for which records will be removed
+      # @param options [Hash] used to control the behavior of background migration.
+      #     See `#enqueue_background_migration`
+      #
+      # @return [OnlineMigrations::BackgroundMigrations::Migration]
+      #
+      # @example
+      #     delete_associated_records_in_background("Link", 1, :clicks)
+      #
+      # @note This method is better suited for large tables (10/100s of millions of records).
+      #     For smaller tables it is probably better and easier to directly delete associated records.
+      #
+      def delete_associated_records_in_background(model_name, record_id, association, **options)
+        model_name = model_name.name if model_name.is_a?(Class)
+
+        enqueue_background_migration(
+          "DeleteAssociatedRecords",
+          model_name,
+          record_id,
+          association,
+          **options
+        )
+      end
+
+      # Performs specific action on a relation or individual records.
+      # This is useful when you want to delete/destroy/update/etc records based on some conditions.
+      #
+      # @param model_name [String]
+      # @param conditions [Array, Hash, String] conditions to filter the relation
+      # @param action [String, Symbol] action to perform on the relation or individual records.
+      #     Relation-wide available actions: `:delete_all`, `:destroy_all`, and `:update_all`.
+      # @param updates [Hash] updates to perform when `action` is set to `:update_all`
+      # @param options [Hash] used to control the behavior of background migration.
+      #     See `#enqueue_background_migration`
+      #
+      # @return [OnlineMigrations::BackgroundMigrations::Migration]
+      #
+      # @example Delete records
+      #     perform_action_on_relation_in_background("User", { banned: true }, :delete_all)
+      #
+      # @example Destroy records
+      #     perform_action_on_relation_in_background("User", { banned: true }, :destroy_all)
+      #
+      # @example Update records
+      #     perform_action_on_relation_in_background("User", { banned: nil }, :update_all, updates: { banned: false })
+      #
+      # @example Perform custom method on individual records
+      #     class User < ApplicationRecord
+      #       def generate_invite_token
+      #         self.invite_token = # some complex logic
+      #       end
+      #     end
+      #
+      #     perform_action_on_relation_in_background("User", { invite_token: nil }, :generate_invite_token)
+      #
+      # @note This method is better suited for large tables (10/100s of millions of records).
+      #     For smaller tables it is probably better and easier to directly delete associated records.
+      #
+      def perform_action_on_relation_in_background(model_name, conditions, action, updates: nil, **options)
+        model_name = model_name.name if model_name.is_a?(Class)
+
+        enqueue_background_migration(
+          "PerformActionOnRelation",
+          model_name,
+          conditions,
+          action,
+          { updates: updates },
+          **options
+        )
+      end
+
       # Creates a background migration for the given job class name.
       #
       # A background migration runs one job at a time, computing the bounds of the next batch

data/lib/online_migrations/background_migrations/perform_action_on_relation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OnlineMigrations
+  module BackgroundMigrations
+    # @private
+    class PerformActionOnRelation < BackgroundMigration
+      attr_reader :model, :conditions, :action, :options
+
+      def initialize(model_name, conditions, action, options = {})
+        @model = Object.const_get(model_name, false)
+        @conditions = conditions
+        @action = action.to_sym
+        @options = options.symbolize_keys
+      end
+
+      def relation
+        model.unscoped.where(conditions)
+      end
+
+      def process_batch(relation)
+        case action
+        when :update_all
+          updates = options.fetch(:updates)
+          relation.public_send(action, updates)
+        when :delete_all, :destroy_all
+          relation.public_send(action)
+        else
+          relation.each(&action)
+        end
+      end
+    end
+  end
+end

data/lib/online_migrations/change_column_type_helpers.rb

@@ -100,7 +100,7 @@ module OnlineMigrations
       end.to_h
 
       if (extra_keys = (options.keys - conversions.keys)).any?
-        raise ArgumentError, "Options has unknown keys: #{extra_keys.map(&:inspect).join(', ')}. "\
+        raise ArgumentError, "Options has unknown keys: #{extra_keys.map(&:inspect).join(', ')}. " \
                              "Can contain only column names: #{conversions.keys.map(&:inspect).join(', ')}."
       end
 
@@ -110,7 +110,7 @@ module OnlineMigrations
           column_options = options[column_name] || {}
           tmp_column_name = conversions[column_name]
 
-          if __raw_connection.server_version >= 11_00_00 &&
+          if raw_connection.server_version >= 11_00_00 &&
              primary_key(table_name) == column_name.to_s && old_col.type == :integer
             # If the column to be converted is a Primary Key, set it to
             # `NOT NULL DEFAULT 0` and we'll copy the correct values when backfilling.
@@ -173,7 +173,7 @@ module OnlineMigrations
     #   backfill_column_for_type_change(:files, :size, batch_size: 10_000)
     #
     # @note This method should not be run within a transaction
-    # @note For extra large tables (100s of millions of records)
+    # @note For large tables (10/100s of millions of records)
     #   it is recommended to use `backfill_column_for_type_change_in_background`.
     #
     def backfill_column_for_type_change(table_name, column_name, type_cast_function: nil, **options)
@@ -400,7 +400,7 @@ module OnlineMigrations
 
           # This is necessary as we can't properly rename indexes such as "taggings_idx".
           unless index.name.include?(from_column)
-            raise "The index #{index.name} can not be copied as it does not "\
+            raise "The index #{index.name} can not be copied as it does not " \
                   "mention the old column. You have to rename this index manually first."
           end
 

data/lib/online_migrations/command_checker.rb

@@ -316,7 +316,7 @@ module OnlineMigrations
               initialize_change_code: command_str(:initialize_column_type_change, table_name, column_name, type, **options),
               backfill_code: command_str(:backfill_column_for_type_change, table_name, column_name, **options),
               finalize_code: command_str(:finalize_column_type_change, table_name, column_name),
-              cleanup_code: command_str(:cleanup_change_column_type_concurrently, table_name, column_name),
+              cleanup_code: command_str(:cleanup_column_type_change, table_name, column_name),
               cleanup_down_code: command_str(:initialize_column_type_change, table_name, column_name, existing_type)
           end
         end
@@ -381,9 +381,10 @@ module OnlineMigrations
           raise_error :remove_column,
             model: table_name.to_s.classify,
             columns: columns.inspect,
-            command: command_str(command, *args),
+            command: command_str(command, *args, options),
             table_name: table_name.inspect,
-            indexes: indexes.map { |i| i.name.to_sym.inspect }
+            indexes: indexes.map { |i| i.name.to_sym.inspect },
+            small_table: small_table?(table_name)
         end
       end
 
@@ -450,6 +451,10 @@ module OnlineMigrations
               command: command_str(:add_index, table_name, column_name, **options.merge(algorithm: :concurrently))
           end
 
+          if options[:algorithm] == :concurrently && index_corruption?
+            raise_error :add_index_corruption
+          end
+
           if @removed_indexes.any?
             index = IndexDefinition.new(table: table_name, columns: column_name, **options)
             existing_indexes = connection.indexes(table_name)
@@ -576,30 +581,30 @@ module OnlineMigrations
       end
 
       def new_or_small_table?(table_name)
-        small_tables = OnlineMigrations.config.small_tables
-
-        new_table?(table_name) ||
-          small_tables.include?(table_name.to_s)
+        new_table?(table_name) || small_table?(table_name)
       end
 
       def new_table?(table_name)
         @new_tables.include?(table_name.to_s)
       end
 
+      def small_table?(table_name)
+        OnlineMigrations.config.small_tables.include?(table_name.to_s)
+      end
+
       def postgresql_version
         version =
           if Utils.developer_env? && (target_version = OnlineMigrations.config.target_version)
             target_version.to_s
           else
-            # For rails 6.0+ we can use connection.database_version
-            pg_connection = connection.send(:__raw_connection)
-            database_version = pg_connection.server_version
-            patch = database_version % 100
-            database_version /= 100
-            minor = database_version % 100
-            database_version /= 100
-            major = database_version
-            "#{major}.#{minor}.#{patch}"
+            database_version = connection.select_value("SHOW server_version_num").to_i
+            major = database_version / 10000
+            if database_version >= 100000
+              minor = database_version % 10000
+            else
+              minor = (database_version % 10000) / 100
+            end
+            "#{major}.#{minor}"
           end
 
         Gem::Version.new(version)
@@ -737,6 +742,11 @@ module OnlineMigrations
         [table1.to_s, table2.to_s].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
       end
 
+      def index_corruption?
+        postgresql_version >= Gem::Version.new("14.0") &&
+          postgresql_version < Gem::Version.new("14.4")
+      end
+
       def run_custom_checks(method, args)
         OnlineMigrations.config.checks.each do |options, check|
           if !options[:start_after] || version > options[:start_after]

data/lib/online_migrations/command_recorder.rb

@@ -16,7 +16,9 @@ module OnlineMigrations
       :swap_column_names,
       :add_column_with_default,
       :add_not_null_constraint,
+      :remove_not_null_constraint,
       :add_text_limit_constraint,
+      :remove_text_limit_constraint,
       :add_reference_concurrently,
       :change_column_type_in_background,
       :enqueue_background_migration,
@@ -127,11 +129,14 @@ module OnlineMigrations
       end
 
       def invert_remove_text_limit_constraint(args)
-        unless args[2]
+        options = args.extract_options!
+        table_name, column, limit = args
+
+        unless limit
           raise ActiveRecord::IrreversibleMigration, "remove_text_limit_constraint is only reversible if given a limit."
         end
 
-        super
+        [:add_text_limit_constraint, [table_name, column, limit, **options]]
       end
   end
 end

data/lib/online_migrations/error_messages.rb

@@ -233,7 +233,7 @@ class <%= migration_name %> < <%= migration_parent %>
 end",
 
       remove_column:
-"<% if indexes.any? %>
+"<% if !small_table && indexes.any? %>
 Removing a column will automatically remove all of the indexes that involved the removed column.
 But the indexes would be removed non-concurrently, so you need to safely remove the indexes first:
 
@@ -333,6 +333,11 @@ class <%= migration_name %> < <%= migration_parent %>
   end
 end",
 
+      add_index_corruption:
+"Adding an index concurrently can cause silent data corruption in PostgreSQL 14.0 to 14.3.
+Upgrade PostgreSQL before adding new indexes, or wrap this step in a safety_assured { ... }
+block to accept the risk.",
+
       remove_index:
 "Removing an index non-concurrently blocks writes. Instead, use:
 

data/lib/online_migrations/schema_statements.rb

@@ -48,7 +48,7 @@ module OnlineMigrations
     # @note This method should not be run within a transaction
     # @note Consider `update_columns_in_batches` when updating multiple columns
     #   to avoid rewriting the table multiple times.
-    # @note For extra large tables (100s of millions of records)
+    # @note For large tables (10/100s of millions of records)
     #   you may consider using `backfill_column_in_background` or `copy_column_in_background`.
     #
     def update_column_in_batches(table_name, column_name, value, **options, &block)
@@ -361,7 +361,7 @@ module OnlineMigrations
     # These steps ensure a column can be added to a large and commonly used table
     # without locking the entire table for the duration of the table modification.
     #
-    # For extra large tables (100s of millions of records) you may consider implementing
+    # For large tables (10/100s of millions of records) you may consider implementing
     #   the steps from this helper method yourself as a separate migrations, replacing step #3
     #   with the help of background migrations (see `backfill_column_in_background`).
     #
@@ -396,7 +396,7 @@ module OnlineMigrations
         raise ArgumentError, "Expressions as default are not supported"
       end
 
-      if __raw_connection.server_version >= 11_00_00 && !Utils.volatile_default?(self, type, default)
+      if raw_connection.server_version >= 11_00_00 && !Utils.volatile_default?(self, type, default)
         add_column(table_name, column_name, type, **options)
       else
         __ensure_not_in_transaction!
@@ -404,7 +404,7 @@ module OnlineMigrations
         batch_options = options.extract!(:batch_size, :batch_column_name, :progress, :pause_ms)
 
         if column_exists?(table_name, column_name)
-          Utils.say("Column was not created because it already exists (this may be due to an aborted migration "\
+          Utils.say("Column was not created because it already exists (this may be due to an aborted migration " \
                     "or similar) table_name: #{table_name}, column_name: #{column_name}")
         else
           transaction do
@@ -422,7 +422,7 @@ module OnlineMigrations
           add_not_null_constraint(table_name, column_name, validate: false)
           validate_not_null_constraint(table_name, column_name)
 
-          if __raw_connection.server_version >= 12_00_00
+          if raw_connection.server_version >= 12_00_00
             # In PostgreSQL 12+ it is safe to "promote" a CHECK constraint to `NOT NULL` for the column
             change_column_null(table_name, column_name, false)
             remove_not_null_constraint(table_name, column_name)
@@ -655,7 +655,7 @@ module OnlineMigrations
         schema = __schema_for_table(table_name)
 
         if __index_valid?(index_name, schema: schema)
-          Utils.say("Index was not created because it already exists (this may be due to an aborted migration "\
+          Utils.say("Index was not created because it already exists (this may be due to an aborted migration " \
                     "or similar): table_name: #{table_name}, column_name: #{column_name}")
           return
         else
@@ -699,7 +699,7 @@ module OnlineMigrations
           end
         end
       else
-        Utils.say("Index was not removed because it does not exist (this may be due to an aborted migration "\
+        Utils.say("Index was not removed because it does not exist (this may be due to an aborted migration " \
                   "or similar): table_name: #{table_name}, column_name: #{column_names}")
       end
     end
@@ -768,7 +768,7 @@ module OnlineMigrations
       constraint_name = __check_constraint_name(table_name, expression: expression, **options)
 
       if __check_constraint_exists?(table_name, constraint_name)
-        Utils.say("Check constraint was not created because it already exists (this may be due to an aborted migration "\
+        Utils.say("Check constraint was not created because it already exists (this may be due to an aborted migration " \
                   "or similar) table_name: #{table_name}, expression: #{expression}, constraint name: #{constraint_name}")
       else
         query = "ALTER TABLE #{table_name} ADD CONSTRAINT #{constraint_name} CHECK (#{expression})"
@@ -1046,14 +1046,5 @@ module OnlineMigrations
         _, schema = table_name.to_s.split(".").reverse
         schema ? quote(schema) : "current_schema()"
       end
-
-      def __raw_connection
-        # ActiveRecord > 7.0.2.2 (https://github.com/rails/rails/pull/44530)
-        if defined?(@raw_connection)
-          @raw_connection
-        else
-          @connection
-        end
-      end
   end
 end

data/lib/online_migrations/verbose_sql_logs.rb

@@ -26,7 +26,7 @@ module OnlineMigrations
 
       private
         def verbose_query_logs
-          if Utils.ar_version > 7.0
+          if Utils.ar_version >= 7.0
             ActiveRecord.verbose_query_logs
           elsif Utils.ar_version >= 5.2
             ActiveRecord::Base.verbose_query_logs
@@ -34,7 +34,7 @@ module OnlineMigrations
         end
 
         def set_verbose_query_logs(value) # rubocop:disable Naming/AccessorMethodName
-          if Utils.ar_version > 7.0
+          if Utils.ar_version >= 7.0
             ActiveRecord.verbose_query_logs = value
           elsif Utils.ar_version >= 5.2
             ActiveRecord::Base.verbose_query_logs = value

data/lib/online_migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OnlineMigrations
-  VERSION = "0.4.0"
+  VERSION = "0.5.1"
 end

data/lib/online_migrations.rb

@@ -46,6 +46,9 @@ module OnlineMigrations
     autoload :BackgroundMigrationClassValidator
     autoload :BackfillColumn
     autoload :CopyColumn
+    autoload :DeleteAssociatedRecords
+    autoload :DeleteOrphanedRecords
+    autoload :PerformActionOnRelation
     autoload :ResetCounters
     autoload :MigrationJob
     autoload :Migration

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: online_migrations
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - fatkodima
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-17 00:00:00.000000000 Z
+date: 2022-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -47,6 +47,8 @@ files:
 - lib/online_migrations/background_migrations/background_migration_class_validator.rb
 - lib/online_migrations/background_migrations/config.rb
 - lib/online_migrations/background_migrations/copy_column.rb
+- lib/online_migrations/background_migrations/delete_associated_records.rb
+- lib/online_migrations/background_migrations/delete_orphaned_records.rb
 - lib/online_migrations/background_migrations/migration.rb
 - lib/online_migrations/background_migrations/migration_helpers.rb
 - lib/online_migrations/background_migrations/migration_job.rb
@@ -54,6 +56,7 @@ files:
 - lib/online_migrations/background_migrations/migration_job_status_validator.rb
 - lib/online_migrations/background_migrations/migration_runner.rb
 - lib/online_migrations/background_migrations/migration_status_validator.rb
+- lib/online_migrations/background_migrations/perform_action_on_relation.rb
 - lib/online_migrations/background_migrations/reset_counters.rb
 - lib/online_migrations/background_migrations/scheduler.rb
 - lib/online_migrations/batch_iterator.rb
@@ -98,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Catch unsafe PostgreSQL migrations in development and run them easier in