Ticket #9640: preload_ar.3.diff

activerecord/test/associations/preload_test.rb

@@ +1 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+require 'fixtures/company'
+require 'fixtures/person'
+require 'fixtures/reader'
+
+class PreloadAssociationTest < Test::Unit::TestCase
+  fixtures :posts, :comments, :authors, :categories, :categories_posts,
+            :companies, :accounts, :tags, :people, :readers
+
+  def test_loading_with_one_association
+    posts = Post.find(:all, :preload => :comments)
+    post = posts.find { |p| p.id == 1 }
+    assert_no_queries do
+      assert_equal 2, post.comments.size
+    end
+    assert post.comments.include?(comments(:greetings))
+
+    post = Post.find(:first, :preload => :comments, :conditions => "posts.title = 'Welcome to the weblog'")
+    assert_equal 2, post.comments.size
+    assert post.comments.include?(comments(:greetings))
+  end
+
+  def test_with_ordering
+    list = Post.find(:all, :preload => :comments, :order => "posts.id DESC")
+    [:eager_other, :sti_habtm, :sti_post_and_comments, :sti_comments,
+     :authorless, :thinking, :welcome
+    ].each_with_index do |post, index|
+      assert_equal posts(post), list[index]
+    end
+  end
+
+  def test_loading_with_multiple_associations
+    posts = Post.find(:all, :preload => [ :comments, :author, :categories ], :order => "posts.id")
+    assert_equal 2, posts.first.comments.size
+    assert_equal 2, posts.first.categories.size
+    assert posts.first.comments.include?(comments(:greetings))
+  end
+
+  def test_loading_from_an_association
+    posts = authors(:david).posts.find(:all, :preload => :comments, :order => "posts.id")
+    assert_equal 2, posts.first.comments.size
+  end
+
+  def test_loading_with_no_associations
+    assert_nil Post.find(posts(:authorless).id, :preload => :author).author
+  end
+
+  def test_eager_association_loading_with_belongs_to
+    comments = Comment.find(:all, :preload => :post)
+    assert_equal 10, comments.length
+    titles = comments.map { |c| c.post.title }
+    assert titles.include?(posts(:welcome).title)
+    assert titles.include?(posts(:sti_post_and_comments).title)
+  end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit
+    comments = Comment.find(:all, :preload => :post, :limit => 5, :order => 'comments.id')
+    assert_equal 5, comments.length
+    assert_equal [1,2,3,5,6], comments.collect { |c| c.id }
+  end
+
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset
+    comments = Comment.find(:all, :preload => :post, :limit => 3, :offset => 2, :order => 'comments.id')
+    assert_equal 3, comments.length
+    assert_equal [3,5,6], comments.collect { |c| c.id }
+  end
+
+  
+  def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
+    posts = Post.find(:all, :preload => [:author, :very_special_comment], :limit => 1, :order => 'posts.id')
+    assert_equal 1, posts.length
+    assert_equal [1], posts.collect { |p| p.id }
+  end
+  
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
+    posts = Post.find(:all, :preload => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id')
+    assert_equal 1, posts.length
+    assert_equal [2], posts.collect { |p| p.id }
+  end
+  
+  def test_eager_association_loading_with_explicit_join
+    posts = Post.find(:all, :preload => :comments, :joins => "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", :limit => 1, :order => 'author_id')
+    assert_equal 1, posts.length
+  end
+  
+  def test_eager_with_has_many_through
+    posts_with_comments = people(:michael).posts.find(:all, :preload => :comments)
+    posts_with_author = people(:michael).posts.find(:all, :preload => :author )
+    posts_with_comments_and_author = people(:michael).posts.find(:all, :preload => [ :comments, :author ])
+    assert_equal 2, posts_with_comments.inject(0) { |sum, post| sum += post.comments.size }
+    assert_equal authors(:david), assert_no_queries { posts_with_author.first.author }
+    assert_equal authors(:david), assert_no_queries { posts_with_comments_and_author.first.author }
+  end
+
+  def test_eager_with_has_many_through_an_sti_join_model
+    author = Author.find(:first, :preload => :special_post_comments, :order => 'authors.id')
+    assert_equal [comments(:does_it_hurt)], assert_no_queries { author.special_post_comments }
+  end
+  
+  def test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both
+    author = Author.find(:first, :preload => :special_nonexistant_post_comments, :order => 'authors.id')
+    assert_equal [], author.special_nonexistant_post_comments
+  end
+
+  def test_eager_with_has_many_through_join_model_with_conditions
+    assert_equal Author.find(:first, :preload => :hello_post_comments,
+                             :order => 'authors.id').hello_post_comments.sort_by(&:id),
+                 Author.find(:first, :order => 'authors.id').hello_post_comments.sort_by(&:id)
+  end
+
+  def test_eager_with_has_many_and_limit
+    posts = Post.find(:all, :order => 'posts.id asc', :preload => [ :author, :comments ], :limit => 2)
+    assert_equal 2, posts.size
+    assert_equal 3, posts.inject(0) { |sum, post| sum += post.comments.size }
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions_array
+    if current_adapter?(:OpenBaseAdapter)
+      posts = Post.find(:all, :preload => [ :author, :comments ], :limit => 2, :conditions => [ "FETCHBLOB(posts.body) = ?", 'hello' ], :order => "posts.id")
+    else
+      posts = Post.find(:all, :preload => [ :author, :comments ], :limit => 2, :conditions => [ "posts.body = ?", 'hello' ], :order => "posts.id")
+    end
+    assert_equal 2, posts.size
+    assert_equal [4,5], posts.collect { |p| p.id }    
+  end
+
+  def test_eager_with_has_many_and_limit_with_no_results
+    posts = Post.find(:all, :preload => [ :author, :comments ], :limit => 2, :conditions => "posts.title = 'magic forest'")
+    assert_equal 0, posts.size
+  end
+  
+  def test_eager_with_has_and_belongs_to_many_and_limit
+    posts = Post.find(:all, :preload => :categories, :order => "posts.id", :limit => 3)
+    assert_equal 3, posts.size
+    assert_equal 2, posts[0].categories.size
+    assert_equal 1, posts[1].categories.size
+    assert_equal 0, posts[2].categories.size
+    assert posts[0].categories.include?(categories(:technology))
+    assert posts[1].categories.include?(categories(:general))
+  end
+
+  def test_eager_association_loading_with_habtm
+    posts = Post.find(:all, :preload => :categories, :order => "posts.id")
+    assert_equal 2, posts[0].categories.size
+    assert_equal 1, posts[1].categories.size
+    assert_equal 0, posts[2].categories.size
+    assert posts[0].categories.include?(categories(:technology))
+    assert posts[1].categories.include?(categories(:general))
+  end
+
+  def test_eager_with_inheritance
+    posts = SpecialPost.find(:all, :preload => [ :comments ])
+  end
+
+  def test_eager_has_one_with_association_inheritance
+    post = Post.find(4, :preload => [ :very_special_comment ])
+    assert_equal "VerySpecialComment", post.very_special_comment.class.to_s
+  end
+
+  def test_eager_has_many_with_association_inheritance
+    post = Post.find(4, :preload => [ :special_comments ])
+    post.special_comments.each do |special_comment|
+      assert_equal "SpecialComment", special_comment.class.to_s
+    end
+  end
+
+  def test_eager_habtm_with_association_inheritance
+    post = Post.find(6, :preload => [ :special_categories ])
+    assert_equal 1, post.special_categories.size
+    post.special_categories.each do |special_category|
+      assert_equal "SpecialCategory", special_category.class.to_s
+    end
+  end
+
+  def test_eager_with_has_one_dependent_does_not_destroy_dependent
+    assert_not_nil companies(:first_firm).account
+    f = Firm.find(:first, :preload => :account,
+            :conditions => ["companies.name = ?", "37signals"])
+    assert_not_nil f.account
+    assert_equal companies(:first_firm, :reload).account, f.account
+  end
+  
+  def test_eager_with_multi_table_conditional_properly_counts_the_records_when_using_size
+    author = authors(:david)
+    posts_with_no_comments = author.posts.select { |post| post.comments.blank? }
+    assert_equal posts_with_no_comments.size, author.posts_with_no_comments.size
+    assert_equal posts_with_no_comments, author.posts_with_no_comments
+  end
+
+  def test_eager_with_invalid_association_reference
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :preload => :monkeys") {
+      post = Post.find(6, :preload=> :monkeys )
+    }
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :preload => :monkeys") {
+      post = Post.find(6, :preload=>[ :monkeys ])
+    }
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :preload => :monkeys") {
+      post = Post.find(6, :preload=>[ 'monkeys' ])
+    }
+    assert_raises(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :preload => :monkeys, :elephants") {
+      post = Post.find(6, :preload=>[ :monkeys, :elephants ])
+    }
+  end
+  
+  def find_all_ordered(className, include=nil)
+    className.find(:all, :order=>"#{className.table_name}.#{className.primary_key}", :preload=>include)
+  end
+    
+  def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
+    # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
+    def assert_equal_after_sort(item1, item2, item3 = nil)
+      assert_equal(item1.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id})
+      assert_equal(item3.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id}) if item3
+    end
+    # Test regular association, association with conditions, association with
+    # STI, and association with conditions assured not to be true
+    post_types = [:posts, :other_posts, :special_posts]
+    # test both has_many and has_and_belongs_to_many
+    [Author, Category].each do |className|
+      d1 = find_all_ordered(className)
+      # test including all post types at once
+      d2 = find_all_ordered(className, post_types) 
+      d1.each_index do |i| 
+        assert_equal(d1[i], d2[i])
+        assert_equal_after_sort(d1[i].posts, d2[i].posts)
+        post_types[1..-1].each do |post_type|
+          # test including post_types together
+          d3 = find_all_ordered(className, [:posts, post_type])
+          assert_equal(d1[i], d3[i])
+          assert_equal_after_sort(d1[i].posts, d3[i].posts)
+          assert_equal_after_sort(d1[i].send(post_type), d2[i].send(post_type), d3[i].send(post_type))
+        end
+      end
+    end
+  end
+  
+  def test_eager_with_multiple_associations_with_same_table_has_one
+    d1 = find_all_ordered(Firm)
+    d2 = find_all_ordered(Firm, :account)
+    d1.each_index do |i| 
+      assert_equal(d1[i], d2[i])
+      assert_equal(d1[i].account, d2[i].account)
+    end
+  end
+  
+  def test_eager_with_multiple_associations_with_same_table_belongs_to
+    firm_types = [:firm, :firm_with_basic_id, :firm_with_other_name, :firm_with_condition]
+    d1 = find_all_ordered(Client)
+    d2 = find_all_ordered(Client, firm_types)
+    d1.each_index do |i| 
+      assert_equal(d1[i], d2[i])
+      firm_types.each { |type| assert_equal(d1[i].send(type), d2[i].send(type)) }
+    end
+  end
+  
+  def test_eager_with_valid_association_as_string_not_symbol
+    assert_nothing_raised { Post.find(:all, :preload => 'comments') }
+  end
+  
+  def test_preload_has_one
+    post = Post.find(posts(:sti_comments).id, :preload => 'very_special_comment', :order => 'id')
+    assert_no_queries {post.very_special_comment.body}
+    assert_equal comments(:eager_sti_on_associations_vs_comment), post.very_special_comment
+  end
+  
+  def test_preload_belongs_to
+    posts = Post.find(:all, :preload => 'author', :order => 'id', :conditions => 'author_id != 0')
+    assert_no_queries {posts.each {|post| post.author.name}}
+    assert_equal authors(:david), posts.first.author
+  end
+  
+  def test_duplicate_middle_objects
+    comments = Comment.find :all, :conditions => 'post_id = 1', :preload => [:post => :author]
+    assert_no_queries do
+      comments.each {|comment| comment.post.author.name}
+    end
+  end
+end

