activerecord 5.1.7 → 5.2.4.3

data/lib/active_record/gem_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # Returns the version of the currently loaded Active Record as a <tt>Gem::Version</tt>
   def self.gem_version
@@ -6,9 +8,9 @@ module ActiveRecord
 
   module VERSION
     MAJOR = 5
-    MINOR = 1
-    TINY  = 7
-    PRE   = nil
+    MINOR = 2
+    TINY  = 4
+    PRE   = "3"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
@@ -30,7 +32,7 @@ module ActiveRecord
   # for differentiating between them or reloading the right type with find.
   #
   # Note, all the attributes for all the cases are kept in the same table. Read more:
-  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  # https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
   #
   module Inheritance
     extend ActiveSupport::Concern
@@ -38,22 +40,20 @@ module ActiveRecord
     included do
       # Determines whether to store the full constant name including namespace when using STI.
       # This is true, by default.
-      class_attribute :store_full_sti_class, instance_writer: false
-      self.store_full_sti_class = true
+      class_attribute :store_full_sti_class, instance_writer: false, default: true
     end
 
     module ClassMethods
       # Determines if one of the attributes passed in is the inheritance column,
       # and if the inheritance column is attr accessible, it initializes an
       # instance of the given subclass instead of the base class.
-      def new(*args, &block)
+      def new(attributes = nil, &block)
         if abstract_class? || self == Base
           raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
 
-        attrs = args.first
         if has_attribute?(inheritance_column)
-          subclass = subclass_from_attributes(attrs)
+          subclass = subclass_from_attributes(attributes)
 
           if subclass.nil? && base_class == self
             subclass = subclass_from_attributes(column_defaults)
@@ -61,7 +61,7 @@ module ActiveRecord
         end
 
         if subclass && subclass != self
-          subclass.new(*args, &block)
+          subclass.new(attributes, &block)
         else
           super
         end
@@ -104,21 +104,47 @@ module ActiveRecord
         end
       end
 
-      # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
-      # If you are using inheritance with ActiveRecord and don't want child classes
-      # to utilize the implied STI table name of the parent class, this will need to be true.
-      # For example, given the following:
+      # Set this to +true+ if this is an abstract class (see
+      # <tt>abstract_class?</tt>).
+      # If you are using inheritance with Active Record and don't want a class
+      # to be considered as part of the STI hierarchy, you must set this to
+      # true.
+      # +ApplicationRecord+, for example, is generated as an abstract class.
+      #
+      # Consider the following default behaviour:
+      #
+      #   Shape = Class.new(ActiveRecord::Base)
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
+      #
+      #   Shape.table_name   # => "shapes"
+      #   Polygon.table_name # => "shapes"
+      #   Square.table_name  # => "shapes"
+      #   Shape.create!      # => #<Shape id: 1, type: nil>
+      #   Polygon.create!    # => #<Polygon id: 2, type: "Polygon">
+      #   Square.create!     # => #<Square id: 3, type: "Square">
+      #
+      # However, when using <tt>abstract_class</tt>, +Shape+ is omitted from
+      # the hierarchy:
       #
-      #   class SuperClass < ActiveRecord::Base
+      #   class Shape < ActiveRecord::Base
       #     self.abstract_class = true
       #   end
-      #   class Child < SuperClass
-      #     self.table_name = 'the_table_i_really_want'
-      #   end
-      #
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
       #
-      # <tt>self.abstract_class = true</tt> is required to make <tt>Child<.find,.create, or any Arel method></tt> use <tt>the_table_i_really_want</tt> instead of a table called <tt>super_classes</tt>
+      #   Shape.table_name   # => nil
+      #   Polygon.table_name # => "polygons"
+      #   Square.table_name  # => "polygons"
+      #   Shape.create!      # => NotImplementedError: Shape is an abstract class and cannot be instantiated.
+      #   Polygon.create!    # => #<Polygon id: 1, type: nil>
+      #   Square.create!     # => #<Square id: 2, type: "Square">
       #
+      # Note that in the above example, to disallow the creation of a plain
+      # +Polygon+, you should use <tt>validates :type, presence: true</tt>,
+      # instead of setting it as an abstract class. This way, +Polygon+ will
+      # stay in the hierarchy, and Active Record will continue to correctly
+      # derive the table name.
       attr_accessor :abstract_class
 
       # Returns whether this class is an abstract class or not.
