activerecord 6.1.7.8 → 7.0.8.4

data/lib/active_record/migration.rb

@@ -9,7 +9,7 @@ require "active_support/core_ext/module/attribute_accessors"
 require "active_support/actionable_error"
 
 module ActiveRecord
-  class MigrationError < ActiveRecordError #:nodoc:
+  class MigrationError < ActiveRecordError # :nodoc:
     def initialize(message = nil)
       message = "\n\n#{message}\n\n" if message
       super
@@ -20,7 +20,7 @@ module ActiveRecord
   # For example the following migration is not reversible.
   # Rolling back this migration will raise an ActiveRecord::IrreversibleMigration error.
   #
-  #   class IrreversibleMigrationExample < ActiveRecord::Migration[6.0]
+  #   class IrreversibleMigrationExample < ActiveRecord::Migration[7.0]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -38,7 +38,7 @@ module ActiveRecord
   #
   # 1. Define <tt>#up</tt> and <tt>#down</tt> methods instead of <tt>#change</tt>:
   #
-  #  class ReversibleMigrationExample < ActiveRecord::Migration[6.0]
+  #  class ReversibleMigrationExample < ActiveRecord::Migration[7.0]
   #    def up
   #      create_table :distributors do |t|
   #        t.string :zipcode
@@ -63,7 +63,7 @@ module ActiveRecord
   #
   # 2. Use the #reversible method in <tt>#change</tt> method:
   #
-  #   class ReversibleMigrationExample < ActiveRecord::Migration[6.0]
+  #   class ReversibleMigrationExample < ActiveRecord::Migration[7.0]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -90,7 +90,7 @@ module ActiveRecord
   class IrreversibleMigration < MigrationError
   end
 
-  class DuplicateMigrationVersionError < MigrationError #:nodoc:
+  class DuplicateMigrationVersionError < MigrationError # :nodoc:
     def initialize(version = nil)
       if version
         super("Multiple migrations have the version number #{version}.")
@@ -100,7 +100,7 @@ module ActiveRecord
     end
   end
 
-  class DuplicateMigrationNameError < MigrationError #:nodoc:
+  class DuplicateMigrationNameError < MigrationError # :nodoc:
     def initialize(name = nil)
       if name
         super("Multiple migrations have the name #{name}.")
@@ -110,7 +110,7 @@ module ActiveRecord
     end
   end
 
-  class UnknownMigrationVersionError < MigrationError #:nodoc:
+  class UnknownMigrationVersionError < MigrationError # :nodoc:
     def initialize(version = nil)
       if version
         super("No migration with version number #{version}.")
@@ -120,7 +120,7 @@ module ActiveRecord
     end
   end
 
-  class IllegalMigrationNameError < MigrationError #:nodoc:
+  class IllegalMigrationNameError < MigrationError # :nodoc:
     def initialize(name = nil)
       if name
         super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed).")
@@ -130,13 +130,13 @@ module ActiveRecord
     end
   end
 
-  class PendingMigrationError < MigrationError #:nodoc:
+  class PendingMigrationError < MigrationError # :nodoc:
     include ActiveSupport::ActionableError
 
     action "Run pending migrations" do
       ActiveRecord::Tasks::DatabaseTasks.migrate
 
-      if ActiveRecord::Base.dump_schema_after_migration
+      if ActiveRecord.dump_schema_after_migration
         ActiveRecord::Tasks::DatabaseTasks.dump_schema(
           ActiveRecord::Base.connection_db_config
         )
@@ -165,7 +165,7 @@ module ActiveRecord
       end
   end
 
-  class ConcurrentMigrationError < MigrationError #:nodoc:
+  class ConcurrentMigrationError < MigrationError # :nodoc:
     DEFAULT_MESSAGE = "Cannot run migrations because another migration process is currently running."
     RELEASE_LOCK_FAILED_MESSAGE = "Failed to release advisory lock"
 
@@ -174,7 +174,7 @@ module ActiveRecord
     end
   end
 
