activerecord 5.2.0.rc1 → 5.2.0.rc2

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -119,11 +119,11 @@ module ActiveRecord
         end
       end
 
-      def migrations_paths
+      def migrations_paths # :nodoc:
         @config[:migrations_paths] || Migrator.migrations_paths
       end
 
-      def migration_context
+      def migration_context # :nodoc:
         MigrationContext.new(migrations_paths)
       end
 

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -515,7 +515,7 @@ module ActiveRecord
           s.gsub(/\s+(?:ASC|DESC)\b/i, "")
         }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
-        [super, *order_columns].join(", ")
+        (order_columns << super).join(", ")
       end
 
       def strict_mode?

data/lib/active_record/connection_adapters/postgresql/oid.rb

@@ -5,6 +5,7 @@ require "active_record/connection_adapters/postgresql/oid/bit"
 require "active_record/connection_adapters/postgresql/oid/bit_varying"
 require "active_record/connection_adapters/postgresql/oid/bytea"
 require "active_record/connection_adapters/postgresql/oid/cidr"
+require "active_record/connection_adapters/postgresql/oid/date"
 require "active_record/connection_adapters/postgresql/oid/date_time"
 require "active_record/connection_adapters/postgresql/oid/decimal"
 require "active_record/connection_adapters/postgresql/oid/enum"

data/lib/active_record/connection_adapters/postgresql/oid/date.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Date < Type::Date # :nodoc:
+          def cast_value(value)
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -107,7 +107,7 @@ module ActiveRecord
             oid = row[4]
             comment = row[5]
 
-            using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/).flatten
+            using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/m).flatten
 
             orders = {}
             opclasses = {}
@@ -583,7 +583,7 @@ module ActiveRecord
                .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
             }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
-          [super, *order_columns].join(", ")
+          (order_columns << super).join(", ")
         end
 
         def update_table_definition(table_name, base) # :nodoc:

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -465,7 +465,7 @@ module ActiveRecord
           register_class_with_limit m, "bit", OID::Bit
           register_class_with_limit m, "varbit", OID::BitVarying
           m.alias_type "timestamptz", "timestamp"
-          m.register_type "date", Type::Date.new
+          m.register_type "date", OID::Date.new
 
           m.register_type "money", OID::Money.new
           m.register_type "bytea", OID::Bytea.new
@@ -837,6 +837,7 @@ module ActiveRecord
         ActiveRecord::Type.register(:bit_varying, OID::BitVarying, adapter: :postgresql)
         ActiveRecord::Type.register(:binary, OID::Bytea, adapter: :postgresql)
         ActiveRecord::Type.register(:cidr, OID::Cidr, adapter: :postgresql)
+        ActiveRecord::Type.register(:date, OID::Date, adapter: :postgresql)
         ActiveRecord::Type.register(:datetime, OID::DateTime, adapter: :postgresql)
         ActiveRecord::Type.register(:decimal, OID::Decimal, adapter: :postgresql)
         ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)

data/lib/active_record/connection_adapters/sqlite3/quoting.rb

@@ -17,7 +17,7 @@ module ActiveRecord
         end
 
         def quoted_time(value)
-          quoted_date(value)
+          quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
         end
 
         def quoted_binary(value)

data/lib/active_record/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     MAJOR = 5
     MINOR = 2
     TINY  = 0
-    PRE   = "rc1"
+    PRE   = "rc2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -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.
       #
-      #   class SuperClass < ActiveRecord::Base
+      # 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 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

data/lib/active_record/locking/optimistic.rb

@@ -61,13 +61,6 @@ module ActiveRecord
       end
 
       private
-
-        def increment_lock
-          lock_col = self.class.locking_column
-          previous_lock_value = send(lock_col)
-          send("#{lock_col}=", previous_lock_value + 1)
-        end
-
         def _create_record(attribute_names = self.attribute_names, *)
           if locking_enabled?
             # We always want to persist the locking version, even if we don't detect
@@ -77,63 +70,56 @@ module ActiveRecord
           super
         end
 
-        def _update_record(attribute_names = self.attribute_names)
+        def _touch_row(attribute_names, time)
+          super
+        ensure
+          clear_attribute_change(self.class.locking_column) if locking_enabled?
+        end
+
+        def _update_row(attribute_names, attempted_action = "update")
           return super unless locking_enabled?
