activerecord 7.2.3 → 8.0.0.beta1

data/lib/active_record/attribute_methods.rb

@@ -84,7 +84,7 @@ module ActiveRecord
         attribute_method_patterns_cache.clear
       end
 
-      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
+      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
         old_name = old_name.to_s
 
         if !abstract_class? && !has_attribute?(old_name)
@@ -113,14 +113,13 @@ module ActiveRecord
           unless abstract_class?
             load_schema
             super(attribute_names)
-            alias_attribute :id_value, :id if _has_attribute?("id") && !_has_attribute?("id_value")
+            alias_attribute :id_value, :id if _has_attribute?("id")
           end
 
-          generate_alias_attributes
-
           @attribute_methods_generated = true
-        end
 
+          generate_alias_attributes
+        end
         true
       end
 
@@ -473,27 +472,23 @@ module ActiveRecord
       end
 
       def method_missing(name, ...)
-        # We can't know whether some method was defined or not because
-        # multiple thread might be concurrently be in this code path.
-        # So the first one would define the methods and the others would
-        # appear to already have them.
-        self.class.define_attribute_methods
-
-        # So in all cases we must behave as if the method was just defined.
-        method = begin
-          self.class.public_instance_method(name)
-        rescue NameError
-          nil
+        unless self.class.attribute_methods_generated?
+          if self.class.method_defined?(name)
+            # The method is explicitly defined in the model, but calls a generated
+            # method with super. So we must resume the call chain at the right step.
+            last_method = method(name)
+            last_method = last_method.super_method while last_method.super_method
+            self.class.define_attribute_methods
+            if last_method.super_method
+              return last_method.super_method.call(...)
+            end
+          elsif self.class.define_attribute_methods
+            # Some attribute methods weren't generated yet, we retry the call
+            return public_send(name, ...)
+          end
         end
 
-        # The method might be explicitly defined in the model, but call a generated
-        # method with super. So we must resume the call chain at the right step.
-        method = method.super_method while method && !method.owner.is_a?(GeneratedAttributeMethods)
-        if method
-          method.bind_call(self, ...)
-        else
-          super
-        end
+        super
       end
 
       def attribute_method?(attr_name)

data/lib/active_record/attributes.rb

@@ -21,34 +21,28 @@ module ActiveRecord
       # your domain objects across much of Active Record, without having to
       # rely on implementation details or monkey patching.
       #
-      # ==== Parameters
+      # +name+ The name of the methods to define attribute methods for, and the
+      # column which this will persist to.
       #
-      # [+name+]
-      #   The name of the methods to define attribute methods for, and the
-      #   column which this will persist to.
-      #
-      # [+cast_type+]
-      #   A symbol such as +:string+ or +:integer+, or a type object to be used
-      #   for this attribute. If this parameter is not passed, the previously
-      #   defined type (if any) will be used. Otherwise, the type will be
-      #   ActiveModel::Type::Value. See the examples below for more information
-      #   about providing custom type objects.
+      # +cast_type+ A symbol such as +:string+ or +:integer+, or a type object
+      # to be used for this attribute. If this parameter is not passed, the previously
+      # defined type (if any) will be used.
+      # Otherwise, the type will be ActiveModel::Type::Value.
+      # See the examples below for more information about providing custom type objects.
       #
       # ==== Options
       #
-      # [+:default+]
-      #   The default value to use when no value is provided. If this option is
-      #   not passed, the previously defined default value (if any) on the
-      #   superclass or in the schema will be used. Otherwise, the default will
-      #   be +nil+.
+      # The following options are accepted:
+      #
+      # +default+ The default value to use when no value is provided. If this option
+      # is not passed, the previously defined default value (if any) on the superclass or in the schema will be used.
+      # Otherwise, the default will be +nil+.
       #
-      # [+:array+]
-      #   (PostgreSQL only) Specifies that the type should be an array. See the
-      #   examples below.
+      # +array+ (PostgreSQL only) specifies that the type should be an array (see the
+      # examples below).
       #
