Ticket #9640: preload_ar_polymorph.diff

activerecord/test/associations/preload_test.rb

@@ +1 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/tag'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+require 'fixtures/categorization'
+require 'fixtures/tagging'
+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, :taggings, :categorizations, :items
+
+  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
+  
+  def test_finding_with_condition
+    firm = Firm.find(:first, :preload => :clients_like_ms)
+    assert_no_queries do
+      assert_equal "Microsoft", firm.clients_like_ms.first.name
+    end
+  end
+
+  def test_finding_with_condition_hash
+    firm = Firm.find(:first, :preload => :clients_like_ms_with_hash_conditions)
+    assert_no_queries do
+      assert_equal "Microsoft", firm.clients_like_ms_with_hash_conditions.first.name
+    end
+  end
+
+  def test_belongs_to_association_with_preload
+    author = posts(:welcome).author_with_preloaded_posts
+    assert_no_queries do
+      author.posts.length
+    end
+  end
+  
+  def test_has_many_association_with_preload
+    comments = posts(:welcome).comments_with_post
+    comments.length
+    assert_no_queries do
+      comments.each {|comment| comment.post}
+    end
+  end
+  
+  def test_hatbm_association_with_preload
+    categories = posts(:welcome).categories_with_categorizations
+    general= categories.sort_by(&:id).first
+    technology = categories.sort_by(&:id)[1]
+    
+    assert_equal categories(:general), general
+    assert_equal categories(:technology), technology
+    
+    expected = [categorizations(:david_welcome_general), categorizations(:mary_thinking_general)]
+    assert_no_queries do
+      assert_equal [], technology.categorizations
+      assert_equal expected, general.categorizations
+    end
+  end
+  
+  def test_has_one_association_with_preload
+    comment = posts(:sti_comments).very_special_comment_with_preloaded_post
+    assert_no_queries do
+      assert_equal posts(:sti_comments), comment.post
+    end
+  end
+  
+
+  def test_polymorphic_has_many
+    expected = taggings(:welcome_general)
+    p = Post.find(posts(:welcome).id, :preload => :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, :preload => :taggable)
+    assert_no_queries { assert_equal expected, tagging.taggable}
+  end
+
+  def test_polymorphic_belongs_to
+    p = Post.find(posts(:welcome).id, :preload => {: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, :preload => :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, :preload => :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, :preload => :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
+  
+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/test/fixtures/post.rb

@@ -6 +6 @@
-  end
-
-  belongs_to :author_with_posts, :class_name => "Author", :foreign_key => :author_id, :include => :posts
+  belongs_to :author_with_preloaded_posts, :class_name => "Author", :foreign_key => :author_id, :preload => :posts
-
-  has_many   :comments, :order => "body" do
-    def find_most_recent
@@ -15 +16 @@
-
-  has_one  :very_special_comment
-  has_one  :very_special_comment_with_post, :class_name => "VerySpecialComment", :include => :post
+  has_one  :very_special_comment_with_preloaded_post, :class_name => "VerySpecialComment", :preload => :post
-  has_many :special_comments
-
-  has_and_belongs_to_many :categories
-  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
+  has_and_belongs_to_many :categories_with_categorizations, :class_name => "Category", :join_table => "categories_posts", :join_table => "categories_posts",
+                          :association_foreign_key => 'category_id', :preload => :categorizations
-
+  has_many :comments_with_post, :class_name => 'Comment', :preload => :post
+  
-  has_many :taggings, :as => :taggable
-  has_many :tags, :through => :taggings, :include => :tagging do
-    def add_joins_and_select

activerecord/lib/active_record/associations/association_proxy.rb

@@ -114 +114 @@
-            :offset  => @reflection.options[:offset],
-            :joins   => @reflection.options[:joins],
-            :include => @reflection.options[:include],
+            :preload => @reflection.options[:preload],
-            :select  => @reflection.options[:select]
-          )
-        end

activerecord/lib/active_record/associations/belongs_to_association.rb

@@ -44 +44 @@
-          @reflection.klass.find(
-            @owner[@reflection.primary_key_name], 
-            :conditions => conditions,
-
+
+
-          )
-        end
-

activerecord/lib/active_record/associations/has_one_association.rb

@@ -53 +53 @@
-          @reflection.klass.find(:first, 
-            :conditions => @finder_sql, 
-            :order      => @reflection.options[:order], 
-
+
+
-          )
-        end
-

activerecord/lib/active_record/associations.rb

@@ -1166 +1166 @@
-            :uniq,
-            :finder_sql, :counter_sql, 
-            :before_add, :after_add, :before_remove, :after_remove, 
-
+, :preload
-          )
-
-          options[:extend] = create_extension_modules(association_id, extension, options[:extend]) if block_given?
@@ -1176 +1176 @@
-
-        def create_has_one_reflection(association_id, options)
-          options.assert_valid_keys(
-
+, :preload
-          )
-
-          create_reflection(:has_one, association_id, options, self)
@@ -1185 +1185 @@
-        def create_belongs_to_reflection(association_id, options)
-          options.assert_valid_keys(
-            :class_name, :foreign_key, :foreign_type, :remote, :conditions, :order, :include, :dependent, 
-
+, :preload
-          )
-          
-          reflection = create_reflection(:belongs_to, association_id, options, self)
@@ -1204 +1204 @@
-            :uniq, 
-            :finder_sql, :delete_sql, :insert_sql,
-            :before_add, :after_add, :before_remove, :after_remove, 
-
+, :preload
-          )
-
-          options[:extend] = create_extension_modules(association_id, extension, options[:extend]) if block_given?

activerecord/lib/active_record/base.rb

@@ -428 +428 @@
-      #   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:
@@ -1663 +1668 @@
-          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 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.classify.foreign_key
+            conditions = "#{reflection.klass.table_name}.#{foreign_key} IN (?)"
+          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 unless options[:polymorphic]
+          primary_key_name = reflection.primary_key_name
+          foreign_key = options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key
+          if options[:as]
+            foreign_key = "#{options[:as]}_id"
+          end         
+          #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
+            if options[:polymorphic]
+              polymorph_type = options[:foreign_type]
+              klasses = top_objects.map {|object| object.send polymorph_type}.uniq.compact.map &:constantize
+            else
+              klasses = [reflection.klass]
+            end
+            klasses.each do |klass|
+              table_name = klass.table_name
+              conditions = "t0.#{self.primary_key} IN (?)"
+              conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+              
+              joins = "INNER JOIN #{self.table_name} AS t0 ON #{table_name}.#{primary_key} = t0.#{primary_key_name}"
+              if options[:polymorphic]
+                joins << " AND #{polymorph_type} = '#{klass.name}'"
+              end
+              associated_objects = klass.find(:all, :conditions => [conditions, ids],
+              :joins => joins,
+              :preload => options[:preload],
+              :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
+            end
+          when :has_one
+            top_objects.each {|object| object.send("set_#{reflection.name}_target", nil)}
+            conditions = has_n_preload_conditions(reflection)
+            conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+            associated_objects =  reflection.klass.find(:all, :conditions => [conditions, ids],
+            :select => (options[:select] || "#{table_name}.*"),
+            :preload => options[:preload],
+            :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 = has_n_preload_conditions(reflection)
+              conditions << " AND (#{sanitize_sql options[:conditions]})" if options[:conditions]
+              associated_objects =  reflection.klass.find(:all, :conditions => [conditions, ids],
+                                  :select => (options[:select] || "#{table_name}.*"),
+                                  :preload => options[:preload],
+                                  :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],
+            :preload => options[:preload],
+            :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