activerecord 7.2.3 → 8.0.4

data/README.rdoc

@@ -139,7 +139,7 @@ A short rundown of some of the major features:
 
 * Database agnostic schema management with Migrations.
 
-    class AddSystemSettings < ActiveRecord::Migration[7.2]
+    class AddSystemSettings < ActiveRecord::Migration[8.0]
       def up
         create_table :system_settings do |t|
           t.string  :name

data/lib/active_record/association_relation.rb

@@ -43,6 +43,7 @@ module ActiveRecord
       def exec_queries
         super do |record|
           @association.set_inverse_instance_from_queries(record)
+          @association.set_strict_loading(record)
           yield record if block_given?
         end
       end

data/lib/active_record/associations/association.rb

@@ -34,7 +34,7 @@ module ActiveRecord
     # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
     class Association # :nodoc:
       attr_accessor :owner
-      attr_reader :target, :reflection, :disable_joins
+      attr_reader :reflection, :disable_joins
 
       delegate :options, to: :reflection
 
@@ -50,6 +50,13 @@ module ActiveRecord
         @skip_strict_loading = nil
       end
 
+      def target
+        if @target.is_a?(Promise)
+          @target = @target.value
+        end
+        @target
+      end
+
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
@@ -113,6 +120,14 @@ module ActiveRecord
         @association_scope = nil
       end
 
+      def set_strict_loading(record)
+        if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
+          record.strict_loading!
+        else
+          record.strict_loading!(false, mode: owner.strict_loading_mode)
+        end
+      end
+
       # Set the inverse association, if possible
       def set_inverse_instance(record)
         if inverse = inverse_association_for(record)
@@ -172,7 +187,7 @@ module ActiveRecord
       # ActiveRecord::RecordNotFound is rescued within the method, and it is
       # not reraised. The proxy is \reset and +nil+ is the return value.
       def load_target
-        @target = find_target if (@stale_state && stale_target?) || find_target?
+        @target = find_target(async: false) if (@stale_state && stale_target?) || find_target?
 
         loaded! unless loaded?
         target
@@ -180,6 +195,13 @@ module ActiveRecord
         reset
       end
 
+      def async_load_target # :nodoc:
+        @target = find_target(async: true) if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        nil
+      end
+
       # We can't dump @reflection and @through_reflection since it contains the scope proc
       def marshal_dump
         ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
@@ -223,13 +245,19 @@ module ActiveRecord
           klass
         end
 
-        def find_target
+        def find_target(async: false)
           if violates_strict_loading?
             Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
           scope = self.scope
-          return scope.to_a if skip_statement_cache?(scope)
+          if skip_statement_cache?(scope)
+            if async
+              return scope.load_async.then(&:to_a)
+            else
+              return scope.to_a
+            end
+          end
 
           sc = reflection.association_scope_cache(klass, owner) do |params|
             as = AssociationScope.create { params.bind }
@@ -238,13 +266,9 @@ module ActiveRecord
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
           klass.with_connection do |c|
-            sc.execute(binds, c) do |record|
+            sc.execute(binds, c, async: async) do |record|
               set_inverse_instance(record)
-              if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
-                record.strict_loading!
-              else
-                record.strict_loading!(false, mode: owner.strict_loading_mode)
-              end
+              set_strict_loading(record)
             end
           end
         end

data/lib/active_record/associations/builder/association.rb

@@ -30,10 +30,10 @@ module ActiveRecord::Associations::Builder # :nodoc:
       end
 
       reflection = create_reflection(model, name, scope, options, &block)
-      define_accessors model, reflection
-      define_callbacks model, reflection
-      define_validations model, reflection
-      define_change_tracking_methods model, reflection
+      define_accessors(model, reflection)
+      define_callbacks(model, reflection)
+      define_validations(model, reflection)
+      define_change_tracking_methods(model, reflection)
       reflection
     end
 
@@ -71,6 +71,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.define_extensions(model, name)
+      # noop
     end
 
     def self.define_callbacks(model, reflection)
