activerecord 6.1.6 → 7.1.2

data/lib/active_record/migration.rb

@@ -7,9 +7,10 @@ require "active_support/core_ext/array/access"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/actionable_error"
+require "active_record/migration/pending_migration_connection"
 
 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 +21,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.1]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -38,7 +39,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.1]
   #    def up
   #      create_table :distributors do |t|
   #        t.string :zipcode
@@ -63,7 +64,7 @@ module ActiveRecord
   #
   # 2. Use the #reversible method in <tt>#change</tt> method:
   #
-  #   class ReversibleMigrationExample < ActiveRecord::Migration[6.0]
+  #   class ReversibleMigrationExample < ActiveRecord::Migration[7.1]
   #     def change
   #       create_table :distributors do |t|
   #         t.string :zipcode
@@ -90,7 +91,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 +101,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 +111,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 +121,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,42 +131,48 @@ 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
-        ActiveRecord::Tasks::DatabaseTasks.dump_schema(
-          ActiveRecord::Base.connection_db_config
-        )
+      if ActiveRecord.dump_schema_after_migration
+        connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
+        ActiveRecord::Tasks::DatabaseTasks.dump_schema(connection.pool.db_config)
       end
     end
 
-    def initialize(message = nil)
-      super(message || detailed_migration_message)
+    def initialize(message = nil, pending_migrations: nil)
+      if pending_migrations.nil?
+        connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
+        pending_migrations = connection.migration_context.open.pending_migrations
+      end
+
+      super(message || detailed_migration_message(pending_migrations))
     end
 
     private
-      def detailed_migration_message
+      def detailed_migration_message(pending_migrations)
         message = "Migrations are pending. To resolve this issue, run:\n\n        bin/rails db:migrate"
-        message += " RAILS_ENV=#{::Rails.env}" if defined?(Rails.env)
+        message += " RAILS_ENV=#{::Rails.env}" if defined?(Rails.env) && !Rails.env.local?
         message += "\n\n"
 
-        pending_migrations = ActiveRecord::Base.connection.migration_context.open.pending_migrations
-
         message += "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}\n\n"
 
         pending_migrations.each do |pending_migration|
-          message += "#{pending_migration.basename}\n"
+          message += "#{pending_migration.filename}\n"
         end
 
         message
       end
+
+      def connection
+        ActiveRecord::Tasks::DatabaseTasks.migration_connection
+      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 +181,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 +192,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 +235,7 @@ module ActiveRecord
   #
   # Example of a simple migration:
   #
-  #   class AddSsl < ActiveRecord::Migration[6.0]
+  #   class AddSsl < ActiveRecord::Migration[7.1]
   #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, default: true
   #     end
@@ -248,7 +255,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.1]
   #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
@@ -326,7 +333,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.
@@ -356,12 +363,12 @@ module ActiveRecord
   # == Irreversible transformations
   #
   # Some transformations are destructive in a manner that cannot be reversed.
-  # Migrations of that kind should raise an <tt>ActiveRecord::IrreversibleMigration</tt>
+  # Migrations of that kind should raise an ActiveRecord::IrreversibleMigration
   # exception in their +down+ method.
   #
-  # == Running migrations from within Rails
+  # == Running migrations from within \Rails
   #
-  # The Rails package has several tools to help create and apply migrations.
+  # The \Rails package has several tools to help create and apply migrations.
   #
   # To generate a new migration, you can use
   #   bin/rails generate migration MyNewMigration
@@ -376,7 +383,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.1]
   #     def change
   #       add_column :tablenames, :fieldname, :string
   #     end
@@ -395,14 +402,14 @@ module ActiveRecord
   # wish to rollback last few migrations. <tt>bin/rails db:rollback STEP=2</tt> will rollback
   # the latest two migrations.
   #
-  # If any of the migrations throw an <tt>ActiveRecord::IrreversibleMigration</tt> exception,
+  # If any of the migrations throw an ActiveRecord::IrreversibleMigration exception,
   # that step will fail and you'll have some manual work to do.
   #
   # == More examples
   #
   # Not all migrations change the schema. Some just fix the data:
   #
-  #   class RemoveEmptyTags < ActiveRecord::Migration[6.0]
+  #   class RemoveEmptyTags < ActiveRecord::Migration[7.1]
   #     def up
   #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
@@ -415,7 +422,7 @@ module ActiveRecord
   #
   # Others remove columns when they migrate up instead of down:
   #
-  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[6.0]
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[7.1]
   #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