-          return 0 if attribute_names.empty?
 
           begin
-            lock_col = self.class.locking_column
-
-            previous_lock_value = read_attribute_before_type_cast(lock_col)
-
-            increment_lock
-
-            attribute_names.push(lock_col)
+            locking_column = self.class.locking_column
+            previous_lock_value = read_attribute_before_type_cast(locking_column)
+            attribute_names << locking_column
 
-            relation = self.class.unscoped
+            self[locking_column] += 1
 
-            affected_rows = relation.where(
-              self.class.primary_key => id,
-              lock_col => previous_lock_value
-            ).update_all(
-              attributes_for_update(attribute_names).map do |name|
-                [name, _read_attribute(name)]
-              end.to_h
+            affected_rows = self.class._update_record(
+              attributes_with_values(attribute_names),
+              self.class.primary_key => id_in_database,
+              locking_column => previous_lock_value
             )
 
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError.new(self, "update")
+            if affected_rows != 1
+              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
             end
 
             affected_rows
 
           # If something went wrong, revert the locking_column value.
           rescue Exception
-            send("#{lock_col}=", previous_lock_value.to_i)
-
+            self[locking_column] = previous_lock_value.to_i
             raise
           end
         end
 
         def destroy_row
-          affected_rows = super
-
-          if locking_enabled? && affected_rows != 1
-            raise ActiveRecord::StaleObjectError.new(self, "destroy")
-          end
+          return super unless locking_enabled?
 
-          affected_rows
-        end
+          locking_column = self.class.locking_column
 
-        def relation_for_destroy
-          relation = super
+          affected_rows = self.class._delete_record(
+            self.class.primary_key => id_in_database,
+            locking_column => read_attribute_before_type_cast(locking_column)
+          )
 
-          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/migration.rb

@@ -140,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
@@ -1355,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

data/lib/active_record/model_schema.rb

@@ -379,6 +379,7 @@ module ActiveRecord
       end
 
       def _default_attributes # :nodoc:
+        load_schema
         @default_attributes ||= ActiveModel::AttributeSet.new({})
       end
 

data/lib/active_record/persistence.rb

@@ -169,12 +169,11 @@ module ActiveRecord
         primary_key_value = nil
 
         if primary_key && Hash === values
-          arel_primary_key = arel_attribute(primary_key)
-          primary_key_value = values[arel_primary_key]
+          primary_key_value = values[primary_key]
 
           if !primary_key_value && prefetch_primary_key?
             primary_key_value = next_sequence_value
-            values[arel_primary_key] = primary_key_value
+            values[primary_key] = primary_key_value
           end
         end
 
@@ -188,15 +187,26 @@ module ActiveRecord
         connection.insert(im, "#{self} Create", primary_key || false, primary_key_value)
       end
 
-      def _update_record(values, id, id_was) # :nodoc:
-        bind = predicate_builder.build_bind_attribute(primary_key, id_was || id)
+      def _update_record(values, constraints) # :nodoc:
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
         um = arel_table.where(
-          arel_attribute(primary_key).eq(bind)
+          constraints.reduce(&:and)
         ).compile_update(_substitute_values(values), primary_key)
 
         connection.update(um, "#{self} Update")
       end
 
+      def _delete_record(constraints) # :nodoc:
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        dm = Arel::DeleteManager.new
+        dm.from(arel_table)
+        dm.wheres = constraints
+
+        connection.delete(dm, "#{self} Destroy")
+      end
+
       private
         # Called by +instantiate+ to decide which class to use for a new
         # record instance.
@@ -208,8 +218,9 @@ module ActiveRecord
         end
 
         def _substitute_values(values)
-          values.map do |attr, value|
-            bind = predicate_builder.build_bind_attribute(attr.name, value)
+          values.map do |name, value|
+            attr = arel_attribute(name)
+            bind = predicate_builder.build_bind_attribute(name, value)
             [attr, bind]
           end
         end
@@ -310,7 +321,7 @@ module ActiveRecord
     # callbacks or any <tt>:dependent</tt> association
     # options, use <tt>#destroy</tt>.
     def delete
-      _relation_for_itself.delete_all if persisted?
+      _delete_row if persisted?
       @destroyed = true
       freeze
     end
@@ -363,6 +374,7 @@ module ActiveRecord
       became.send(:initialize)
       became.instance_variable_set("@attributes", @attributes)
       became.instance_variable_set("@mutations_from_database", @mutations_from_database) if defined?(@mutations_from_database)
+      became.instance_variable_set("@changed_attributes", attributes_changed_by_setter)
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
       became.errors.copy!(errors)
@@ -461,13 +473,16 @@ module ActiveRecord
         verify_readonly_attribute(key.to_s)
       end
 
-      updated_count = _relation_for_itself.update_all(attributes)
+      affected_rows = self.class._update_record(
+        attributes,
+        self.class.primary_key => id_in_database
+      )
 
       attributes.each do |k, v|
         write_attribute_without_type_cast(k, v)
       end
 
-      updated_count == 1
+      affected_rows == 1
     end
 
     # Initializes +attribute+ to zero if +nil+ and adds the value passed as +by+ (default is 1).
@@ -640,35 +655,12 @@ module ActiveRecord
         MSG
       end
 
-      time ||= current_time_from_proper_timezone
-      attributes = timestamp_attributes_for_update_in_model
-      attributes.concat(names)
-
-      unless attributes.empty?
-        changes = {}
-
-        attributes.each do |column|
-          column = column.to_s
-          changes[column] = write_attribute(column, time)
-        end
-
-        scope = _relation_for_itself
-
-        if locking_enabled?
-          locking_column = self.class.locking_column
-          scope = scope.where(locking_column => read_attribute_before_type_cast(locking_column))
-          changes[locking_column] = increment_lock
-        end
-
-        clear_attribute_changes(changes.keys)
-        result = scope.update_all(changes) == 1
-
-        if !result && locking_enabled?
-          raise ActiveRecord::StaleObjectError.new(self, "touch")
-        end
+      attribute_names = timestamp_attributes_for_update_in_model
+      attribute_names.concat(names)
 
-        @_trigger_update_callback = result
-        result
+      unless attribute_names.empty?
+        affected_rows = _touch_row(attribute_names, time)
+        @_trigger_update_callback = affected_rows == 1
       else
         true
       end
@@ -681,15 +673,29 @@ module ActiveRecord
     end
 
     def destroy_row
-      relation_for_destroy.delete_all
+      _delete_row
     end
 
-    def relation_for_destroy
-      _relation_for_itself
+    def _delete_row
+      self.class._delete_record(self.class.primary_key => id_in_database)
     end
 
-    def _relation_for_itself
-      self.class.unscoped.where(self.class.primary_key => id)
+    def _touch_row(attribute_names, time)
+      time ||= current_time_from_proper_timezone
+
+      attribute_names.each do |attr_name|
+        write_attribute(attr_name, time)
+        clear_attribute_change(attr_name)
+      end
+
+      _update_row(attribute_names, "touch")
+    end
+
+    def _update_row(attribute_names, attempted_action = "update")
+      self.class._update_record(
+        attributes_with_values(attribute_names),
+        self.class.primary_key => id_in_database
+      )
     end
 
     def create_or_update(*args, &block)
@@ -702,24 +708,27 @@ module ActiveRecord
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
     def _update_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_update(attribute_names)
-      if attributes_values.empty?
-        rows_affected = 0
+      attribute_names &= self.class.column_names
+      attribute_names = attributes_for_update(attribute_names)
+
+      if attribute_names.empty?
+        affected_rows = 0
         @_trigger_update_callback = true
       else
-        rows_affected = self.class._update_record(attributes_values, id, id_in_database)
-        @_trigger_update_callback = rows_affected > 0
+        affected_rows = _update_row(attribute_names)
+        @_trigger_update_callback = affected_rows == 1
       end
 
       yield(self) if block_given?
 
-      rows_affected
+      affected_rows
     end
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def _create_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_create(attribute_names)
+      attribute_names &= self.class.column_names
+      attributes_values = attributes_with_values_for_create(attribute_names)
 
       new_id = self.class._insert_record(attributes_values)
       self.id ||= new_id if self.class.primary_key