activerecord 7.1.3.2 → 7.2.1

data/lib/active_record/associations.rb

@@ -1,268 +1,6 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  class AssociationNotFoundError < ConfigurationError # :nodoc:
-    attr_reader :record, :association_name
-
-    def initialize(record = nil, association_name = nil)
-      @record           = record
-      @association_name = association_name
-      if record && association_name
-        super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
-      else
-        super("Association was not found.")
-      end
-    end
-
-    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
-      include DidYouMean::Correctable
-
-      def corrections
-        if record && association_name
-          @corrections ||= begin
-            maybe_these = record.class.reflections.keys
-            DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(association_name)
-          end
-        else
-          []
-        end
-      end
-    end
-  end
-
-  class InverseOfAssociationNotFoundError < ActiveRecordError # :nodoc:
-    attr_reader :reflection, :associated_class
-
-    def initialize(reflection = nil, associated_class = nil)
-      if reflection
-        @reflection = reflection
-        @associated_class = associated_class.nil? ? reflection.klass : associated_class
-        super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
-      else
-        super("Could not find the inverse association.")
-      end
-    end
-
-    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
-      include DidYouMean::Correctable
-
-      def corrections
-        if reflection && associated_class
-          @corrections ||= begin
-            maybe_these = associated_class.reflections.keys
-            DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(reflection.options[:inverse_of].to_s)
-          end
-        else
-          []
-        end
-      end
-    end
-  end
-
-  class InverseOfAssociationRecursiveError < ActiveRecordError # :nodoc:
-    attr_reader :reflection
-    def initialize(reflection = nil)
-      if reflection
-        @reflection = reflection
-        super("Inverse association #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{reflection.class_name}) is recursive.")
-      else
-        super("Inverse association is recursive.")
-      end
-    end
-  end
-
-  class HasManyThroughAssociationNotFoundError < ActiveRecordError # :nodoc:
-    attr_reader :owner_class, :reflection
-
-    def initialize(owner_class = nil, reflection = nil)
-      if owner_class && reflection
-        @owner_class = owner_class
-        @reflection = reflection
-        super("Could not find the association #{reflection.options[:through].inspect} in model #{owner_class.name}")
-      else
-        super("Could not find the association.")
-      end
-    end
-
-    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
-      include DidYouMean::Correctable
-
-      def corrections
-        if owner_class && reflection
-          @corrections ||= begin
-            maybe_these = owner_class.reflections.keys
-            maybe_these -= [reflection.name.to_s] # remove failing reflection
-            DidYouMean::SpellChecker.new(dictionary: maybe_these).correct(reflection.options[:through].to_s)
-          end
-        else
-          []
-        end
-      end
-    end
-  end
-
-  class HasManyThroughAssociationPolymorphicSourceError < ActiveRecordError # :nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
-      if owner_class_name && reflection && source_reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' on the polymorphic object '#{source_reflection.class_name}##{source_reflection.name}' without 'source_type'. Try adding 'source_type: \"#{reflection.name.to_s.classify}\"' to 'has_many :through' definition.")
-      else
-        super("Cannot have a has_many :through association.")
-      end
-    end
-  end
-
-  class HasManyThroughAssociationPolymorphicThroughError < ActiveRecordError # :nodoc:
-    def initialize(owner_class_name = nil, reflection = nil)
-      if owner_class_name && reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
-      else
-        super("Cannot have a has_many :through association.")
-      end
-    end
-  end
-
-  class HasManyThroughAssociationPointlessSourceTypeError < ActiveRecordError # :nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
-      if owner_class_name && reflection && source_reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' with a :source_type option if the '#{reflection.through_reflection.class_name}##{source_reflection.name}' is not polymorphic. Try removing :source_type on your association.")
-      else
-        super("Cannot have a has_many :through association.")
-      end
-    end
-  end
-
-  class HasOneThroughCantAssociateThroughCollection < ActiveRecordError # :nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
-      if owner_class_name && reflection && through_reflection
-        super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' where the :through association '#{owner_class_name}##{through_reflection.name}' is a collection. Specify a has_one or belongs_to association in the :through option instead.")
-      else
-        super("Cannot have a has_one :through association.")
-      end
-    end
-  end
-
-  class HasOneAssociationPolymorphicThroughError < ActiveRecordError # :nodoc:
-    def initialize(owner_class_name = nil, reflection = nil)
-      if owner_class_name && reflection
-        super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
-      else
-        super("Cannot have a has_one :through association.")
-      end
-    end
-  end
-
-  class HasManyThroughSourceAssociationNotFoundError < ActiveRecordError # :nodoc:
-    def initialize(reflection = nil)
-      if reflection
-        through_reflection      = reflection.through_reflection
-        source_reflection_names = reflection.source_reflection_names
-        source_associations     = reflection.through_reflection.klass._reflections.keys
-        super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')} in model #{through_reflection.klass}. Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'. Is it one of #{source_associations.to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')}?")
-      else
-        super("Could not find the source association(s).")
-      end
-    end
-  end
-
-  class HasManyThroughOrderError < ActiveRecordError # :nodoc:
-    def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
-      if owner_class_name && reflection && through_reflection
-        super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through '#{owner_class_name}##{through_reflection.name}' before the through association is defined.")
-      else
-        super("Cannot have a has_many :through association before the through association is defined.")
-      end
-    end
-  end
-
-  class ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecordError # :nodoc:
-    def initialize(owner = nil, reflection = nil)
-      if owner && reflection
-        super("Cannot modify association '#{owner.class.name}##{reflection.name}' because the source reflection class '#{reflection.source_reflection.class_name}' is associated to '#{reflection.through_reflection.class_name}' via :#{reflection.source_reflection.macro}.")
-      else
-        super("Cannot modify association.")
-      end
-    end
-  end
-
-  class CompositePrimaryKeyMismatchError < ActiveRecordError # :nodoc:
-    attr_reader :reflection
-
-    def initialize(reflection = nil)
-      if reflection
-        if reflection.has_one? || reflection.collection?
-          super("Association #{reflection.active_record}##{reflection.name} primary key #{reflection.active_record_primary_key} doesn't match with foreign key #{reflection.foreign_key}. Please specify query_constraints, or primary_key and foreign_key values.")
-        else
-          super("Association #{reflection.active_record}##{reflection.name} primary key #{reflection.association_primary_key} doesn't match with foreign key #{reflection.foreign_key}. Please specify query_constraints, or primary_key and foreign_key values.")
-        end
-      else
-        super("Association primary key doesn't match with foreign key.")
-      end
-    end
-  end
-
-  class AmbiguousSourceReflectionForThroughAssociation < ActiveRecordError # :nodoc:
-    def initialize(klass, macro, association_name, options, possible_sources)
-      example_options = options.dup
-      example_options[:source] = possible_sources.first
-
-      super("Ambiguous source reflection for through association. Please " \
-            "specify a :source directive on your declaration like:\n" \
-            "\n" \
-            "  class #{klass} < ActiveRecord::Base\n" \
-            "    #{macro} :#{association_name}, #{example_options}\n" \
-            "  end"
-           )
-    end
-  end
-
-  class HasManyThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection # :nodoc:
-  end
-
-  class HasOneThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection # :nodoc:
-  end
-
-  class ThroughNestedAssociationsAreReadonly < ActiveRecordError # :nodoc:
-    def initialize(owner = nil, reflection = nil)
-      if owner && reflection
-        super("Cannot modify association '#{owner.class.name}##{reflection.name}' because it goes through more than one other association.")
-      else
-        super("Through nested associations are read-only.")
-      end
-    end
-  end
-
-  class HasManyThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly # :nodoc:
-  end
-
-  class HasOneThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly # :nodoc:
-  end
-
-  # This error is raised when trying to eager load a polymorphic association using a JOIN.
-  # Eager loading polymorphic associations is only possible with
-  # {ActiveRecord::Relation#preload}[rdoc-ref:QueryMethods#preload].
-  class EagerLoadPolymorphicError < ActiveRecordError
-    def initialize(reflection = nil)
-      if reflection
-        super("Cannot eagerly load the polymorphic association #{reflection.name.inspect}")
-      else
-        super("Eager load polymorphic error.")
-      end
-    end
-  end
-
-  # This error is raised when trying to destroy a parent instance in N:1 or 1:1 associations
-  # (has_many, has_one) when there is at least 1 child associated instance.
-  # ex: if @project.tasks.size > 0, DeleteRestrictionError will be raised when trying to destroy @project
-  class DeleteRestrictionError < ActiveRecordError # :nodoc:
-    def initialize(name = nil)
-      if name
-        super("Cannot delete record because of dependent #{name}")
-      else
-        super("Delete restriction error.")
-      end
-    end
-  end
-
   # See ActiveRecord::Associations::ClassMethods for documentation.
   module Associations # :nodoc:
     extend ActiveSupport::Autoload