@@ -81,7 +82,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       end
 
       Association.extensions.each do |extension|
-        extension.build model, reflection
+        extension.build(model, reflection)
       end
     end
 
@@ -131,7 +132,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
         err_message = "A valid destroy_association_async_job is required to use `dependent: :destroy_async` on associations"
         raise ActiveRecord::ConfigurationError, err_message
       end
-      unless valid_dependent_options.include? dependent
+      unless valid_dependent_options.include?(dependent)
         raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
     end

data/lib/active_record/associations/collection_association.rb

@@ -94,7 +94,7 @@ module ActiveRecord
       def find(*args)
         if options[:inverse_of] && loaded?
           args_flatten = args.flatten
-          model = scope.klass
+          model = scope.model
 
           if args_flatten.blank?
             error_message = "Couldn't find #{model.name} without an ID"

data/lib/active_record/associations/disable_joins_association_scope.rb

@@ -47,7 +47,7 @@ module ActiveRecord
           end
 
           if scope.order_values.empty? && ordered
-            split_scope = DisableJoinsAssociationRelation.create(scope.klass, key, join_ids)
+            split_scope = DisableJoinsAssociationRelation.create(scope.model, key, join_ids)
             split_scope.where_clause += scope.where_clause
             split_scope
           else

data/lib/active_record/associations/has_many_through_association.rb

@@ -146,7 +146,7 @@ module ActiveRecord
 
           case method
           when :destroy
-            if scope.klass.primary_key
+            if scope.model.primary_key
               count = scope.destroy_all.count(&:destroyed?)
             else
               scope.each(&:_run_destroy_callbacks)
@@ -222,7 +222,8 @@ module ActiveRecord
           end
         end
 
-        def find_target
+        def find_target(async: false)
+          raise NotImplementedError, "No async loading for HasManyThroughAssociation yet" if async
           return [] unless target_reflection_has_associated_record?
           return scope.to_a if disable_joins
           super

data/lib/active_record/associations/preloader/association.rb

@@ -17,12 +17,12 @@ module ActiveRecord
           def eql?(other)
             association_key_name == other.association_key_name &&
               scope.table_name == other.scope.table_name &&
-              scope.connection_specification_name == other.scope.connection_specification_name &&
+              scope.model.connection_specification_name == other.scope.model.connection_specification_name &&
               scope.values_for_queries == other.scope.values_for_queries
           end
 
           def hash
-            [association_key_name, scope.table_name, scope.connection_specification_name, scope.values_for_queries].hash
+            [association_key_name, scope.model.table_name, scope.model.connection_specification_name, scope.values_for_queries].hash
           end
 
           def records_for(loaders)

data/lib/active_record/associations/singular_association.rb

@@ -18,6 +18,7 @@ module ActiveRecord
       def reset
         super
         @target = nil
+        @future_target = nil
       end
 
       # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
@@ -43,11 +44,15 @@ module ActiveRecord
           super.except!(*Array(klass.primary_key))
         end
 
-        def find_target
+        def find_target(async: false)
           if disable_joins
-            scope.first
+            if async
+              scope.load_async.then(&:first)
+            else
+              scope.first
+            end
           else
-            super.first
+            super.then(&:first)
           end
         end
 

data/lib/active_record/associations.rb

@@ -379,21 +379,43 @@ module ActiveRecord
       #              after_add: :congratulate_client,
       #              after_remove: :log_after_remove
       #
-      #     def congratulate_client(record)
+      #     def congratulate_client(client)
       #       # ...
       #     end
       #
-      #     def log_after_remove(record)
+      #     def log_after_remove(client)
       #       # ...
       #     end
       #   end
       #