@@ -429,7 +436,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.1]
   #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
@@ -446,7 +453,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.1]
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
@@ -482,7 +489,7 @@ module ActiveRecord
   #
   # == Timestamped Migrations
   #
-  # By default, Rails generates migrations that look like:
+  # By default, \Rails generates migrations that look like:
   #
   #    20080717013526_your_migration_name.rb
   #
@@ -504,7 +511,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.1]
   #     def change
   #       create_table(:horses) do |t|
   #         t.column :content, :text
@@ -521,11 +528,11 @@ module ActiveRecord
   # as before.
   #
   # If a command cannot be reversed, an
-  # <tt>ActiveRecord::IrreversibleMigration</tt> exception will be raised when
+  # ActiveRecord::IrreversibleMigration exception will be raised when
   # the migration is moving down.
   #
   # For a list of commands that are reversible, please see
-  # <tt>ActiveRecord::Migration::CommandRecorder</tt>.
+  # +ActiveRecord::Migration::CommandRecorder+.
   #
   # == Transactional Migrations
   #
@@ -534,7 +541,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.1]
   #     disable_ddl_transaction!
   #
   #     def up
@@ -548,18 +555,57 @@ module ActiveRecord
     autoload :CommandRecorder, "active_record/migration/command_recorder"
     autoload :Compatibility, "active_record/migration/compatibility"
     autoload :JoinTable, "active_record/migration/join_table"
+    autoload :ExecutionStrategy, "active_record/migration/execution_strategy"
+    autoload :DefaultStrategy, "active_record/migration/default_strategy"
 
     # 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 +617,17 @@ 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:
+
+    def self.valid_version_format?(version_string) # :nodoc:
+      [
+        MigrationFilenameRegexp,
+        /\A\d(_?\d)*\z/ # integer with optional underscores
+      ].any? { |pattern| pattern.match?(version_string) }
+    end
 
     # 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
@@ -587,7 +640,7 @@ module ActiveRecord
         @mutex.synchronize do
           @watcher ||= build_watcher do
             @needs_check = true
-            ActiveRecord::Migration.check_pending!(connection)
+            ActiveRecord::Migration.check_pending_migrations
             @needs_check = false
           end
 
@@ -603,61 +656,84 @@ module ActiveRecord
 
       private
         def build_watcher(&block)
-          paths = Array(connection.migration_context.migrations_paths)
+          current_environment = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+          all_configs = ActiveRecord::Base.configurations.configs_for(env_name: current_environment)
+          paths = all_configs.flat_map { |config| config.migrations_paths || Migrator.migrations_paths }.uniq
           @file_watcher.new([], paths.index_with(["rb"]), &block)
         end
 
         def connection
-          ActiveRecord::Base.connection
+          ActiveRecord::Tasks::DatabaseTasks.migration_connection
         end
     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
 
-      # Raises <tt>ActiveRecord::PendingMigrationError</tt> error if any migrations are pending.
-      def check_pending!(connection = Base.connection)
-        raise ActiveRecord::PendingMigrationError if connection.migration_context.needs_migration?
+      # Raises ActiveRecord::PendingMigrationError error if any migrations are pending.
+      #
+      # This is deprecated in favor of +check_all_pending!+
+      def check_pending!(connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection)
+        ActiveRecord.deprecator.warn(<<-MSG.squish)
+          The `check_pending!` method is deprecated in favor of `check_all_pending!`. The
+          new implementation will loop through all available database configurations and find
+          pending migrations. The prior implementation did not permit this.
+        MSG
+
+        pending_migrations = connection.migration_context.open.pending_migrations
+
+        if pending_migrations.any?
+          raise ActiveRecord::PendingMigrationError.new(pending_migrations: pending_migrations)
+        end
       end
 
-      def load_schema_if_pending!
-        current_db_config = Base.connection_db_config
-        all_configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
+      # Raises ActiveRecord::PendingMigrationError error if any migrations are pending
+      # for all database configurations in an environment.
+      def check_all_pending!
+        pending_migrations = []
+
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: env) do |connection|
+          if pending = connection.migration_context.open.pending_migrations
+            pending_migrations << pending
+          end
+        end
+
+        migrations = pending_migrations.flatten
 
-        needs_update = !all_configs.all? do |db_config|
-          Tasks::DatabaseTasks.schema_up_to_date?(db_config, ActiveRecord::Base.schema_format)
+        if migrations.any?
+          raise ActiveRecord::PendingMigrationError.new(pending_migrations: migrations)
         end
+      end
 
