online_migrations 0.10.0 → 0.11.0

data/lib/online_migrations/change_column_type_helpers.rb

@@ -72,6 +72,9 @@ module OnlineMigrations
     #
     # @example With additional column options
     #   initialize_column_type_change(:users, :name, :string, limit: 64)
+    # @example With type casting
+    #   initialize_column_type_change(:users, :settings, :jsonb, type_cast_function: "jsonb")
+    #   initialize_column_type_change(:users, :company_id, :integer, type_cast_function: Arel.sql("company_id::integer"))
     #
     def initialize_column_type_change(table_name, column_name, new_type, **options)
       initialize_columns_type_change(table_name, [[column_name, new_type]], column_name => options)
@@ -91,13 +94,13 @@ module OnlineMigrations
     # @see #initialize_column_type_change
     #
     def initialize_columns_type_change(table_name, columns_and_types, **options)
-      if !columns_and_types.is_a?(Array) || !columns_and_types.all? { |e| e.is_a?(Array) }
+      if !columns_and_types.is_a?(Array) || !columns_and_types.all?(Array)
         raise ArgumentError, "columns_and_types must be an array of arrays"
       end
 
-      conversions = columns_and_types.map do |(column_name, _new_type)|
+      conversions = columns_and_types.to_h do |(column_name, _new_type)|
         [column_name, __change_type_column(column_name)]
-      end.to_h
+      end
 
       if (extra_keys = (options.keys - conversions.keys)).any?
         raise ArgumentError, "Options has unknown keys: #{extra_keys.map(&:inspect).join(', ')}. " \
@@ -105,10 +108,14 @@ module OnlineMigrations
       end
 
       transaction do
+        type_cast_functions = {}.with_indifferent_access
+
         columns_and_types.each do |(column_name, new_type)|
-          old_col = __column_for(table_name, column_name)
+          old_col = column_for(table_name, column_name)
           old_col_options = __options_from_column(old_col, [:collation, :comment])
           column_options = options[column_name] || {}
+          type_cast_function = column_options.delete(:type_cast_function)
+          type_cast_functions[column_name] = type_cast_function if type_cast_function
           tmp_column_name = conversions[column_name]
 
           if raw_connection.server_version >= 11_00_00
@@ -132,7 +139,7 @@ module OnlineMigrations
           end
         end
 
-        __create_copy_triggers(table_name, conversions.keys, conversions.values)
+        __create_copy_triggers(table_name, conversions.keys, conversions.values, type_cast_functions: type_cast_functions)
       end
     end
 
@@ -239,13 +246,15 @@ module OnlineMigrations
     def finalize_columns_type_change(table_name, *column_names)
       __ensure_not_in_transaction!
 
-      conversions = column_names.map do |column_name|
+      conversions = column_names.to_h do |column_name|
         [column_name.to_s, __change_type_column(column_name)]
-      end.to_h
+      end
+
+      primary_key = primary_key(table_name)
 
       conversions.each do |column_name, tmp_column_name|
-        old_column = __column_for(table_name, column_name)
-        column = __column_for(table_name, tmp_column_name)
+        old_column = column_for(table_name, column_name)
+        column = column_for(table_name, tmp_column_name)
 
         # We already set default and NOT NULL for to-be-PK columns
         # for PG >= 11, so can skip this case
@@ -264,7 +273,12 @@ module OnlineMigrations
         __copy_foreign_keys(table_name, column_name, tmp_column_name)
         __copy_check_constraints(table_name, column_name, tmp_column_name)
 
-        if primary_key(table_name) == column_name
+        # Exclusion constraints were added in https://github.com/rails/rails/pull/40224.
+        if Utils.ar_version >= 7.1
+          __copy_exclusion_constraints(table_name, column_name, tmp_column_name)
+        end
+
+        if column_name == primary_key
           __finalize_primary_key_type_change(table_name, column_name, column_names)
         end
       end
@@ -274,7 +288,7 @@ module OnlineMigrations
       # already were swapped and which were not.
       transaction do
         conversions
-          .reject { |column_name, _tmp_column_name| column_name == primary_key(table_name) }
+          .reject { |column_name, _tmp_column_name| column_name == primary_key }
           .each do |column_name, tmp_column_name|
             swap_column_names(table_name, column_name, tmp_column_name)
           end
@@ -302,40 +316,27 @@ module OnlineMigrations
     def revert_finalize_columns_type_change(table_name, *column_names)
       __ensure_not_in_transaction!
 
