activerecord 4.2.6 → 5.0.0

data/lib/active_record/migration.rb

@@ -9,40 +9,170 @@ module ActiveRecord
     end
   end
 
-  # Exception that can be raised to stop migrations from going backwards.
+  # Exception that can be raised to stop migrations from being rolled back.
+  # For example the following migration is not reversible.
+  # Rolling back this migration will raise an ActiveRecord::IrreversibleMigration error.
+  #
+  #   class IrreversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #     def change
+  #       create_table :distributors do |t|
+  #         t.string :zipcode
+  #       end
+  #
+  #       execute <<-SQL
+  #         ALTER TABLE distributors
+  #           ADD CONSTRAINT zipchk
+  #             CHECK (char_length(zipcode) = 5) NO INHERIT;
+  #       SQL
+  #     end
+  #   end
+  #
+  # There are two ways to mitigate this problem.
+  #
+  # 1. Define <tt>#up</tt> and <tt>#down</tt> methods instead of <tt>#change</tt>:
+  #
+  #  class ReversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #    def up
+  #      create_table :distributors do |t|
+  #        t.string :zipcode
+  #      end
+  #
+  #      execute <<-SQL
+  #        ALTER TABLE distributors
+  #          ADD CONSTRAINT zipchk
+  #            CHECK (char_length(zipcode) = 5) NO INHERIT;
+  #      SQL
+  #    end
+  #
+  #    def down
+  #      execute <<-SQL
+  #        ALTER TABLE distributors
+  #          DROP CONSTRAINT zipchk
+  #      SQL
+  #
+  #      drop_table :distributors
+  #    end
+  #  end
+  #
+  # 2. Use the #reversible method in <tt>#change</tt> method:
+  #
+  #   class ReversibleMigrationExample < ActiveRecord::Migration[5.0]
+  #     def change
+  #       create_table :distributors do |t|
+  #         t.string :zipcode
+  #       end
+  #
+  #       reversible do |dir|
+  #         dir.up do
+  #           execute <<-SQL
+  #             ALTER TABLE distributors
+  #               ADD CONSTRAINT zipchk
+  #                 CHECK (char_length(zipcode) = 5) NO INHERIT;
+  #           SQL
+  #         end
+  #
+  #         dir.down do
+  #           execute <<-SQL
+  #             ALTER TABLE distributors
+  #               DROP CONSTRAINT zipchk
+  #           SQL
+  #         end
+  #       end
+  #     end
+  #   end
   class IrreversibleMigration < MigrationError
   end
 
   class DuplicateMigrationVersionError < MigrationError#:nodoc:
-    def initialize(version)
-      super("Multiple migrations have the version number #{version}")
+    def initialize(version = nil)
+      if version
+        super("Multiple migrations have the version number #{version}.")
+      else
+        super("Duplicate migration version error.")
+      end
     end
   end
 
   class DuplicateMigrationNameError < MigrationError#:nodoc:
-    def initialize(name)
-      super("Multiple migrations have the name #{name}")
+    def initialize(name = nil)
+      if name
+        super("Multiple migrations have the name #{name}.")
+      else
+        super("Duplicate migration name.")
+      end
     end
   end
 
   class UnknownMigrationVersionError < MigrationError #:nodoc:
-    def initialize(version)
-      super("No migration with version number #{version}")
+    def initialize(version = nil)
+      if version
+        super("No migration with version number #{version}.")
+      else
+        super("Unknown migration version.")
+      end
     end
   end
 
   class IllegalMigrationNameError < MigrationError#:nodoc:
-    def initialize(name)
-      super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed)")
+    def initialize(name = nil)
+      if name
+        super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed).")
+      else
+        super("Illegal name for migration.")
+      end
     end
   end
 
   class PendingMigrationError < MigrationError#:nodoc:
+    def initialize(message = nil)
+      if !message && defined?(Rails.env)
+        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate RAILS_ENV=#{::Rails.env}")
+      elsif !message
+        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate")
+      else
+        super
+      end
+    end
+  end
+
+  class ConcurrentMigrationError < MigrationError #:nodoc:
+    DEFAULT_MESSAGE = "Cannot run migrations because another migration process is currently running.".freeze
+
+    def initialize(message = DEFAULT_MESSAGE)
+      super
+    end
+  end
+
+  class NoEnvironmentInSchemaError < MigrationError #:nodoc:
     def initialize