-        if needs_update
+      def load_schema_if_pending!
+        if any_schema_needs_update?
           # Roundtrip to Rake to allow plugins to hook into database initialization.
           root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
+
           FileUtils.cd(root) do
-            Base.clear_all_connections!
+            Base.connection_handler.clear_all_connections!(:all)
             system("bin/rails db:test:prepare")
           end
         end
 
-        # Establish a new connection, the old database may be gone (db:test:prepare uses purge)
-        Base.establish_connection(current_db_config)
-
-        check_pending!
+        check_pending_migrations
       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
@@ -670,9 +746,46 @@ module ActiveRecord
       def disable_ddl_transaction!
         @disable_ddl_transaction = true
       end
+
+      def check_pending_migrations # :nodoc:
+        migrations = pending_migrations
+
+        if migrations.any?
+          raise ActiveRecord::PendingMigrationError.new(pending_migrations: migrations)
+        end
+      end
+
+      private
+        def any_schema_needs_update?
+          !db_configs_in_current_env.all? do |db_config|
+            Tasks::DatabaseTasks.schema_up_to_date?(db_config, ActiveRecord.schema_format)
+          end
+        end
+
+        def db_configs_in_current_env
+          ActiveRecord::Base.configurations.configs_for(env_name: env)
+        end
+
+        def pending_migrations
+          pending_migrations = []
+
+          ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
+            ActiveRecord::PendingMigrationConnection.establish_temporary_connection(db_config) do |conn|
+              if pending = conn.migration_context.open.pending_migrations
+                pending_migrations << pending
+              end
+            end
+          end
+
+          pending_migrations.flatten
+        end
+
+        def env
+          ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+        end
     end
 
-    def disable_ddl_transaction #:nodoc:
+    def disable_ddl_transaction # :nodoc:
       self.class.disable_ddl_transaction
     end
 
@@ -685,6 +798,10 @@ module ActiveRecord
       @connection = nil
     end
 
+    def execution_strategy
+      @execution_strategy ||= ActiveRecord.migration_strategy.new(self)
+    end
+
     self.verbose = true
     # instantiate the delegate object after initialize is defined
     self.delegate = new
@@ -696,7 +813,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.1]
     #     def change
     #       revert do
     #         create_table(:horses) do |t|
@@ -715,7 +832,7 @@ module ActiveRecord
     #
     #   require_relative "20121212123456_tenderlove_migration"
     #
-    #   class FixupTLMigration < ActiveRecord::Migration[6.0]
+    #   class FixupTLMigration < ActiveRecord::Migration[7.1]
     #     def change
     #       revert TenderloveMigration
     #
@@ -726,16 +843,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 +864,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 +883,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.1]
     #      def change
     #        add_column :users, :first_name, :string
     #        add_column :users, :last_name, :string
@@ -794,7 +911,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.1]
     #      def change
     #        add_column :posts, :published, :boolean, default: false
     #        up_only do
@@ -802,14 +919,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
@@ -846,7 +964,7 @@ module ActiveRecord
       end
 
       time = nil
-      ActiveRecord::Base.connection_pool.with_connection do |conn|
+      ActiveRecord::Tasks::DatabaseTasks.migration_connection.pool.with_connection do |conn|
         time = Benchmark.measure do
           exec_migration(conn, direction)
         end
@@ -871,6 +989,7 @@ module ActiveRecord
       end
     ensure
       @connection = nil
+      @execution_strategy = nil
     end
 
     def write(text = "")
@@ -909,38 +1028,37 @@ module ActiveRecord
     end
 
     def connection
-      @connection || ActiveRecord::Base.connection
+      @connection || ActiveRecord::Tasks::DatabaseTasks.migration_connection
     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
           end
         end
-        return super unless connection.respond_to?(method)
-        connection.send(method, *arguments, &block)
+        return super unless execution_strategy.respond_to?(method)
+        execution_strategy.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 = []
-      schema_migration = options[:schema_migration] || ActiveRecord::SchemaMigration
 
       FileUtils.mkdir_p(destination) unless File.exist?(destination)
+      schema_migration = SchemaMigration::NullSchemaMigration.new
+      internal_metadata = InternalMetadata::NullInternalMetadata.new
 
-      destination_migrations = ActiveRecord::MigrationContext.new(destination, schema_migration).migrations
+      destination_migrations = ActiveRecord::MigrationContext.new(destination, schema_migration, internal_metadata).migrations
       last = destination_migrations.last
       sources.each do |scope, path|