-      conversions = column_names.map do |column_name|
+      conversions = column_names.to_h do |column_name|
         [column_name.to_s, __change_type_column(column_name)]
-      end.to_h
-
-      transaction do
-        conversions
-          .reject { |column_name, _tmp_column_name| column_name == primary_key(table_name) }
-          .each do |column_name, tmp_column_name|
-            swap_column_names(table_name, column_name, tmp_column_name)
-          end
-
-        __reset_trigger_function(table_name, column_names)
       end
 
-      conversions.each do |column_name, tmp_column_name|
-        indexes(table_name).each do |index|
-          if index.columns.include?(tmp_column_name)
-            remove_index(table_name, tmp_column_name, algorithm: :concurrently)
-          end
-        end
+      primary_key = primary_key(table_name)
+      primary_key_conversion = conversions.delete(primary_key)
 
-        foreign_keys(table_name).each do |fk|
-          if fk.column == tmp_column_name
-            remove_foreign_key(table_name, column: tmp_column_name)
+      # No need to remove indexes, foreign keys etc, because it  can take a significant amount
+      # of time and will be automatically removed if decided to remove the column itself.
+      if conversions.any?
+        transaction do
+          conversions.each do |column_name, tmp_column_name|
+            swap_column_names(table_name, column_name, tmp_column_name)
           end
-        end
 
-        __check_constraints_for(table_name, tmp_column_name).each do |constraint|
-          remove_check_constraint(table_name, name: constraint.constraint_name)
+          __reset_trigger_function(table_name, column_names)
         end
+      end
 
-        if primary_key(table_name) == column_name
-          __finalize_primary_key_type_change(table_name, column_name, column_names)
-        end
+      if primary_key_conversion
+        __finalize_primary_key_type_change(table_name, primary_key, column_names)
       end
     end
 
@@ -362,9 +363,9 @@ module OnlineMigrations
     # @see #cleanup_column_type_change
     #
     def cleanup_columns_type_change(table_name, *column_names)
-      conversions = column_names.map do |column_name|
-        [column_name, __change_type_column(column_name)]
-      end.to_h
+      conversions = column_names.index_with do |column_name|
+        __change_type_column(column_name)
+      end
 
       transaction do
         __remove_copy_triggers(table_name, conversions.keys, conversions.values)
@@ -392,8 +393,8 @@ module OnlineMigrations
         CopyTrigger.on_table(table_name, connection: self).name(from_column, to_column)
       end
 
-      def __create_copy_triggers(table_name, from_column, to_column)
-        CopyTrigger.on_table(table_name, connection: self).create(from_column, to_column)
+      def __create_copy_triggers(table_name, from_columns, to_columns, type_cast_functions: nil)
+        CopyTrigger.on_table(table_name, connection: self).create(from_columns, to_columns, type_cast_functions: type_cast_functions)
       end
 
       def __remove_copy_triggers(table_name, from_column, to_column)
@@ -419,8 +420,6 @@ module OnlineMigrations
             name = index.name.gsub(from_column, to_column)
           end
 
