activerecord 7.0.0.alpha2 → 7.0.0

data/lib/active_record/associations/collection_association.rb

@@ -335,7 +335,7 @@ module ActiveRecord
             end
           end
 
-          persisted + memory
+          persisted + memory.reject(&:persisted?)
         end
 
         def _create_record(attributes, raise = false, &block)
@@ -456,6 +456,10 @@ module ActiveRecord
 
           yield(record) if block_given?
 
+          if !index && @replaced_or_added_targets.include?(record)
+            index = @target.index(record)
+          end
+
           @replaced_or_added_targets << record if inversing || index || record.new_record?
 
           if index
@@ -480,7 +484,11 @@ module ActiveRecord
 
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{reflection.name}"
-          owner.class.send(full_callback_name)
+          if owner.class.respond_to?(full_callback_name)
+            owner.class.send(full_callback_name)
+          else
+            []
+          end
         end
 
         def include_in_memory?(record)

data/lib/active_record/associations/join_dependency.rb

@@ -3,8 +3,12 @@
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      autoload :JoinBase,        "active_record/associations/join_dependency/join_base"
-      autoload :JoinAssociation, "active_record/associations/join_dependency/join_association"
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :JoinBase
+        autoload :JoinAssociation
+      end
 
       class Aliases # :nodoc:
         def initialize(tables)

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

@@ -23,11 +23,7 @@ module ActiveRecord
           end
 
           def records_for(loaders)
-            ids = loaders.flat_map(&:owner_keys).uniq
-
-            scope.where(association_key_name => ids).load do |record|
-              loaders.each { |l| l.set_inverse(record) }
-            end
+            LoaderRecords.new(loaders, self).records
           end
 
           def load_records_in_batch(loaders)
@@ -38,6 +34,52 @@ module ActiveRecord
               loader.run
             end
           end
+
+          def load_records_for_keys(keys, &block)
+            scope.where(association_key_name => keys).load(&block)
+          end
+        end
+
+        class LoaderRecords
+          def initialize(loaders, loader_query)
+            @loader_query = loader_query
+            @loaders = loaders
+            @keys_to_load = Set.new
+            @already_loaded_records_by_key = {}
+
+            populate_keys_to_load_and_already_loaded_records
+          end
+
+          def records
+            load_records + already_loaded_records
+          end
+
+          private
+            attr_reader :loader_query, :loaders, :keys_to_load, :already_loaded_records_by_key
+
+            def populate_keys_to_load_and_already_loaded_records
+              loaders.each do |loader|
+                loader.owners_by_key.each do |key, owners|
+                  if loaded_owner = owners.find { |owner| loader.loaded?(owner) }
+                    already_loaded_records_by_key[key] = loader.target_for(loaded_owner)
+                  else
+                    keys_to_load << key
+                  end
+                end
+              end
+
+              @keys_to_load.subtract(already_loaded_records_by_key.keys)
+            end
+
+            def load_records
+              loader_query.load_records_for_keys(keys_to_load) do |record|
+                loaders.each { |l| l.set_inverse(record) }
+              end
+            end
+
+            def already_loaded_records
+              already_loaded_records_by_key.values.flatten
+            end
         end
 
         attr_reader :klass
@@ -57,12 +99,8 @@ module ActiveRecord
           @klass.table_name
         end
 
-        def data_available?
-          already_loaded?
-        end
-
         def future_classes
-          if run? || already_loaded?
+          if run?
             []
           else
             [@klass]
@@ -81,11 +119,6 @@ module ActiveRecord
           return self if run?
           @run = true
 
-          if already_loaded?
-            fetch_from_preloaded_records
-            return self
-          end
-
           records = records_by_owner
 
           owners.each do |owner|
@@ -96,25 +129,17 @@ module ActiveRecord
         end
 
         def records_by_owner
-          ensure_loaded unless defined?(@records_by_owner)
+          load_records unless defined?(@records_by_owner)
 
           @records_by_owner
         end
 
         def preloaded_records