-        source_migrations = ActiveRecord::MigrationContext.new(path, schema_migration).migrations
+        source_migrations = ActiveRecord::MigrationContext.new(path, schema_migration, internal_metadata).migrations
 
         source_migrations.each do |migration|
           source = File.binread(migration.filename)
@@ -955,6 +1073,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,16 +1116,16 @@ 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)
+        "%.3d" % number.to_i
       end
     end
 
     # 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 +1141,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 +1182,66 @@ 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:
-    attr_reader :migrations_paths, :schema_migration
+  # = \Migration \Context
+  #
+  # 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. Multiple database applications will instantiate
+  # a +SchemaMigration+ object per database. From the Rake tasks, \Rails will
+  # handle this for you.
+  class MigrationContext
+    attr_reader :migrations_paths, :schema_migration, :internal_metadata
+
+    def initialize(migrations_paths, schema_migration = nil, internal_metadata = nil)
+      if schema_migration == SchemaMigration
+        ActiveRecord.deprecator.warn(<<-MSG.squish)
+          SchemaMigration no longer inherits from ActiveRecord::Base. If you want
+          to use the default connection, remove this argument. If you want to use a
+          specific connection, instantiate MigrationContext with the connection's schema
+          migration, for example `MigrationContext.new(path, Dog.connection.schema_migration)`.
+        MSG
+
+        schema_migration = nil
+      end
+
+      if internal_metadata == InternalMetadata
+        ActiveRecord.deprecator.warn(<<-MSG.squish)
+          SchemaMigration no longer inherits from ActiveRecord::Base. If you want
+          to use the default connection, remove this argument. If you want to use a
+          specific connection, instantiate MigrationContext with the connection's internal
+          metadata, for example `MigrationContext.new(path, nil, Dog.connection.internal_metadata)`.
+        MSG
+
+        internal_metadata = nil
+      end
 
-    def initialize(migrations_paths, schema_migration)
       @migrations_paths = migrations_paths
-      @schema_migration = schema_migration
+      @schema_migration = schema_migration || SchemaMigration.new(connection)
+      @internal_metadata = internal_metadata || InternalMetadata.new(connection)
     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,64 +1255,64 @@ 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
 