-          # Generate a shorter name if needed.
-          max_identifier_length = 63 # could use just `max_identifier_length` method for ActiveRecord >= 5.0.
           name = index_name(table_name, new_columns) if !name || name.length > max_identifier_length
 
           options = {
@@ -433,8 +432,7 @@ module OnlineMigrations
           options[:using] = index.using if index.using
           options[:where] = index.where if index.where
 
-          # Opclasses were added in 5.2
-          if Utils.ar_version >= 5.2 && !index.opclasses.blank?
+          if index.opclasses.present?
             opclasses = index.opclasses.dup
 
             # Copy the operator classes for the old column (if any) to the new column.
@@ -475,23 +473,39 @@ module OnlineMigrations
       end
 
       def __copy_check_constraints(table_name, from_column, to_column)
-        __check_constraints_for(table_name, from_column).each do |check|
-          expression = check["constraint_def"][/CHECK \({2}(.+)\){2}/, 1]
-          new_expression = expression.gsub(from_column.to_s, to_column.to_s)
+        check_constraints = check_constraints(table_name).select { |c| c.expression.include?(from_column) }
+
+        check_constraints.each do |check|
+          new_expression = check.expression.gsub(from_column, to_column)
 
           add_check_constraint(table_name, new_expression, validate: false)
 
-          if check["valid"]
+          if check.validated?
             validate_check_constraint(table_name, expression: new_expression)
           end
         end
       end
 
+      def __copy_exclusion_constraints(table_name, from_column, to_column)
+        exclusion_constraints = exclusion_constraints(table_name).select { |c| c.expression.include?(from_column) }
+
+        exclusion_constraints.each do |constraint|
+          new_expression = constraint.expression.gsub(from_column, to_column)
+          add_exclusion_constraint(
+            table_name,
+            new_expression,
+            using: constraint.using,
+            where: constraint.where,
+            deferrable: constraint.deferrable
+          )
+        end
+      end
+
       def __set_not_null(table_name, column_name)
         # For PG >= 12 we can "promote" CHECK constraint to NOT NULL constraint:
         # https://github.com/postgres/postgres/commit/bbb96c3704c041d139181c6601e5bc770e045d26
         if raw_connection.server_version >= 12_00_00
-          execute(<<-SQL.strip_heredoc)
+          execute(<<~SQL)
             ALTER TABLE #{quote_table_name(table_name)}
             ALTER #{quote_column_name(column_name)}
             SET NOT NULL
@@ -501,7 +515,7 @@ module OnlineMigrations
           # through PG internal tables.
           # In-depth analysis of implications of this was made, so this approach
           # is considered safe - https://habr.com/ru/company/haulmont/blog/493954/  (in russian).
-          execute(<<-SQL.strip_heredoc)
+          execute(<<~SQL)
             UPDATE pg_catalog.pg_attribute
             SET attnotnull = true
             WHERE attrelid = #{quote(table_name)}::regclass
@@ -510,37 +524,8 @@ module OnlineMigrations
         end
       end
 
-      def __check_constraints_for(table_name, column_name)
-        __check_constraints(table_name).select { |c| c["column_name"] == column_name }
-      end
-
-      def __check_constraints(table_name)
-        schema = __schema_for_table(table_name)
-
-        check_sql = <<-SQL.strip_heredoc
-          SELECT
-            ccu.column_name as column_name,
-            con.conname as constraint_name,
-            pg_get_constraintdef(con.oid) as constraint_def,
-            con.convalidated AS valid
-          FROM pg_catalog.pg_constraint con
-            INNER JOIN pg_catalog.pg_class rel
-              ON rel.oid = con.conrelid
-            INNER JOIN pg_catalog.pg_namespace nsp
-              ON nsp.oid = con.connamespace
-            INNER JOIN information_schema.constraint_column_usage ccu
-              ON con.conname = ccu.constraint_name
-                AND rel.relname = ccu.table_name
-          WHERE rel.relname = #{quote(table_name)}
-            AND con.contype = 'c'
-            AND nsp.nspname = #{schema}
-        SQL
-
-        select_all(check_sql)
-      end
-
       def __rename_constraint(table_name, old_name, new_name)
-        execute(<<-SQL.strip_heredoc)
+        execute(<<~SQL)
           ALTER TABLE #{quote_table_name(table_name)}
           RENAME CONSTRAINT #{quote_column_name(old_name)} TO #{quote_column_name(new_name)}
         SQL
@@ -612,7 +597,7 @@ module OnlineMigrations
       def __referencing_table_names(table_name)
         schema = __schema_for_table(table_name)
 
-        select_values(<<-SQL.strip_heredoc)
+        select_values(<<~SQL)
           SELECT DISTINCT con.conrelid::regclass::text AS conrelname
           FROM pg_catalog.pg_constraint con
             INNER JOIN pg_catalog.pg_namespace nsp

data/lib/online_migrations/command_checker.rb

@@ -154,13 +154,7 @@ module OnlineMigrations
           check_columns_removal(command, *args, **options)
         else
           if respond_to?(command, true)
-            if options.any?
-              # Workaround for Active Record < 5 change_column_default
-              # not accepting options.
-              send(command, *args, **options, &block)
-            else
-              send(command, *args, &block)
-            end
+            send(command, *args, **options, &block)
           else
             # assume it is safe
             true
@@ -362,9 +356,7 @@ module OnlineMigrations
               precision = options[:precision] || options[:limit] || 6
               existing_precision = existing_column.precision || existing_column.limit || 6
 
-              # PostgreSQL interval data type was added in https://github.com/rails/rails/pull/16919
-              (existing_type == :interval || (Utils.ar_version < 6.1 && existing_column.sql_type.start_with?("interval"))) &&
-              precision >= existing_precision
+              existing_type == :interval && precision >= existing_precision
             when :inet
               existing_type == :cidr
             else
@@ -487,7 +479,7 @@ module OnlineMigrations
 
       def add_reference(table_name, ref_name, **options)
         # Always added by default in 5.0+
-        index = options.fetch(:index) { Utils.ar_version >= 5.0 }
+        index = options.fetch(:index, true)
 
         if index.is_a?(Hash) && index[:using].to_s == "hash" && postgresql_version < Gem::Version.new("10")
           raise_error :add_hash_index
@@ -515,7 +507,7 @@ module OnlineMigrations
         end
 
         if !options[:polymorphic]
-          type = (options[:type] || (Utils.ar_version >= 5.1 ? :bigint : :integer)).to_sym
+          type = (options[:type] || :bigint).to_sym
           column_name = "#{ref_name}_id"
 
           foreign_key_options = foreign_key.is_a?(Hash) ? foreign_key : {}
@@ -573,9 +565,9 @@ module OnlineMigrations
         end
 
         if index_def
-          existing_options = [:name, :columns, :unique, :where, :type, :using, :opclasses].map do |option|
+          existing_options = [:name, :columns, :unique, :where, :type, :using, :opclasses].filter_map do |option|
             [option, index_def.public_send(option)] if index_def.respond_to?(option)
-          end.compact.to_h
+          end.to_h
 
           @removed_indexes << IndexDefinition.new(table: table_name, **existing_options)
         end
@@ -738,20 +730,10 @@ module OnlineMigrations
         template = OnlineMigrations.config.error_messages.fetch(message_key)
 
         vars[:migration_name] = @migration.name
-        vars[:migration_parent] = Utils.migration_parent_string
-        vars[:model_parent] = Utils.model_parent_string
+        vars[:migration_parent] = "ActiveRecord::Migration[#{Utils.ar_version}]"
         vars[:ar_version] = Utils.ar_version
 
-        if RUBY_VERSION >= "2.6"
-          message = ERB.new(template, trim_mode: "<>").result_with_hash(vars)
-        else
-          # `result_with_hash` was added in ruby 2.5
-          b = TOPLEVEL_BINDING.dup
-          vars.each_pair do |key, value|
-            b.local_variable_set(key, value)
-          end
-          message = ERB.new(template, nil, "<>").result(b)
-        end
+        message = ERB.new(template, trim_mode: "<>").result_with_hash(vars)
 
         if (link = ERROR_MESSAGE_TO_LINK[message_key])
           message += "\nFor more details, see https://github.com/fatkodima/online_migrations##{link}"
@@ -790,7 +772,7 @@ module OnlineMigrations
       end
 
       def crud_blocked?
-        locks_query = <<-SQL.strip_heredoc
+        locks_query = <<~SQL
           SELECT relation::regclass::text
           FROM pg_locks
           WHERE mode IN ('ShareLock', 'ShareRowExclusiveLock', 'ExclusiveLock', 'AccessExclusiveLock')
@@ -808,7 +790,7 @@ module OnlineMigrations
       end
 
       def check_constraints(table_name)
-        constraints_query = <<-SQL.strip_heredoc
+        constraints_query = <<~SQL
           SELECT pg_get_constraintdef(oid) AS def
           FROM pg_constraint
           WHERE contype = 'c'
@@ -829,7 +811,7 @@ module OnlineMigrations
 
       def check_mismatched_foreign_key_type(table_name, column_name, type, **options)
         column_name = column_name.to_s
-        ref_name = column_name.sub(/_id\z/, "")
+        ref_name = column_name.delete_suffix("_id")
 
         if like_foreign_key?(column_name, type)
           foreign_table_name = Utils.foreign_table_name(ref_name, options)

data/lib/online_migrations/config.rb

@@ -16,7 +16,6 @@ module OnlineMigrations
     #
     def start_after=(value)
       if value.is_a?(Hash)
-        ensure_supports_multiple_dbs
         @start_after = value.stringify_keys
       else
         @start_after = value
@@ -49,7 +48,6 @@ module OnlineMigrations
     #
     def target_version=(value)
       if value.is_a?(Hash)
-        ensure_supports_multiple_dbs
         @target_version = value.stringify_keys
       else
         @target_version = value
@@ -148,7 +146,7 @@ module OnlineMigrations
     # Returns a list of enabled checks
     #
     # All checks are enabled by default. To disable/enable a check use `disable_check`/`enable_check`.
-    # For the list of available checks look at `lib/error_messages` folder.
+    # For the list of available checks look at the `error_messages.rb` file.
     #
     # @return [Array]
     #
@@ -184,7 +182,7 @@ module OnlineMigrations
         attempts: 30,
         base_delay: 0.01.seconds,
         max_delay: 1.minute,
-        lock_timeout: 0.05.seconds
+        lock_timeout: 0.2.seconds
       )
 
       @background_migrations = BackgroundMigrations::Config.new
