activerecord 6.0.0 → 6.1.3

data/lib/active_record/associations/alias_tracker.rb

@@ -6,9 +6,14 @@ module ActiveRecord
   module Associations
     # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
     class AliasTracker # :nodoc:
-      def self.create(connection, initial_table, joins)
+      def self.create(connection, initial_table, joins, aliases = nil)
         if joins.empty?
-          aliases = Hash.new(0)
+          aliases ||= Hash.new(0)
+        elsif aliases
+          default_proc = aliases.default_proc || proc { 0 }
+          aliases.default_proc = proc { |h, k|
+            h[k] = initial_count_for(connection, k, joins) + default_proc.call(h, k)
+          }
         else
           aliases = Hash.new { |h, k|
             h[k] = initial_count_for(connection, k, joins)
@@ -32,8 +37,6 @@ module ActiveRecord
             ).size
           elsif join.is_a?(Arel::Nodes::Join)
             join.left.name == name ? 1 : 0
-          elsif join.is_a?(Hash)
-            join[name]
           else
             raise ArgumentError, "joins list should be initialized by list of Arel::Nodes::Join"
           end
@@ -48,31 +51,31 @@ module ActiveRecord
         @connection = connection
       end
 
-      def aliased_table_for(table_name, aliased_name, type_caster)
-        if aliases[table_name].zero?
+      def aliased_table_for(arel_table, table_name = nil)
+        table_name ||= arel_table.name
+
+        if aliases[table_name] == 0
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
-          Arel::Table.new(table_name, type_caster: type_caster)
+          arel_table = arel_table.alias(table_name) if arel_table.name != table_name
         else
           # Otherwise, we need to use an alias
-          aliased_name = @connection.table_alias_for(aliased_name)
+          aliased_name = @connection.table_alias_for(yield)
 
           # Update the count
-          aliases[aliased_name] += 1
+          count = aliases[aliased_name] += 1
 
-          table_alias = if aliases[aliased_name] > 1
-            "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
-          else
-            aliased_name
-          end
-          Arel::Table.new(table_name, type_caster: type_caster).alias(table_alias)
+          aliased_name = "#{truncate(aliased_name)}_#{count}" if count > 1
+
+          arel_table = arel_table.alias(aliased_name)
         end
+
+        arel_table
       end
 
       attr_reader :aliases
 
       private
-
         def truncate(name)
           name.slice(0, @connection.table_alias_length - 2)
         end

data/lib/active_record/associations/association.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/array/wrap"
-
 module ActiveRecord
   module Associations
     # = Active Record Associations
@@ -56,6 +54,10 @@ module ActiveRecord
         @inversed = false
       end
 
+      def reset_negative_cache # :nodoc:
+        reset if loaded? && target.nil?
+      end
+
       # Reloads the \target and returns +self+ on success.
       # The QueryCache is cleared if +force+ is true.
       def reload(force = false)
@@ -95,7 +97,11 @@ module ActiveRecord
       end
 
       def scope
-        target_scope.merge!(association_scope)
+        if (scope = klass.current_scope) && scope.try(:proxy_association) == self
+          scope.spawn
+        else
+          target_scope.merge!(association_scope)
+        end
       end
 
       def reset_scope
@@ -128,7 +134,15 @@ module ActiveRecord
         self.target = record
         @inversed = !!record
       end
-      alias :inversed_from_queries :inversed_from
+
+      def inversed_from_queries(record)
+        if inversable?(record)
+          self.target = record
+          @inversed = true
+        else
+          @inversed = false
+        end
+      end
 
       # Returns the class of the target. belongs_to polymorphic overrides this to look at the
       # polymorphic_type field on the owner.
@@ -187,27 +201,30 @@ module ActiveRecord
         set_inverse_instance(record)
       end
 
-      def create(attributes = {}, &block)
+      def create(attributes = nil, &block)
         _create_record(attributes, &block)
       end
 
-      def create!(attributes = {}, &block)
+      def create!(attributes = nil, &block)
         _create_record(attributes, true, &block)
       end
 
       private
         def find_target
+          if (owner.strict_loading? || reflection.strict_loading?) && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
+          end
+
           scope = self.scope
           return scope.to_a if skip_statement_cache?(scope)
 
-          conn = klass.connection
-          sc = reflection.association_scope_cache(conn, owner) do |params|
+          sc = reflection.association_scope_cache(klass, owner) do |params|
             as = AssociationScope.create { params.bind }
             target_scope.merge!(as.scope(self))
           end
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute(binds, conn) { |record| set_inverse_instance(record) } || []
+          sc.execute(binds, klass.connection) { |record| set_inverse_instance(record) }
         end
 
         # The scope for this association.