-          ensure_loaded unless defined?(@preloaded_records)
+          load_records unless defined?(@preloaded_records)
 
           @preloaded_records
         end
 
-        def ensure_loaded
-          if already_loaded?
-            fetch_from_preloaded_records
-          else
-            load_records
-          end
-        end
-
         # The name of the key on the associated records
         def association_key_name
           reflection.join_primary_key(klass)
@@ -124,8 +149,19 @@ module ActiveRecord
           LoaderQuery.new(scope, association_key_name)
         end
 
-        def owner_keys
-          @owner_keys ||= owners_by_key.keys
+        def owners_by_key
+          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+            key = convert_key(owner[owner_key_name])
+            (result[key] ||= []) << owner if key
+          end
+        end
+
+        def loaded?(owner)
+          owner.association(reflection.name).loaded?
+        end
+
+        def target_for(owner)
+          Array.wrap(owner.association(reflection.name).target)
         end
 
         def scope
@@ -169,7 +205,7 @@ module ActiveRecord
           return if preload_scope && !preload_scope.empty_scope?
           return if reflection.collection?
 
-          unscoped_records.each do |record|
+          unscoped_records.select { |r| r[association_key_name].present? }.each do |record|
             owners = owners_by_key[convert_key(record[association_key_name])]
             owners&.each_with_index do |owner, i|
               association = owner.association(reflection.name)
@@ -185,25 +221,16 @@ module ActiveRecord
         private
           attr_reader :owners, :reflection, :preload_scope, :model
 
-          def already_loaded?
-            @already_loaded ||= owners.all? { |o| o.association(reflection.name).loaded? }
-          end
-
-          def fetch_from_preloaded_records
-            @records_by_owner = owners.index_with do |owner|
-              Array(owner.association(reflection.name).target)
-            end
-
-            @preloaded_records = records_by_owner.flat_map(&:last)
-          end
-
           # The name of the key on the model which declares the association
           def owner_key_name
             reflection.join_foreign_key
           end
 
           def associate_records_to_owner(owner, records)
+            return if loaded?(owner)
+
             association = owner.association(reflection.name)
+
             if reflection.collection?
               association.target = records
             else
@@ -211,13 +238,6 @@ module ActiveRecord
             end
           end
 
-          def owners_by_key
-            @owners_by_key ||= owners.each_with_object({}) do |owner, result|
-              key = convert_key(owner[owner_key_name])
-              (result[key] ||= []) << owner if key
-            end
-          end
-
           def key_conversion_required?
             unless defined?(@key_conversion_required)
               @key_conversion_required = (association_key_type != owner_key_type)
@@ -243,7 +263,7 @@ module ActiveRecord
           end
 
           def reflection_scope
-            @reflection_scope ||= reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass).inject(&:merge!) || klass.unscoped
+            @reflection_scope ||= reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass).inject(klass.unscoped, &:merge!)
           end
 
           def build_scope

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

@@ -6,7 +6,7 @@ module ActiveRecord
       class Batch # :nodoc:
         def initialize(preloaders, available_records:)
           @preloaders = preloaders.reject(&:empty?)
-          @available_records = available_records.flatten.group_by(&:class)
+          @available_records = available_records.flatten.group_by { |r| r.class.base_class }
         end
 
         def call
@@ -14,12 +14,9 @@ module ActiveRecord
           until branches.empty?
             loaders = branches.flat_map(&:runnable_loaders)
 
-            loaders.each { |loader| loader.associate_records_from_unscoped(@available_records[loader.klass]) }
+            loaders.each { |loader| loader.associate_records_from_unscoped(@available_records[loader.klass.base_class]) }
 
-            already_loaded = loaders.select(&:data_available?)
-            if already_loaded.any?
-              already_loaded.each(&:run)
-            elsif loaders.any?
+            if loaders.any?
               future_tables = branches.flat_map do |branch|
                 branch.future_classes - branch.runnable_loaders.map(&:klass)
               end.map(&:table_name).uniq

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

@@ -10,10 +10,13 @@ module ActiveRecord
 
         def records_by_owner
           return @records_by_owner if defined?(@records_by_owner)