@@ -196,8 +194,8 @@ module OnlineMigrations
       @check_down = false
       @auto_analyze = false
       @alphabetize_schema = false
-      @enabled_checks = @error_messages.keys.map { |k| [k, {}] }.to_h
-      @verbose_sql_logs = defined?(Rails.env) && Rails.env.production?
+      @enabled_checks = @error_messages.keys.index_with({})
+      @verbose_sql_logs = defined?(Rails.env) && (Rails.env.production? || Rails.env.staging?)
     end
 
     def lock_retrier=(value)
@@ -210,7 +208,7 @@ module OnlineMigrations
 
     # Enables specific check
     #
-    # For the list of available checks look at `lib/error_messages` module.
+    # For the list of available checks look at the `error_messages.rb` file.
     #
     # @param name [Symbol] check name
     # @param start_after [Integer] migration version from which this check will be performed
@@ -222,7 +220,7 @@ module OnlineMigrations
 
     # Disables specific check
     #
-    # For the list of available checks look at `lib/error_messages` module.
+    # For the list of available checks look at the `error_messages.rb` file.
     #
     # @param name [Symbol] check name
     # @return [void]
@@ -233,7 +231,7 @@ module OnlineMigrations
 
     # Test whether specific check is enabled
     #
-    # For the list of available checks look at `lib/error_messages` module.
+    # For the list of available checks look at the `error_messages.rb` file.
     #
     # @param name [Symbol] check name
     # @param version [Integer] migration version