-      # [+:range+]
-      #   (PostgreSQL only) Specifies that the type should be a range. See the
-      #   examples below.
+      # +range+ (PostgreSQL only) specifies that the type should be a range (see the
+      # examples below).
       #
       # When using a symbol for +cast_type+, extra options are forwarded to the
       # constructor of the type object.
@@ -184,8 +178,8 @@ module ActiveRecord
       #       @currency_converter = currency_converter
       #     end
       #
-      #     # value will be the result of #deserialize or
-      #     # #cast. Assumed to be an instance of Money in
+      #     # value will be the result of +deserialize+ or
+      #     # +cast+. Assumed to be an instance of +Money+ in
       #     # this case.
       #     def serialize(value)
       #       value_in_bitcoins = @currency_converter.convert_to_bitcoins(value)
@@ -223,22 +217,17 @@ module ActiveRecord
       # is provided so it can be used by plugin authors, application code
       # should probably use ClassMethods#attribute.
       #
-      # ==== Parameters
-      #
-      # [+name+]
-      #   The name of the attribute being defined. Expected to be a +String+.
+      # +name+ The name of the attribute being defined. Expected to be a +String+.
       #
-      # [+cast_type+]
-      #   The type object to use for this attribute.
+      # +cast_type+ The type object to use for this attribute.
       #
-      # [+default+]
-      #   The default value to use when no value is provided. If this option
-      #   is not passed, the previous default value (if any) will be used.
-      #   Otherwise, the default will be +nil+. A proc can also be passed, and
-      #   will be called once each time a new value is needed.
+      # +default+ The default value to use when no value is provided. If this option
+      # is not passed, the previous default value (if any) will be used.
+      # Otherwise, the default will be +nil+. A proc can also be passed, and
+      # will be called once each time a new value is needed.
       #
-      # [+user_provided_default+]
-      #   Whether the default value should be cast using +cast+ or +deserialize+.
+      # +user_provided_default+ Whether the default value should be cast using
+      # +cast+ or +deserialize+.
       def define_attribute(
         name,
         cast_type,

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
@@ -338,29 +372,19 @@ module ActiveRecord
         return true if record.destroyed? || (association.options[:autosave] && record.marked_for_destruction?)
 
         context = validation_context if custom_validation_context?
-        return true if record.valid?(context)
 
-        if context || record.changed_for_autosave?
-          associated_errors = record.errors.objects
-        else
-          # If there are existing invalid records in the DB, we should still be able to reference them.
-          # Unless a record (no matter where in the association chain) is invalid and is being changed.
-          associated_errors = record.errors.objects.select { |error| error.is_a?(Associations::NestedError) }
-        end
-
-        if association.options[:autosave]
-          return if equal?(record)
-
-          associated_errors.each { |error|
-            errors.objects.append(
-              Associations::NestedError.new(association, error)
-            )
-          }
-        elsif associated_errors.any?
-          errors.add(association.reflection.name)
+        unless valid = record.valid?(context)
+          if association.options[:autosave]
+            record.errors.each { |error|
+              self.errors.objects.append(
+                Associations::NestedError.new(association, error)
+              )
+            }
+          else
+            errors.add(association.reflection.name)
+          end
         end
-
-        errors.any?
+        valid
       end
 
       # Is used as an around_save callback to check while saving a collection
@@ -441,33 +465,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,8 +517,7 @@ 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
+        reflection.active_record != record.class.polymorphic_class_for(class_name)
       end
 
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
@@ -512,7 +536,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)

data/lib/active_record/base.rb

@@ -256,13 +256,13 @@ module ActiveRecord # :nodoc:
   # * AssociationTypeMismatch - The object assigned to the association wasn't of the type
   #   specified in the association definition.
   # * AttributeAssignmentError - An error occurred while doing a mass assignment through the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
+  #   {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
   #   You can inspect the +attribute+ property of the exception object to determine which attribute
   #   triggered the error.
   # * ConnectionNotEstablished - No connection has been established.
   #   Use {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection] before querying.
   # * MultiparameterAssignmentErrors - Collection of errors that occurred during a mass assignment using the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
