activerecord 6.1.7 → 7.2.0

data/lib/active_record/asynchronous_queries_tracker.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class AsynchronousQueriesTracker # :nodoc:
+    module NullSession # :nodoc:
+      class << self
+        def active?
+          true
+        end
+
+        def finalize
+        end
+      end
+    end
+
+    class Session # :nodoc:
+      def initialize
+        @active = true
+      end
+
+      def active?
+        @active
+      end
+
+      def finalize
+        @active = false
+      end
+    end
+
+    class << self
+      def install_executor_hooks(executor = ActiveSupport::Executor)
+        executor.register_hook(self)
+      end
+
+      def run
+        ActiveRecord::Base.asynchronous_queries_tracker.start_session
+      end
+
+      def complete(asynchronous_queries_tracker)
+        asynchronous_queries_tracker.finalize_session
+      end
+    end
+
+    attr_reader :current_session
+
+    def initialize
+      @current_session = NullSession
+    end
+
+    def start_session
+      @current_session = Session.new
+      self
+    end
+
+    def finalize_session
+      @current_session.finalize
+      @current_session = NullSession
+    end
+  end
+end

data/lib/active_record/attribute_assignment.rb

@@ -1,36 +1,24 @@
 # frozen_string_literal: true
 
-require "active_model/forbidden_attributes_protection"
-
 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
@@ -46,7 +34,7 @@ module ActiveRecord
       def execute_callstack_for_multiparameter_attributes(callstack)
         errors = []
         callstack.each do |name, values_with_empty_parameters|
-          if values_with_empty_parameters.each_value.all?(&:nil?)
+          if values_with_empty_parameters.each_value.all?(NilClass)
             values = nil
           else
             values = values_with_empty_parameters

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -29,8 +29,8 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix "_before_type_cast", "_for_database"
-        attribute_method_suffix "_came_from_user?"
+        attribute_method_suffix "_before_type_cast", "_for_database", parameters: false
+        attribute_method_suffix "_came_from_user?", parameters: false
       end
 
       # Returns the value of the attribute identified by +attr_name+ before
@@ -52,6 +52,23 @@ module ActiveRecord
         attribute_before_type_cast(name)
       end
 
+      # Returns the value of the attribute identified by +attr_name+ after
+      # serialization.
+      #
+      #   class Book < ActiveRecord::Base
+      #     enum :status, { draft: 1, published: 2 }
+      #   end
+      #
+      #   book = Book.new(status: "published")
+      #   book.read_attribute(:status)              # => "published"
+      #   book.read_attribute_for_database(:status) # => 2
+      def read_attribute_for_database(attr_name)
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
+        attribute_for_database(name)
+      end
+
       # Returns a hash of attributes before typecasting and deserialization.
       #
       #   class Task < ActiveRecord::Base
@@ -66,6 +83,11 @@ module ActiveRecord
         @attributes.values_before_type_cast
       end
 
+      # Returns a hash of attributes for assignment to the database.
+      def attributes_for_database
+        @attributes.values_for_database
+      end
+
       private
         # Dispatch target for <tt>*_before_type_cast</tt> attribute methods.
         def attribute_before_type_cast(attr_name)

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

@@ -4,6 +4,38 @@ require "active_support/core_ext/module/attribute_accessors"
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Dirty
+    #
+    # Provides a way to track changes in your Active Record models. It adds all
+    # methods from ActiveModel::Dirty and adds database-specific methods.
+    #
+    # A newly created +Person+ object is unchanged:
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.create(name: "Allison")
+    #   person.changed? # => false
+    #
+    # Change the name:
+    #
+    #   person.name = 'Alice'
+    #   person.name_in_database          # => "Allison"
+    #   person.will_save_change_to_name? # => true
+    #   person.name_change_to_be_saved   # => ["Allison", "Alice"]
+    #   person.changes_to_save           # => {"name"=>["Allison", "Alice"]}
+    #
+    # Save the changes:
+    #
+    #   person.save
+    #   person.name_in_database        # => "Alice"
+    #   person.saved_change_to_name?   # => true
+    #   person.saved_change_to_name    # => ["Allison", "Alice"]
+    #   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
+    # <tt>saved_change_to_attribute?("name")</tt>.
     module Dirty
       extend ActiveSupport::Concern
 
@@ -14,16 +46,17 @@ module ActiveRecord
           raise "You cannot include Dirty after Timestamp"
         end
 
-        class_attribute :partial_writes, instance_writer: false, default: true
+        class_attribute :partial_updates, instance_writer: false, default: true
+        class_attribute :partial_inserts, instance_writer: false, default: true
 
         # Attribute methods for "changed in last call to save?"