@@ -1506,6 +1244,13 @@ module ActiveRecord
         #   Serves as a composite foreign key. Defines the list of columns to be used to query the associated object.
         #   This is an optional option. By default Rails will attempt to derive the value automatically.
         #   When the value is set the Array size must match associated model's primary key or +query_constraints+ size.
+        # [+:index_errors+]
+        #   Allows differentiation of multiple validation errors from the association records, by including
+        #   an index in the error attribute name, e.g. +roles[2].level+.
+        #   When set to +true+, the index is based on association order, i.e. database order, with yet to be
+        #   persisted new records placed at the end.
+        #   When set to +:nested_attributes_order+, the index is based on the record order received by
+        #   nested attributes setter, when accepts_nested_attributes_for is used.
         #
         # Option examples:
         #   has_many :comments, -> { order("posted_on") }
@@ -1519,6 +1264,7 @@ module ActiveRecord
         #   has_many :subscribers, through: :subscriptions, disable_joins: true
         #   has_many :comments, strict_loading: true
         #   has_many :comments, query_constraints: [:blog_id, :post_id]
+        #   has_many :comments, index_errors: :nested_attributes_order
         def has_many(name, scope = nil, **options, &extension)
           reflection = Builder::HasMany.build(self, name, scope, options, &extension)
           Reflection.add_reflection self, name, reflection
