activerecord 5.1.0 → 5.2.0.rc1

data/lib/active_record/associations/join_dependency.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
@@ -33,20 +35,14 @@ module ActiveRecord
         end
 
         Table = Struct.new(:node, :columns) do # :nodoc:
-          def table
-            Arel::Nodes::TableAlias.new node.table, node.aliased_table_name
-          end
-
           def column_aliases
-            t = table
+            t = node.table
             columns.map { |column| t[column.name].as Arel.sql column.alias }
           end
         end
         Column = Struct.new(:name, :alias)
       end
 
-      attr_reader :alias_tracker, :base_klass, :join_root
-
       def self.make_tree(associations)
         hash = {}
         walk_tree associations, hash
@@ -92,11 +88,11 @@ module ActiveRecord
       #    associations # => [:appointments]
       #    joins # =>  []
       #
-      def initialize(base, associations, joins, eager_loading: true)
-        @alias_tracker = AliasTracker.create_with_joins(base.connection, base.table_name, joins, base.type_caster)
+      def initialize(base, table, associations, alias_tracker, eager_loading: true)
+        @alias_tracker = alias_tracker
         @eager_loading = eager_loading
         tree = self.class.make_tree associations
-        @join_root = JoinBase.new base, build(tree, base)
+        @join_root = JoinBase.new(base, table, build(tree, base))
         @join_root.children.each { |child| construct_tables! @join_root, child }
       end
 
@@ -104,29 +100,24 @@ module ActiveRecord
         join_root.drop(1).map!(&:reflection)
       end
 
-      def join_constraints(outer_joins, join_type)
+      def join_constraints(joins_to_add, join_type)
         joins = join_root.children.flat_map { |child|
-
-          if join_type == Arel::Nodes::OuterJoin
-            make_left_outer_joins join_root, child
-          else
-            make_inner_joins join_root, child
-          end
+          make_join_constraints(join_root, child, join_type)
         }
 
-        joins.concat outer_joins.flat_map { |oj|
+        joins.concat joins_to_add.flat_map { |oj|
           if join_root.match? oj.join_root
             walk join_root, oj.join_root
           else
             oj.join_root.children.flat_map { |child|
-              make_outer_joins oj.join_root, child
+              make_join_constraints(oj.join_root, child, join_type)
             }
           end
         }
       end
 
       def aliases
-        Aliases.new join_root.each_with_index.map { |join_part, i|
+        @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
           columns = join_part.column_names.each_with_index.map { |column_name, j|
             Aliases::Column.new column_name, "t#{i}_r#{j}"
           }
@@ -134,7 +125,7 @@ module ActiveRecord
         }
       end
 
-      def instantiate(result_set, aliases)
+      def instantiate(result_set, &block)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
         seen = Hash.new { |i, object_id|
@@ -157,7 +148,7 @@ module ActiveRecord
         message_bus.instrument("instantiation.active_record", payload) do
           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)
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
             construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
           }
         end
@@ -165,6 +156,9 @@ module ActiveRecord
         parents.values
       end
 
+      protected
+        attr_reader :alias_tracker, :base_klass, :join_root
+
       private
 
         def make_constraints(parent, child, tables, join_type)
@@ -175,34 +169,23 @@ module ActiveRecord
         end
 
         def make_outer_joins(parent, child)