@@ -130,6 +156,10 @@ module ActiveRecord
         store_full_sti_class ? name : name.demodulize
       end
 
+      def polymorphic_name
+        base_class.name
+      end
+
       def inherited(subclass)
         subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
         super
@@ -217,7 +247,7 @@ module ActiveRecord
         def subclass_from_attributes(attrs)
           attrs = attrs.to_h if attrs.respond_to?(:permitted?)
           if attrs.is_a?(Hash)
-            subclass_name = attrs.with_indifferent_access[inheritance_column]
+            subclass_name = attrs[inheritance_column] || attrs[inheritance_column.to_sym]
 
             if subclass_name.present?
               find_sti_class(subclass_name)
@@ -246,7 +276,7 @@ module ActiveRecord
       def ensure_proper_type
         klass = self.class
         if klass.finder_needs_type_condition?
-          write_attribute(klass.inheritance_column, klass.sti_name)
+          _write_attribute(klass.inheritance_column, klass.sti_name)
         end
       end
   end

data/lib/active_record/integration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/filters"
 
 module ActiveRecord
@@ -7,12 +9,19 @@ module ActiveRecord
     included do
       ##
       # :singleton-method:
-      # Indicates the format used to generate the timestamp in the cache key.
-      # Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      # Indicates the format used to generate the timestamp in the cache key, if
+      # versioning is off. Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
       #
       # This is +:usec+, by default.
-      class_attribute :cache_timestamp_format, instance_writer: false
-      self.cache_timestamp_format = :usec
+      class_attribute :cache_timestamp_format, instance_writer: false, default: :usec
+
+      ##
+      # :singleton-method:
+      # Indicates whether to use a stable #cache_key method that is accompanied
+      # by a changing version in the #cache_version method.
+      #
+      # This is +false+, by default until Rails 6.0.
+      class_attribute :cache_versioning, instance_writer: false, default: false
     end
 
     # Returns a +String+, which Action Pack uses for constructing a URL to this
@@ -42,35 +51,65 @@ module ActiveRecord
       id && id.to_s # Be sure to stringify the id for routes
     end
 
-    # Returns a cache key that can be used to identify this record.
+    # Returns a stable cache key that can be used to identify this record.
     #
     #   Product.new.cache_key     # => "products/new"
-    #   Product.find(5).cache_key # => "products/5" (updated_at not available)
-    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
+    #   Product.find(5).cache_key # => "products/5"
     #
-    # You can also pass a list of named timestamps, and the newest in the list will be
-    # used to generate the key:
+    # If ActiveRecord::Base.cache_versioning is turned off, as it was in Rails 5.1 and earlier,
+    # the cache key will also include a version.
     #
-    #   Person.find(5).cache_key(:updated_at, :last_reviewed_at)
+    #   Product.cache_versioning = false
+    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
     def cache_key(*timestamp_names)
       if new_record?
         "#{model_name.cache_key}/new"
       else
-        timestamp = if timestamp_names.any?
-          max_updated_column_timestamp(timestamp_names)
+        if cache_version && timestamp_names.none?
+          "#{model_name.cache_key}/#{id}"
         else
-          max_updated_column_timestamp
-        end
+          timestamp = if timestamp_names.any?
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Specifying a timestamp name for #cache_key has been deprecated in favor of
+              the explicit #cache_version method that can be overwritten.
+            MSG
 
-        if timestamp
-          timestamp = timestamp.utc.to_s(cache_timestamp_format)
-          "#{model_name.cache_key}/#{id}-#{timestamp}"
-        else
-          "#{model_name.cache_key}/#{id}"
+            max_updated_column_timestamp(timestamp_names)
+          else
+            max_updated_column_timestamp
+          end
+
+          if timestamp
+            timestamp = timestamp.utc.to_s(cache_timestamp_format)
+            "#{model_name.cache_key}/#{id}-#{timestamp}"
+          else
+            "#{model_name.cache_key}/#{id}"
+          end
         end
       end
     end
 