-          source_records_by_owner = source_preloaders.map(&:records_by_owner).reduce(:merge)
-          through_records_by_owner = through_preloaders.map(&:records_by_owner).reduce(:merge)
 
           @records_by_owner = owners.each_with_object({}) do |owner, result|
+            if loaded?(owner)
+              result[owner] = target_for(owner)
+              next
+            end
+
             through_records = through_records_by_owner[owner] || []
 
             if owners.first.association(through_reflection.name).loaded?
@@ -35,12 +38,6 @@ module ActiveRecord
           end
         end
 
-        def data_available?
-          return true if super()
-          through_preloaders.all?(&:run?) &&
-            source_preloaders.all?(&:run?)
-        end
-
         def runnable_loaders
           if data_available?
             [self]
@@ -52,7 +49,7 @@ module ActiveRecord
         end
 
         def future_classes
-          if run? || data_available?
+          if run?
             []
           elsif through_preloaders.all?(&:run?)
             source_preloaders.flat_map(&:future_classes).uniq
@@ -67,6 +64,11 @@ module ActiveRecord
         end
 
         private
+          def data_available?
+            owners.all? { |owner| loaded?(owner) } ||
+              through_preloaders.all?(&:run?) && source_preloaders.all?(&:run?)
+          end
+
           def source_preloaders
             @source_preloaders ||= ActiveRecord::Associations::Preloader.new(records: middle_records, associations: source_reflection.name, scope: scope, associate_by_default: false).loaders
           end
@@ -87,6 +89,14 @@ module ActiveRecord
             reflection.source_reflection
           end
 
+          def source_records_by_owner
+            @source_records_by_owner ||= source_preloaders.map(&:records_by_owner).reduce(:merge)
+          end
+
+          def through_records_by_owner
+            @through_records_by_owner ||= through_preloaders.map(&:records_by_owner).reduce(:merge)
+          end
+
           def preload_index
             @preload_index ||= preloaded_records.each_with_object({}).with_index do |(record, result), index|
               result[record] = index

data/lib/active_record/associations/preloader.rb

@@ -93,25 +93,21 @@ module ActiveRecord
       # associations before querying the database. This can save database
       # queries by reusing in-memory objects. The optimization is only applied
       # to single associations (i.e. :belongs_to, :has_one) with no scopes.
-      def initialize(associate_by_default: true, **kwargs)
-        if kwargs.empty?
-          ActiveSupport::Deprecation.warn("Calling `Preloader#initialize` without arguments is deprecated and will be removed in Rails 7.0.")
-        else
-          @records = kwargs[:records]
-          @associations = kwargs[:associations]
-          @scope = kwargs[:scope]
-          @available_records = kwargs[:available_records] || []
-          @associate_by_default = associate_by_default
+      def initialize(records:, associations:, scope: nil, available_records: [], associate_by_default: true)
+        @records = records
+        @associations = associations
+        @scope = scope
+        @available_records = available_records || []
+        @associate_by_default = associate_by_default
 
-          @tree = Branch.new(
-            parent: nil,
-            association: nil,
-            children: associations,
-            associate_by_default: @associate_by_default,
-            scope: @scope
-          )
-          @tree.preloaded_records = records
-        end
+        @tree = Branch.new(
+          parent: nil,
+          association: nil,
+          children: @associations,
+          associate_by_default: @associate_by_default,
+          scope: @scope
+        )
+        @tree.preloaded_records = @records
       end
 
       def empty?
@@ -124,12 +120,6 @@ module ActiveRecord
         loaders
       end
 
-      def preload(records, associations, preload_scope = nil)
-        ActiveSupport::Deprecation.warn("`preload` is deprecated and will be removed in Rails 7.0. Call `Preloader.new(kwargs).call` instead.")
-
-        Preloader.new(records: records, associations: associations, scope: preload_scope).call
-      end
-
       def branches
         @tree.children
       end

data/lib/active_record/associations/through_association.rb

@@ -74,8 +74,8 @@ module ActiveRecord
           end
         end
 
