activerecord 5.2.4 → 6.0.2.1

data/lib/active_record/associations/foreign_association.rb

@@ -9,5 +9,12 @@ module ActiveRecord::Associations
         false
       end
     end
+
+    def nullified_owner_attributes
+      Hash.new.tap do |attrs|
+        attrs[reflection.foreign_key] = nil
+        attrs[reflection.type] = nil if reflection.type.present?
+      end
+    end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -36,14 +36,6 @@ module ActiveRecord
         super
       end
 
-      def empty?
-        if reflection.has_cached_counter?
-          size.zero?
-        else
-          super
-        end
-      end
-
       private
 
         # Returns the number of records in this collection.
@@ -69,7 +61,7 @@ module ActiveRecord
           # If there's nothing in the database and @target has no new records
           # we are certain the current target is an empty array. This is a
           # documented side-effect of the method that may avoid an extra SELECT.
-          (@target ||= []) && loaded! if count == 0
+          loaded! if count == 0
 
           [association_scope.limit_value, count].compact.min
         end
@@ -92,7 +84,7 @@ module ActiveRecord
           if method == :delete_all
             scope.delete_all
           else
-            scope.update_all(reflection.foreign_key => nil)
+            scope.update_all(nullified_owner_attributes)
           end
         end
 

data/lib/active_record/associations/has_many_through_association.rb

@@ -21,20 +21,6 @@ module ActiveRecord
         super
       end
 
-      def concat_records(records)
-        ensure_not_nested
-
-        records = super(records, true)
-
-        if owner.new_record? && records
-          records.flatten.each do |record|
-            build_through_record(record)
-          end
-        end
-
-        records
-      end
-
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
@@ -48,6 +34,20 @@ module ActiveRecord
       end
 
       private
+        def concat_records(records)
+          ensure_not_nested
+
+          records = super(records, true)
+
+          if owner.new_record? && records
+            records.flatten.each do |record|
+              build_through_record(record)
+            end
+          end
+
+          records
+        end
+
         # The through record (built with build_record) is temporarily cached
         # so that it may be reused if insert_record is subsequently called.
         #

data/lib/active_record/associations/has_one_association.rb

@@ -23,35 +23,6 @@ module ActiveRecord
         end
       end
 
-      def replace(record, save = true)
-        raise_on_type_mismatch!(record) if record
-        load_target
-
-        return target unless target || record
-
-        assigning_another_record = target != record
-        if assigning_another_record || record.has_changes_to_save?
-          save &&= owner.persisted?
-
-          transaction_if(save) do
-            remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
-
-            if record
-              set_owner_attributes(record)
-              set_inverse_instance(record)
-
-              if save && !record.save
-                nullify_owner_attributes(record)
-                set_owner_attributes(target) if target
-                raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
-              end
-            end
-          end
-        end
-
-        self.target = record
-      end
-
       def delete(method = options[:dependent])
         if load_target
           case method
@@ -62,12 +33,39 @@ module ActiveRecord
             target.destroy
             throw(:abort) unless target.destroyed?
           when :nullify
-            target.update_columns(reflection.foreign_key => nil) if target.persisted?
+            target.update_columns(nullified_owner_attributes) if target.persisted?
           end
         end
       end
 
       private
+        def replace(record, save = true)
+          raise_on_type_mismatch!(record) if record
+
+          return target unless load_target || record
+
+          assigning_another_record = target != record
+          if assigning_another_record || record.has_changes_to_save?
+            save &&= owner.persisted?
+
+            transaction_if(save) do
+              remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
+
+              if record
+                set_owner_attributes(record)
+                set_inverse_instance(record)
+
+                if save && !record.save
+                  nullify_owner_attributes(record)
+                  set_owner_attributes(target) if target
+                  raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+                end
+              end
+            end
+          end
+
+          self.target = record
+        end
 
         # The reason that the save param for replace is false, if for create (not just build),
         # is because the setting of the foreign keys is actually handled by the scoping when

data/lib/active_record/associations/has_one_through_association.rb

@@ -6,12 +6,12 @@ module ActiveRecord
     class HasOneThroughAssociation < HasOneAssociation #:nodoc:
       include ThroughAssociation
 
-      def replace(record, save = true)
-        create_through_record(record, save)
-        self.target = record
-      end
-
       private
+        def replace(record, save = true)
+          create_through_record(record, save)
+          self.target = record
+        end
+
         def create_through_record(record, save)
           ensure_not_nested
 

data/lib/active_record/associations/join_dependency.rb

@@ -14,10 +14,8 @@ module ActiveRecord
               i[column.name] = column.alias
             }
           }
-          @name_and_alias_cache = tables.each_with_object({}) { |table, h|
-            h[table.node] = table.columns.map { |column|
-              [column.name, column.alias]
-            }
+          @columns_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns
           }
         end
 
@@ -25,9 +23,8 @@ module ActiveRecord
           @tables.flat_map(&:column_aliases)
         end
 
-        # An array of [column_name, alias] pairs for the table
         def column_aliases(node)
-          @name_and_alias_cache[node]
+          @columns_cache[node]
         end
 
         def column_alias(node, column)