-  class NoEnvironmentInSchemaError < MigrationError #:nodoc:
+  class NoEnvironmentInSchemaError < MigrationError # :nodoc:
     def initialize
       msg = "Environment data not found in the schema. To resolve this issue, run: \n\n        bin/rails db:environment:set"
       if defined?(Rails.env)
@@ -185,7 +185,7 @@ module ActiveRecord
     end
   end
 
-  class ProtectedEnvironmentError < ActiveRecordError #:nodoc:
+  class ProtectedEnvironmentError < ActiveRecordError # :nodoc:
     def initialize(env = "production")
       msg = +"You are attempting to run a destructive action against your '#{env}' database.\n"
       msg << "If you are sure you want to continue, run the same command with the environment variable:\n"
@@ -228,7 +228,7 @@ module ActiveRecord
   #
   # Example of a simple migration:
   #
-  #   class AddSsl < ActiveRecord::Migration[6.0]
+  #   class AddSsl < ActiveRecord::Migration[7.0]
   #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, default: true
   #     end
@@ -248,7 +248,7 @@ module ActiveRecord
   #
   # Example of a more complex migration that also needs to initialize data:
   #
-  #   class AddSystemSettings < ActiveRecord::Migration[6.0]
+  #   class AddSystemSettings < ActiveRecord::Migration[7.0]
   #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
@@ -326,7 +326,7 @@ module ActiveRecord
   #   details.
   # * <tt>change_table(name, options)</tt>: Allows to make column alterations to
   #   the table called +name+. It makes the table object available to a block that
-  #   can then add/remove columns, indexes or foreign keys to it.
+  #   can then add/remove columns, indexes, or foreign keys to it.
   # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames
   #   a column but keeps the type and content.
   # * <tt>rename_index(table_name, old_name, new_name)</tt>: Renames an index.
@@ -376,7 +376,7 @@ module ActiveRecord
   #   bin/rails generate migration add_fieldname_to_tablename fieldname:string
   #
   # This will generate the file <tt>timestamp_add_fieldname_to_tablename.rb</tt>, which will look like this:
-  #   class AddFieldnameToTablename < ActiveRecord::Migration[6.0]
+  #   class AddFieldnameToTablename < ActiveRecord::Migration[7.0]
   #     def change
   #       add_column :tablenames, :fieldname, :string
   #     end
@@ -402,7 +402,7 @@ module ActiveRecord
   #
   # Not all migrations change the schema. Some just fix the data:
   #
-  #   class RemoveEmptyTags < ActiveRecord::Migration[6.0]
+  #   class RemoveEmptyTags < ActiveRecord::Migration[7.0]
   #     def up
   #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
@@ -415,7 +415,7 @@ module ActiveRecord
   #
   # Others remove columns when they migrate up instead of down:
   #
-  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[6.0]
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[7.0]
   #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
@@ -429,7 +429,7 @@ module ActiveRecord
   #
   # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
-  #   class MakeJoinUnique < ActiveRecord::Migration[6.0]
+  #   class MakeJoinUnique < ActiveRecord::Migration[7.0]
   #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
@@ -446,7 +446,7 @@ module ActiveRecord
   # <tt>Base#reset_column_information</tt> in order to ensure that the model has the
   # latest column data from after the new column was added. Example:
   #
-  #   class AddPeopleSalary < ActiveRecord::Migration[6.0]
+  #   class AddPeopleSalary < ActiveRecord::Migration[7.0]
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
@@ -504,7 +504,7 @@ module ActiveRecord
   # To define a reversible migration, define the +change+ method in your
   # migration like this:
   #
-  #   class TenderloveMigration < ActiveRecord::Migration[6.0]
+  #   class TenderloveMigration < ActiveRecord::Migration[7.0]
   #     def change
   #       create_table(:horses) do |t|
   #         t.column :content, :text
@@ -534,7 +534,7 @@ module ActiveRecord
   # can't execute inside a transaction though, and for these situations
   # you can turn the automatic transactions off.
   #