@@ -1661,9 +1407,14 @@ module ActiveRecord
         #   When set to +true+, validates new objects added to association when saving the parent object. +false+ by default.
         #   If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
         # [+:autosave+]
-        #   If true, always save the associated object or destroy it if marked for destruction,
-        #   when saving the parent object. If false, never save or destroy the associated object.
-        #   By default, only save the associated object if it's a new record.
+        #   If +true+, always saves the associated object or destroys it if marked for destruction,
+        #   when saving the parent object.
+        #   If +false+, never save or destroy the associated object.
+        #
+        #   By default, only saves the associated object if it's a new record. Setting this option
+        #   to +true+ also enables validations on the associated object unless explicitly disabled
+        #   with <tt>validate: false</tt>. This is because saving an object with invalid associated
+        #   objects would fail, so any associated objects will go through validation checks.
         #
         #   Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for sets
         #   <tt>:autosave</tt> to <tt>true</tt>.
@@ -1816,15 +1567,25 @@ module ActiveRecord
         #   named <tt>#{table_name}_count</tt> (such as +comments_count+ for a belonging Comment class)
         #   is used on the associate class (such as a Post class) - that is the migration for
         #   <tt>#{table_name}_count</tt> is created on the associate class (such that <tt>Post.comments_count</tt> will
-        #   return the count cached, see note below). You can also specify a custom counter
+        #   return the count cached). You can also specify a custom counter
         #   cache column by providing a column name instead of a +true+/+false+ value to this
         #   option (e.g., <tt>counter_cache: :my_custom_counter</tt>.)
-        #   Note: Specifying a counter cache will add it to that model's list of readonly attributes
-        #   using +attr_readonly+.
-        # [+:polymorphic+]
-        #   Specify this association is a polymorphic association by passing +true+.
+        #
+        #   Starting to use counter caches on existing large tables can be troublesome, because the column
+        #   values must be backfilled separately of the column addition (to not lock the table for too long)
+        #   and before the use of +:counter_cache+ (otherwise methods like +size+/+any?+/etc, which use
+        #   counter caches internally, can produce incorrect results). To safely backfill the values while keeping
+        #   counter cache columns updated with the child records creation/removal and to avoid the mentioned methods
+        #   use the possibly incorrect counter cache column values and always get the results from the database,
+        #   use <tt>counter_cache: { active: false }</tt>.
+        #   If you also need to specify a custom column name, use <tt>counter_cache: { active: false, column: :my_custom_counter }</tt>.
+        #
         #   Note: If you've enabled the counter cache, then you may want to add the counter cache attribute
         #   to the +attr_readonly+ list in the associated classes (e.g. <tt>class Post; attr_readonly :comments_count; end</tt>).
+        # [+:polymorphic+]
+        #   Specify this association is a polymorphic association by passing +true+.
+        #   Note: Since polymorphic associations rely on storing class names in the database, make sure to update the class names in the
+        #   <tt>*_type</tt> polymorphic type column of the corresponding rows.
         # [+:validate+]
         #   When set to +true+, validates new objects added to association when saving the parent object. +false+ by default.
         #   If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
@@ -1882,7 +1643,7 @@ module ActiveRecord
         #   belongs_to :user, optional: true
         #   belongs_to :account, default: -> { company.account }
         #   belongs_to :account, strict_loading: true