+    # Returns a cache version that can be used together with the cache key to form
+    # a recyclable caching scheme. By default, the #updated_at column is used for the
+    # cache_version, but this method can be overwritten to return something else.
+    #
+    # Note, this method will return nil if ActiveRecord::Base.cache_versioning is set to
+    # +false+ (which it is by default until Rails 6.0).
+    def cache_version
+      if cache_versioning && timestamp = try(:updated_at)
+        timestamp.utc.to_s(:usec)
+      end
+    end
+
+    # Returns a cache key along with the version.
+    def cache_key_with_version
+      if version = cache_version
+        "#{cache_key}-#{version}"
+      else
+        cache_key
+      end
+    end
+
     module ClassMethods
       # Defines your model's +to_param+ method to generate "pretty" URLs
       # using +method_name+, which can be any attribute or method that

data/lib/active_record/internal_metadata.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record/scoping/default"
 require "active_record/scoping/named"
 

data/lib/active_record/legacy_yaml_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module LegacyYamlAdapter
     def self.convert(klass, coder)
@@ -6,7 +8,7 @@ module ActiveRecord
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
-        if coder["attributes"].is_a?(AttributeSet)
+        if coder["attributes"].is_a?(ActiveModel::AttributeSet)
           Rails420.convert(klass, coder)
         else
           Rails41.convert(klass, coder)

data/lib/active_record/locking/optimistic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Locking
     # == What is Optimistic Locking
@@ -51,8 +53,7 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :lock_optimistically, instance_writer: false
-        self.lock_optimistically = true
+        class_attribute :lock_optimistically, instance_writer: false, default: true
       end
 
       def locking_enabled? #:nodoc:
@@ -85,8 +86,8 @@ module ActiveRecord
 
             self[locking_column] += 1
 
-            affected_rows = self.class.unscoped._update_record(
-              arel_attributes_with_values(attribute_names),
+            affected_rows = self.class._update_record(
+              attributes_with_values(attribute_names),
               self.class.primary_key => id_in_database,
               locking_column => previous_lock_value
             )
@@ -105,24 +106,20 @@ module ActiveRecord
         end
 
         def destroy_row
-          affected_rows = super
+          return super unless locking_enabled?
 
-          if locking_enabled? && affected_rows != 1
-            raise ActiveRecord::StaleObjectError.new(self, "destroy")
-          end
+          locking_column = self.class.locking_column
 
-          affected_rows
-        end
+          affected_rows = self.class._delete_record(
+            self.class.primary_key => id_in_database,
+            locking_column => read_attribute_before_type_cast(locking_column)
+          )
 
-        def relation_for_destroy
-          relation = super
-
-          if locking_enabled?
-            locking_column = self.class.locking_column
-            relation = relation.where(locking_column => read_attribute_before_type_cast(locking_column))
+          if affected_rows != 1
+            raise ActiveRecord::StaleObjectError.new(self, "destroy")
           end
 
-          relation
+          affected_rows
         end
 
         module ClassMethods

data/lib/active_record/locking/pessimistic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Locking
     # Locking::Pessimistic provides support for row-level locking using
@@ -51,8 +53,8 @@ module ActiveRecord
     #   end
     #
     # Database-specific information on row locking:
-    #   MySQL: http://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
-    #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    #   MySQL: https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
+    #   PostgreSQL: https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
     module Pessimistic
       # Obtain a row lock on this record. Reloads the record to obtain the requested
       # lock. Pass an SQL locking clause to append the end of the SELECT statement
@@ -61,12 +63,13 @@ module ActiveRecord
       def lock!(lock = true)
         if persisted?
           if has_changes_to_save?
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Locking a record with unpersisted changes is deprecated and will raise an
-              exception in Rails 5.2. Use `save` to persist the changes, or `reload` to
-              discard them explicitly.
+            raise(<<-MSG.squish)
+              Locking a record with unpersisted changes is not supported. Use
+              `save` to persist the changes, or `reload` to discard them
+              explicitly.
             MSG
           end
+
           reload(lock: lock)
         end
         self

data/lib/active_record/log_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class LogSubscriber < ActiveSupport::LogSubscriber
     IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
@@ -88,6 +90,47 @@ module ActiveRecord
       def logger
         ActiveRecord::Base.logger
       end
+
+      def debug(progname = nil, &block)
+        return unless super
+
+        if ActiveRecord::Base.verbose_query_logs
+          log_query_source
+        end
+      end
+
+      def log_query_source
+        source_line, line_number = extract_callstack(caller_locations)
+
+        if source_line
+          if defined?(::Rails.root)
+            app_root = "#{::Rails.root.to_s}/".freeze
+            source_line = source_line.sub(app_root, "")
+          end
+
+          logger.debug("  ↳ #{ source_line }:#{ line_number }")
+        end
+      end
+
+      def extract_callstack(callstack)
+        line = callstack.find do |frame|
+          frame.absolute_path && !ignored_callstack(frame.absolute_path)
+        end
+
+        offending_line = line || callstack.first
+
+        [
+          offending_line.path,
+          offending_line.lineno
+        ]
+      end
+
+      RAILS_GEM_ROOT = File.expand_path("../../..", __dir__) + "/"
+
+      def ignored_callstack(path)
+        path.start_with?(RAILS_GEM_ROOT) ||
+        path.start_with?(RbConfig::CONFIG["rubylibdir"])
+      end
   end
 end
 

data/lib/active_record/migration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 require "zlib"
 require "active_support/core_ext/module/attribute_accessors"
@@ -138,6 +140,7 @@ module ActiveRecord
 
   class ConcurrentMigrationError < MigrationError #:nodoc:
     DEFAULT_MESSAGE = "Cannot run migrations because another migration process is currently running.".freeze
+    RELEASE_LOCK_FAILED_MESSAGE = "Failed to release advisory lock".freeze
 
     def initialize(message = DEFAULT_MESSAGE)
       super
@@ -157,7 +160,7 @@ module ActiveRecord
 
   class ProtectedEnvironmentError < ActiveRecordError #:nodoc:
     def initialize(env = "production")
-      msg = "You are attempting to run a destructive action against your '#{env}' database.\n"
+      msg = "You are attempting to run a destructive action against your '#{env}' database.\n".dup
       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)