-          tables    = table_aliases_for(parent, child)
-          join_type = Arel::Nodes::OuterJoin
-          info      = make_constraints parent, child, tables, join_type
-
-          [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
-        end
-
-        def make_left_outer_joins(parent, child)
-          tables    = child.tables
           join_type = Arel::Nodes::OuterJoin
-          info      = make_constraints parent, child, tables, join_type
-
-          [info] + child.children.flat_map { |c| make_left_outer_joins(child, c) }
+          make_join_constraints(parent, child, join_type, true)
         end
 
-        def make_inner_joins(parent, child)
-          tables    = child.tables
-          join_type = Arel::Nodes::InnerJoin
-          info      = make_constraints parent, child, tables, join_type
+        def make_join_constraints(parent, child, join_type, aliasing = false)
+          tables = aliasing ? table_aliases_for(parent, child) : child.tables
+          joins  = make_constraints(parent, child, tables, join_type)
 
-          [info] + child.children.flat_map { |c| make_inner_joins(child, c) }
+          joins.concat child.children.flat_map { |c| make_join_constraints(child, c, join_type, aliasing) }
         end
 
         def table_aliases_for(parent, node)
           node.reflection.chain.map { |reflection|
             alias_tracker.aliased_table_for(
               reflection.table_name,
-              table_alias_for(reflection, parent, reflection != node.reflection)
+              table_alias_for(reflection, parent, reflection != node.reflection),
+              reflection.klass.type_caster
             )
           }
         end
@@ -214,8 +197,7 @@ module ActiveRecord
 
         def table_alias_for(reflection, parent, join)
           name = "#{reflection.plural_name}_#{parent.table_name}"
-          name << "_join" if join
-          name
+          join ? "#{name}_join" : name
         end
 
         def walk(left, right)
@@ -243,7 +225,7 @@ module ActiveRecord
               raise EagerLoadPolymorphicError.new(reflection)
             end
 
-            JoinAssociation.new reflection, build(right, reflection.klass)
+            JoinAssociation.new(reflection, build(right, reflection.klass), alias_tracker)
           end.compact
         end
 
@@ -275,7 +257,8 @@ module ActiveRecord
             else
               model = construct_model(ar_parent, node, row, model_cache, id, aliases)
 
-              if node.reflection.scope_for(node.base_klass).readonly_value
+              if node.reflection.scope &&
+                  node.reflection.scope_for(node.base_klass.unscoped).readonly_value
                 model.readonly!
               end
 

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class Preloader
       class Association #:nodoc:
-        attr_reader :owners, :reflection, :preload_scope, :model, :klass
         attr_reader :preloaded_records
 
         def initialize(klass, owners, reflection, preload_scope)
@@ -11,86 +12,65 @@ module ActiveRecord
           @reflection    = reflection
           @preload_scope = preload_scope
           @model         = owners.first && owners.first.class
-          @scope         = nil
           @preloaded_records = []
         end
 
         def run(preloader)
-          preload(preloader)
-        end
-
-        def preload(preloader)
-          raise NotImplementedError
-        end
-
-        def scope
-          @scope ||= build_scope
-        end
-
-        def records_for(ids)
-          scope.where(association_key_name => ids)
-        end
-
-        def table
-          klass.arel_table
-        end
-
-        # The name of the key on the associated records
-        def association_key_name
-          raise NotImplementedError
-        end
-
-        # This is overridden by HABTM as the condition should be on the foreign_key column in
-        # the join table
-        def association_key
-          klass.arel_attribute(association_key_name, table)
-        end
+          records = load_records do |record|
+            owner = owners_by_key[convert_key(record[association_key_name])]
+            association = owner.association(reflection.name)
+            association.set_inverse_instance(record)
+          end
 
-        # The name of the key on the model which declares the association
-        def owner_key_name
-          raise NotImplementedError
+          owners.each do |owner|
+            associate_records_to_owner(owner, records[convert_key(owner[owner_key_name])] || [])
+          end
         end
 
-        def options
-          reflection.options
-        end
+        protected
+          attr_reader :owners, :reflection, :preload_scope, :model, :klass
 
         private
+          # The name of the key on the associated records
+          def association_key_name
+            reflection.join_primary_key(klass)
+          end
 
-          def associated_records_by_owner(preloader)
-            records = load_records do |record|
-              owner = owners_by_key[convert_key(record[association_key_name])]
-              association = owner.association(reflection.name)
-              association.set_inverse_instance(record)
-            end
+          # The name of the key on the model which declares the association
+          def owner_key_name
+            reflection.join_foreign_key
+          end
 
-            owners.each_with_object({}) do |owner, result|
-              result[owner] = records[convert_key(owner[owner_key_name])] || []
+          def associate_records_to_owner(owner, records)
+            association = owner.association(reflection.name)
+            if reflection.collection?
+              association.loaded!
+              association.target.concat(records)
+            else
+              association.target = records.first
             end
           end
 
           def owner_keys
-            unless defined?(@owner_keys)
-              @owner_keys = owners.map do |owner|
-                owner[owner_key_name]
-              end
-              @owner_keys.uniq!
-              @owner_keys.compact!
-            end
-            @owner_keys
+            @owner_keys ||= owners_by_key.keys
           end
 
           def owners_by_key
             unless defined?(@owners_by_key)
               @owners_by_key = owners.each_with_object({}) do |owner, h|
-                h[convert_key(owner[owner_key_name])] = owner
+                key = convert_key(owner[owner_key_name])
+                h[key] = owner if key
               end
             end
             @owners_by_key
           end
 
           def key_conversion_required?
-            @key_conversion_required ||= association_key_type != owner_key_type
+            unless defined?(@key_conversion_required)
+              @key_conversion_required = (association_key_type != owner_key_type)
+            end
+
+            @key_conversion_required
           end
 
           def convert_key(key)
@@ -102,11 +82,11 @@ module ActiveRecord
           end
 
           def association_key_type
-            @klass.type_for_attribute(association_key_name.to_s).type
+            @klass.type_for_attribute(association_key_name).type
           end
 
           def owner_key_type
-            @model.type_for_attribute(owner_key_name.to_s).type
+            @model.type_for_attribute(owner_key_name).type
           end
 
           def load_records(&block)
@@ -115,54 +95,35 @@ module ActiveRecord
             # Make several smaller queries if necessary or make one query if the adapter supports it
             slices = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
             @preloaded_records = slices.flat_map do |slice|
-              records_for(slice).load(&block)
+              records_for(slice, &block)
             end
             @preloaded_records.group_by do |record|
               convert_key(record[association_key_name])
             end
           end
 
-          def reflection_scope
-            @reflection_scope ||= reflection.scope_for(klass)
+          def records_for(ids, &block)
+            scope.where(association_key_name => ids).load(&block)
           end
 
-          def build_scope
-            scope = klass.unscoped
-
-            values = reflection_scope.values
-            preload_values = preload_scope.values
-
-            scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
-            scope.references_values = Array(values[:references]) + Array(preload_values[:references])
-
-            if preload_values[:select] || values[:select]
-              scope._select!(preload_values[:select] || values[:select])
-            end
-            scope.includes! preload_values[:includes] || values[:includes]
-            if preload_scope.joins_values.any?
-              scope.joins!(preload_scope.joins_values)
-            else
-              scope.joins!(reflection_scope.joins_values)
-            end
-
-            if order_values = preload_values[:order] || values[:order]
-              scope.order!(order_values)
-            end
+          def scope
+            @scope ||= build_scope
+          end
 
-            if preload_values[:reordering] || values[:reordering]
-              scope.reordering_value = true
-            end
+          def reflection_scope
+            @reflection_scope ||= reflection.scope ? reflection.scope_for(klass.unscoped) : klass.unscoped
+          end
 
-            if preload_values[:readonly] || values[:readonly]
-              scope.readonly!
-            end
+          def build_scope
+            scope = klass.scope_for_association
 
-            if options[:as]
-              scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
+            if reflection.type
+              scope.where!(reflection.type => model.base_class.sti_name)
             end
 
-            scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
-            klass.default_scoped.merge(scope)
+            scope.merge!(reflection_scope) if reflection.scope
+            scope.merge!(preload_scope) if preload_scope
+            scope
           end
       end
     end

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

@@ -1,106 +1,105 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class Preloader
-      module ThroughAssociation #:nodoc:
-        def through_reflection
-          reflection.through_reflection
-        end
-
-        def source_reflection
-          reflection.source_reflection
-        end
-
-        def associated_records_by_owner(preloader)
-          preloader.preload(owners,
-                            through_reflection.name,
-                            through_scope)
-
-          through_records = owners.map do |owner|
-            association = owner.association through_reflection.name
-
-            center = target_records_from_association(association)
-            [owner, Array(center)]
-          end
-
-          reset_association owners, through_reflection.name
-
-          middle_records = through_records.flat_map { |(_, rec)| rec }
-
-          preloaders = preloader.preload(middle_records,
-                                         source_reflection.name,
-                                         reflection_scope)
-
+      class ThroughAssociation < Association # :nodoc:
+        def run(preloader)
+          already_loaded     = owners.first.association(through_reflection.name).loaded?
+          through_scope      = through_scope()
+          reflection_scope   = target_reflection_scope
+          through_preloaders = preloader.preload(owners, through_reflection.name, through_scope)
+          middle_records     = through_preloaders.flat_map(&:preloaded_records)
+          preloaders         = preloader.preload(middle_records, source_reflection.name, reflection_scope)
           @preloaded_records = preloaders.flat_map(&:preloaded_records)
 
-          middle_to_pl = preloaders.each_with_object({}) do |pl, h|
-            pl.owners.each { |middle|
-              h[middle] = pl
-            }
-          end
-
-          through_records.each_with_object({}) do |(lhs, center), records_by_owner|
-            pl_to_middle = center.group_by { |record| middle_to_pl[record] }
-
-            records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
-              rhs_records = middles.flat_map { |r|
-                association = r.association source_reflection.name
-
-                target_records_from_association(association)
-              }.compact
-
-              # Respect the order on `reflection_scope` if it exists, else use the natural order.
-              if reflection_scope.values[:order].present?
-                @id_map ||= id_to_index_map @preloaded_records
-                rhs_records.sort_by { |rhs| @id_map[rhs] }
-              else
-                rhs_records
+          owners.each do |owner|
+            through_records = Array(owner.association(through_reflection.name).target)
+            if already_loaded
+              if source_type = reflection.options[:source_type]
+                through_records = through_records.select do |record|
+                  record[reflection.foreign_type] == source_type
+                end
               end
+            else
+              owner.association(through_reflection.name).reset if through_scope
+            end
+            result = through_records.flat_map do |record|
+              association = record.association(source_reflection.name)
+              target = association.target
+              association.reset if preload_scope
+              target
+            end
+            result.compact!
+            if reflection_scope
+              result.sort_by! { |rhs| preload_index[rhs] } if reflection_scope.order_values.any?
+              result.uniq! if reflection_scope.distinct_value
             end
+            associate_records_to_owner(owner, result)
           end
         end
 
         private
-
-          def id_to_index_map(ids)
-            id_map = {}
-            ids.each_with_index { |id, index| id_map[id] = index }
-            id_map
+          def through_reflection
+            reflection.through_reflection
           end
 
-          def reset_association(owners, association_name)
-            should_reset = (through_scope != through_reflection.klass.unscoped) ||
-               (reflection.options[:source_type] && through_reflection.collection?)
+          def source_reflection
+            reflection.source_reflection
+          end
 
-            # Don't cache the association - we would only be caching a subset
-            if should_reset
-              owners.each { |owner|
-                owner.association(association_name).reset
-              }
+          def preload_index
+            @preload_index ||= @preloaded_records.each_with_object({}).with_index do |(id, result), index|
+              result[id] = index
             end
           end
 
           def through_scope
             scope = through_reflection.klass.unscoped
+            options = reflection.options
 
             if options[:source_type]
               scope.where! reflection.foreign_type => options[:source_type]
-            else
-              unless reflection_scope.where_clause.empty?
-                scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
-                scope.where_clause = reflection_scope.where_clause
+            elsif !reflection_scope.where_clause.empty?
+              scope.where_clause = reflection_scope.where_clause
+              values = reflection_scope.values
+
+              if includes = values[:includes]
+                scope.includes!(source_reflection.name => includes)
+              else
+                scope.includes!(source_reflection.name)
               end
 
-              scope.references! reflection_scope.values[:references]
-              if scope.eager_loading? && order_values = reflection_scope.values[:order]
+              if values[:references] && !values[:references].empty?
+                scope.references!(values[:references])
+              else
+                scope.references!(source_reflection.table_name)
+              end
+
+              if joins = values[:joins]
+                scope.joins!(source_reflection.name => joins)
+              end
+
+              if left_outer_joins = values[:left_outer_joins]
+                scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+              end
+
+              if scope.eager_loading? && order_values = values[:order]
                 scope = scope.order(order_values)
               end
             end
 
-            scope
+            scope unless scope.empty_scope?
           end
 
-          def target_records_from_association(association)
-            association.loaded? ? association.target : association.reader
+          def target_reflection_scope
+            if preload_scope
+              reflection_scope.merge(preload_scope)
+            elsif reflection.scope
+              reflection_scope
+            else
+              nil
+            end
           end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     # Implements the details of eager loading of Active Record associations.
@@ -42,20 +44,10 @@ module ActiveRecord
       extend ActiveSupport::Autoload
 
       eager_autoload do
-        autoload :Association,           "active_record/associations/preloader/association"
-        autoload :SingularAssociation,   "active_record/associations/preloader/singular_association"
-        autoload :CollectionAssociation, "active_record/associations/preloader/collection_association"
-        autoload :ThroughAssociation,    "active_record/associations/preloader/through_association"
-
-        autoload :HasMany,             "active_record/associations/preloader/has_many"
-        autoload :HasManyThrough,      "active_record/associations/preloader/has_many_through"
-        autoload :HasOne,              "active_record/associations/preloader/has_one"
-        autoload :HasOneThrough,       "active_record/associations/preloader/has_one_through"
-        autoload :BelongsTo,           "active_record/associations/preloader/belongs_to"
+        autoload :Association,        "active_record/associations/preloader/association"
+        autoload :ThroughAssociation, "active_record/associations/preloader/through_association"
       end
 
-      NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
-
       # Eager loads the named associations for the given Active Record record(s).
       #
       # In this description, 'association name' shall refer to the name passed
@@ -91,14 +83,13 @@ module ActiveRecord
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
       def preload(records, associations, preload_scope = nil)
-        records       = Array.wrap(records).compact.uniq
-        associations  = Array.wrap(associations)
-        preload_scope = preload_scope || NULL_RELATION
+        records = Array.wrap(records).compact
 
         if records.empty?
           []
         else
-          associations.flat_map { |association|
+          records.uniq!
+          Array.wrap(associations).flat_map { |association|
             preloaders_on association, records, preload_scope
           }
         end
@@ -147,7 +138,7 @@ module ActiveRecord
         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, rhs_klass).new(rhs_klass, rs, reflection, scope)
+              loader = preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope)
               loader.run self
               loader
             end