-        #   belong_to  :note, query_constraints: [:organization_id, :note_id]
+        #   belongs_to :note, query_constraints: [:organization_id, :note_id]
         def belongs_to(name, scope = nil, **options)
           reflection = Builder::BelongsTo.build(self, name, scope, options)
           Reflection.add_reflection self, name, reflection
@@ -1905,7 +1666,7 @@ module ActiveRecord
         # The join table should not have a primary key or a model associated with it. You must manually generate the
         # join table with a migration such as this:
         #
-        #   class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[7.1]
+        #   class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[7.2]
         #     def change
         #       create_join_table :developers, :projects
         #     end
@@ -2099,7 +1860,7 @@ module ActiveRecord
           end
 
           has_many name, scope, **hm_options, &extension
-          _reflections[name.to_s].parent_reflection = habtm_reflection
+          _reflections[name].parent_reflection = habtm_reflection
         end
       end
   end

data/lib/active_record/attribute_assignment.rb

@@ -2,33 +2,23 @@
 
 module ActiveRecord
   module AttributeAssignment
-    include ActiveModel::AttributeAssignment
-
     private
       def _assign_attributes(attributes)
-        multi_parameter_attributes = nested_parameter_attributes = nil
+        multi_parameter_attributes = nil
 
         attributes.each do |k, v|
           key = k.to_s
 
           if key.include?("(")
             (multi_parameter_attributes ||= {})[key] = v
-          elsif v.is_a?(Hash)
-            (nested_parameter_attributes ||= {})[key] = v
           else
             _assign_attribute(key, v)
           end
         end
 
-        assign_nested_parameter_attributes(nested_parameter_attributes) if nested_parameter_attributes
         assign_multiparameter_attributes(multi_parameter_attributes) if multi_parameter_attributes
       end
 
-      # Assign any deferred nested attributes after the base attributes have been set.
-      def assign_nested_parameter_attributes(pairs)
-        pairs.each { |k, v| _assign_attribute(k, v) }
-      end
-
       # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
       # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
       # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate

data/lib/active_record/attribute_methods/composite_primary_key.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module AttributeMethods
+    module CompositePrimaryKey # :nodoc:
+      # Returns the primary key column's value. If the primary key is composite,
+      # returns an array of the primary key column values.
+      def id
+        if self.class.composite_primary_key?
+          @primary_key.map { |pk| _read_attribute(pk) }
+        else
+          super
+        end
+      end
+
+      def primary_key_values_present? # :nodoc:
+        if self.class.composite_primary_key?
+          id.all?
+        else
+          super
+        end
+      end
+
+      # Sets the primary key column's value. If the primary key is composite,
+      # raises TypeError when the set value not enumerable.
+      def id=(value)
+        if self.class.composite_primary_key?
+          raise TypeError, "Expected value matching #{self.class.primary_key.inspect}, got #{value.inspect}." unless value.is_a?(Enumerable)
+          @primary_key.zip(value) { |attr, value| _write_attribute(attr, value) }
+        else
+          super
+        end
+      end
+
+      # Queries the primary key column's value. If the primary key is composite,
+      # all primary key column values must be queryable.
+      def id?
+        if self.class.composite_primary_key?
+          @primary_key.all? { |col| _query_attribute(col) }
+        else
+          super
+        end
+      end
+
+      # Returns the primary key column's value before type cast. If the primary key is composite,
+      # returns an array of primary key column values before type cast.
+      def id_before_type_cast
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_before_type_cast(col) }
+        else
+          super
+        end
+      end
+
+      # Returns the primary key column's previous value. If the primary key is composite,
+      # returns an array of primary key column previous values.
+      def id_was
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_was(col) }
+        else
+          super
+        end
+      end
+
+      # Returns the primary key column's value from the database. If the primary key is composite,
+      # returns an array of primary key column values from database.
+      def id_in_database
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_in_database(col) }
+        else
+          super
+        end
+      end
+
+      def id_for_database # :nodoc:
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| @attributes[col].value_for_database }
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/dirty.rb

@@ -31,7 +31,7 @@ module ActiveRecord
     #   person.name_in_database        # => "Alice"
     #   person.saved_change_to_name?   # => true
     #   person.saved_change_to_name    # => ["Allison", "Alice"]
-    #   person.name_before_last_change # => "Allison"
+    #   person.name_before_last_save   # => "Allison"
     #
     # Similar to ActiveModel::Dirty, methods can be invoked as
     # +saved_change_to_name?+ or by passing an argument to the generic method
@@ -251,7 +251,7 @@ module ActiveRecord
             changed_attribute_names_to_save
           else
             attribute_names.reject do |attr_name|