-        attribute_method_affix(prefix: "saved_change_to_", suffix: "?")
-        attribute_method_prefix("saved_change_to_")
-        attribute_method_suffix("_before_last_save")
+        attribute_method_affix(prefix: "saved_change_to_", suffix: "?", parameters: "**options")
+        attribute_method_prefix("saved_change_to_", parameters: false)
+        attribute_method_suffix("_before_last_save", parameters: false)
 
         # Attribute methods for "will change if I call save?"
-        attribute_method_affix(prefix: "will_save_change_to_", suffix: "?")
-        attribute_method_suffix("_change_to_be_saved", "_in_database")
+        attribute_method_affix(prefix: "will_save_change_to_", suffix: "?", parameters: "**options")
+        attribute_method_suffix("_change_to_be_saved", "_in_database", parameters: false)
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
@@ -43,11 +76,13 @@ module ActiveRecord
       #
       # ==== Options
       #
-      # +from+ When passed, this method will return false unless the original
-      # value is equal to the given option
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
       #
-      # +to+ When passed, this method will return false unless the value was
-      # changed to the given value
+      # [+to+]
+      #   When specified, this method will return false unless the value will be
+      #   changed to the given value.
       def saved_change_to_attribute?(attr_name, **options)
         mutations_before_last_save.changed?(attr_name.to_s, **options)
       end
@@ -93,11 +128,13 @@ module ActiveRecord
       #
       # ==== Options
       #
-      # +from+ When passed, this method will return false unless the original
-      # value is equal to the given option
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
       #
-      # +to+ When passed, this method will return false unless the value will be
-      # changed to the given value
+      # [+to+]
+      #   When specified, this method will return false unless the value will be
+      #   changed to the given value.
       def will_save_change_to_attribute?(attr_name, **options)
         mutations_from_database.changed?(attr_name.to_s, **options)
       end
@@ -156,10 +193,12 @@ module ActiveRecord
       end
 
       private
-        def write_attribute_without_type_cast(attr_name, value)
-          result = super
-          clear_attribute_change(attr_name)
-          result
+        def init_internals
+          super
+          @mutations_before_last_save = nil
+          @mutations_from_database = nil
+          @_touch_attr_names = nil
+          @_skip_dirty_tracking = nil
         end
 
         def _touch_row(attribute_names, time)
@@ -191,20 +230,32 @@ module ActiveRecord
           @_touch_attr_names, @_skip_dirty_tracking = nil, nil
         end
 
-        def _update_record(attribute_names = attribute_names_for_partial_writes)
+        def _update_record(attribute_names = attribute_names_for_partial_updates)
           affected_rows = super
           changes_applied
           affected_rows
         end
 
-        def _create_record(attribute_names = attribute_names_for_partial_writes)
+        def _create_record(attribute_names = attribute_names_for_partial_inserts)
           id = super
           changes_applied
           id
         end
 
-        def attribute_names_for_partial_writes
-          partial_writes? ? changed_attribute_names_to_save : attribute_names
+        def attribute_names_for_partial_updates
+          partial_updates? ? changed_attribute_names_to_save : attribute_names
+        end
+
+        def attribute_names_for_partial_inserts
+          if partial_inserts?
+            changed_attribute_names_to_save
+          else
+            attribute_names.reject do |attr_name|
+              if column_for_attribute(attr_name).auto_populated?
+                !attribute_changed?(attr_name)
+              end
+            end
+          end
         end
     end
   end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -4,6 +4,7 @@ require "set"
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods Primary Key
     module PrimaryKey
       extend ActiveSupport::Concern
 
@@ -11,35 +12,45 @@ module ActiveRecord
       # available.
       def to_key
         key = id
-        [key] if key
+        Array(key) if key
       end
 
-      # Returns the primary key column's value.
+      # Returns the primary key column's value. If the primary key is composite,
+      # returns an array of the primary key column values.
       def id
         _read_attribute(@primary_key)
       end
 
-      # Sets the primary key column's value.
+      def primary_key_values_present? # :nodoc:
+        !!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)
         _write_attribute(@primary_key, value)
       end
 
-      # Queries the primary key column's value.
+      # Queries the primary key column's value. If the primary key is composite,
+      # all primary key column values must be queryable.
       def id?
-        query_attribute(@primary_key)
+        _query_attribute(@primary_key)
       end
 
-      # Returns the primary key column's value before type cast.
+      # 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
         attribute_before_type_cast(@primary_key)
       end
 
-      # Returns the primary key column's previous value.
+      # 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
         attribute_was(@primary_key)
       end
 
-      # Returns the primary key column's value from the database.
+      # 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
         attribute_in_database(@primary_key)
       end