+      msg = "Environment data not found in the schema. To resolve this issue, run: \n\n\tbin/rails db:environment:set"
+      if defined?(Rails.env)
+        super("#{msg} RAILS_ENV=#{::Rails.env}")
+      else
+        super(msg)
+      end
+    end
+  end
+
+  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"
+      msg << "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      super(msg)
+    end
+  end
+
+  class EnvironmentMismatchError < ActiveRecordError
+    def initialize(current: nil, stored: nil)
+      msg =  "You are attempting to modify a database that was last run in `#{ stored }` environment.\n"
+      msg << "You are running in `#{ current }` environment. "
+      msg << "If you are sure you want to continue, first set the environment using:\n\n"
+      msg << "\tbin/rails db:environment:set"
       if defined?(Rails.env)
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rake db:migrate RAILS_ENV=#{::Rails.env}")
+        super("#{msg} RAILS_ENV=#{::Rails.env}\n\n")
       else
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rake db:migrate")
+        super("#{msg}\n\n")
       end
     end
   end
@@ -59,7 +189,7 @@ module ActiveRecord
   #
   # Example of a simple migration:
   #
-  #   class AddSsl < ActiveRecord::Migration
+  #   class AddSsl < ActiveRecord::Migration[5.0]
   #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, default: true
   #     end
@@ -79,7 +209,7 @@ module ActiveRecord
   #
   # Example of a more complex migration that also needs to initialize data:
   #
-  #   class AddSystemSettings < ActiveRecord::Migration
+  #   class AddSystemSettings < ActiveRecord::Migration[5.0]
   #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
@@ -106,17 +236,18 @@ module ActiveRecord
   #
   # == Available transformations
   #
+  # === Creation
+  #
+  # * <tt>create_join_table(table_1, table_2, options)</tt>: Creates a join
+  #   table having its name as the lexical order of the first two
+  #   arguments. See
+  #   ActiveRecord::ConnectionAdapters::SchemaStatements#create_join_table for
+  #   details.
   # * <tt>create_table(name, options)</tt>: Creates a table called +name+ and
   #   makes the table object available to a block that can then add columns to it,
   #   following the same format as +add_column+. See example above. The options hash
   #   is for fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create
   #   table definition.
-  # * <tt>drop_table(name)</tt>: Drops the table called +name+.
-  # * <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.
-  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+
-  #   to +new_name+.
   # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column
   #   to the table called +table_name+
   #   named +column_name+ specified to be one of the following types:
@@ -127,21 +258,59 @@ module ActiveRecord
   #   Other options include <tt>:limit</tt> and <tt>:null</tt> (e.g.
   #   <tt>{ limit: 50, null: false }</tt>) -- see
   #   ActiveRecord::ConnectionAdapters::TableDefinition#column for details.
-  # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames
-  #   a column but keeps the type and content.
-  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes
-  #   the column to a different type using the same parameters as add_column.
-  # * <tt>remove_column(table_name, column_name, type, options)</tt>: Removes the column
-  #   named +column_name+ from the table called +table_name+.
+  # * <tt>add_foreign_key(from_table, to_table, options)</tt>: Adds a new
+  #   foreign key. +from_table+ is the table with the key column, +to_table+ contains
+  #   the referenced primary key.
   # * <tt>add_index(table_name, column_names, options)</tt>: Adds a new index
   #   with the name of the column. Other options include
   #   <tt>:name</tt>, <tt>:unique</tt> (e.g.
   #   <tt>{ name: 'users_name_index', unique: true }</tt>) and <tt>:order</tt>
   #   (e.g. <tt>{ order: { name: :desc } }</tt>).