@@ -166,7 +169,7 @@ module ActiveRecord
 
   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 attempting to modify a database that was last run in `#{ stored }` environment.\n".dup
       msg << "You are running in `#{ current }` environment. "
       msg << "If you are sure you want to continue, first set the environment using:\n\n"
       msg << "        bin/rails db:environment:set"
@@ -352,9 +355,9 @@ module ActiveRecord
   # to match the structure of your database.
   #
   # To roll the database back to a previous migration version, use
-  # <tt>rails db:migrate VERSION=X</tt> where <tt>X</tt> is the version to which
+  # <tt>rails db:rollback 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>rails db:migrate STEP=2</tt> will rollback
+  # wish to rollback last few migrations. <tt>rails db:rollback STEP=2</tt> will rollback
   # the latest two migrations.
   #
   # If any of the migrations throw an <tt>ActiveRecord::IrreversibleMigration</tt> exception,
@@ -548,7 +551,7 @@ module ActiveRecord
       end
 
       def call(env)
-        mtime = ActiveRecord::Migrator.last_migration.mtime.to_i
+        mtime = ActiveRecord::Base.connection.migration_context.last_migration.mtime.to_i
         if @last_check < mtime
           ActiveRecord::Migration.check_pending!(connection)
           @last_check = mtime
@@ -573,13 +576,14 @@ module ActiveRecord
 
       # 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)
+        raise ActiveRecord::PendingMigrationError if connection.migration_context.needs_migration?
       end
 
       def load_schema_if_pending!
-        if ActiveRecord::Migrator.needs_migration? || !ActiveRecord::Migrator.any_migrations?
+        if Base.connection.migration_context.needs_migration? || !Base.connection.migration_context.any_migrations?
           # Roundtrip to Rake to allow plugins to hook into database initialization.
-          FileUtils.cd Rails.root do
+          root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
+          FileUtils.cd(root) do
             current_config = Base.connection_config
             Base.clear_all_connections!
             system("bin/rails db:test:prepare")
@@ -731,6 +735,24 @@ module ActiveRecord
       execute_block { yield helper }
     end
 