-  #   class ChangeEnum < ActiveRecord::Migration[6.0]
+  #   class ChangeEnum < ActiveRecord::Migration[7.0]
   #     disable_ddl_transaction!
   #
   #     def up
@@ -550,16 +550,53 @@ module ActiveRecord
     autoload :JoinTable, "active_record/migration/join_table"
 
     # This must be defined before the inherited hook, below
-    class Current < Migration #:nodoc:
+    class Current < Migration # :nodoc:
+      def create_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def change_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def create_join_table(table_1, table_2, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def drop_table(table_name, **options)
+        if block_given?
+          super { |t| yield compatible_table_definition(t) }
+        else
+          super
+        end
+      end
+
+      def compatible_table_definition(t)
+        t
+      end
     end
 
-    def self.inherited(subclass) #:nodoc:
+    def self.inherited(subclass) # :nodoc:
       super
       if subclass.superclass == Migration
+        major = ActiveRecord::VERSION::MAJOR
+        minor = ActiveRecord::VERSION::MINOR
         raise StandardError, "Directly inheriting from ActiveRecord::Migration is not supported. " \
-          "Please specify the Rails release the migration was written for:\n" \
+          "Please specify the Active Record release the migration was written for:\n" \
           "\n" \
-          "  class #{subclass} < ActiveRecord::Migration[4.2]"
+          "  class #{subclass} < ActiveRecord::Migration[#{major}.#{minor}]"
       end
     end
 
@@ -571,10 +608,10 @@ module ActiveRecord
       ActiveRecord::VERSION::STRING.to_f
     end
 
-    MigrationFilenameRegexp = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/ #:nodoc:
+    MigrationFilenameRegexp = /\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/ # :nodoc:
 
     # This class is used to verify that all migrations have been run before
-    # loading a web page if <tt>config.active_record.migration_error</tt> is set to :page_load
+    # loading a web page if <tt>config.active_record.migration_error</tt> is set to +:page_load+.
     class CheckPending
       def initialize(app, file_watcher: ActiveSupport::FileUpdateChecker)
         @app = app
@@ -613,10 +650,10 @@ module ActiveRecord
     end
 
     class << self
-      attr_accessor :delegate #:nodoc:
-      attr_accessor :disable_ddl_transaction #:nodoc:
+      attr_accessor :delegate # :nodoc:
+      attr_accessor :disable_ddl_transaction # :nodoc:
 
-      def nearest_delegate #:nodoc:
+      def nearest_delegate # :nodoc:
         delegate || superclass.nearest_delegate
       end
 
@@ -630,7 +667,7 @@ module ActiveRecord
         all_configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
 
         needs_update = !all_configs.all? do |db_config|
-          Tasks::DatabaseTasks.schema_up_to_date?(db_config, ActiveRecord::Base.schema_format)
+          Tasks::DatabaseTasks.schema_up_to_date?(db_config, ActiveRecord.schema_format)
         end
 
         if needs_update
@@ -648,16 +685,16 @@ module ActiveRecord
         check_pending!
       end
 
-      def maintain_test_schema! #:nodoc:
-        if ActiveRecord::Base.maintain_test_schema
+      def maintain_test_schema! # :nodoc:
+        if ActiveRecord.maintain_test_schema
           suppress_messages { load_schema_if_pending! }
         end
       end
 
-      def method_missing(name, *args, &block) #:nodoc:
+      def method_missing(name, *args, &block) # :nodoc:
         nearest_delegate.send(name, *args, &block)
       end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      ruby2_keywords(:method_missing)
 
       def migrate(direction)
         new.migrate direction
@@ -672,7 +709,7 @@ module ActiveRecord
       end
     end
 
-    def disable_ddl_transaction #:nodoc:
+    def disable_ddl_transaction # :nodoc:
       self.class.disable_ddl_transaction
     end
 
@@ -696,7 +733,7 @@ module ActiveRecord
     # and create the table 'apples' on the way up, and the reverse
     # on the way down.
     #
-    #   class FixTLMigration < ActiveRecord::Migration[6.0]
+    #   class FixTLMigration < ActiveRecord::Migration[7.0]
     #     def change
     #       revert do
     #         create_table(:horses) do |t|
@@ -715,7 +752,7 @@ module ActiveRecord
     #
     #   require_relative "20121212123456_tenderlove_migration"
     #
-    #   class FixupTLMigration < ActiveRecord::Migration[6.0]
+    #   class FixupTLMigration < ActiveRecord::Migration[7.0]
     #     def change
     #       revert TenderloveMigration
     #
@@ -726,16 +763,16 @@ module ActiveRecord
     #   end
     #
     # This command can be nested.
-    def revert(*migration_classes)
+    def revert(*migration_classes, &block)
       run(*migration_classes.reverse, revert: true) unless migration_classes.empty?
       if block_given?
         if connection.respond_to? :revert
-          connection.revert { yield }
+          connection.revert(&block)
         else
           recorder = command_recorder
           @connection = recorder
           suppress_messages do
-            connection.revert { yield }
+            connection.revert(&block)
           end
           @connection = recorder.delegate
           recorder.replay(self)
@@ -747,7 +784,7 @@ module ActiveRecord
       connection.respond_to?(:reverting) && connection.reverting
     end
 
-    ReversibleBlockHelper = Struct.new(:reverting) do #:nodoc:
+    ReversibleBlockHelper = Struct.new(:reverting) do # :nodoc:
       def up
         yield unless reverting
       end
@@ -766,7 +803,7 @@ module ActiveRecord
     # when the three columns 'first_name', 'last_name' and 'full_name' exist,
     # even when migrating down:
     #
-    #    class SplitNameMigration < ActiveRecord::Migration[6.0]
+    #    class SplitNameMigration < ActiveRecord::Migration[7.0]
     #      def change
     #        add_column :users, :first_name, :string
     #        add_column :users, :last_name, :string
@@ -794,7 +831,7 @@ module ActiveRecord
     # In the following example, the new column +published+ will be given
     # the value +true+ for all existing records.
     #
-    #    class AddPublishedToPosts < ActiveRecord::Migration[6.0]
+    #    class AddPublishedToPosts < ActiveRecord::Migration[7.0]
     #      def change
     #        add_column :posts, :published, :boolean, default: false
     #        up_only do
@@ -802,14 +839,15 @@ module ActiveRecord
     #        end
     #      end
     #    end
-    def up_only
-      execute_block { yield } unless reverting?
+    def up_only(&block)
+      execute_block(&block) unless reverting?
     end
 
     # Runs the given migration classes.
     # Last argument can specify options:
-    # - :direction (default is :up)
-    # - :revert (default is false)
+    #
+    # - +:direction+ - Default is +:up+.
+    # - +:revert+ - Default is +false+.
     def run(*migration_classes)
       opts = migration_classes.extract_options!
       dir = opts[:direction] || :up
@@ -913,13 +951,11 @@ module ActiveRecord
     end
 
     def method_missing(method, *arguments, &block)
-      arg_list = arguments.map(&:inspect) * ", "
-
-      say_with_time "#{method}(#{arg_list})" do
+      say_with_time "#{method}(#{format_arguments(arguments)})" do
         unless connection.respond_to? :revert
           unless arguments.empty? || [:execute, :enable_extension, :disable_extension].include?(method)
             arguments[0] = proper_table_name(arguments.first, table_name_options)
-            if [:rename_table, :add_foreign_key].include?(method) ||
+            if method == :rename_table ||
               (method == :remove_foreign_key && !arguments.second.is_a?(Hash))
               arguments[1] = proper_table_name(arguments.second, table_name_options)
             end
@@ -929,7 +965,7 @@ module ActiveRecord
         connection.send(method, *arguments, &block)
       end
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:method_missing)
 
     def copy(destination, sources, options = {})
       copied = []