@@ -159,6 +150,7 @@ module ActiveRecord
           records.each do |record|
             next unless record
             assoc = record.association(association)
+            next unless assoc.klass
             klasses = h[assoc.reflection] ||= {}
             (klasses[assoc.klass] ||= []) << record
           end
@@ -166,8 +158,6 @@ module ActiveRecord
         end
 
         class AlreadyLoaded # :nodoc:
-          attr_reader :owners, :reflection
-
           def initialize(klass, owners, reflection, preload_scope)
             @owners = owners
             @reflection = reflection
@@ -178,34 +168,24 @@ module ActiveRecord
           def preloaded_records
             owners.flat_map { |owner| owner.association(reflection.name).target }
           end
-        end
 
-        class NullPreloader # :nodoc:
-          def self.new(klass, owners, reflection, preload_scope); self; end
-          def self.run(preloader); end
-          def self.preloaded_records; []; end
-          def self.owners; []; end
+          protected
+            attr_reader :owners, :reflection
         end
 
         # Returns a class containing the logic needed to load preload the data
-        # and attach it to a relation. For example +Preloader::Association+ or
-        # +Preloader::HasManyThrough+. The class returned implements a `run` method
+        # and attach it to a relation. The class returned implements a `run` method
         # that accepts a preloader.
-        def preloader_for(reflection, owners, rhs_klass)
-          return NullPreloader unless rhs_klass
-
+        def preloader_for(reflection, owners)
           if owners.first.association(reflection.name).loaded?
             return AlreadyLoaded
           end
           reflection.check_preloadable!
 
-          case reflection.macro
-          when :has_many
-            reflection.options[:through] ? HasManyThrough : HasMany
-          when :has_one
-            reflection.options[:through] ? HasOneThrough : HasOne
-          when :belongs_to
-            BelongsTo
+          if reflection.options[:through]
+            ThroughAssociation
+          else
+            Association
           end
         end
     end