-              if column_for_attribute(attr_name).default_function
+              if column_for_attribute(attr_name).auto_populated?
                 !attribute_changed?(attr_name)
               end
             end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -18,74 +18,45 @@ module ActiveRecord
       # Returns the primary key column's value. If the primary key is composite,
       # returns an array of the primary key column values.
       def id
-        return _read_attribute(@primary_key) unless @primary_key.is_a?(Array)
-
-        @primary_key.map { |pk| _read_attribute(pk) }
+        _read_attribute(@primary_key)
       end
 
       def primary_key_values_present? # :nodoc:
-        return id.all? if self.class.composite_primary_key?
-
         !!id
       end
 
       # Sets the primary key column's value. If the primary key is composite,
       # raises TypeError when the set value not enumerable.
       def id=(value)
-        if self.class.composite_primary_key?
-          raise TypeError, "Expected value matching #{self.class.primary_key.inspect}, got #{value.inspect}." unless value.is_a?(Enumerable)
-          @primary_key.zip(value) { |attr, value| _write_attribute(attr, value) }
-        else
-          _write_attribute(@primary_key, value)
-        end
+        _write_attribute(@primary_key, value)
       end
 
       # Queries the primary key column's value. If the primary key is composite,
       # all primary key column values must be queryable.
       def id?
-        if self.class.composite_primary_key?
-          @primary_key.all? { |col| _query_attribute(col) }
-        else
-          _query_attribute(@primary_key)
-        end
+        _query_attribute(@primary_key)
       end
 
       # Returns the primary key column's value before type cast. If the primary key is composite,
       # returns an array of primary key column values before type cast.
       def id_before_type_cast
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| attribute_before_type_cast(col) }
-        else
-          attribute_before_type_cast(@primary_key)
-        end
+        attribute_before_type_cast(@primary_key)
       end
 
       # Returns the primary key column's previous value. If the primary key is composite,
       # returns an array of primary key column previous values.
       def id_was
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| attribute_was(col) }
-        else
-          attribute_was(@primary_key)
-        end
+        attribute_was(@primary_key)
       end
 
       # Returns the primary key column's value from the database. If the primary key is composite,
       # returns an array of primary key column values from database.
       def id_in_database
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| attribute_in_database(col) }
-        else
-          attribute_in_database(@primary_key)
-        end
+        attribute_in_database(@primary_key)
       end
 
       def id_for_database # :nodoc:
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| @attributes[col].value_for_database }
-        else
-          @attributes[@primary_key].value_for_database
-        end
+        @attributes[@primary_key].value_for_database
       end
 
       private
@@ -109,20 +80,19 @@ module ActiveRecord
           # Overwriting will negate any effect of the +primary_key_prefix_type+
           # setting, though.
           def primary_key
-            if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
-              @primary_key = reset_primary_key
-            end
+            reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
             @primary_key
           end
 
           def composite_primary_key? # :nodoc:
-            primary_key.is_a?(Array)
+            reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
+            @composite_primary_key
           end
 
           # Returns a quoted version of the primary key name, used to construct
           # SQL statements.
           def quoted_primary_key
-            @quoted_primary_key ||= connection.quote_column_name(primary_key)
+            @quoted_primary_key ||= adapter_class.quote_column_name(primary_key)
           end
 
           def reset_primary_key # :nodoc:
@@ -138,12 +108,10 @@ module ActiveRecord
               base_name.foreign_key(false)
             elsif base_name && primary_key_prefix_type == :table_name_with_underscore
               base_name.foreign_key
+            elsif ActiveRecord::Base != self && table_exists?
+              schema_cache.primary_keys(table_name)
             else
-              if ActiveRecord::Base != self && table_exists?
-                connection.schema_cache.primary_keys(table_name)
-              else
-                "id"
-              end
+              "id"
             end
           end
 
@@ -163,25 +131,25 @@ module ActiveRecord
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key        = derive_primary_key(value)
+            @primary_key = if value.is_a?(Array)
+              @composite_primary_key = true
+              include CompositePrimaryKey
+              @primary_key = value.map { |v| -v.to_s }.freeze
+            elsif value
+              -value.to_s
+            end
             @quoted_primary_key = nil
             @attributes_builder = nil
           end
 
           private
-            def derive_primary_key(value)
-              return unless value
-
-              return -value.to_s unless value.is_a?(Array)
-
-              value.map { |v| -v.to_s }.freeze
-            end
-
             def inherited(base)
               super
               base.class_eval do
                 @primary_key = PRIMARY_KEY_NOT_SET
+                @composite_primary_key = false
                 @quoted_primary_key = nil
+                @attributes_builder = nil
               end
             end
         end