+  #   {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
   #   The +errors+ property of this exception contains an array of
   #   AttributeAssignmentError
   #   objects that should be inspected to determine which attributes triggered the errors.

data/lib/active_record/callbacks.rb

@@ -418,7 +418,7 @@ module ActiveRecord
 
     def destroy # :nodoc:
       @_destroy_callback_already_called ||= false
-      return true if @_destroy_callback_already_called
+      return if @_destroy_callback_already_called
       @_destroy_callback_already_called = true
       _run_destroy_callbacks { super }
     rescue RecordNotDestroyed => e

data/lib/active_record/connection_adapters/abstract/connection_handler.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "concurrent/map"
 
 module ActiveRecord
@@ -210,18 +209,25 @@ module ActiveRecord
       # This makes retrieving the connection pool O(1) once the process is warm.
       # When a connection is established or removed, we invalidate the cache.
       def retrieve_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard, strict: false)
-        pool = get_pool_manager(connection_name)&.get_pool_config(role, shard)&.pool
+        pool_manager = get_pool_manager(connection_name)
+        pool = pool_manager&.get_pool_config(role, shard)&.pool
 
         if strict && !pool
-          if shard != ActiveRecord::Base.default_shard
-            message = "No connection pool for '#{connection_name}' found for the '#{shard}' shard."
-          elsif role != ActiveRecord::Base.default_role
-            message = "No connection pool for '#{connection_name}' found for the '#{role}' role."
-          else
-            message = "No connection pool for '#{connection_name}' found."
-          end
+          selector = [
+            ("'#{shard}' shard" unless shard == ActiveRecord::Base.default_shard),
+            ("'#{role}' role" unless role == ActiveRecord::Base.default_role),
+          ].compact.join(" and ")
+
+          selector = [
+            (connection_name unless connection_name == "ActiveRecord::Base"),
+            selector.presence,
+          ].compact.join(" with ")
+
+          selector = " for #{selector}" if selector.present?
+
+          message = "No database connection defined#{selector}."
 
-          raise ConnectionNotEstablished, message
+          raise ConnectionNotDefined.new(message, connection_name: connection_name, shard: shard, role: role)
         end
 
         pool

data/lib/active_record/connection_adapters/abstract/connection_pool/queue.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "monitor"
 
 module ActiveRecord

data/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "weakref"
 
 module ActiveRecord

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "concurrent/map"
 require "monitor"
 
@@ -38,7 +37,6 @@ module ActiveRecord
 
       def schema_cache; end
       def connection_class; end
-      def query_cache; end
       def checkin(_); end
       def remove(_); end
       def async_executor; end
@@ -119,30 +117,24 @@ module ActiveRecord
     # * private methods that require being called in a +synchronize+ blocks
     #   are now explicitly documented
     class ConnectionPool
-      # Prior to 3.3.5, WeakKeyMap had a use after free bug
-      # https://bugs.ruby-lang.org/issues/20688
-      if ObjectSpace.const_defined?(:WeakKeyMap) && RUBY_VERSION >= "3.3.5"
-        WeakThreadKeyMap = ObjectSpace::WeakKeyMap
-      else
-        class WeakThreadKeyMap # :nodoc:
-          # FIXME: On 3.3 we could use ObjectSpace::WeakKeyMap
-          # but it currently cause GC crashes: https://github.com/byroot/rails/pull/3
-          def initialize
-            @map = {}
-          end
+      class WeakThreadKeyMap # :nodoc:
+        # FIXME: On 3.3 we could use ObjectSpace::WeakKeyMap
+        # but it currently cause GC crashes: https://github.com/byroot/rails/pull/3
+        def initialize
+          @map = {}
+        end
 
-          def clear
-            @map.clear
-          end
+        def clear
+          @map.clear
+        end
 
-          def [](key)
-            @map[key]
-          end
+        def [](key)
+          @map[key]
+        end
 