@@ -272,12 +270,6 @@ module OnlineMigrations
     end
 
     private
-      def ensure_supports_multiple_dbs
-        if !Utils.supports_multiple_dbs?
-          raise "OnlineMigrations does not support multiple databases for Active Record < 6.1"
-        end
-      end
-
       def db_config_name
         connection = OnlineMigrations.current_migration.connection
         connection.pool.db_config.name

data/lib/online_migrations/copy_trigger.rb

@@ -18,12 +18,12 @@ module OnlineMigrations
       "trigger_#{hashed_identifier}"
     end
 
-    def create(from_columns, to_columns)
+    def create(from_columns, to_columns, type_cast_functions: {})
       from_columns, to_columns = normalize_column_names(from_columns, to_columns)
       trigger_name = name(from_columns, to_columns)
-      assignment_clauses = assignment_clauses_for_columns(from_columns, to_columns)
+      assignment_clauses = assignment_clauses_for_columns(from_columns, to_columns, type_cast_functions)
 
-      connection.execute(<<-SQL.strip_heredoc)
+      connection.execute(<<~SQL)
         CREATE OR REPLACE FUNCTION #{trigger_name}() RETURNS TRIGGER AS $$
         BEGIN
           #{assignment_clauses};
@@ -32,11 +32,11 @@ module OnlineMigrations
         $$ LANGUAGE plpgsql;
       SQL
 
-      connection.execute(<<-SQL.strip_heredoc)
+      connection.execute(<<~SQL)
         DROP TRIGGER IF EXISTS #{trigger_name} ON #{quoted_table_name}
       SQL
 
-      connection.execute(<<-SQL.strip_heredoc)
+      connection.execute(<<~SQL)
         CREATE TRIGGER #{trigger_name}
           BEFORE INSERT OR UPDATE
           ON #{quoted_table_name}
@@ -75,14 +75,19 @@ module OnlineMigrations
         [from_columns, to_columns]
       end
 
-      def assignment_clauses_for_columns(from_columns, to_columns)
+      def assignment_clauses_for_columns(from_columns, to_columns, type_cast_functions)
         combined_column_names = to_columns.zip(from_columns)
 
         assignment_clauses = combined_column_names.map do |(new_name, old_name)|
-          new_name = connection.quote_column_name(new_name)
-          old_name = connection.quote_column_name(old_name)
-
-          "NEW.#{new_name} := NEW.#{old_name}"
+          quoted_new_name = connection.quote_column_name(new_name)
+          quoted_old_name = connection.quote_column_name(old_name)
+          type_cast_function = type_cast_functions[old_name]
+
+          if type_cast_function
+            "NEW.#{quoted_new_name} := #{type_cast_function.gsub(old_name.to_s, "NEW.#{quoted_old_name}")}"
+          else
+            "NEW.#{quoted_new_name} := NEW.#{quoted_old_name}"
+          end
         end
 
         assignment_clauses.join(";\n  ")