@@ -67,16 +64,21 @@ module ActiveRecord
         end
       end
 
-      def initialize(base, table, associations)
+      def initialize(base, table, associations, join_type)
         tree = self.class.make_tree associations
         @join_root = JoinBase.new(base, table, build(tree, base))
+        @join_type = join_type
+      end
+
+      def base_klass
+        join_root.base_klass
       end
 
       def reflections
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(joins_to_add, join_type, alias_tracker)
+      def join_constraints(joins_to_add, alias_tracker)
         @alias_tracker = alias_tracker
 
         construct_tables!(join_root)
@@ -85,9 +87,9 @@ module ActiveRecord
         joins.concat joins_to_add.flat_map { |oj|
           construct_tables!(oj.join_root)
           if join_root.match? oj.join_root
-            walk join_root, oj.join_root
+            walk(join_root, oj.join_root, oj.join_type)
           else
-            make_join_constraints(oj.join_root, join_type)
+            make_join_constraints(oj.join_root, oj.join_type)
           end
         }
       end
@@ -116,7 +118,7 @@ module ActiveRecord
           result_set.each { |row_hash|
             parent_key = primary_key ? row_hash[primary_key] : row_hash
             parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
-            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+            construct(parent, join_root, row_hash, seen, model_cache)
           }
         end
 
@@ -128,9 +130,11 @@ module ActiveRecord
       end
 
       protected
-        attr_reader :alias_tracker, :join_root
+        attr_reader :join_root, :join_type
 
       private
+        attr_reader :alias_tracker
+
         def aliases
           @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
             columns = join_part.column_names.each_with_index.map { |column_name, j|
@@ -152,7 +156,7 @@ module ActiveRecord
           end
         end
 
-        def make_constraints(parent, child, join_type = Arel::Nodes::OuterJoin)
+        def make_constraints(parent, child, join_type)
           foreign_table = parent.table
           foreign_klass = parent.base_klass
           joins = child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
@@ -170,17 +174,17 @@ module ActiveRecord
         end
 
         def table_alias_for(reflection, parent, join)
-          name = "#{reflection.plural_name}_#{parent.table_name}"
+          name = reflection.alias_candidate(parent.table_name)
           join ? "#{name}_join" : name
         end
 
-        def walk(left, right)
+        def walk(left, right, join_type)
           intersection, missing = right.children.map { |node1|
             [left.children.find { |node2| node1.match? node2 }, node1]
           }.partition(&:first)
 
-          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r) }
-          joins.concat missing.flat_map { |_, n| make_constraints(left, n) }
+          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r, join_type) }
+          joins.concat missing.flat_map { |_, n| make_constraints(left, n, join_type) }
         end
 
         def find_reflection(klass, name)
@@ -202,7 +206,7 @@ module ActiveRecord
           end
         end
 
-        def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        def construct(ar_parent, parent, row, seen, model_cache)
           return if ar_parent.nil?
 
           parent.children.each do |node|
@@ -211,7 +215,7 @@ module ActiveRecord
               other.loaded!
             elsif ar_parent.association_cached?(node.reflection.name)
               model = ar_parent.association(node.reflection.name).target
-              construct(model, node, row, rs, seen, model_cache, aliases)
+              construct(model, node, row, seen, model_cache)
               next
             end
 
@@ -226,22 +230,17 @@ module ActiveRecord
             model = seen[ar_parent.object_id][node][id]
 
             if model
-              construct(model, node, row, rs, seen, model_cache, aliases)
+              construct(model, node, row, seen, model_cache)
             else
-              model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-
-              if node.reflection.scope &&
-                  node.reflection.scope_for(node.base_klass.unscoped).readonly_value
-                model.readonly!
-              end
+              model = construct_model(ar_parent, node, row, model_cache, id)
 
               seen[ar_parent.object_id][node][id] = model
-              construct(model, node, row, rs, seen, model_cache, aliases)
+              construct(model, node, row, seen, model_cache)
             end
           end
         end
 
-        def construct_model(record, node, row, model_cache, id, aliases)
+        def construct_model(record, node, row, model_cache, id)
           other = record.association(node.reflection.name)
 
           model = model_cache[node][id] ||=
@@ -255,6 +254,7 @@ module ActiveRecord
             other.target = model
           end
 
+          model.readonly! if node.readonly?
           model
         end
     end

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record/associations/join_dependency/join_part"
+require "active_support/core_ext/array/extract"
 
 module ActiveRecord
   module Associations
@@ -35,10 +36,9 @@ module ActiveRecord
             arel = join_scope.arel(alias_tracker.aliases)
             nodes = arel.constraints.first
 
-            others, children = nodes.children.partition do |node|
-              !fetch_arel_attribute(node) { |attr| attr.relation.name == table.name }
+            others = nodes.children.extract! do |node|
+              !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
             end
-            nodes = table.create_and(children)
 
             joins << table.create_join(table, table.create_on(nodes), join_type)
 
@@ -59,14 +59,13 @@ module ActiveRecord
           @table  = tables.first
         end
 
