Ticket #9640: replace_include.diff

activerecord/test/associations/join_model_test.rb

@@ -315 +315 @@
-      assert_equal posts(:welcome, :thinking), tags(:general).taggables
-    end
-    assert_raises ActiveRecord::EagerLoadPolymorphicError do
-
-
+, :conditions => 'bogus_table.column = 1'
+    
-  end
-  
-  def test_has_many_polymorphic_with_source_type
@@ -329 +329 @@
-    assert_no_queries do
-      assert_equal desired, tag_with_include.tagged_posts
-    end
+    assert_equal 4, tag_with_include.taggings.length
-  end
-
-  def test_has_many_through_has_many_find_all
@@ -518 +519 @@
-    assert_equal [comments(:does_it_hurt)], authors(:david).special_post_comments
-  end
-
+  def test_polymorphic_has_many
+    expected = taggings(:welcome_general)
+    p = Post.find(posts(:welcome).id, :include => :taggings)
+    assert_no_queries {assert p.taggings.include?(expected)}
+    assert posts(:welcome).taggings.include?(taggings(:welcome_general))
+  end
+
+  def test_polymorphic_has_one
+    expected = posts(:welcome)
+    
+    tagging  = Tagging.find(taggings(:welcome_general).id, :include => :taggable)
+    assert_no_queries { assert_equal expected, tagging.taggable}
+  end
+
+  def test_polymorphic_belongs_to
+    p = Post.find(posts(:welcome).id, :include => {:taggings => :taggable})
+    assert_no_queries {assert_equal posts(:welcome), p.taggings.first.taggable}
+  end
+
+  def test_preload_polymorphic_has_many_through
+    posts           = Post.find(:all, :order => 'posts.id')
+    posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
+    assert_equal posts.length, posts_with_tags.length
+    posts.length.times do |i|
+      assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
+    end
+  end
+   
+  def test_preload_polymorph_many_types
+    taggings = Tagging.find :all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']
+    assert_no_queries do
+      taggings.first.taggable.id
+      taggings[1].taggable.id
+    end
+    assert_equal items(:dvd), taggings.last.taggable
+    assert_equal posts(:welcome), taggings.first.taggable
+  end
+
+  def test_preload_polymorphic_has_many
+    posts               = Post.find(:all, :order => 'posts.id')
+    posts_with_taggings = Post.find(:all, :include => :taggings, :order => 'posts.id')
+    assert_equal posts.length, posts_with_taggings.length
+    posts.length.times do |i|
+      assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
+    end
+  end
+  
+  def test_belongs_to_shared_parent
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 1')
+    assert_no_queries do
+      assert_equal comments.first.post, comments[1].post
+    end
+  end
+  
-  private
-    # create dynamic Post models to allow different dependency options
-    def find_post_with_dependency(post_id, association, association_name, dependency)

activerecord/test/associations/eager_test.rb

@@ -44 +44 @@
-    assert posts.first.comments.include?(comments(:greetings))
-  end
-
+  def test_duplicate_middle_objects
+    comments = Comment.find :all, :conditions => 'post_id = 1', :include => [:post => :author]
+    assert_no_queries do
+      comments.each {|comment| comment.post.author.name}
+    end
+  end
+
-  def test_loading_from_an_association
-    posts = authors(:david).posts.find(:all, :include => :comments, :order => "posts.id")
-    assert_equal 2, posts.first.comments.size

activerecord/lib/active_record/association_preload.rb