+    # Used to specify an operation that is only run when migrating up
+    # (for example, populating a new column with its initial values).
+    #
+    # In the following example, the new column +published+ will be given
+    # the value +true+ for all existing records.
+    #
+    #    class AddPublishedToPosts < ActiveRecord::Migration[5.2]
+    #      def change
+    #        add_column :posts, :published, :boolean, default: false
+    #        up_only do
+    #          execute "update posts set published = 'true'"
+    #        end
+    #      end
+    #    end
+    def up_only
+      execute_block { yield } unless reverting?
+    end
+
     # Runs the given migration classes.
     # Last argument can specify options:
     # - :direction (default is :up)
@@ -855,23 +877,25 @@ module ActiveRecord
 
       FileUtils.mkdir_p(destination) unless File.exist?(destination)
 
-      destination_migrations = ActiveRecord::Migrator.migrations(destination)
+      destination_migrations = ActiveRecord::MigrationContext.new(destination).migrations
       last = destination_migrations.last
       sources.each do |scope, path|
-        source_migrations = ActiveRecord::Migrator.migrations(path)
+        source_migrations = ActiveRecord::MigrationContext.new(path).migrations
 
         source_migrations.each do |migration|
           source = File.binread(migration.filename)
           inserted_comment = "# This migration comes from #{scope} (originally #{migration.version})\n"
-          if /\A#.*\b(?:en)?coding:\s*\S+/ =~ source
+          magic_comments = "".dup
+          loop do
             # If we have a magic comment in the original migration,
             # insert our comment after the first newline(end of the magic comment line)
             # so the magic keep working.
             # Note that magic comments must be at the first line(except sh-bang).