-        private
-          def fetch_arel_attribute(value)
-            case value
-            when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
-              yield value.left.is_a?(Arel::Attributes::Attribute) ? value.left : value.right
-            end
-          end
+        def readonly?
+          return @readonly if defined?(@readonly)
 
+          @readonly = reflection.scope && reflection.scope_for(base_klass.unscoped).readonly_value
+        end
+
+        private
           def append_constraints(join, constraints)
             if join.is_a?(Arel::Nodes::StringJoin)
               join_string = table.create_and(constraints.unshift(join.left))

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -54,8 +54,8 @@ module ActiveRecord
           length = column_names_with_alias.length
 
           while index < length
-            column_name, alias_name = column_names_with_alias[index]
-            hash[column_name] = row[alias_name]
+            column = column_names_with_alias[index]
+            hash[column.name] = row[column.alias]
             index += 1
           end
 

data/lib/active_record/associations/preloader.rb

@@ -88,7 +88,6 @@ module ActiveRecord
         if records.empty?
           []
         else
-          records.uniq!
           Array.wrap(associations).flat_map { |association|
             preloaders_on association, records, preload_scope
           }
@@ -98,34 +97,34 @@ module ActiveRecord
       private
 
         # Loads all the given data into +records+ for the +association+.
-        def preloaders_on(association, records, scope)
+        def preloaders_on(association, records, scope, polymorphic_parent = false)
           case association
           when Hash
-            preloaders_for_hash(association, records, scope)
-          when Symbol
-            preloaders_for_one(association, records, scope)
-          when String
-            preloaders_for_one(association.to_sym, records, scope)
+            preloaders_for_hash(association, records, scope, polymorphic_parent)
+          when Symbol, String
+            preloaders_for_one(association, records, scope, polymorphic_parent)
           else
             raise ArgumentError, "#{association.inspect} was not recognized for preload"
           end
         end
 
-        def preloaders_for_hash(association, records, scope)
+        def preloaders_for_hash(association, records, scope, polymorphic_parent)
           association.flat_map { |parent, child|
-            loaders = preloaders_for_one parent, records, scope
-
-            recs = loaders.flat_map(&:preloaded_records).uniq
-            loaders.concat Array.wrap(child).flat_map { |assoc|
-              preloaders_on assoc, recs, scope
-            }
-            loaders
+            grouped_records(parent, records, polymorphic_parent).flat_map do |reflection, reflection_records|
+              loaders = preloaders_for_reflection(reflection, reflection_records, scope)
+              recs = loaders.flat_map(&:preloaded_records).uniq
+              child_polymorphic_parent = reflection && reflection.options[:polymorphic]
+              loaders.concat Array.wrap(child).flat_map { |assoc|
+                preloaders_on assoc, recs, scope, child_polymorphic_parent
+              }
+              loaders
+            end
           }
         end
 
         # Loads all the given data into +records+ for a singular +association+.
         #
-        # Functions by instantiating a preloader class such as Preloader::HasManyThrough and
+        # Functions by instantiating a preloader class such as Preloader::Association and
         # call the +run+ method for each passed in class in the +records+ argument.
         #
         # Not all records have the same class, so group then preload group on the reflection
@@ -135,24 +134,25 @@ module ActiveRecord
         # Additionally, polymorphic belongs_to associations can have multiple associated
         # classes, depending on the polymorphic_type field. So we group by the classes as
         # well.
-        def preloaders_for_one(association, records, scope)
-          grouped_records(association, records).flat_map do |reflection, klasses|
-            klasses.map do |rhs_klass, rs|
-              loader = preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope)
-              loader.run self
-              loader
+        def preloaders_for_one(association, records, scope, polymorphic_parent)
+          grouped_records(association, records, polymorphic_parent)
+            .flat_map do |reflection, reflection_records|
+              preloaders_for_reflection reflection, reflection_records, scope
             end
+        end
+
+        def preloaders_for_reflection(reflection, records, scope)
+          records.group_by { |record| record.association(reflection.name).klass }.map do |rhs_klass, rs|
+            preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope).run
           end
         end
 
-        def grouped_records(association, records)
+        def grouped_records(association, records, polymorphic_parent)
           h = {}
           records.each do |record|
-            next unless record
-            assoc = record.association(association)
-            next unless assoc.klass
-            klasses = h[assoc.reflection] ||= {}
-            (klasses[assoc.klass] ||= []) << record
+            reflection = record.class._reflect_on_association(association)
+            next if polymorphic_parent && !reflection || !record.association(association).klass
+            (h[reflection] ||= []) << record
           end
           h
         end
@@ -163,13 +163,21 @@ module ActiveRecord
             @reflection = reflection
           end
 
-          def run(preloader); end
+          def run
+            self
+          end
 
           def preloaded_records
-            owners.flat_map { |owner| owner.association(reflection.name).target }
+            @preloaded_records ||= records_by_owner.flat_map(&:last)
+          end
+
+          def records_by_owner
+            @records_by_owner ||= owners.each_with_object({}) do |owner, result|
+              result[owner] = Array(owner.association(reflection.name).target)
+            end
           end
 
-          protected
+          private
             attr_reader :owners, :reflection
         end