@@ -236,25 +253,6 @@ module ActiveRecord
           !loaded? && (!owner.new_record? || foreign_key_present?) && klass
         end
 
-        def creation_attributes
-          attributes = {}
-
-          if (reflection.has_one? || reflection.collection?) && !options[:through]
-            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
-
-            if reflection.type
-              attributes[reflection.type] = owner.class.polymorphic_name
-            end
-          end
-
-          attributes
-        end
-
-        # Sets the owner attributes on the given record
-        def set_owner_attributes(record)
-          creation_attributes.each { |key, value| record[key] = value }
-        end
-
         # Returns true if there is a foreign key present on the owner which
         # references the target. This is used to determine whether we can load
         # the target if the owner is currently a new record (and therefore
@@ -302,7 +300,7 @@ module ActiveRecord
 
         # Returns true if record contains the foreign_key
         def foreign_key_for?(record)
-          record.has_attribute?(reflection.foreign_key)
+          record._has_attribute?(reflection.foreign_key)
         end
 
         # This should be implemented to return the values of the relevant key(s) on the owner,
@@ -327,6 +325,28 @@ module ActiveRecord
             klass.scope_attributes? ||
             reflection.source_reflection.active_record.default_scopes.any?
         end
+
+        def enqueue_destroy_association(options)
+          job_class = owner.class.destroy_association_async_job
+
+          if job_class
+            owner._after_commit_jobs.push([job_class, options])
+          end
+        end
+
+        def inversable?(record)
+          record &&
+            ((!record.persisted? || !owner.persisted?) || matches_foreign_key?(record))
+        end
+
+        def matches_foreign_key?(record)
+          if foreign_key_for?(record)
+            record.read_attribute(reflection.foreign_key) == owner.id ||
+              (foreign_key_for?(owner) && owner.read_attribute(reflection.foreign_key) == record.id)
+          else
+            owner.read_attribute(reflection.foreign_key) == record.id
+          end
+        end
     end
   end
 end

data/lib/active_record/associations/association_scope.rb

@@ -52,17 +52,16 @@ module ActiveRecord
         attr_reader :value_transformation
 
         def join(table, constraint)
-          table.create_join(table, table.create_on(constraint))
+          Arel::Nodes::LeadingJoin.new(table, Arel::Nodes::On.new(constraint))
         end
 
         def last_chain_scope(scope, reflection, owner)
-          join_keys = reflection.join_keys
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
+          primary_key = reflection.join_primary_key
+          foreign_key = reflection.join_foreign_key
 
           table = reflection.aliased_table
           value = transform_value(owner[foreign_key])
-          scope = apply_scope(scope, table, key, value)
+          scope = apply_scope(scope, table, primary_key, value)
 
           if reflection.type
             polymorphic_type = transform_value(owner.class.polymorphic_name)
@@ -77,13 +76,12 @@ module ActiveRecord
         end
 
         def next_chain_scope(scope, reflection, next_reflection)
-          join_keys = reflection.join_keys
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
+          primary_key = reflection.join_primary_key
+          foreign_key = reflection.join_foreign_key
 
           table = reflection.aliased_table
           foreign_table = next_reflection.aliased_table
-          constraint = table[key].eq(foreign_table[foreign_key])
+          constraint = table[primary_key].eq(foreign_table[foreign_key])
 
           if reflection.type
             value = transform_value(next_reflection.klass.polymorphic_name)
@@ -108,11 +106,9 @@ module ActiveRecord
           name = reflection.name
           chain = [Reflection::RuntimeReflection.new(reflection, association)]
           reflection.chain.drop(1).each do |refl|
-            aliased_table = tracker.aliased_table_for(
-              refl.table_name,
-              refl.alias_candidate(name),
-              refl.klass.type_caster
-            )
+            aliased_table = tracker.aliased_table_for(refl.klass.arel_table) do
+              refl.alias_candidate(name)
+            end
             chain << ReflectionProxy.new(refl, aliased_table)
           end
           chain
@@ -134,10 +130,18 @@ module ActiveRecord
 
               if scope_chain_item == chain_head.scope
                 scope.merge! item.except(:where, :includes, :unscope, :order)
+              elsif !item.references_values.empty?
+                scope.merge! item.only(:joins, :left_outer_joins)
+
+                associations = item.eager_load_values | item.includes_values
+
+                unless associations.empty?
+                  scope.joins! item.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
               end
 
               reflection.all_includes do
-                scope.includes! item.includes_values
+                scope.includes_values |= item.includes_values
               end
 
               scope.unscope!(*item.unscope_values)

data/lib/active_record/associations/belongs_to_association.rb

@@ -11,8 +11,20 @@ module ActiveRecord
         when :destroy
           target.destroy
           raise ActiveRecord::Rollback unless target.destroyed?