@@ -955,6 +991,12 @@ module ActiveRecord
               magic_comments << magic_comment; ""
             end || break
           end
+
+          if !magic_comments.empty? && source.start_with?("\n")
+            magic_comments << "\n"
+            source = source[1..-1]
+          end
+
           source = "#{magic_comments}#{inserted_comment}#{source}"
 
           if duplicate = destination_migrations.detect { |m| m.name == migration.name }
@@ -992,7 +1034,7 @@ module ActiveRecord
 
     # Determines the version number of the next migration.
     def next_migration_number(number)
-      if ActiveRecord::Base.timestamped_migrations
+      if ActiveRecord.timestamped_migrations
         [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % number].max
       else
         SchemaMigration.normalize_migration_number(number)
@@ -1001,7 +1043,7 @@ module ActiveRecord
 
     # Builds a hash for use in ActiveRecord::Migration#proper_table_name using
     # the Active Record object's table_name prefix and suffix
-    def table_name_options(config = ActiveRecord::Base) #:nodoc:
+    def table_name_options(config = ActiveRecord::Base) # :nodoc:
       {
         table_name_prefix: config.table_name_prefix,
         table_name_suffix: config.table_name_suffix
@@ -1017,6 +1059,22 @@ module ActiveRecord
         end
       end
 
+      def format_arguments(arguments)
+        arg_list = arguments[0...-1].map(&:inspect)
+        last_arg = arguments.last
+        if last_arg.is_a?(Hash)
+          last_arg = last_arg.reject { |k, _v| internal_option?(k) }
+          arg_list << last_arg.inspect unless last_arg.empty?
+        else
+          arg_list << last_arg.inspect
+        end
+        arg_list.join(", ")
+      end
+
+      def internal_option?(option_name)
+        option_name.start_with?("_")
+      end
+
       def command_recorder
         CommandRecorder.new(connection)
       end
@@ -1042,19 +1100,41 @@ module ActiveRecord
       end
 
       def load_migration
-        require(File.expand_path(filename))
+        Object.send(:remove_const, name) rescue nil
+
+        load(File.expand_path(filename))
         name.constantize.new(name, version)
       end
   end
 
-  class MigrationContext #:nodoc:
+  # MigrationContext sets the context in which a migration is run.
+  #
+  # A migration context requires the path to the migrations is set
+  # in the +migrations_paths+ parameter. Optionally a +schema_migration+
+  # class can be provided. For most applications, +SchemaMigration+ is
+  # sufficient. Multiple database applications need a +SchemaMigration+
+  # per primary database.
+  class MigrationContext
     attr_reader :migrations_paths, :schema_migration
 
-    def initialize(migrations_paths, schema_migration)
+    def initialize(migrations_paths, schema_migration = SchemaMigration)
       @migrations_paths = migrations_paths
       @schema_migration = schema_migration
     end
 
+    # Runs the migrations in the +migrations_path+.
+    #
+    # If +target_version+ is +nil+, +migrate+ will run +up+.
+    #
+    # If the +current_version+ and +target_version+ are both
+    # 0 then an empty array will be returned and no migrations
+    # will be run.
+    #
+    # If the +current_version+ in the schema is greater than
+    # the +target_version+, then +down+ will be run.
+    #
+    # If none of the conditions are met, +up+ will be run with
+    # the +target_version+.
     def migrate(target_version = nil, &block)
       case
       when target_version.nil?
@@ -1068,17 +1148,17 @@ module ActiveRecord
       end
     end
 
-    def rollback(steps = 1)
+    def rollback(steps = 1) # :nodoc:
       move(:down, steps)
     end
 
-    def forward(steps = 1)
+    def forward(steps = 1) # :nodoc:
       move(:up, steps)
     end
 
-    def up(target_version = nil)
+    def up(target_version = nil, &block) # :nodoc:
       selected_migrations = if block_given?
-        migrations.select { |m| yield m }
+        migrations.select(&block)
       else
         migrations
       end
@@ -1086,9 +1166,9 @@ module ActiveRecord
       Migrator.new(:up, selected_migrations, schema_migration, target_version).migrate
     end
 
-    def down(target_version = nil)
+    def down(target_version = nil, &block) # :nodoc:
       selected_migrations = if block_given?
-        migrations.select { |m| yield m }
+        migrations.select(&block)
       else
         migrations
       end
@@ -1096,15 +1176,15 @@ module ActiveRecord
       Migrator.new(:down, selected_migrations, schema_migration, target_version).migrate
     end
 
-    def run(direction, target_version)
+    def run(direction, target_version) # :nodoc:
       Migrator.new(direction, migrations, schema_migration, target_version).run
     end
 
-    def open
+    def open # :nodoc:
       Migrator.new(:up, migrations, schema_migration)
     end
 
-    def get_all_versions
+    def get_all_versions # :nodoc:
       if schema_migration.table_exists?
         schema_migration.all_versions.map(&:to_i)
       else
@@ -1112,20 +1192,20 @@ module ActiveRecord
       end
     end
 
-    def current_version
+    def current_version # :nodoc:
       get_all_versions.max || 0
     rescue ActiveRecord::NoDatabaseError
     end
 
-    def needs_migration?
-      (migrations.collect(&:version) - get_all_versions).size > 0
+    def needs_migration? # :nodoc:
+      pending_migration_versions.size > 0
     end
 
-    def any_migrations?
-      migrations.any?
+    def pending_migration_versions # :nodoc:
+      migrations.collect(&:version) - get_all_versions
     end
 
-    def migrations
+    def migrations # :nodoc:
       migrations = migration_files.map do |file|
         version, name, scope = parse_migration_filename(file)
         raise IllegalMigrationNameError.new(file) unless version
@@ -1138,33 +1218,33 @@ module ActiveRecord
       migrations.sort_by(&:version)
     end
 
-    def migrations_status
+    def migrations_status # :nodoc:
       db_list = schema_migration.normalized_versions
 
-      file_list = migration_files.map do |file|
+      file_list = migration_files.filter_map do |file|
         version, name, scope = parse_migration_filename(file)
         raise IllegalMigrationNameError.new(file) unless version
         version = schema_migration.normalize_migration_number(version)
         status = db_list.delete(version) ? "up" : "down"
         [status, version, (name + scope).humanize]
-      end.compact
+      end
 
       db_list.map! do |version|
         ["up", version, "********** NO FILE **********"]
       end
 
-      (db_list + file_list).sort_by { |_, version, _| version }
+      (db_list + file_list).sort_by { |_, version, _| version.to_i }
     end
 
-    def current_environment
+    def current_environment # :nodoc:
       ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
     end
 
-    def protected_environment?
+    def protected_environment? # :nodoc:
       ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
     end
 
-    def last_stored_environment
+    def last_stored_environment # :nodoc:
       return nil unless ActiveRecord::InternalMetadata.enabled?
       return nil if current_version == 0
       raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
@@ -1307,7 +1387,7 @@ module ActiveRecord
       # Stores the current environment in the database.
       def record_environment
         return if down?
-        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Base.connection.migration_context.current_environment
+        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Base.connection.pool.db_config.env_name
       end
 
       def ran?(migration)
@@ -1375,9 +1455,9 @@ module ActiveRecord
       end
 
       # Wrap the migration in a transaction only if supported by the adapter.
-      def ddl_transaction(migration)
+      def ddl_transaction(migration, &block)
         if use_transaction?(migration)
-          Base.transaction { yield }
+          Base.transaction(&block)
         else
           yield
         end
@@ -1408,12 +1488,12 @@ module ActiveRecord
         end
       end
 
-      def with_advisory_lock_connection
+      def with_advisory_lock_connection(&block)
         pool = ActiveRecord::ConnectionAdapters::ConnectionHandler.new.establish_connection(
           ActiveRecord::Base.connection_db_config
         )
 
-        pool.with_connection { |connection| yield(connection) }
+        pool.with_connection(&block)
       ensure
         pool&.disconnect!
       end