-          def []=(key, value)
-            @map.select! { |c, _| c&.alive? }
-            @map[key] = value
-          end
+        def []=(key, value)
+          @map.select! { |c, _| c.alive? }
+          @map[key] = value
         end
       end
 
@@ -191,31 +183,6 @@ module ActiveRecord
         end
       end
 
-      module ExecutorHooks # :nodoc:
-        class << self
-          def run
-            # noop
-          end
-
-          def complete(_)
-            ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
-              if (connection = pool.active_connection?)
-                transaction = connection.current_transaction
-                if transaction.closed? || !transaction.joinable?
-                  pool.release_connection
-                end
-              end
-            end
-          end
-        end
-      end
-
-      class << self
-        def install_executor_hooks(executor = ActiveSupport::Executor)
-          executor.register_hook(ExecutorHooks)
-        end
-      end
-
       include MonitorMixin
       prepend QueryCache::ConnectionPoolConfiguration
       include ConnectionAdapters::AbstractPool
@@ -316,9 +283,8 @@ module ActiveRecord
       # held in a cache keyed by a thread.
       def lease_connection
         lease = connection_lease
-        lease.connection ||= checkout
         lease.sticky = true
-        lease.connection
+        lease.connection ||= checkout
       end
 
       def permanent_lease? # :nodoc:
@@ -344,7 +310,6 @@ module ActiveRecord
         end
 
         @pinned_connection.lock_thread = ActiveSupport::IsolatedExecutionState.context if lock_thread
-        @pinned_connection.pinned = true
         @pinned_connection.verify! # eagerly validate the connection
         @pinned_connection.begin_transaction joinable: false, _lazy: false
       end
@@ -367,8 +332,6 @@ module ActiveRecord
           end
 
           if @pinned_connection.nil?
-            connection.pinned = false
-            connection.steal!
             connection.lock_thread = nil
             checkin(connection)
           end
@@ -558,25 +521,20 @@ module ActiveRecord
       # Raises:
       # - ActiveRecord::ConnectionTimeoutError no connection can be obtained from the pool.
       def checkout(checkout_timeout = @checkout_timeout)
-        return checkout_and_verify(acquire_connection(checkout_timeout)) unless @pinned_connection
-
-        @pinned_connection.lock.synchronize do
-          synchronize do
-            # The pinned connection may have been cleaned up before we synchronized, so check if it is still present
-            if @pinned_connection
+        if @pinned_connection
+          @pinned_connection.lock.synchronize do
+            synchronize do
               @pinned_connection.verify!
-
               # Any leased connection must be in @connections otherwise
               # some methods like #connected? won't behave correctly
               unless @connections.include?(@pinned_connection)
                 @connections << @pinned_connection
               end
-
-              @pinned_connection
-            else
-              checkout_and_verify(acquire_connection(checkout_timeout))
             end
           end
+          @pinned_connection
+        else
+          checkout_and_verify(acquire_connection(checkout_timeout))
         end
       end
 
@@ -711,14 +669,6 @@ module ActiveRecord
         Thread.pass
       end
 
-      def new_connection # :nodoc:
-        connection = db_config.new_connection
-        connection.pool = self
-        connection
-      rescue ConnectionNotEstablished => ex
-        raise ex.set_pool(self)
-      end
-
       private
         def connection_lease
           @leases[ActiveSupport::IsolatedExecutionState.context]
@@ -898,12 +848,18 @@ module ActiveRecord
         #--
         # if owner_thread param is omitted, this must be called in synchronize block
         def remove_connection_from_thread_cache(conn, owner_thread = conn.owner)
-          if owner_thread
-            @leases[owner_thread].clear(conn)
-          end
+          @leases[owner_thread].clear(conn)
         end
         alias_method :release, :remove_connection_from_thread_cache
 
+        def new_connection
+          connection = db_config.new_connection
+          connection.pool = self
+          connection
+        rescue ConnectionNotEstablished => ex
+          raise ex.set_pool(self)
+        end
+
         # If the pool is not at a <tt>@size</tt> limit, establish new connection. Connecting
         # to the DB is done outside main synchronized section.
         #--