-  # * <tt>remove_index(table_name, column: column_name)</tt>: Removes the index
-  #   specified by +column_name+.
+  # * <tt>add_reference(:table_name, :reference_name)</tt>: Adds a new column
+  #   +reference_name_id+ by default an integer. See
+  #   ActiveRecord::ConnectionAdapters::SchemaStatements#add_reference for details.
+  # * <tt>add_timestamps(table_name, options)</tt>: Adds timestamps (+created_at+
+  #   and +updated_at+) columns to +table_name+.
+  #
+  # === Modification
+  #
+  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes
+  #   the column to a different type using the same parameters as add_column.
+  # * <tt>change_column_default(table_name, column_name, default)</tt>: Sets a
+  #   default value for +column_name+ defined by +default+ on +table_name+.
+  # * <tt>change_column_null(table_name, column_name, null, default = nil)</tt>:
+  #   Sets or removes a +NOT NULL+ constraint on +column_name+. The +null+ flag
+  #   indicates whether the value can be +NULL+. See
+  #   ActiveRecord::ConnectionAdapters::SchemaStatements#change_column_null for
+  #   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.
+  # * <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.
+  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+
+  #   to +new_name+.
+  #
+  # === Deletion
+  #
+  # * <tt>drop_table(name)</tt>: Drops the table called +name+.
+  # * <tt>drop_join_table(table_1, table_2, options)</tt>: Drops the join table
+  #   specified by the given arguments.
+  # * <tt>remove_column(table_name, column_name, type, options)</tt>: Removes the column
+  #   named +column_name+ from the table called +table_name+.
+  # * <tt>remove_columns(table_name, *column_names)</tt>: Removes the given
+  #   columns from the table definition.
+  # * <tt>remove_foreign_key(from_table, options_or_to_table)</tt>: Removes the
+  #   given foreign key from the table called +table_name+.
+  # * <tt>remove_index(table_name, column: column_names)</tt>: Removes the index
+  #   specified by +column_names+.
   # * <tt>remove_index(table_name, name: index_name)</tt>: Removes the index
   #   specified by +index_name+.
+  # * <tt>remove_reference(table_name, ref_name, options)</tt>: Removes the
+  #   reference(s) on +table_name+ specified by +ref_name+.
+  # * <tt>remove_timestamps(table_name, options)</tt>: Removes the timestamp
+  #   columns (+created_at+ and +updated_at+) from the table definition.
   #
   # == Irreversible transformations
   #
@@ -165,24 +334,24 @@ module ActiveRecord
   #
   #   rails generate migration add_fieldname_to_tablename fieldname:string
   #
-  # This will generate the file <tt>timestamp_add_fieldname_to_tablename</tt>, which will look like this:
-  #   class AddFieldnameToTablename < ActiveRecord::Migration
+  # This will generate the file <tt>timestamp_add_fieldname_to_tablename.rb</tt>, which will look like this:
+  #   class AddFieldnameToTablename < ActiveRecord::Migration[5.0]
   #     def change
-  #       add_column :tablenames, :field, :string
+  #       add_column :tablenames, :fieldname, :string
   #     end
   #   end
   #
   # To run migrations against the currently configured database, use
-  # <tt>rake db:migrate</tt>. This will update the database by running all of the
+  # <tt>rails db:migrate</tt>. This will update the database by running all of the
   # pending migrations, creating the <tt>schema_migrations</tt> table
   # (see "About the schema_migrations table" section below) if missing. It will also
   # invoke the db:schema:dump task, which will update your db/schema.rb file
   # to match the structure of your database.
   #
   # To roll the database back to a previous migration version, use
-  # <tt>rake db:migrate VERSION=X</tt> where <tt>X</tt> is the version to which
+  # <tt>rails db:migrate VERSION=X</tt> where <tt>X</tt> is the version to which
   # you wish to downgrade. Alternatively, you can also use the STEP option if you
-  # wish to rollback last few migrations. <tt>rake db:migrate STEP=2</tt> will rollback
+  # wish to rollback last few migrations. <tt>rails db:migrate STEP=2</tt> will rollback
   # the latest two migrations.
   #
   # If any of the migrations throw an <tt>ActiveRecord::IrreversibleMigration</tt> exception,
@@ -197,7 +366,7 @@ module ActiveRecord
   #
   # Not all migrations change the schema. Some just fix the data:
   #
-  #   class RemoveEmptyTags < ActiveRecord::Migration
+  #   class RemoveEmptyTags < ActiveRecord::Migration[5.0]
   #     def up
   #       Tag.all.each { |tag| tag.destroy if tag.pages.empty? }
   #     end
@@ -210,7 +379,7 @@ module ActiveRecord
   #
   # Others remove columns when they migrate up instead of down:
   #
-  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration[5.0]
   #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
@@ -224,7 +393,7 @@ module ActiveRecord
   #
   # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
-  #   class MakeJoinUnique < ActiveRecord::Migration
+  #   class MakeJoinUnique < ActiveRecord::Migration[5.0]
   #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
@@ -241,7 +410,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
+  #   class AddPeopleSalary < ActiveRecord::Migration[5.0]
   #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