+        when :destroy_async
+          id = owner.public_send(reflection.foreign_key.to_sym)
+          primary_key_column = reflection.active_record_primary_key.to_sym
+
+          enqueue_destroy_association(
+            owner_model_name: owner.class.to_s,
+            owner_id: owner.id,
+            association_class: reflection.klass.to_s,
+            association_ids: [id],
+            association_primary_key_column: primary_key_column,
+            ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+          )
         else
-          target.send(options[:dependent])
+          target.public_send(options[:dependent])
         end
       end
 
@@ -44,7 +56,7 @@ module ActiveRecord
 
       def decrement_counters_before_last_save
         if reflection.polymorphic?
-          model_was = owner.attribute_before_last_save(reflection.foreign_type).try(:constantize)
+          model_was = owner.attribute_before_last_save(reflection.foreign_type)&.constantize
         else
           model_was = klass
         end
@@ -68,7 +80,7 @@ module ActiveRecord
             @updated = true
           end
 
-          replace_keys(record)
+          replace_keys(record, force: true)
 
           self.target = record
         end
@@ -96,8 +108,12 @@ module ActiveRecord
           reflection.counter_cache_column && owner.persisted?
         end
 
-        def replace_keys(record)
-          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record.class)) : nil
+        def replace_keys(record, force: false)
+          target_key = record ? record._read_attribute(primary_key(record.class)) : nil
+
+          if force || owner[reflection.foreign_key] != target_key
+            owner[reflection.foreign_key] = target_key
+          end
         end
 
         def primary_key(klass)
@@ -108,11 +124,9 @@ module ActiveRecord
           owner._read_attribute(reflection.foreign_key)
         end
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && inverse.has_one?
+          inverse && (inverse.has_one? || ActiveRecord::Base.has_many_inversing)
         end
 
         def stale_state

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
       def klass
         type = owner[reflection.foreign_type]
-        type.presence && type.constantize
+        type.presence && owner.class.polymorphic_class_for(type)
       end
 
       def target_changed?
@@ -14,9 +14,14 @@ module ActiveRecord
       end
 
       private
-        def replace_keys(record)
+        def replace_keys(record, force: false)
           super
-          owner[reflection.foreign_type] = record ? record.class.polymorphic_name : nil
+
+          target_type = record ? record.class.polymorphic_name : nil
+
+          if force || owner[reflection.foreign_type] != target_type
+            owner[reflection.foreign_type] = target_type
+          end
         end
 
         def inverse_reflection_for(record)

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

@@ -18,7 +18,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
     self.extensions = []
 
-    VALID_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate] # :nodoc:
+    VALID_OPTIONS = [
+      :class_name, :anonymous_class, :primary_key, :foreign_key, :dependent, :validate, :inverse_of, :strict_loading
+    ].freeze # :nodoc:
 
     def self.build(model, name, scope, options, &block)
       if model.dangerous_attribute_method?(name)
@@ -72,8 +74,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.define_callbacks(model, reflection)
       if dependent = reflection.options[:dependent]
-        check_dependent_options(dependent)
+        check_dependent_options(dependent, model)
         add_destroy_callbacks(model, reflection)
+        add_after_commit_jobs_callback(model, dependent)
       end
 
       Association.extensions.each do |extension|
@@ -118,7 +121,11 @@ module ActiveRecord::Associations::Builder # :nodoc:
       raise NotImplementedError
     end
 
-    def self.check_dependent_options(dependent)
+    def self.check_dependent_options(dependent, model)
+      if dependent == :destroy_async && !model.destroy_association_async_job
+        err_message = "ActiveJob is required to use destroy_async on associations"
+        raise ActiveRecord::ActiveJobRequiredError, err_message
+      end
       unless valid_dependent_options.include? dependent
         raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
@@ -126,11 +133,31 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.add_destroy_callbacks(model, reflection)
       name = reflection.name
-      model.before_destroy lambda { |o| o.association(name).handle_dependency }
+      model.before_destroy(->(o) { o.association(name).handle_dependency })
+    end
+
+    def self.add_after_commit_jobs_callback(model, dependent)
+      if dependent == :destroy_async
+        mixin = model.generated_association_methods
+
+        unless mixin.method_defined?(:_after_commit_jobs)
+          model.after_commit(-> do
+            _after_commit_jobs.each do |job_class, job_arguments|
+              job_class.perform_later(**job_arguments)
+            end
+          end)
+
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def _after_commit_jobs
+              @_after_commit_jobs ||= []
+            end
+          CODE
+        end
+      end
     end
 
     private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
       :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
-      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks
+      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks, :add_after_commit_jobs_callback
   end
 end