data/lib/online_migrations/error_messages.rb

@@ -109,14 +109,8 @@ A safer approach is to:
 
 1. ignore the column:
 
-  class <%= model %> < <%= model_parent %>
-<% if ar_version >= 5 %>
+  class <%= model %> < ApplicationRecord
     self.ignored_columns = [\"<%= column_name %>\"]
-<% else %>
-    def self.columns
-      super.reject { |c| c.name == \"<%= column_name %>\" }
-    end
-<% end %>
   end
 
 2. deploy
@@ -157,13 +151,7 @@ It will use a combination of a VIEW and column aliasing to work with both column
 <% if enumerate_columns_in_select_statements %>
 5. Ignore old column
 
-<% if ar_version >= 5 %>
   self.ignored_columns = [:<%= column_name %>]
-<% else %>
-  def self.columns
-    super.reject { |c| c.name == \"<%= column_name %>\" }
-  end
-<% end %>
 
 6. Deploy
 7. Remove the column rename config from step 1
@@ -216,6 +204,8 @@ which will be passed to `add_column` when creating a new column, so you can over
 
     def up
       <%= backfill_code %>
+      # You can use `backfill_column_for_type_change_in_background` if want to
+      # backfill using background migrations.
     end
 
     def down
@@ -223,7 +213,10 @@ which will be passed to `add_column` when creating a new column, so you can over
     end
   end
 
-3. Copy indexes, foreign keys, check constraints, NOT NULL constraint, swap new column in place:
+3. Make sure your application works with values in both formats (when read from the database, converting
+during writes works automatically). For most column type changes, this does not need any updates in the app.
+4. Deploy
+5. Copy indexes, foreign keys, check constraints, NOT NULL constraint, swap new column in place:
 
   class Finalize<%= migration_name %> < <%= migration_parent %>
     disable_ddl_transaction!
@@ -233,8 +226,8 @@ which will be passed to `add_column` when creating a new column, so you can over
     end
   end
 
-4. Deploy
-5. Finally, if everything is working as expected, remove copy trigger and old column:
+6. Deploy
+7. Finally, if everything works as expected, remove copy trigger and old column:
 
   class Cleanup<%= migration_name %> < <%= migration_parent %>
     def up
@@ -246,7 +239,8 @@ which will be passed to `add_column` when creating a new column, so you can over
     end
   end
 
-6. Deploy",
+8. Remove changes from step 3, if any
+9. Deploy",
 
       change_column_default:
 "Partial writes are enabled, which can cause incorrect values
@@ -303,14 +297,8 @@ A safer approach is to:
 
 1. Ignore the column(s):
 
-  class <%= model %> < <%= model_parent %>
-<% if ar_version >= 5 %>
+  class <%= model %> < ApplicationRecord
     self.ignored_columns = <%= columns %>
-<% else %>
-    def self.columns
-      super.reject { |c| <%= columns %>.include?(c.name) }
-    end
-<% end %>
   end
 
 2. Deploy
@@ -504,7 +492,7 @@ execute call, so cannot help you here. Make really sure that what
 you're doing is safe before proceeding, then wrap it in a safety_assured { ... } block.",
 
       multiple_foreign_keys:
-"Adding multiple foreign keys in a single migration blocks reads and writes on all involved tables until migration is completed.
+"Adding multiple foreign keys in a single migration blocks writes on all involved tables until migration is completed.
 Avoid adding foreign key more than once per migration file, unless the source and target tables are identical.",
 
       drop_table_multiple_foreign_keys:

data/lib/online_migrations/foreign_keys_collector.rb

@@ -9,8 +9,8 @@ module OnlineMigrations
       @referenced_tables = Set.new
     end
 
-    def collect(&table_definition)
-      table_definition.call(self)
+    def collect
+      yield self
     end
 
     def foreign_key(to_table, **_options)

data/lib/online_migrations/indexes_collector.rb

@@ -12,8 +12,8 @@ module OnlineMigrations
       @indexes = []
     end
 
-    def collect(&table_definition)
-      table_definition.call(self)
+    def collect
+      yield self
     end
 
     def index(_column_name, **options)
@@ -21,7 +21,7 @@ module OnlineMigrations
     end
 
     def references(*_ref_names, **options)
-      index = options.fetch(:index) { Utils.ar_version >= 5.0 }
+      index = options.fetch(:index, true)
 
       if index
         using = index.is_a?(Hash) ? index[:using].to_s : nil