@@ -275,21 +444,6 @@ module ActiveRecord
   # The phrase "Updating salaries..." would then be printed, along with the
   # benchmark for the block when the block completes.
   #
-  # == About the schema_migrations table
-  #
-  # Rails versions 2.0 and prior used to create a table called
-  # <tt>schema_info</tt> when using migrations. This table contained the
-  # version of the schema as of the last applied migration.
-  #
-  # Starting with Rails 2.1, the <tt>schema_info</tt> table is
-  # (automatically) replaced by the <tt>schema_migrations</tt> table, which
-  # contains the version numbers of all the migrations applied.
-  #
-  # As a result, it is now possible to add migration files that are numbered
-  # lower than the current schema version: when migrating up, those
-  # never-applied "interleaved" migrations will be automatically applied, and
-  # when migrating down, never-applied "interleaved" migrations will be skipped.
-  #
   # == Timestamped Migrations
   #
   # By default, Rails generates migrations that look like:
@@ -314,7 +468,7 @@ module ActiveRecord
   # To define a reversible migration, define the +change+ method in your
   # migration like this:
   #
-  #   class TenderloveMigration < ActiveRecord::Migration
+  #   class TenderloveMigration < ActiveRecord::Migration[5.0]
   #     def change
   #       create_table(:horses) do |t|
   #         t.column :content, :text
@@ -344,7 +498,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
+  #   class ChangeEnum < ActiveRecord::Migration[5.0]
   #     disable_ddl_transaction!
   #
   #     def up
@@ -356,10 +510,31 @@ module ActiveRecord
   # are in a Migration with <tt>self.disable_ddl_transaction!</tt>.
   class Migration
     autoload :CommandRecorder, 'active_record/migration/command_recorder'
+    autoload :Compatibility, 'active_record/migration/compatibility'
 
+    # This must be defined before the inherited hook, below
+    class Current < Migration # :nodoc:
+    end
+
+    def self.inherited(subclass) # :nodoc:
+      super
+      if subclass.superclass == Migration
+        subclass.include Compatibility::Legacy
+      end
+    end
+
+    def self.[](version)
+      Compatibility.find(version)
+    end
+
+    def self.current_version
+      ActiveRecord::VERSION::STRING.to_f
+    end
+
+    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 config.active_record.migration_error 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)
         @app = app
@@ -388,17 +563,22 @@ module ActiveRecord
       attr_accessor :delegate # :nodoc:
       attr_accessor :disable_ddl_transaction # :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 ActiveRecord::Migrator.needs_migration?(connection)
       end
 
       def load_schema_if_pending!
         if ActiveRecord::Migrator.needs_migration? || !ActiveRecord::Migrator.any_migrations?
-          # Roundrip to Rake to allow plugins to hook into database initialization.
+          # Roundtrip to Rake to allow plugins to hook into database initialization.
           FileUtils.cd Rails.root do
             current_config = Base.connection_config
             Base.clear_all_connections!
-            system("bin/rake db:test:prepare")
+            system("bin/rails db:test:prepare")
             # Establish a new connection, the old database may be gone (db:test:prepare uses purge)
             Base.establish_connection(current_config)
           end
@@ -413,7 +593,7 @@ module ActiveRecord
       end
 
       def method_missing(name, *args, &block) # :nodoc:
-        (delegate || superclass.delegate).send(name, *args, &block)
+        nearest_delegate.send(name, *args, &block)
       end
 
       def migrate(direction)
@@ -453,7 +633,7 @@ module ActiveRecord
     # and create the table 'apples' on the way up, and the reverse
     # on the way down.
     #
-    #   class FixTLMigration < ActiveRecord::Migration
+    #   class FixTLMigration < ActiveRecord::Migration[5.0]
     #     def change
     #       revert do
     #         create_table(:horses) do |t|
@@ -470,9 +650,9 @@ module ActiveRecord
     # Or equivalently, if +TenderloveMigration+ is defined as in the
     # documentation for Migration:
     #
-    #   require_relative '2012121212_tenderlove_migration'
+    #   require_relative '20121212123456_tenderlove_migration'
     #
-    #   class FixupTLMigration < ActiveRecord::Migration
+    #   class FixupTLMigration < ActiveRecord::Migration[5.0]
     #     def change
     #       revert TenderloveMigration
     #