-      Migrator.new(:up, selected_migrations, schema_migration, target_version).migrate
+      Migrator.new(:up, selected_migrations, schema_migration, internal_metadata, 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
 
-      Migrator.new(:down, selected_migrations, schema_migration, target_version).migrate
+      Migrator.new(:down, selected_migrations, schema_migration, internal_metadata, target_version).migrate
     end
 
-    def run(direction, target_version)
-      Migrator.new(direction, migrations, schema_migration, target_version).run
+    def run(direction, target_version) # :nodoc:
+      Migrator.new(direction, migrations, schema_migration, internal_metadata, target_version).run
     end
 
-    def open
-      Migrator.new(:up, migrations, schema_migration)
+    def open # :nodoc:
+      Migrator.new(:up, migrations, schema_migration, internal_metadata)
     end
 
-    def get_all_versions
+    def get_all_versions # :nodoc:
       if schema_migration.table_exists?
-        schema_migration.all_versions.map(&:to_i)
+        schema_migration.integer_versions
       else
         []
       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,43 +1325,47 @@ 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
-      return nil unless ActiveRecord::InternalMetadata.enabled?
+    def last_stored_environment # :nodoc:
+      return nil unless connection.internal_metadata.enabled?
       return nil if current_version == 0
-      raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
+      raise NoEnvironmentInSchemaError unless connection.internal_metadata.table_exists?
 
-      environment = ActiveRecord::InternalMetadata[:environment]
+      environment = connection.internal_metadata[:environment]
       raise NoEnvironmentInSchemaError unless environment
       environment
     end
 
     private
+      def connection
+        ActiveRecord::Tasks::DatabaseTasks.migration_connection
+      end
+
       def migration_files
         paths = Array(migrations_paths)
         Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
@@ -1185,7 +1376,7 @@ module ActiveRecord
       end
 
       def move(direction, steps)
-        migrator = Migrator.new(direction, migrations, schema_migration)
+        migrator = Migrator.new(direction, migrations, schema_migration, internal_metadata)
 
         if current_version != 0 && !migrator.current_migration
           raise UnknownMigrationVersionError.new(current_version)
@@ -1210,23 +1401,28 @@ module ActiveRecord
 
       # For cases where a table doesn't exist like loading from schema cache
       def current_version
-        MigrationContext.new(migrations_paths, SchemaMigration).current_version
+        connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
+        schema_migration = SchemaMigration.new(connection)
+        internal_metadata = InternalMetadata.new(connection)
+
+        MigrationContext.new(migrations_paths, schema_migration, internal_metadata).current_version
       end
     end
 
     self.migrations_paths = ["db/migrate"]
 
-    def initialize(direction, migrations, schema_migration, target_version = nil)
+    def initialize(direction, migrations, schema_migration, internal_metadata, target_version = nil)
       @direction         = direction
       @target_version    = target_version
       @migrated_versions = nil
       @migrations        = migrations
       @schema_migration  = schema_migration
+      @internal_metadata = internal_metadata
 
       validate(@migrations)
 
       @schema_migration.create_table
-      ActiveRecord::InternalMetadata.create_table
+      @internal_metadata.create_table
     end
 
     def current_version
@@ -1279,18 +1475,21 @@ module ActiveRecord
     end
 
     def load_migrated
-      @migrated_versions = Set.new(@schema_migration.all_versions.map(&:to_i))
+      @migrated_versions = Set.new(@schema_migration.integer_versions)
     end
 
     private
+      def connection
+        ActiveRecord::Tasks::DatabaseTasks.migration_connection
+      end
+
       # Used for running a specific migration.
       def run_without_lock
         migration = migrations.detect { |m| m.version == @target_version }
         raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
-        result = execute_migration_in_transaction(migration)
 
         record_environment
-        result
+        execute_migration_in_transaction(migration)
       end
 
       # Used for running multiple migrations up to or down to a certain value.
@@ -1299,15 +1498,15 @@ module ActiveRecord
           raise UnknownMigrationVersionError.new(@target_version)
         end
 
-        result = runnable.each(&method(:execute_migration_in_transaction))
         record_environment
-        result
+        runnable.each(&method(:execute_migration_in_transaction))
       end
 
       # Stores the current environment in the database.
       def record_environment
         return if down?
-        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Base.connection.migration_context.current_environment
+
+        @internal_metadata[:environment] = connection.pool.db_config.env_name
       end
 
       def ran?(migration)
@@ -1359,10 +1558,10 @@ module ActiveRecord
       def record_version_state_after_migrating(version)
         if down?
           migrated.delete(version)
-          @schema_migration.delete_by(version: version.to_s)
+          @schema_migration.delete_version(version.to_s)
         else
           migrated << version
-          @schema_migration.create!(version: version.to_s)
+          @schema_migration.create_version(version.to_s)
         end
       end
 
@@ -1375,52 +1574,40 @@ 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 }
+          connection.transaction(&block)
         else
           yield
         end
       end
 
       def use_transaction?(migration)
-        !migration.disable_ddl_transaction && Base.connection.supports_ddl_transactions?
+        !migration.disable_ddl_transaction && connection.supports_ddl_transactions?
       end
 
       def use_advisory_lock?
-        Base.connection.advisory_locks_enabled?
+        connection.advisory_locks_enabled?
       end
 
       def with_advisory_lock
         lock_id = generate_migrator_advisory_lock_id
 
-        with_advisory_lock_connection do |connection|
-          got_lock = connection.get_advisory_lock(lock_id)
-          raise ConcurrentMigrationError unless got_lock
-          load_migrated # reload schema_migrations to be sure it wasn't changed by another process before we got the lock
-          yield
-        ensure
-          if got_lock && !connection.release_advisory_lock(lock_id)
-            raise ConcurrentMigrationError.new(
-              ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE
-            )
-          end
-        end
-      end
-
-      def with_advisory_lock_connection
-        pool = ActiveRecord::ConnectionAdapters::ConnectionHandler.new.establish_connection(
-          ActiveRecord::Base.connection_db_config
-        )
-
-        pool.with_connection { |connection| yield(connection) }
+        got_lock = connection.get_advisory_lock(lock_id)
+        raise ConcurrentMigrationError unless got_lock
+        load_migrated # reload schema_migrations to be sure it wasn't changed by another process before we got the lock
+        yield
       ensure
-        pool&.disconnect!
+        if got_lock && !connection.release_advisory_lock(lock_id)
+          raise ConcurrentMigrationError.new(
+            ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE
+          )
+        end
       end
 
       MIGRATOR_SALT = 2053462845
       def generate_migrator_advisory_lock_id
-        db_name_hash = Zlib.crc32(Base.connection.current_database)
+        db_name_hash = Zlib.crc32(connection.current_database)
         MIGRATOR_SALT * db_name_hash
       end
   end