activerecord 4.1.16 → 4.2.11.3

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   # = Active Record Has Many Through Association
@@ -12,13 +13,14 @@ module ActiveRecord
         @through_association = nil
       end
 
-      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been
-      # loaded and calling collection.size if it has. If it's more likely than not that the collection does
-      # have a size larger than zero, and you need to fetch that collection afterwards, it'll take one fewer
-      # SELECT query if you use #length.
+      # Returns the size of the collection by executing a SELECT COUNT(*) query
+      # if the collection hasn't been loaded, and by calling collection.size if
+      # it has. If the collection will likely have a size greater than zero,
+      # and if fetching the collection will be needed afterwards, one less
+      # SELECT query will be generated by using #length instead.
       def size
         if has_cached_counter?
-          owner.send(:read_attribute, cached_counter_attribute_name)
+          owner._read_attribute cached_counter_attribute_name(reflection)
         elsif loaded?
           target.size
         else
@@ -62,7 +64,16 @@ module ActiveRecord
         end
 
         save_through_record(record)
-        update_counter(1)
+        if has_cached_counter? && !through_reflection_updates_counter_cache?
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Automatic updating of counter caches on through associations has been
+            deprecated, and will be removed in Rails 5. Instead, please set the
+            appropriate `counter_cache` options on the `has_many` and `belongs_to`
+            for your associations to #{through_reflection.name}.
+          MSG
+
+          update_counter_in_database(1)
+        end
         record
       end
 
@@ -72,19 +83,22 @@ module ActiveRecord
           @through_association ||= owner.association(through_reflection.name)
         end
 
-        # We temporarily cache through record that has been build, because if we build a
-        # through record in build_record and then subsequently call insert_record, then we
-        # want to use the exact same object.
+        # The through record (built with build_record) is temporarily cached
+        # so that it may be reused if insert_record is subsequently called.
         #
-        # However, after insert_record has been called, we clear the cache entry because
-        # we want it to be possible to have multiple instances of the same record in an
-        # association
+        # However, after insert_record has been called, the cache is cleared in
+        # order to allow multiple instances of the same record in an association.
         def build_through_record(record)
           @through_records[record.object_id] ||= begin
             ensure_mutable
 
             through_record = through_association.build(*options_for_through_record)
             through_record.send("#{source_reflection.name}=", record)
+
+            if options[:source_type]
+              through_record.send("#{source_reflection.foreign_type}=", options[:source_type])
+            end
+
             through_record
           end
         end
@@ -112,9 +126,9 @@ module ActiveRecord
 
           inverse = source_reflection.inverse_of
           if inverse
-            if inverse.macro == :has_many
+            if inverse.collection?
               record.send(inverse.name) << build_through_record(record)
-            elsif inverse.macro == :has_one
+            elsif inverse.has_one?
               record.send("#{inverse.name}=", build_through_record(record))
             end
           end
@@ -123,7 +137,7 @@ module ActiveRecord
         end
 
         def target_reflection_has_associated_record?
-          !(through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?)
+          !(through_reflection.belongs_to? && owner[through_reflection.foreign_key].blank?)
         end
 
         def update_through_counter?(method)
@@ -137,13 +151,13 @@ module ActiveRecord
           end
         end
 
+        def delete_or_nullify_all_records(method)
+          delete_records(load_target, method)
+        end
+
         def delete_records(records, method)
           ensure_not_nested
 
-          # This is unoptimised; it will load all the target records
-          # even when we just want to delete everything.
-          records = load_target if records == :all
-
           scope = through_association.scope
           scope.where! construct_join_attributes(*records)
 
@@ -152,8 +166,8 @@ module ActiveRecord
             if scope.klass.primary_key
               count = scope.destroy_all.length
             else
-              scope.to_a.each do |record|
-                record.run_callbacks :destroy
+              scope.each do |record|
+                record._run_destroy_callbacks
               end
 
               arel = scope.arel
@@ -177,11 +191,11 @@ module ActiveRecord
             klass.decrement_counter counter, records.map(&:id)
           end
 
-          if through_reflection.macro == :has_many && update_through_counter?(method)
+          if through_reflection.collection? && update_through_counter?(method)
             update_counter(-count, through_reflection)
+          else
+            update_counter(-count)
           end
-
-          update_counter(-count)
         end
 
         def through_records_for(record)
@@ -198,7 +212,7 @@ module ActiveRecord
           records.each do |record|
             through_records = through_records_for(record)
 