@@ -486,13 +666,13 @@ module ActiveRecord
     def revert(*migration_classes)
       run(*migration_classes.reverse, revert: true) unless migration_classes.empty?
       if block_given?
-        if @connection.respond_to? :revert
-          @connection.revert { yield }
+        if connection.respond_to? :revert
+          connection.revert { yield }
         else
-          recorder = CommandRecorder.new(@connection)
+          recorder = CommandRecorder.new(connection)
           @connection = recorder
           suppress_messages do
-            @connection.revert { yield }
+            connection.revert { yield }
           end
           @connection = recorder.delegate
           recorder.commands.each do |cmd, args, block|
@@ -503,7 +683,7 @@ module ActiveRecord
     end
 
     def reverting?
-      @connection.respond_to?(:reverting) && @connection.reverting
+      connection.respond_to?(:reverting) && connection.reverting
     end
 
     class ReversibleBlockHelper < Struct.new(:reverting) # :nodoc:
@@ -525,7 +705,7 @@ module ActiveRecord
     # when the three columns 'first_name', 'last_name' and 'full_name' exist,
     # even when migrating down:
     #
-    #    class SplitNameMigration < ActiveRecord::Migration
+    #    class SplitNameMigration < ActiveRecord::Migration[5.0]
     #      def change
     #        add_column :users, :first_name, :string
     #        add_column :users, :last_name, :string
@@ -560,7 +740,7 @@ module ActiveRecord
         revert { run(*migration_classes, direction: dir, revert: true) }
       else
         migration_classes.each do |migration_class|
-          migration_class.new.exec_migration(@connection, dir)
+          migration_class.new.exec_migration(connection, dir)
         end
       end
     end
@@ -649,10 +829,10 @@ module ActiveRecord
     end
 
     def method_missing(method, *arguments, &block)
-      arg_list = arguments.map{ |a| a.inspect } * ', '
+      arg_list = arguments.map(&:inspect) * ', '
 
       say_with_time "#{method}(#{arg_list})" do
-        unless @connection.respond_to? :revert
+        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) ||
@@ -731,7 +911,9 @@ module ActiveRecord
       end
     end
 
-    def table_name_options(config = ActiveRecord::Base)
+    # 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:
       {
         table_name_prefix: config.table_name_prefix,
         table_name_suffix: config.table_name_suffix
@@ -823,7 +1005,7 @@ module ActiveRecord
         new(:up, migrations, target_version).migrate
       end
 
-      def down(migrations_paths, target_version = nil, &block)
+      def down(migrations_paths, target_version = nil)
         migrations = migrations(migrations_paths)
         migrations.select! { |m| yield m } if block_given?
 
@@ -843,10 +1025,12 @@ module ActiveRecord
       end
 
       def get_all_versions(connection = Base.connection)
-        if connection.table_exists?(schema_migrations_table_name)
-          SchemaMigration.all.map { |x| x.version.to_i }.sort
-        else
-          []
+        ActiveSupport::Deprecation.silence do
+          if connection.table_exists?(schema_migrations_table_name)
+            SchemaMigration.all.map { |x| x.version.to_i }.sort
+          else
+            []
+          end
         end
       end
 
@@ -862,22 +1046,22 @@ module ActiveRecord
         migrations(migrations_paths).any?
       end
 
-      def last_version
-        last_migration.version
-      end
-
       def last_migration #:nodoc:
         migrations(migrations_paths).last || NullMigration.new
       end
 
       def migrations_paths
         @migrations_paths ||= ['db/migrate']
-        # just to not break things if someone uses: migration_path = some_string
+        # just to not break things if someone uses: migrations_path = some_string
         Array(@migrations_paths)
       end
 
-      def migrations_path
-        migrations_paths.first
+      def match_to_migration_filename?(filename) # :nodoc:
+        File.basename(filename) =~ Migration::MigrationFilenameRegexp
+      end
+
+      def parse_migration_filename(filename) # :nodoc:
+        File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
       end
 
       def migrations(paths)
@@ -886,8 +1070,7 @@ module ActiveRecord
         files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]
 
         migrations = files.map do |file|