+      # Callbacks can be defined in three ways:
+      #
+      # 1. A symbol that references a method defined on the class with the
+      #    associated collection. For example, <tt>after_add: :congratulate_client</tt>
+      #    invokes <tt>Firm#congratulate_client(client)</tt>.
+      # 2. A callable with a signature that accepts both the record with the
+      #    associated collection and the record being added or removed. For
+      #    example, <tt>after_add: ->(firm, client) { ... }</tt>.
+      # 3. An object that responds to the callback name. For example, passing
+      #    <tt>after_add: CallbackObject.new</tt> invokes <tt>CallbackObject#after_add(firm,
+      #    client)</tt>.
+      #
       # It's possible to stack callbacks by passing them as an array. Example:
       #
+      #   class CallbackObject
+      #     def after_add(firm, client)
+      #       firm.log << "after_adding #{client.id}"
+      #     end
+      #   end
+      #
       #   class Firm < ActiveRecord::Base
       #     has_many :clients,
       #              dependent: :destroy,
-      #              after_add: [:congratulate_client, -> (firm, record) { firm.log << "after_adding#{record.id}" }],
+      #              after_add: [
+      #                :congratulate_client,
+      #                -> (firm, client) { firm.log << "after_adding #{client.id}" },
+      #                CallbackObject.new
+      #              ],
       #              after_remove: :log_after_remove
       #   end
       #
@@ -1255,6 +1277,14 @@ module ActiveRecord
         #   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.
+        # [:before_add]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>before an object is added</b> to the association collection.
+        # [:after_add]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>after an object is added</b> to the association collection.
+        # [:before_remove]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>before an object is removed</b> from the association collection.
+        # [:after_remove]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>after an object is removed</b> from the association collection.
         #
         # Option examples:
         #   has_many :comments, -> { order("posted_on") }
@@ -1678,7 +1708,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.2]
+        #   class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[8.0]
         #     def change
         #       create_join_table :developers, :projects
         #     end

data/lib/active_record/asynchronous_queries_tracker.rb

@@ -1,29 +1,30 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/atomic/read_write_lock"
+
 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
+        @active = Concurrent::AtomicBoolean.new(true)
+        @lock = Concurrent::ReadWriteLock.new
       end
 
       def active?
-        @active
+        @active.true?
       end
 
-      def finalize
-        @active = false
+      def synchronize(&block)
+        @lock.with_read_lock(&block)
+      end
+
+      def finalize(wait = false)
+        @active.make_false
+        if wait
+          # Wait until all thread with a read lock are done
+          @lock.with_write_lock { }
+        end
       end
     end
 
@@ -33,7 +34,7 @@ module ActiveRecord
       end
 
       def run
-        ActiveRecord::Base.asynchronous_queries_tracker.start_session
+        ActiveRecord::Base.asynchronous_queries_tracker.tap(&:start_session)
       end
 
       def complete(asynchronous_queries_tracker)
@@ -41,20 +42,23 @@ module ActiveRecord
       end
     end
 
-    attr_reader :current_session
-
     def initialize
-      @current_session = NullSession
+      @stack = []
+    end
+
+    def current_session
+      @stack.last or raise ActiveRecordError, "Can't perform asynchronous queries without a query session"
     end
 
     def start_session
-      @current_session = Session.new
-      self
+      session = Session.new
+      @stack << session
     end
 
-    def finalize_session
-      @current_session.finalize
-      @current_session = NullSession
+    def finalize_session(wait = false)
+      session = @stack.pop
+      session&.finalize(wait)
+      self
     end
   end
 end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module ActiveRecord
   module AttributeMethods
     # = Active Record Attribute Methods Primary Key
@@ -89,10 +87,9 @@ module ActiveRecord
             @composite_primary_key
           end
 
-          # Returns a quoted version of the primary key name, used to construct
-          # SQL statements.
+          # Returns a quoted version of the primary key name.
           def quoted_primary_key
-            @quoted_primary_key ||= adapter_class.quote_column_name(primary_key)
+            adapter_class.quote_column_name(primary_key)
           end
 
           def reset_primary_key # :nodoc:
@@ -132,13 +129,13 @@ module ActiveRecord
           #   Project.primary_key # => "foo_id"
           def 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
+
+            @composite_primary_key = value.is_a?(Array)
             @attributes_builder = nil
           end
 
