activerecord 4.1.0 → 4.2.0

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

@@ -21,8 +21,11 @@ module ActiveRecord
           super && reflection == other.reflection
         end
 
+        JoinInformation = Struct.new :joins, :binds
+
         def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
           joins         = []
+          bind_values   = []
           tables        = tables.reverse
 
           scope_chain_index = 0
@@ -34,14 +37,9 @@ module ActiveRecord
             table = tables.shift
             klass = reflection.klass
 
-            case reflection.source_macro
-            when :belongs_to
-              key         = reflection.association_primary_key
-              foreign_key = reflection.foreign_key
-            else
-              key         = reflection.foreign_key
-              foreign_key = reflection.active_record_primary_key
-            end
+            join_keys   = reflection.join_keys(klass)
+            key         = join_keys.key
+            foreign_key = join_keys.foreign_key
 
             constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
@@ -54,27 +52,33 @@ module ActiveRecord
             end
             scope_chain_index += 1
 
-            scope_chain_items.concat [klass.send(:build_default_scope)].compact
+            scope_chain_items.concat [klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))].compact
 
             rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
               left.merge right
             end
 
-            if reflection.type
-              constraint = constraint.and table[reflection.type].eq foreign_klass.base_class.name
-            end
-
             if rel && !rel.arel.constraints.empty?
+              bind_values.concat rel.bind_values
               constraint = constraint.and rel.arel.constraints
             end
 
+            if reflection.type
+              value = foreign_klass.base_class.name
+              column = klass.columns_hash[reflection.type.to_s]
+
+              substitute = klass.connection.substitute_at(column)
+              bind_values.push [column, value]
+              constraint = constraint.and table[reflection.type].eq substitute
+            end
+
             joins << table.create_join(table, table.create_on(constraint), join_type)
 
             # The current table in this iteration becomes the foreign table in the next
             foreign_table, foreign_klass = table, klass
           end
 
-          joins
+          JoinInformation.new joins, bind_values
         end
 
         #  Builds equality condition.
@@ -86,7 +90,7 @@ module ActiveRecord
         #  end
         #
         #  If I execute `Physician.joins(:appointments).to_a` then
-        #    reflection    # => #<ActiveRecord::Reflection::AssociationReflection @macro=:has_many ...>
+        #    klass         # => Physician
         #    table         # => #<Arel::Table @name="appointments" ...>
         #    key           # =>  physician_id
         #    foreign_table # => #<Arel::Table @name="physicians" ...>

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

@@ -19,7 +19,6 @@ module ActiveRecord
 
         def initialize(base_klass, children)
           @base_klass = base_klass
-          @column_names_with_alias = nil
           @children = children
         end
 

data/lib/active_record/associations/join_dependency.rb

@@ -94,7 +94,7 @@ module ActiveRecord
       #
       def initialize(base, associations, joins)
         @alias_tracker = AliasTracker.create(base.connection, joins)
-        @alias_tracker.aliased_name_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
+        @alias_tracker.aliased_table_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
         tree = self.class.make_tree associations
         @join_root = JoinBase.new base, build(tree, base)
         @join_root.children.each { |child| construct_tables! @join_root, child }
@@ -131,7 +131,6 @@ module ActiveRecord
 
       def instantiate(result_set, aliases)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