-        # Note: this does not capture all cases, for example it would be crazy to try to
-        # properly support stale-checking for nested associations.
+        # Note: this does not capture all cases, for example it would be impractical
+        # to try to properly support stale-checking for nested associations.
         def stale_state
           if through_reflection.belongs_to?
             owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s

data/lib/active_record/associations.rb

@@ -59,6 +59,18 @@ module ActiveRecord
     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
 
@@ -748,9 +760,10 @@ module ActiveRecord
       # inverse detection only works on #has_many, #has_one, and
       # #belongs_to associations.
       #
-      # <tt>:foreign_key</tt> and <tt>:through</tt> options on the associations,
-      # or a custom scope, will also prevent the association's inverse
-      # from being found automatically.
+      # <tt>:foreign_key</tt> and <tt>:through</tt> options on the associations
+      # will also prevent the association's inverse from being found automatically,
+      # as will a custom scopes in some cases. See further details in the
+      # {Active Record Associations guide}[https://guides.rubyonrails.org/association_basics.html#bi-directional-associations].
       #
       # The automatic guessing of the inverse association uses a heuristic based
       # on the name of the class, so it may not work for all associations,

data/lib/active_record/asynchronous_queries_tracker.rb

@@ -7,6 +7,9 @@ module ActiveRecord
         def active?
           true
         end
+
+        def finalize
+        end
       end
     end
 

data/lib/active_record/attribute_methods/dirty.rb

@@ -229,7 +229,15 @@ module ActiveRecord
         end
 
         def attribute_names_for_partial_inserts
-          partial_inserts? ? changed_attribute_names_to_save : attribute_names
+          if partial_inserts?
+            changed_attribute_names_to_save
+          else
+            attribute_names.reject do |attr_name|
+              if column_for_attribute(attr_name).default_function
+                !attribute_changed?(attr_name)
+              end
+            end
+          end
         end
     end
   end

data/lib/active_record/attribute_methods.rb

@@ -387,20 +387,22 @@ module ActiveRecord
         attribute_names.index_with { |name| @attributes[name] }
       end
 
-      # Filters the primary keys and readonly attributes from the attribute names.
+      # Filters the primary keys, readonly attributes and virtual columns from the attribute names.
       def attributes_for_update(attribute_names)
         attribute_names &= self.class.column_names
         attribute_names.delete_if do |name|
-          self.class.readonly_attribute?(name)
+          self.class.readonly_attribute?(name) ||
+            column_for_attribute(name).virtual?
         end
       end
 
-      # Filters out the primary keys, from the attribute names, when the primary
+      # Filters out the virtual columns and also primary keys, from the attribute names, when the primary
       # key is to be generated (e.g. the id attribute has no value).
       def attributes_for_create(attribute_names)
         attribute_names &= self.class.column_names
         attribute_names.delete_if do |name|
-          pk_attribute?(name) && id.nil?
+          (pk_attribute?(name) && id.nil?) ||
+            column_for_attribute(name).virtual?
         end
       end
 
@@ -411,7 +413,7 @@ module ActiveRecord
           inspected_value = if value.is_a?(String) && value.length > 50
             "#{value[0, 50]}...".inspect
           elsif value.is_a?(Date) || value.is_a?(Time)
-            %("#{value.to_s(:inspect)}")
+            %("#{value.to_formatted_s(:inspect)}")
           else
             value.inspect
           end

data/lib/active_record/autosave_association.rb

@@ -404,6 +404,8 @@ module ActiveRecord
               saved = true
 
               if autosave != false && (new_record_before_save || record.new_record?)
+                association.set_inverse_instance(record)
+
                 if autosave
                   saved = association.insert_record(record, false)
                 elsif !reflection.nested?
@@ -447,9 +449,7 @@ module ActiveRecord
             if (autosave && record.changed_for_autosave?) || record_changed?(reflection, record, key)
               unless reflection.through_reflection
                 record[reflection.foreign_key] = key
-                if inverse_reflection = reflection.inverse_of
-                  record.association(inverse_reflection.name).inversed_from(self)
-                end
+                association.set_inverse_instance(record)
               end
 
               saved = record.save(validate: !autosave)

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