@@ -55,6 +66,7 @@ module ActiveRecord
 
         module ClassMethods
           ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database id_for_database).to_set
+          PRIMARY_KEY_NOT_SET = BasicObject.new
 
           def instance_method_already_implemented?(method_name)
             super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
@@ -68,17 +80,22 @@ module ActiveRecord
           # Overwriting will negate any effect of the +primary_key_prefix_type+
           # setting, though.
           def primary_key
-            @primary_key = reset_primary_key unless defined? @primary_key
+            reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
             @primary_key
           end
 
+          def composite_primary_key? # :nodoc:
+            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:
+          def reset_primary_key # :nodoc:
             if base_class?
               self.primary_key = get_primary_key(base_class.name)
             else
@@ -86,18 +103,15 @@ module ActiveRecord
             end
           end
 
-          def get_primary_key(base_name) #:nodoc:
+          def get_primary_key(base_name) # :nodoc:
             if base_name && primary_key_prefix_type == :table_name
               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?
-                pk = connection.schema_cache.primary_keys(table_name)
-                suppress_composite_primary_key(pk)
-              else
-                "id"
-              end
+              "id"
             end
           end
 
@@ -117,20 +131,26 @@ module ActiveRecord
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key        = value && -value.to_s
+            @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 suppress_composite_primary_key(pk)
-              return pk unless pk.is_a?(Array)
-
-              warn <<~WARNING
-                WARNING: Active Record does not support composite primary key.
-
-                #{table_name} has composite primary key. Composite primary key is ignored.
-              WARNING
+            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
     end

data/lib/active_record/attribute_methods/query.rb

@@ -2,37 +2,49 @@
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Query
     module Query
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix "?"
+        attribute_method_suffix "?", parameters: false
       end
 
       def query_attribute(attr_name)
-        value = self[attr_name]
-
-        case value
-        when true        then true
-        when false, nil  then false
-        else
-          if !type_for_attribute(attr_name) { false }
-            if Numeric === value || !value.match?(/[^0-9]/)
-              !value.to_i.zero?
+        value = self.public_send(attr_name)
+
+        query_cast_attribute(attr_name, value)
+      end
+
+      def _query_attribute(attr_name) # :nodoc:
+        value = self._read_attribute(attr_name.to_s)
+
+        query_cast_attribute(attr_name, value)
+      end
+
+      alias :attribute? :query_attribute
+      private :attribute?
+
+      private
+        def query_cast_attribute(attr_name, value)
+          case value
+          when true        then true
+          when false, nil  then false
+          else
+            if !type_for_attribute(attr_name) { false }
+              if Numeric === value || !value.match?(/[^0-9]/)
+                !value.to_i.zero?
+              else
+                return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+                !value.blank?
+              end
+            elsif value.respond_to?(:zero?)
+              !value.zero?
             else
-              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
               !value.blank?
             end
-          elsif value.respond_to?(:zero?)
-            !value.zero?
-          else
-            !value.blank?
           end
         end
-      end
-
-      alias :attribute? :query_attribute
-      private :attribute?
     end
   end
 end

data/lib/active_record/attribute_methods/read.rb

@@ -2,37 +2,40 @@
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Read
     module Read
       extend ActiveSupport::Concern
 
       module ClassMethods # :nodoc:
         private
-          def define_method_attribute(name, owner:)
+          def define_method_attribute(canonical_name, owner:, as: canonical_name)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              owner, name
+              owner, canonical_name
             ) do |temp_method_name, attr_name_expr|
-              owner <<
-                "def #{temp_method_name}" <<
-                "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
-                "end"
+              owner.define_cached_method(temp_method_name, as: as, namespace: :active_record) do |batch|
+                batch <<
+                  "def #{temp_method_name}" <<
+                  "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
+                  "end"
+              end
             end
           end
       end
 
-      # Returns the value of the attribute identified by <tt>attr_name</tt> after
-      # it has been typecast (for example, "2004-12-12" in a date column is cast
-      # to a date object, like Date.new(2004, 12, 12)).
+      # Returns the value of the attribute identified by +attr_name+ after it
+      # has been type cast. For example, a date attribute will cast "2004-12-12"
+      # to <tt>Date.new(2004, 12, 12)</tt>. (For information about specific type
+      # casting behavior, see the types under ActiveModel::Type.)
       def read_attribute(attr_name, &block)
         name = attr_name.to_s
         name = self.class.attribute_aliases[name] || name
 
-        name = @primary_key if name == "id" && @primary_key
         @attributes.fetch_value(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the read_attribute API
-      def _read_attribute(attr_name, &block) # :nodoc
+      def _read_attribute(attr_name, &block) # :nodoc:
         @attributes.fetch_value(attr_name, &block)
       end