@@ -148,7 +145,6 @@ module ActiveRecord
               base.class_eval do
                 @primary_key = PRIMARY_KEY_NOT_SET
                 @composite_primary_key = false
-                @quoted_primary_key = nil
                 @attributes_builder = nil
               end
             end

data/lib/active_record/attribute_methods/query.rb

@@ -3,6 +3,38 @@
 module ActiveRecord
   module AttributeMethods
     # = Active Record Attribute Methods \Query
+    #
+    # Adds query methods for attributes that return either +true+ or +false+
+    # depending on the attribute type and value.
+    #
+    # For Boolean attributes this will return +true+ if the value is present
+    # and return +false+ otherwise:
+    #
+    #   class Product < ActiveRecord::Base
+    #   end
+    #
+    #   product = Product.new(archived: false)
+    #   product.archived? # => false
+    #   product.archived = true
+    #   product.archived? # => true
+    #
+    # For Numeric attributes this will return +true+ if the value is a non-zero
+    # number and return +false+ otherwise:
+    #
+    #   product.inventory_count = 0
+    #   product.inventory_count? # => false
+    #   product.inventory_count = 1
+    #   product.inventory_count? # => true
+    #
+    # For other attributes it will return +true+ if the value is present
+    # and return +false+ otherwise:
+    #
+    #   product.name = nil
+    #   product.name? # => false
+    #   product.name = " "
+    #   product.name? # => false
+    #   product.name = "Orange"
+    #   product.name? # => true
     module Query
       extend ActiveSupport::Concern
 
@@ -10,6 +42,8 @@ module ActiveRecord
         attribute_method_suffix "?", parameters: false
       end
 
+      # Returns +true+ or +false+ for the attribute identified by +attr_name+,
+      # depending on the attribute type and value.
       def query_attribute(attr_name)
         value = self.public_send(attr_name)
 

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -28,7 +28,7 @@ module ActiveRecord
           elsif value.respond_to?(:infinite?) && value.infinite?
             value
           else
-            map_avoiding_infinite_recursion(super) { |v| cast(v) }
+            map(super) { |v| cast(v) }
           end
         end
 
@@ -45,23 +45,13 @@ module ActiveRecord
             elsif value.respond_to?(:infinite?) && value.infinite?
               value
             else
-              map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+              map(value) { |v| convert_time_to_time_zone(v) }
             end
           end
 
           def set_time_zone_without_conversion(value)
             ::Time.zone.local_to_utc(value).try(:in_time_zone) if value
           end
-
-          def map_avoiding_infinite_recursion(value)
-            map(value) do |v|
-              if value.equal?(v)
-                nil
-              else
-                yield(v)
-              end
-            end
-          end
       end
 
       extend ActiveSupport::Concern

data/lib/active_record/autosave_association.rb

@@ -221,8 +221,10 @@ module ActiveRecord
           if reflection.validate? && !method_defined?(validation_method)
             if reflection.collection?
               method = :validate_collection_association
+            elsif reflection.has_one?
+              method = :validate_has_one_association
             else
-              method = :validate_single_association
+              method = :validate_belongs_to_association
             end
 
             define_non_cyclic_method(validation_method) { send(method, reflection) }
@@ -274,6 +276,16 @@ module ActiveRecord
       new_record? || has_changes_to_save? || marked_for_destruction? || nested_records_changed_for_autosave?
     end
 
+    def validating_belongs_to_for?(association)
+      @validating_belongs_to_for ||= {}
+      @validating_belongs_to_for[association]
+    end
+
+    def autosaving_belongs_to_for?(association)
+      @autosaving_belongs_to_for ||= {}
+      @autosaving_belongs_to_for[association]
+    end
+
     private
       def init_internals
         super
@@ -313,11 +325,33 @@ module ActiveRecord
       end
 
       # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