-            if through_reflection.macro == :has_many
+            if through_reflection.collection?
               through_records.each { |r| through_association.target.delete(r) }
             else
               if through_records.include?(through_association.target)
@@ -212,13 +226,22 @@ module ActiveRecord
 
         def find_target
           return [] unless target_reflection_has_associated_record?
-          scope.to_a
+          get_records
         end
 
         # NOTE - not sure that we can actually cope with inverses here
         def invertible_for?(record)
           false
         end
+
+        def has_cached_counter?(reflection = reflection())
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
+        end
+
+        def through_reflection_updates_counter_cache?
+          counter_name = cached_counter_attribute_name
+          inverse_updates_counter_named?(counter_name, through_reflection)
+        end
     end
   end
 end

data/lib/active_record/associations/has_one_association.rb

@@ -1,8 +1,8 @@
-
 module ActiveRecord
   # = Active Record Belongs To Has One Association
   module Associations
     class HasOneAssociation < SingularAssociation #:nodoc:
+      include ForeignAssociation
 
       def handle_dependency
         case options[:dependent]

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,39 @@ module ActiveRecord
             end
             scope_chain_index += 1
 
-            scope_chain_items.concat [klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))].compact
+            klass_scope =
+              if klass.current_scope && klass.current_scope.values.blank?
+                klass.unscoped
+              else
+                klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))
+              end
+            scope_chain_items.concat [klass_scope].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 +96,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,13 +142,21 @@ module ActiveRecord
         parents = model_cache[join_root]
         column_aliases = aliases.column_aliases join_root
 
-        result_set.each { |row_hash|
-          parent_key = primary_key ? row_hash[primary_key] : row_hash
-          primary_id = type_caster.type_cast parent_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_key = primary_key ? row_hash[primary_key] : row_hash
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases)
+            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+          }
+        end
+
         parents.values
       end
 
@@ -165,17 +172,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)
@@ -216,8 +223,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
 
@@ -226,6 +234,7 @@ module ActiveRecord
       end
 
       def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        return if ar_parent.nil?
         primary_id  = ar_parent.id
 
         parent.children.each do |node|
@@ -242,7 +251,11 @@ module ActiveRecord
 
           key = aliases.column_alias(node, node.primary_key)
           id = row[key]
-          next if id.nil?
+          if id.nil?
+            nil_association = ar_parent.association(node.reflection.name)
+            nil_association.loaded!
+            next
+          end
 
           model = seen[parent.base_klass][primary_id][node.base_klass][id]
 

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

@@ -104,13 +104,11 @@ module ActiveRecord
         end
 
         def association_key_type
-          column = @klass.column_types[association_key_name.to_s]
-          column && column.type
+          @klass.type_for_attribute(association_key_name.to_s).type
         end
 
         def owner_key_type
-          column = @model.column_types[owner_key_name.to_s]
-          column && column.type
+          @model.type_for_attribute(owner_key_name.to_s).type
         end
 
         def load_slices(slices)
@@ -134,27 +132,32 @@ 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.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[:reordering] || values[:reordering]
+            scope.reordering_value = true
+          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])
+          scope.unscope_values = Array(values[:unscope]) + Array(preload_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, author_id
+    #   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
@@ -151,7 +160,7 @@ module ActiveRecord
         h
       end
 
-      class AlreadyLoaded
+      class AlreadyLoaded # :nodoc:
         attr_reader :owners, :reflection
 
         def initialize(klass, owners, reflection, preload_scope)
@@ -166,7 +175,7 @@ module ActiveRecord
         end
       end
 
-      class NullPreloader
+      class NullPreloader # :nodoc:
         def self.new(klass, owners, reflection, preload_scope); self; end
         def self.run(preloader); end
         def self.preloaded_records; []; end
@@ -178,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

@@ -3,7 +3,7 @@ module ActiveRecord
     class SingularAssociation < Association #:nodoc:
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader(force_reload = false)
-        if force_reload
+        if force_reload && klass
           klass.uncached { reload }
         elsif !loaded? || stale_target?
           reload
@@ -38,8 +38,23 @@ module ActiveRecord
           scope.scope_for_create.stringify_keys.except(klass.primary_key)
         end
 
+        def get_records
+          return scope.limit(1).to_a if skip_statement_cache?
+
+          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

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,14 +13,8 @@ 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!(
               relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
@@ -71,18 +65,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