@@ -81,11 +81,11 @@ module ActiveRecord
       end
 
       def prevent_writes # :nodoc:
-        Thread.current[:prevent_writes]
+        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes]
       end
 
       def prevent_writes=(prevent_writes) # :nodoc:
-        Thread.current[:prevent_writes] = prevent_writes
+        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes] = prevent_writes
       end
 
       # Prevent writing to the database regardless of role.
@@ -126,7 +126,7 @@ module ActiveRecord
       def establish_connection(config, owner_name: Base, role: ActiveRecord::Base.current_role, shard: Base.current_shard)
         owner_name = StringConnectionOwner.new(config.to_s) if config.is_a?(Symbol)
 
-        pool_config = resolve_pool_config(config, owner_name)
+        pool_config = resolve_pool_config(config, owner_name, role, shard)
         db_config = pool_config.db_config
 
         # Protects the connection named `ActiveRecord::Base` from being removed
@@ -218,15 +218,6 @@ module ActiveRecord
         pool && pool.connected?
       end
 
-      # Remove the connection for this class. This will close the active
-      # connection and the defined connection (if they exist). The result
-      # can be used as an argument for #establish_connection, for easily
-      # re-establishing the connection.
-      def remove_connection(owner, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        remove_connection_pool(owner, role: role, shard: shard)&.configuration_hash
-      end
-      deprecate remove_connection: "Use #remove_connection_pool, which now returns a DatabaseConfig object instead of a Hash"
-
       def remove_connection_pool(owner, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
         if pool_manager = get_pool_manager(owner)
           pool_config = pool_manager.remove_pool_config(role, shard)
@@ -250,19 +241,8 @@ module ActiveRecord
         attr_reader :owner_to_pool_manager
 
         # Returns the pool manager for an owner.
-        #
-        # Using `"primary"` to look up the pool manager for `ActiveRecord::Base` is
-        # deprecated in favor of looking it up by `"ActiveRecord::Base"`.
-        #
-        # During the deprecation period, if `"primary"` is passed, the pool manager
-        # for `ActiveRecord::Base` will still be returned.
         def get_pool_manager(owner)
-          return owner_to_pool_manager[owner] if owner_to_pool_manager.key?(owner)
-
-          if owner == "primary"
-            ActiveSupport::Deprecation.warn("Using `\"primary\"` as a `connection_specification_name` is deprecated and will be removed in Rails 7.0.0. Please use `ActiveRecord::Base`.")
-            owner_to_pool_manager[Base.name]
-          end
+          owner_to_pool_manager[owner]
         end
 
         # Returns an instance of PoolConfig for a given adapter.
@@ -275,7 +255,7 @@ module ActiveRecord
         #   pool_config.db_config.configuration_hash
         #   # => { host: "localhost", database: "foo", adapter: "sqlite3" }
         #
-        def resolve_pool_config(config, owner_name)
+        def resolve_pool_config(config, owner_name, role, shard)
           db_config = Base.configurations.resolve(config)
 
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db_config.adapter
@@ -305,7 +285,7 @@ module ActiveRecord
             raise AdapterNotFound, "database configuration specifies nonexistent #{db_config.adapter} adapter"
           end
 
-          ConnectionAdapters::PoolConfig.new(owner_name, db_config)
+          ConnectionAdapters::PoolConfig.new(owner_name, db_config, role, shard)
         end
     end
   end

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

@@ -110,7 +110,7 @@ module ActiveRecord
           def wait_poll(timeout)
             @num_waiting += 1
 
-            t0 = Concurrent.monotonic_time
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             elapsed = 0
             loop do
               ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
@@ -119,7 +119,7 @@ module ActiveRecord
 
               return remove if any?
 
-              elapsed = Concurrent.monotonic_time - t0
+              elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
               if elapsed >= timeout
                 msg = "could not obtain a connection from the pool within %0.3f seconds (waited %0.3f seconds); all pooled connections were in use" %
                   [timeout, elapsed]