-      # turned on for the association.
-      def validate_single_association(reflection)
+      # turned on for the has_one association.
+      def validate_has_one_association(reflection)
+        association = association_instance_get(reflection.name)
+        record      = association && association.reader
+        return unless record && (record.changed_for_autosave? || custom_validation_context?)
+
+        inverse_association = reflection.inverse_of && record.association(reflection.inverse_of.name)
+        return if inverse_association && (record.validating_belongs_to_for?(inverse_association) ||
+          record.autosaving_belongs_to_for?(inverse_association))
+
+        association_valid?(association, record)
+      end
+
+      # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
+      # turned on for the belongs_to association.
+      def validate_belongs_to_association(reflection)
         association = association_instance_get(reflection.name)
         record      = association && association.reader
-        association_valid?(association, record) if record && (record.changed_for_autosave? || custom_validation_context?)
+        return unless record && (record.changed_for_autosave? || custom_validation_context?)
+
+        begin
+          @validating_belongs_to_for ||= {}
+          @validating_belongs_to_for[association] = true
+          association_valid?(association, record)
+        ensure
+          @validating_belongs_to_for[association] = false
+        end
       end
 
       # Validate the associated records if <tt>:validate</tt> or
@@ -441,33 +475,34 @@ module ActiveRecord
         return unless association && association.loaded?
 
         record = association.load_target
+        return unless record && !record.destroyed?
 
-        if record && !record.destroyed?
-          autosave = reflection.options[:autosave]
-
-          if autosave && record.marked_for_destruction?
-            record.destroy
-          elsif autosave != false
-            primary_key = Array(compute_primary_key(reflection, self)).map(&:to_s)
-            primary_key_value = primary_key.map { |key| _read_attribute(key) }
+        autosave = reflection.options[:autosave]
 
-            if (autosave && record.changed_for_autosave?) || _record_changed?(reflection, record, primary_key_value)
-              unless reflection.through_reflection
-                foreign_key = Array(reflection.foreign_key)
-                primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          primary_key = Array(compute_primary_key(reflection, self)).map(&:to_s)
+          primary_key_value = primary_key.map { |key| _read_attribute(key) }
+          return unless (autosave && record.changed_for_autosave?) || _record_changed?(reflection, record, primary_key_value)
 
-                primary_key_foreign_key_pairs.each do |primary_key, foreign_key|
-                  association_id = _read_attribute(primary_key)
-                  record[foreign_key] = association_id unless record[foreign_key] == association_id
-                end
-                association.set_inverse_instance(record)
-              end
+          unless reflection.through_reflection
+            foreign_key = Array(reflection.foreign_key)
+            primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
 
-              saved = record.save(validate: !autosave)
-              raise ActiveRecord::Rollback if !saved && autosave
-              saved
+            primary_key_foreign_key_pairs.each do |primary_key, foreign_key|
+              association_id = _read_attribute(primary_key)
+              record[foreign_key] = association_id unless record[foreign_key] == association_id
             end
+            association.set_inverse_instance(record)
           end
+
+          inverse_association = reflection.inverse_of && record.association(reflection.inverse_of.name)
+          return if inverse_association && record.autosaving_belongs_to_for?(inverse_association)
+
+          saved = record.save(validate: !autosave)
+          raise ActiveRecord::Rollback if !saved && autosave
+          saved
         end
       end
 
@@ -492,7 +527,6 @@ module ActiveRecord
         return false unless reflection.inverse_of&.polymorphic?
 
         class_name = record._read_attribute(reflection.inverse_of.foreign_type)
-
         reflection.active_record.polymorphic_name != class_name
       end
 
@@ -512,7 +546,15 @@ module ActiveRecord
             foreign_key.each { |key| self[key] = nil }
             record.destroy
           elsif autosave != false
-            saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+            saved = if record.new_record? || (autosave && record.changed_for_autosave?)
+              begin
+                @autosaving_belongs_to_for ||= {}
+                @autosaving_belongs_to_for[association] = true
+                record.save(validate: !autosave)
+              ensure
+                @autosaving_belongs_to_for[association] = false
+              end
+            end
 
             if association.updated?
               primary_key = Array(compute_primary_key(reflection, record)).map(&:to_s)