-        type_caster = result_set.column_type primary_key
 
         seen = Hash.new { |h,parent_klass|
           h[parent_klass] = Hash.new { |i,parent_id|
@@ -143,12 +142,20 @@ module ActiveRecord
         parents = model_cache[join_root]
         column_aliases = aliases.column_aliases join_root
 
-        result_set.each { |row_hash|
-          primary_id = type_caster.type_cast row_hash[primary_key]
-          parent = parents[primary_id] ||= join_root.instantiate(row_hash, column_aliases)
-          construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: join_root.base_klass.name
         }
 
+        message_bus.instrument('instantiation.active_record', payload) do
+          result_set.each { |row_hash|
+            parent = parents[row_hash[primary_key]] ||= join_root.instantiate(row_hash, column_aliases)
+            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+          }
+        end
+
         parents.values
       end
 
@@ -164,17 +171,17 @@ module ActiveRecord
       def make_outer_joins(parent, child)
         tables    = table_aliases_for(parent, child)
         join_type = Arel::Nodes::OuterJoin
-        joins     = make_constraints parent, child, tables, join_type
+        info      = make_constraints parent, child, tables, join_type
 
-        joins.concat child.children.flat_map { |c| make_outer_joins(child, c) }
+        [info] + child.children.flat_map { |c| make_outer_joins(child, c) }
       end
 
       def make_inner_joins(parent, child)
         tables    = child.tables
         join_type = Arel::Nodes::InnerJoin
-        joins     = make_constraints parent, child, tables, join_type
+        info      = make_constraints parent, child, tables, join_type
 
-        joins.concat child.children.flat_map { |c| make_inner_joins(child, c) }
+        [info] + child.children.flat_map { |c| make_inner_joins(child, c) }
       end
 
       def table_aliases_for(parent, node)
@@ -207,7 +214,7 @@ module ActiveRecord
       end
 
       def find_reflection(klass, name)
-        klass.reflect_on_association(name) or
+        klass._reflect_on_association(name) or
           raise ConfigurationError, "Association named '#{ name }' was not found on #{ klass.name }; perhaps you misspelled it?"
       end
 
@@ -215,8 +222,9 @@ module ActiveRecord
         associations.map do |name, right|
           reflection = find_reflection base_klass, name
           reflection.check_validity!
+          reflection.check_eager_loadable!
 
-          if reflection.options[:polymorphic]
+          if reflection.polymorphic?
             raise EagerLoadPolymorphicError.new(reflection)
           end
 

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

@@ -57,9 +57,15 @@ module ActiveRecord
         end
 
         def owners_by_key
-          @owners_by_key ||= owners.group_by do |owner|
-            owner[owner_key_name]
-          end
+          @owners_by_key ||= if key_conversion_required?
+                               owners.group_by do |owner|
+                                 owner[owner_key_name].to_s
+                               end
+                             else
+                               owners.group_by do |owner|
+                                 owner[owner_key_name]
+                               end
+                             end
         end
 
         def options
@@ -93,13 +99,28 @@ module ActiveRecord
           records_by_owner
         end
 
+        def key_conversion_required?
+          association_key_type != owner_key_type
+        end
+
+        def association_key_type
+          @klass.type_for_attribute(association_key_name.to_s).type
+        end
+
+        def owner_key_type
+          @model.type_for_attribute(owner_key_name.to_s).type
+        end
+
         def load_slices(slices)
           @preloaded_records = slices.flat_map { |slice|
             records_for(slice)
           }
 
           @preloaded_records.map { |record|
-            [record, record[association_key_name]]
+            key = record[association_key_name]
+            key = key.to_s if key_conversion_required?
+
+            [record, key]
           }
         end
 
@@ -111,26 +132,28 @@ module ActiveRecord
           scope = klass.unscoped
 
           values         = reflection_scope.values
+          reflection_binds = reflection_scope.bind_values
           preload_values = preload_scope.values
+          preload_binds  = preload_scope.bind_values
 
           scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
           scope.references_values = Array(values[:references]) + Array(preload_values[:references])
+          scope.bind_values       = (reflection_binds + preload_binds)
 
-          scope.select!   preload_values[:select] || values[:select] || table[Arel.star]
+          scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
           scope.includes! preload_values[:includes] || values[:includes]
+          scope.joins! preload_values[:joins] || values[:joins]
+          scope.order! preload_values[:order] || values[:order]
 
-          if preload_values.key? :order
-            scope.order! preload_values[:order]
-          else
-            if values.key? :order
-              scope.order! values[:order]
-            end
+          if preload_values[:readonly] || values[:readonly]
+            scope.readonly!
           end
 
           if options[:as]
             scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
           end
 
+          scope.unscope_values = Array(values[:unscope])
           klass.default_scoped.merge(scope)
         end
       end

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

@@ -23,7 +23,7 @@ module ActiveRecord
 
           reset_association owners, through_reflection.name
 
-          middle_records = through_records.map { |(_,rec)| rec }.flatten
+          middle_records = through_records.flat_map { |(_,rec)| rec }
 
           preloaders = preloader.preload(middle_records,
                                          source_reflection.name,
@@ -63,7 +63,7 @@ module ActiveRecord
           should_reset = (through_scope != through_reflection.klass.unscoped) ||
              (reflection.options[:source_type] && through_reflection.collection?)
 
-          # Dont cache the association - we would only be caching a subset
+          # Don't cache the association - we would only be caching a subset
           if should_reset
             owners.each { |owner|
               owner.association(association_name).reset
@@ -81,10 +81,11 @@ module ActiveRecord
             unless reflection_scope.where_values.empty?
               scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
               scope.where_values    = reflection_scope.values[:where]
+              scope.bind_values     = reflection_scope.bind_values
             end
 
             scope.references! reflection_scope.values[:references]
-            scope.order! reflection_scope.values[:order] if scope.eager_loading?
+            scope = scope.order reflection_scope.values[:order] if scope.eager_loading?
           end
 
           scope

data/lib/active_record/associations/preloader.rb

@@ -2,33 +2,42 @@ module ActiveRecord
   module Associations
     # Implements the details of eager loading of Active Record associations.
     #
-    # Note that 'eager loading' and 'preloading' are actually the same thing.
-    # However, there are two different eager loading strategies.
+    # Suppose that you have the following two Active Record models:
     #
-    # The first one is by using table joins. This was only strategy available
-    # prior to Rails 2.1. Suppose that you have an Author model with columns
-    # 'name' and 'age', and a Book model with columns 'name' and 'sales'. Using
-    # this strategy, Active Record would try to retrieve all data for an author
-    # and all of its books via a single query:
+    #   class Author < ActiveRecord::Base
+    #     # columns: name, age
+    #     has_many :books
+    #   end
     #
-    #   SELECT * FROM authors
-    #   LEFT OUTER JOIN books ON authors.id = books.author_id
-    #   WHERE authors.name = 'Ken Akamatsu'
+    #   class Book < ActiveRecord::Base
+    #     # columns: title, sales
+    #   end
     #
-    # However, this could result in many rows that contain redundant data. After
-    # having received the first row, we already have enough data to instantiate
-    # the Author object. In all subsequent rows, only the data for the joined
-    # 'books' table is useful; the joined 'authors' data is just redundant, and
-    # processing this redundant data takes memory and CPU time. The problem
-    # quickly becomes worse and worse as the level of eager loading increases
-    # (i.e. if Active Record is to eager load the associations' associations as
-    # well).
+    # When you load an author with all associated books Active Record will make
+    # multiple queries like this:
+    #
+    #   Author.includes(:books).where(:name => ['bell hooks', 'Homer').to_a
+    #
+    #   => SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
+    #   => SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
+    #
+    # Active Record saves the ids of the records from the first query to use in
+    # the second. Depending on the number of associations involved there can be
+    # arbitrarily many SQL queries made.
+    #
+    # However, if there is a WHERE clause that spans across tables Active
+    # Record will fall back to a slightly more resource-intensive single query:
+    #
+    #   Author.includes(:books).where(books: {title: 'Illiad'}).to_a
+    #   => SELECT `authors`.`id` AS t0_r0, `authors`.`name` AS t0_r1, `authors`.`age` AS t0_r2,
+    #             `books`.`id`   AS t1_r0, `books`.`title`  AS t1_r1, `books`.`sales` AS t1_r2
+    #      FROM `authors`
+    #      LEFT OUTER JOIN `books` ON `authors`.`id` =  `books`.`author_id`
+    #      WHERE `books`.`title` = 'Illiad'
+    #
+    # This could result in many rows that contain redundant data and it performs poorly at scale
+    # and is therefore only used when necessary.
     #
-    # The second strategy is to use multiple database queries, one for each
-    # level of association. Since Rails 2.1, this is the default strategy. In
-    # situations where a table join is necessary (e.g. when the +:conditions+
-    # option references an association's column), it will fallback to the table
-    # join strategy.
     class Preloader #:nodoc:
       extend ActiveSupport::Autoload
 
@@ -80,7 +89,7 @@ module ActiveRecord
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
 
-      NULL_RELATION = Struct.new(:values).new({})
+      NULL_RELATION = Struct.new(:values, :bind_values).new({}, [])
 
       def preload(records, associations, preload_scope = nil)
         records       = Array.wrap(records).compact.uniq
@@ -112,13 +121,14 @@ module ActiveRecord
       end
 
       def preloaders_for_hash(association, records, scope)
-        parent, child = association.to_a.first # hash should only be of length 1
-
-        loaders = preloaders_for_one parent, records, scope
+        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
+          recs = loaders.flat_map(&:preloaded_records).uniq
+          loaders.concat Array.wrap(child).flat_map { |assoc|
+            preloaders_on assoc, recs, scope
+          }
+          loaders
         }
       end
 
@@ -140,36 +150,14 @@ module ActiveRecord
       end
 
       def grouped_records(association, records)
-        reflection_records = records_by_reflection(association, records)
-
-        reflection_records.each_with_object({}) do |(reflection, r_records),h|
-          h[reflection] = r_records.group_by { |record|
-            association_klass(reflection, record)
-          }
-        end
-      end
-
-      def records_by_reflection(association, records)
-        records.group_by do |record|
-          reflection = record.class.reflect_on_association(association)
-
-          reflection || raise_config_error(record, association)
-        end
-      end
-
-      def raise_config_error(record, association)
-        raise ActiveRecord::ConfigurationError,
-              "Association named '#{association}' was not found on #{record.class.name}; " \
-              "perhaps you misspelled it?"
-      end
-
-      def association_klass(reflection, record)
-        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
-          klass = record.read_attribute(reflection.foreign_type.to_s)
-          klass && klass.constantize
-        else
-          reflection.klass
+        h = {}
+        records.each do |record|
+          next unless record
+          assoc = record.association(association)
+          klasses = h[assoc.reflection] ||= {}
+          (klasses[assoc.klass] ||= []) << record
         end
+        h
       end
 
       class AlreadyLoaded
@@ -190,6 +178,7 @@ module ActiveRecord
       class NullPreloader
         def self.new(klass, owners, reflection, preload_scope); self; end
         def self.run(preloader); end
+        def self.preloaded_records; []; end
       end
 
       def preloader_for(reflection, owners, rhs_klass)
@@ -198,6 +187,7 @@ module ActiveRecord
         if owners.first.association(reflection.name).loaded?
           return AlreadyLoaded
         end
+        reflection.check_preloadable!
 
         case reflection.macro
         when :has_many

data/lib/active_record/associations/singular_association.rb

@@ -18,11 +18,11 @@ module ActiveRecord
       end
 
       def create(attributes = {}, &block)
-        create_record(attributes, &block)
+        _create_record(attributes, &block)
       end
 
       def create!(attributes = {}, &block)
-        create_record(attributes, true, &block)
+        _create_record(attributes, true, &block)
       end
 
       def build(attributes = {})
@@ -38,8 +38,29 @@ module ActiveRecord
           scope.scope_for_create.stringify_keys.except(klass.primary_key)
         end
 
+        def get_records
+          if reflection.scope_chain.any?(&:any?) ||
+              scope.eager_loading? ||
+              klass.current_scope ||
+              klass.default_scopes.any?
+
+            return scope.limit(1).to_a
+          end
+
+          conn = klass.connection
+          sc = reflection.association_scope_cache(conn, owner) do
+            StatementCache.create(conn) { |params|
+              as = AssociationScope.create { params.bind }
+              target_scope.merge(as.scope(self, conn)).limit(1)
+            }
+          end
+
+          binds = AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute binds, klass, klass.connection
+        end
+
         def find_target
-          if record = scope.take
+          if record = get_records.first
             set_inverse_instance record
           end
         end
@@ -52,7 +73,7 @@ module ActiveRecord
           replace(record)
         end
 
-        def create_record(attributes, raise_error = false)
+        def _create_record(attributes, raise_error = false)
           record = build_record(attributes)
           yield(record) if block_given?
           saved = record.save

data/lib/active_record/associations/through_association.rb

@@ -3,7 +3,7 @@ module ActiveRecord
   module Associations
     module ThroughAssociation #:nodoc:
 
-      delegate :source_reflection, :through_reflection, :chain, :to => :reflection
+      delegate :source_reflection, :through_reflection, :to => :reflection
 
       protected
 
@@ -13,10 +13,16 @@ module ActiveRecord
         #   2. To get the type conditions for any STI models in the chain
         def target_scope
           scope = super
-          chain.drop(1).each do |reflection|
+          reflection.chain.drop(1).each do |reflection|
+            relation = reflection.klass.all
+
+            reflection_scope = reflection.scope
+            if reflection_scope && reflection_scope.arity.zero?
+              relation.merge!(reflection_scope)
+            end
+
             scope.merge!(
-              reflection.klass.all.
-                except(:select, :create_with, :includes, :preload, :joins, :eager_load)
+              relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
           end
           scope
@@ -39,12 +45,16 @@ module ActiveRecord
         def construct_join_attributes(*records)
           ensure_mutable
 
-          join_attributes = {
-            source_reflection.foreign_key =>
-              records.map { |record|
-                record.send(source_reflection.association_primary_key(reflection.klass))
-              }
-          }
+          if source_reflection.association_primary_key(reflection.klass) == reflection.klass.primary_key
+            join_attributes = { source_reflection.name => records }
+          else
+            join_attributes = {
+              source_reflection.foreign_key =>
+                records.map { |record|
+                  record.send(source_reflection.association_primary_key(reflection.klass))
+                }
+            }
+          end
 
           if options[:source_type]
             join_attributes[source_reflection.foreign_type] =
@@ -61,18 +71,17 @@ module ActiveRecord
         # Note: this does not capture all cases, for example it would be crazy to try to
         # properly support stale-checking for nested associations.
         def stale_state
-          if through_reflection.macro == :belongs_to
+          if through_reflection.belongs_to?
             owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s
           end
         end
 
         def foreign_key_present?
-          through_reflection.macro == :belongs_to &&
-          !owner[through_reflection.foreign_key].nil?
+          through_reflection.belongs_to? && !owner[through_reflection.foreign_key].nil?
         end
 
         def ensure_mutable
-          if source_reflection.macro != :belongs_to
+          unless source_reflection.belongs_to?
             raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
           end
         end