@@ +1 @@
+module ActiveRecord
+  module AssociationPreload
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      #loads the named associations for the activerecord object (or objects) given
+      #preload_options is passed only one level deep: don't pass to the child associations when associations is a Hash
+      #
+      protected
+      def preload_associations(top_objects, associations, preload_options={})
+        top_objects = [top_objects].flatten.compact
+        return if top_objects.empty?
+        case associations
+        when Array then associations.each {|association| preload_associations(top_objects, association, preload_options)}
+        when Symbol, String then preload_one_association(top_objects, associations.to_sym, preload_options)
+        when Hash then
+          associations.each do |parent, child|
+            raise "parent must be an association name" unless parent.is_a?(String) || parent.is_a?(Symbol)
+            preload_associations(top_objects, parent, preload_options)
+            reflection = reflections[parent]
+            parents = top_objects.map {|top_object| top_object.send(reflection.name)}.flatten
+            unless parents.empty?
+              parents.first.class.preload_associations(parents, child)
+            end
+          end
+        end  
+      end
+    
+    
+      private
+    
+      def preload_one_association(top_objects, association, preload_options={}) 
+        reflection = reflections[association]
+        raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?" unless reflection
+      
+        case reflection.macro
+        when :belongs_to
+          preload_belongs_to_association(top_objects, reflection, preload_options)
+        when :has_one
+          preload_has_one_association(top_objects, reflection, preload_options)
+        when :has_many
+          preload_has_many_association(top_objects, reflection, preload_options)
+        when :has_and_belongs_to_many
+          preload_hatbm_association(top_objects, reflection, preload_options)
+        else
+          raise "Unsupported association type #{reflection.name}!"
+        end          
+      end
+    
+      def add_preloaded_object_to_collection(parent_object, reflection_name, associated_object)
+        association_proxy = parent_object.send(reflection_name)
+        association_proxy.loaded
+        if associated_object.is_a? Array
+          association_proxy.target.push(*associated_object)
+        else
+          association_proxy.target << associated_object
+        end
+      end
+
+      def set_association_collection_objects(id_to_object_map, reflection_name, associated_objects, key)
+        associated_objects.each do |associated_object|
+          mapped_objects = id_to_object_map[associated_object[key].to_i]
+          mapped_objects.each do |mapped_object|
+            add_preloaded_object_to_collection(mapped_object, reflection_name, associated_object)
+          end
+        end
+      end
+
+      def set_association_single_objects(id_to_object_map, reflection_name, associated_objects, key)
+        associated_objects.each do |associated_object|
+          mapped_objects = id_to_object_map[associated_object[key].to_i]
+          mapped_objects.each do |mapped_object|
+            mapped_object.send("set_#{reflection_name}_target", associated_object)
+          end
+        end
+      end
+
+      def has_n_preload_conditions(reflection)
+        options = reflection.options
+        if interface = reflection.options[:as]
+          conditions = "#{reflection.klass.table_name}.#{interface}_id IN (?) and #{reflection.klass.table_name}.#{interface}_type = '#{self.name}'"
+        else
+          foreign_key = options[:foreign_key] || reflection.active_record.to_s.foreign_key
+          conditions = "#{reflection.klass.table_name}.#{foreign_key} IN (?)"
+        end
+      end
+
+      def construct_id_map(top_objects)
+        id_to_object_map = {}
+        ids = []
+        top_objects.each do |top_object|
+          ids << top_object.id
+          mapped_objects = (id_to_object_map[top_object.id] ||= [])
+          mapped_objects << top_object
+        end
+        ids.uniq!
+        return id_to_object_map, ids
+      end
+              
+      def preload_hatbm_association(top_objects, reflection, preload_options={})
+        table_name = reflection.klass.table_name
+        id_to_object_map, ids = construct_id_map top_objects
+        top_objects.each {|object| object.send(reflection.name).loaded}
+        options = reflection.options
+
+        conditions = "t0.#{reflection.primary_key_name}  IN (?)"
+        conditions << " AND (#{options[:conditions]})" if options[:conditions]
+        conditions << " AND (#{sanitize_sql preload_options[:conditions]})" if preload_options[:conditions]
+
+        associated_objects = reflection.klass.find(:all, :conditions => [conditions, ids],
+        :include => options[:include],
+        :joins => "INNER JOIN #{options[:join_table]} as t0 ON #{reflection.klass.table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}",
+        :select => "#{options[:select] || table_name+'.*'}, t0.#{reflection.primary_key_name} as _parent_object_id",
+        :order => options[:order])
+
+        set_association_collection_objects(id_to_object_map, reflection.name, associated_objects, '_parent_object_id')
+      end
+
+      def foreign_key_for_preload reflection
+        options = reflection.options
+        if options[:as]
+          foreign_key = "#{options[:as]}_id"
+        else
+          foreign_key = options[:foreign_key] || reflection.active_record.to_s.foreign_key  
+        end          
+      end
+
+      def preload_has_one_association(top_objects, reflection, preload_options={})
+        id_to_object_map, ids = construct_id_map top_objects
+        top_objects.each {|object| object.send("set_#{reflection.name}_target", nil)}
+        options = reflection.options
+        table_name = reflection.klass.table_name
+
+
+        conditions = has_n_preload_conditions(reflection)
+        conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+        conditions << " AND (#{sanitize_sql preload_options[:conditions]})" if preload_options[:conditions]
+        associated_objects =  reflection.klass.find(:all, :conditions => [conditions, ids],
+        :select => (options[:select] || "#{table_name}.*"),
+        :include => options[:include],
+        :order => options[:order])
+        set_association_single_objects(id_to_object_map, reflection.name, associated_objects, foreign_key_for_preload(reflection))
+      end
+
+      def preload_has_many_association(top_objects, reflection, preload_options={})
+        id_to_object_map, ids = construct_id_map top_objects          
+        top_objects.each {|object| object.send(reflection.name).loaded}
+        options = reflection.options
+
+        if options[:through]
+          through_objects = preload_through_objects top_objects, reflection, options[:through]
+          through_reflection = reflections[options[:through]]              
+          through_primary_key = through_reflection.primary_key_name
+          unless through_objects.empty?
+            source = reflection.source_reflection.name
+            through_objects.first.class.preload_associations(through_objects, source)
+            through_objects.compact.each do |through_object|
+              associated_object = through_object.send(source)
+              mapped_objects = id_to_object_map[through_object[through_primary_key].to_i]
+              mapped_objects.each do |mapped_object|
+                add_preloaded_object_to_collection(mapped_object, reflection.name, associated_object)
+              end                  
+            end
+          end
+        else
+          table_name = reflection.klass.table_name
+          conditions = has_n_preload_conditions(reflection)
+          conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+          conditions << " AND (#{sanitize_sql preload_options[:conditions]})" if preload_options[:conditions]
+          associated_objects =  reflection.klass.find(:all, :conditions => [conditions, ids],
+                              :select => (options[:select] || "#{table_name}.*"),
+                              :include => options[:include],
+                              :order => options[:order])
+          set_association_collection_objects(id_to_object_map, reflection.name, associated_objects, foreign_key_for_preload(reflection))
+        end          
+      end
+
+      def preload_through_objects(top_objects, reflection, through_association)
+        through_reflection = reflections[through_association]              
+        through_primary_key = through_reflection.primary_key_name
+        if reflection.options[:source_type]
+          interface = reflection.source_reflection.options[:foreign_type]
+          preload_options = {:conditions => ["#{interface} = ?", reflection.options[:source_type]]}
+
+          top_objects.first.class.preload_associations(top_objects, through_association, preload_options)                  
+          #dont cache the association - we would only be caching a subset
+          through_objects = []
+          top_objects.compact.each do |object|
+            proxy = object.send(through_association)
+            through_objects << proxy.target
+            proxy.reset
+          end
+          through_objects = through_objects.flatten
+        else
+          top_objects.first.class.preload_associations(top_objects, through_association)
+          through_objects = top_objects.compact.map {|object| object.send(through_association)}.flatten
+        end
+      end
+
+
+      def preload_belongs_to_association(top_objects, reflection, preload_options={})
+        options = reflection.options
+        primary_key_name = reflection.primary_key_name
+
+        if options[:polymorphic]
+          polymorph_type = options[:foreign_type]
+          klasses_and_ids = {}
+
+          #construct a mapping from klass to a list of ids to load and a mapping of those ids
+          #back to their parent_objects
+          top_objects.each do |top_object|
+            klass = top_object.send(polymorph_type)
+            klass_id = top_object.send(primary_key_name)
+    
+            id_map = klasses_and_ids[klass] ||= {}
+            id_list_for_klass_id = (id_map[klass_id] ||= [])
+            id_list_for_klass_id << top_object
+          end
+          klasses_and_ids = klasses_and_ids.to_a
+        else
+          id_map = {}
+          top_objects.each do |top_object|
+            mapped_objects = (id_map[top_object.send(primary_key_name)] ||= [])
+            mapped_objects << top_object
+          end
+          klasses_and_ids = [[reflection.klass.name, id_map]]
+        end
+
+        klasses_and_ids.each do |klass_and_id|
+          klass_name, id_map = *klass_and_id
+          klass = klass_name.constantize
+  
+          table_name = klass.table_name
+          conditions = "#{table_name}.#{primary_key} IN (?)"
+          conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+          conditions << " AND (#{sanitize_sql preload_options[:conditions]})" if preload_options[:conditions]
+          associated_objects = klass.find(:all, :conditions => [conditions, id_map.keys.uniq],
+          :include => options[:include],
+          :order => options[:order])
+          set_association_single_objects(id_map, reflection.name, associated_objects, 'id')
+        end
+      end
+    end
+  end
+end

activerecord/lib/active_record/associations.rb

@@ -1330 +1330 @@
-            order_table_name != table_name
-          end
-        end
+        
+        def references_eager_loaded_tables?(options)
+          include_eager_order?(options) || include_eager_conditions?(options)
+        end
-
-        def using_limitable_reflections?(reflections)
-          reflections.reject { |r| [ :belongs_to, :has_one ].include?(r.macro) }.length.zero?

activerecord/lib/active_record/base.rb

@@ -1005 +1005 @@
-        end
-
-        def find_every(options)
-
-
-
+
+
+
+
+
+
+
-
-          records.each { |record| record.readonly! } if options[:readonly]
-

activerecord/lib/active_record.rb

@@ -43 +43 @@
-require 'active_record/callbacks'
-require 'active_record/reflection'
-require 'active_record/associations'
+require 'active_record/association_preload'
-require 'active_record/aggregations'
-require 'active_record/transactions'
-require 'active_record/timestamp'
@@ -63 +64 @@
-  include ActiveRecord::Observing
-  include ActiveRecord::Timestamp
-  include ActiveRecord::Associations
+  include ActiveRecord::AssociationPreload
-  include ActiveRecord::Aggregations
-  include ActiveRecord::Transactions
-  include ActiveRecord::Reflection