-            source[/\n/] = "\n#{inserted_comment}"
-          else
-            source = "#{inserted_comment}#{source}"
+            source.sub!(/\A(?:#.*\b(?:en)?coding:\s*\S+|#\s*frozen_string_literal:\s*(?:true|false)).*\n/) do |magic_comment|
+              magic_comments << magic_comment; ""
+            end || break
           end
+          source = "#{magic_comments}#{inserted_comment}#{source}"
 
           if duplicate = destination_migrations.detect { |m| m.name == migration.name }
             if options[:on_skip] && duplicate.scope != scope.to_s
@@ -974,146 +998,184 @@ module ActiveRecord
     end
   end
 
-  class Migrator#:nodoc:
-    class << self
-      attr_writer :migrations_paths
-      alias :migrations_path= :migrations_paths=
-
-      def migrate(migrations_paths, target_version = nil, &block)
-        case
-        when target_version.nil?
-          up(migrations_paths, target_version, &block)
-        when current_version == 0 && target_version == 0
-          []
-        when current_version > target_version
-          down(migrations_paths, target_version, &block)
-        else
-          up(migrations_paths, target_version, &block)
-        end
-      end
+  class MigrationContext # :nodoc:
+    attr_reader :migrations_paths
 
-      def rollback(migrations_paths, steps = 1)
-        move(:down, migrations_paths, steps)
-      end
+    def initialize(migrations_paths)
+      @migrations_paths = migrations_paths
+    end
 
-      def forward(migrations_paths, steps = 1)
-        move(:up, migrations_paths, steps)
+    def migrate(target_version = nil, &block)
+      case
+      when target_version.nil?
+        up(target_version, &block)
+      when current_version == 0 && target_version == 0
+        []
+      when current_version > target_version
+        down(target_version, &block)
+      else
+        up(target_version, &block)
       end
+    end
+
+    def rollback(steps = 1)
+      move(:down, steps)
+    end
 
-      def up(migrations_paths, target_version = nil)
-        migrations = migrations(migrations_paths)
-        migrations.select! { |m| yield m } if block_given?
+    def forward(steps = 1)
+      move(:up, steps)
+    end
 
-        new(:up, migrations, target_version).migrate
+    def up(target_version = nil)
+      selected_migrations = if block_given?
+        migrations.select { |m| yield m }
+      else
+        migrations
       end
 
-      def down(migrations_paths, target_version = nil)
-        migrations = migrations(migrations_paths)
-        migrations.select! { |m| yield m } if block_given?
+      Migrator.new(:up, selected_migrations, target_version).migrate
+    end
 
-        new(:down, migrations, target_version).migrate
+    def down(target_version = nil)
+      selected_migrations = if block_given?
+        migrations.select { |m| yield m }
+      else
+        migrations
       end
 
-      def run(direction, migrations_paths, target_version)
-        new(direction, migrations(migrations_paths), target_version).run
-      end
+      Migrator.new(:down, selected_migrations, target_version).migrate
+    end
 
-      def open(migrations_paths)
-        new(:up, migrations(migrations_paths), nil)
-      end
+    def run(direction, target_version)
+      Migrator.new(direction, migrations, target_version).run
+    end
 
-      def schema_migrations_table_name
-        SchemaMigration.table_name
-      end
-      deprecate :schema_migrations_table_name
+    def open
+      Migrator.new(:up, migrations, nil)
+    end
 
-      def get_all_versions(connection = Base.connection)
-        if SchemaMigration.table_exists?
-          SchemaMigration.all_versions.map(&:to_i)
-        else
-          []
-        end
+    def get_all_versions
+      if SchemaMigration.table_exists?
+        SchemaMigration.all_versions.map(&:to_i)
+      else
+        []
       end
+    end
 
-      def current_version(connection = Base.connection)
-        get_all_versions(connection).max || 0
-      end
+    def current_version
+      get_all_versions.max || 0
+    rescue ActiveRecord::NoDatabaseError
+    end
 
-      def needs_migration?(connection = Base.connection)
-        (migrations(migrations_paths).collect(&:version) - get_all_versions(connection)).size > 0
-      end
+    def needs_migration?
+      (migrations.collect(&:version) - get_all_versions).size > 0
+    end
 
-      def any_migrations?
-        migrations(migrations_paths).any?
-      end
+    def any_migrations?
+      migrations.any?
+    end
 
-      def last_migration #:nodoc:
-        migrations(migrations_paths).last || NullMigration.new
-      end
+    def last_migration #:nodoc:
+      migrations.last || NullMigration.new
+    end
 
-      def migrations_paths
-        @migrations_paths ||= ["db/migrate"]
-        # just to not break things if someone uses: migrations_path = some_string
-        Array(@migrations_paths)
-      end
+    def parse_migration_filename(filename) # :nodoc:
+      File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
+    end
 
-      def parse_migration_filename(filename) # :nodoc:
-        File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
+    def migrations
+      migrations = migration_files.map do |file|
+        version, name, scope = parse_migration_filename(file)
+        raise IllegalMigrationNameError.new(file) unless version
+        version = version.to_i
+        name = name.camelize
+
+        MigrationProxy.new(name, version, file, scope)
       end
 
-      def migrations(paths)
-        paths = Array(paths)
+      migrations.sort_by(&:version)
+    end
 
-        migrations = migration_files(paths).map do |file|
-          version, name, scope = parse_migration_filename(file)
-          raise IllegalMigrationNameError.new(file) unless version
-          version = version.to_i
-          name = name.camelize
+    def migrations_status
+      db_list = ActiveRecord::SchemaMigration.normalized_versions
 
-          MigrationProxy.new(name, version, file, scope)
-        end
+      file_list = migration_files.map do |file|
+        version, name, scope = parse_migration_filename(file)
+        raise IllegalMigrationNameError.new(file) unless version
+        version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+        status = db_list.delete(version) ? "up" : "down"
+        [status, version, (name + scope).humanize]
+      end.compact
 
-        migrations.sort_by(&:version)
+      db_list.map! do |version|
+        ["up", version, "********** NO FILE **********"]
       end
 
-      def migrations_status(paths)
-        paths = Array(paths)
+      (db_list + file_list).sort_by { |_, version, _| version }
+    end
+
+    def migration_files
+      paths = Array(migrations_paths)
+      Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
+    end
+
+    def current_environment
+      ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    end
+
+    def protected_environment?
+      ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
+    end
+
+    def last_stored_environment
+      return nil if current_version == 0
+      raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
 
-        db_list = ActiveRecord::SchemaMigration.normalized_versions
+      environment = ActiveRecord::InternalMetadata[:environment]
+      raise NoEnvironmentInSchemaError unless environment
+      environment
+    end
 
-        file_list = migration_files(paths).map do |file|
-          version, name, scope = parse_migration_filename(file)
-          raise IllegalMigrationNameError.new(file) unless version
-          version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
-          status = db_list.delete(version) ? "up" : "down"
-          [status, version, (name + scope).humanize]
-        end.compact
+    private
+      def move(direction, steps)
+        migrator = Migrator.new(direction, migrations)
 
-        db_list.map! do |version|
-          ["up", version, "********** NO FILE **********"]
+        if current_version != 0 && !migrator.current_migration
+          raise UnknownMigrationVersionError.new(current_version)
         end
 
-        (db_list + file_list).sort_by { |_, version, _| version }
-      end
+        start_index =
+          if current_version == 0
+            0
+          else
+            migrator.migrations.index(migrator.current_migration)
+          end
 
-      def migration_files(paths)
-        Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
+        finish = migrator.migrations[start_index + steps]
+        version = finish ? finish.version : 0
+        send(direction, version)
       end
+  end
 
-      private
+  class Migrator # :nodoc:
+    class << self
+      attr_accessor :migrations_paths
 
-      def move(direction, migrations_paths, steps)
-        migrator = new(direction, migrations(migrations_paths))
-        start_index = migrator.migrations.index(migrator.current_migration)
+      def migrations_path=(path)
+        ActiveSupport::Deprecation.warn \
+          "`ActiveRecord::Migrator.migrations_path=` is now deprecated and will be removed in Rails 6.0. " \
+          "You can set the `migrations_paths` on the `connection` instead through the `database.yml`."
+        self.migrations_paths = [path]
+      end
 
-        if start_index
-          finish = migrator.migrations[start_index + steps]
-          version = finish ? finish.version : 0
-          send(direction, migrations_paths, version)
-        end
+      # For cases where a table doesn't exist like loading from schema cache
+      def current_version
+        MigrationContext.new(migrations_paths).current_version
       end
     end
 
+    self.migrations_paths = ["db/migrate"]
+
     def initialize(direction, migrations, target_version = nil)
       @direction         = direction
       @target_version    = target_version
@@ -1176,7 +1238,7 @@ module ActiveRecord
     end
 
     def load_migrated
-      @migrated_versions = Set.new(self.class.get_all_versions)
+      @migrated_versions = Set.new(Base.connection.migration_context.get_all_versions)
     end
 
     private
@@ -1208,7 +1270,7 @@ module ActiveRecord
       # Stores the current environment in the database.
       def record_environment
         return if down?
-        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Base.connection.migration_context.current_environment
       end
 
       def ran?(migration)
@@ -1217,7 +1279,7 @@ module ActiveRecord
 
       # Return true if a valid version is not provided.
       def invalid_target?
-        !target && @target_version && @target_version > 0
+        @target_version && @target_version != 0 && !target
       end
 
       def execute_migration_in_transaction(migration, direction)
@@ -1231,7 +1293,7 @@ module ActiveRecord
           record_version_state_after_migrating(migration.version)
         end
       rescue => e
-        msg = "An error has occurred, "
+        msg = "An error has occurred, ".dup
         msg << "this and " if use_transaction?(migration)
         msg << "all later migrations canceled:\n\n#{e}"
         raise StandardError, msg, e.backtrace
@@ -1250,10 +1312,10 @@ module ActiveRecord
       end
 
       def validate(migrations)
-        name , = migrations.group_by(&:name).find { |_, v| v.length > 1 }
+        name, = migrations.group_by(&:name).find { |_, v| v.length > 1 }
         raise DuplicateMigrationNameError.new(name) if name
 
-        version , = migrations.group_by(&:version).find { |_, v| v.length > 1 }
+        version, = migrations.group_by(&:version).find { |_, v| v.length > 1 }
         raise DuplicateMigrationVersionError.new(version) if version
       end
 
@@ -1267,23 +1329,6 @@ module ActiveRecord
         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
@@ -1311,12 +1356,17 @@ module ActiveRecord
 
       def with_advisory_lock
         lock_id = generate_migrator_advisory_lock_id
-        got_lock = Base.connection.get_advisory_lock(lock_id)
+        connection = Base.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
-        Base.connection.release_advisory_lock(lock_id) if got_lock
+        if got_lock && !connection.release_advisory_lock(lock_id)
+          raise ConcurrentMigrationError.new(
+            ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE
+          )
+        end
       end
 
       MIGRATOR_SALT = 2053462845