activerecord/test/associations/cascaded_preload_test.rb

@@ +1 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+require 'fixtures/categorization'
+require 'fixtures/company'
+require 'fixtures/topic'
+require 'fixtures/reply'
+
+class CascadedPreloadTest < Test::Unit::TestCase
+  fixtures :authors, :mixins, :companies, :posts, :topics
+
+  def test_eager_association_loading_with_cascaded_two_levels
+    authors = Author.find(:all, :preload=>{:posts=>:comments}, :order=>"authors.id")
+    assert_equal 2, authors.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal 1, authors[1].posts.size
+    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_and_one_level
+    authors = Author.find(:all, :preload=>[{:posts=>:comments}, :categorizations], :order=>"authors.id")
+    assert_equal 2, authors.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal 1, authors[1].posts.size
+    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 1, authors[0].categorizations.size
+    assert_equal 2, authors[1].categorizations.size
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
+    authors = Author.find(:all, :preload=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id")
+    assert_no_queries do
+      assert_equal 2, authors.size
+      assert_equal 5, authors[0].posts.size
+      assert_equal 1, authors[1].posts.size
+      assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    end
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
+    authors = Author.find(:all, :preload=>{:posts=>[:comments, :author]}, :order=>"authors.id")
+    assert_equal 2, authors.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal authors(:david).name, authors[0].name
+    assert_equal [authors(:david).name], authors[0].posts.collect{|post| post.author.name}.uniq
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_with_condition
+    authors = Author.find(:all, :preload=>{:posts=>:comments}, :conditions=>"authors.id=1", :order=>"authors.id")
+    assert_equal 1, authors.size
+    assert_equal 5, authors[0].posts.size
+  end
+
+  def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
+    firms = Firm.find(:all, :preload=>{:account=>{:firm=>:account}}, :order=>"companies.id")
+    assert_equal 2, firms.size
+    assert_equal firms.first.account, firms.first.account.firm.account
+    assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
+    assert_equal companies(:first_firm).account.firm.account, assert_no_queries { firms.first.account.firm.account }
+  end
+
+  def test_eager_association_loading_with_has_many_sti
+    topics = Topic.find(:all, :preload => :replies, :order => 'topics.id')
+    assert_equal topics(:first, :second), topics
+    assert_no_queries do
+      assert_equal 1, topics[0].replies.size
+      assert_equal 0, topics[1].replies.size
+    end
+  end
+
+  def test_eager_association_loading_with_belongs_to_sti
+    replies = Reply.find(:all, :preload => :topic, :order => 'topics.id')
+    assert_equal [topics(:second)], replies
+    assert_equal topics(:first), assert_no_queries { replies.first.topic }
+  end
+
+end
+
+require 'fixtures/vertex'
+require 'fixtures/edge'
+class CascadedPreloadTest < Test::Unit::TestCase
+  fixtures :edges, :vertices
+
+  def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
+    source = Vertex.find(:first, :preload=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id')
+    assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
+    sink = Vertex.find(:first, :preload=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC')
+    assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
+  end
+end

activerecord/lib/active_record/base.rb

@@ -419 +419 @@
-      #   end
-      def find(*args)
-        options = args.extract_options!
+        associations_to_preload = options.delete(:preload)
-        validate_find_options(options)
-        set_readonly_option!(options)
-
-
+results = 
-          when :first then find_initial(options)
-          when :all   then find_every(options)
-          else             find_from_ids(args, options)
-        end
+        if associations_to_preload
+          preload_associations(results, associations_to_preload)
+        end
+        results
-      end
-      
-      # Works like find(:all), but requires a complete SQL string. Examples:
@@ -1649 +1654 @@
-          quoted_value = "'#{quoted_value[1..-2].gsub(/\'/, "\\\\'")}'" if quoted_value.include?("\\\'") # (for ruby mode) " 
-          quoted_value 
-        end
+        
+        #loads the named associations for the activerecord object (or objects) given
+        #
+        #
+        def preload_associations(top_objects, associations)
+          top_objects = [top_objects].flatten.compact
+          case associations
+          when Array then associations.each {|association| preload_associations(top_objects, association)}
+          when Symbol, String then preload_one_association(top_objects, associations.to_sym)
+          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)
+              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
+        
+        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 preload_collection_object(id_to_object_map, reflection_name, associated_object, key)
+          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
+
+        def preload_single_object(id_to_object_map, reflection_name, associated_object, key)
+          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
+        
+        def preload_one_association(top_objects, association) 
+          reflection = reflections[association]
+          raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?" unless reflection
+                    
+          reflection_name = reflection.name
+          options = reflection.options
+          table_name = reflection.klass.table_name
+          primary_key_name = reflection.primary_key_name
+          foreign_key = options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key
+                   
+          #it is not enough to just do  index_by &:id as there could be duplicates (see test_duplicate_middle_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 = top_objects.uniq
+          
+          case reflection.macro
+          when :belongs_to
+            conditions = "t0.#{self.primary_key} IN (?)"
+            conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+            associated_objects = reflection.klass.find(:all, :conditions => [conditions, ids],
+            :joins => "INNER JOIN #{self.table_name} AS t0 ON #{table_name}.#{primary_key} = t0.#{primary_key_name}",
+            :select => "#{options[:select] || table_name+'.*'}, t0.#{self.primary_key} as _parent_object_id",
+            :order => options[:order])
+            associated_objects.each do |associated_object|
+              preload_single_object(id_to_object_map, reflection_name, associated_object, '_parent_object_id')
+            end
+            
+          when :has_one
+            top_objects.each {|object| object.send("set_#{reflection.name}_target", nil)}
+            conditions = "#{table_name}.#{foreign_key} IN (?)"
+            conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+            associated_objects =  reflection.klass.find(:all, :conditions => [conditions, ids],
+            :select => (options[:select] || "#{table_name}.*"),
+            :order => options[:order])
+            associated_objects.each do |associated_object|
+              preload_single_object(id_to_object_map, reflection_name, associated_object, foreign_key)
+            end
+
+          when :has_many
+            top_objects.each {|object| object.send(reflection.name).loaded}
+            
+            if options[:through]
+              through_reflection = reflections[options[:through]]              
+              through_primary_key = through_reflection.primary_key_name
+              top_objects.first.class.preload_one_association(top_objects, options[:through])
+              through_objects = top_objects.compact.map {|object| object.send options[:through]}.flatten
+              
+              unless through_objects.empty?
+                source = reflection.source_reflection.name
+                through_objects.first.class.preload_one_association(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
+              conditions = "#{table_name}.#{foreign_key} IN (?)"
+              conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+              associated_objects =  reflection.klass.find(:all, :conditions => [conditions, ids],
+                                  :select => (options[:select] || "#{table_name}.*"),
+                                  :order => options[:order])
+              associated_objects.each do |associated_object|
+                preload_collection_object(id_to_object_map, reflection_name, associated_object, foreign_key)
+              end
+            end
+          when :has_and_belongs_to_many
+            top_objects.each {|object| object.send(reflection.name).loaded}
+            conditions = "t0.#{reflection.primary_key_name}  IN (?)"
+            conditions << " AND (#{options[:conditions]})" if options[:conditions]
+            associated_objects = reflection.klass.find(:all, :conditions => [conditions, ids],
+            :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])
+            associated_objects.each do |associated_object|
+              preload_collection_object(id_to_object_map, reflection_name, associated_object, '_parent_object_id')
+            end
+          else
+            raise "Unsupported association type #{reflection.name}!"
+          end
+          
+        end
+        
-    end
-
-    public