-          version, name, scope = file.scan(/([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/).first
-
+          version, name, scope = parse_migration_filename(file)
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
           name = name.camelize
@@ -923,6 +1106,7 @@ module ActiveRecord
       validate(@migrations)
 
       Base.connection.initialize_schema_migrations_table
+      Base.connection.initialize_internal_metadata_table
     end
 
     def current_version
@@ -935,32 +1119,18 @@ module ActiveRecord
     alias :current :current_migration
 
     def run
-      migration = migrations.detect { |m| m.version == @target_version }
-      raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
-      unless (up? && migrated.include?(migration.version.to_i)) || (down? && !migrated.include?(migration.version.to_i))
-        begin
-          execute_migration_in_transaction(migration, @direction)
-        rescue => e
-          canceled_msg = use_transaction?(migration) ? ", this migration was canceled" : ""
-          raise StandardError, "An error has occurred#{canceled_msg}:\n\n#{e}", e.backtrace
-        end
+      if use_advisory_lock?
+        with_advisory_lock { run_without_lock }
+      else
+        run_without_lock
       end
     end
 
     def migrate
-      if !target && @target_version && @target_version > 0
-        raise UnknownMigrationVersionError.new(@target_version)
-      end
-
-      runnable.each do |migration|
-        Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
-
-        begin
-          execute_migration_in_transaction(migration, @direction)
-        rescue => e
-          canceled_msg = use_transaction?(migration) ? "this and " : ""
-          raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
-        end
+      if use_advisory_lock?
+        with_advisory_lock { migrate_without_lock }
+      else
+        migrate_without_lock
       end
     end
 
@@ -985,19 +1155,67 @@ module ActiveRecord
     end
 
     def migrated
-      @migrated_versions ||= Set.new(self.class.get_all_versions)
+      @migrated_versions || load_migrated
+    end
+
+    def load_migrated
+      @migrated_versions = Set.new(self.class.get_all_versions)
     end
 
     private
+
+    # 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?
+      execute_migration_in_transaction(migration, @direction)
+
+      record_environment
+    end
+
+    # Used for running multiple migrations up to or down to a certain value.
+    def migrate_without_lock
+      if invalid_target?
+        raise UnknownMigrationVersionError.new(@target_version)
+      end
+
+      runnable.each do |migration|
+        execute_migration_in_transaction(migration, @direction)
+      end
+
+      record_environment
+    end
+
+    # Stores the current environment in the database.
+    def record_environment
+      return if down?
+      ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+    end
+
     def ran?(migration)
       migrated.include?(migration.version.to_i)
     end
 
+    # Return true if a valid version is not provided.
+    def invalid_target?
+      !target && @target_version && @target_version > 0
+    end
+
     def execute_migration_in_transaction(migration, direction)
+      return if down? && !migrated.include?(migration.version.to_i)
+      return if up?   &&  migrated.include?(migration.version.to_i)
+
+      Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
+
       ddl_transaction(migration) do
         migration.migrate(direction)
         record_version_state_after_migrating(migration.version)
       end
+    rescue => e
+      msg = "An error has occurred, "
+      msg << "this and " if use_transaction?(migration)
+      msg << "all later migrations canceled:\n\n#{e}"
+      raise StandardError, msg, e.backtrace
     end
 
     def target
@@ -1026,10 +1244,27 @@ module ActiveRecord
         ActiveRecord::SchemaMigration.where(:version => version.to_s).delete_all
       else
         migrated << version
-        ActiveRecord::SchemaMigration.create!(:version => version.to_s)
+        ActiveRecord::SchemaMigration.create!(version: version.to_s)
       end
     end
 
+    def self.last_stored_environment
+      return nil if current_version == 0
+      raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
+
+      environment = ActiveRecord::InternalMetadata[:environment]
+      raise NoEnvironmentInSchemaError unless environment
+      environment
+    end
+
+    def self.current_environment
+      ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    end
+
+    def self.protected_environment?
+      ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
+    end
+
     def up?
       @direction == :up
     end
@@ -1050,5 +1285,25 @@ module ActiveRecord
     def use_transaction?(migration)
       !migration.disable_ddl_transaction && Base.connection.supports_ddl_transactions?
     end
+
+    def use_advisory_lock?
+      Base.connection.supports_advisory_locks?
+    end
+
+    def with_advisory_lock
+      lock_id = generate_migrator_advisory_lock_id
+      got_lock = Base.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
+      Base.connection.release_advisory_lock(lock_id) if got_lock
+    end
+
+    MIGRATOR_SALT = 2053462845
+    def generate_migrator_advisory_lock_id
+      db_name_hash = Zlib.crc32(Base.connection.current_database)
+      MIGRATOR_SALT * db_name_hash
+    end
   end
 end