activerecord 1.10.0 → 1.10.1

data/CHANGELOG

@@ -1,3 +1,12 @@
+*1.10.1* (20th April, 2005)
+
+* Fixed frivilous database queries being triggered with eager loading on empty associations and other things
+
+* Fixed order of loading in eager associations
+
+* Fixed stray comma when using eager loading and ordering together from has_many associations #1143
+
+
 *1.10.0* (19th April, 2005)
 
 * Added eager loading of associations as a way to solve the N+1 problem more gracefully without piggy-back queries. Example:

data/lib/active_record/associations.rb

@@ -121,7 +121,7 @@ module ActiveRecord
     #
     # Consider the following loop using the class above:
     #
-    #   for post in Post.find(:all, :limit => 100)
+    #   for post in Post.find(:all)
     #     puts "Post:            " + post.title
     #     puts "Written by:      " + post.author.name
     #     puts "Last comment on: " + post.comments.first.created_on
@@ -129,20 +129,29 @@ module ActiveRecord
     #
     # To iterate over these one hundred posts, we'll generate 201 database queries. Let's first just optimize it for retrieving the author:
     #
-    #   for post in Post.find(:all, :limit => 100, :include => :author)
+    #   for post in Post.find(:all, :include => :author)
     #
     # This references the name of the belongs_to association that also used the :author symbol, so the find will now weave in a join something
     # like this: LEFT OUTER JOIN authors ON authors.id = posts.author_id. Doing so will cut down the number of queries from 201 to 101.
     #
     # We can improve upon the situation further by referencing both associations in the finder with:
     #
-    #   for post in Post.find(:all, :limit => 100, :include => [ :author, :comments ])
+    #   for post in Post.find(:all, :include => [ :author, :comments ])
     #
     # That'll add another join along the lines of: LEFT OUTER JOIN comments ON comments.post_id = posts.id. And we'll be down to 1 query.
     # But that shouldn't fool you to think that you can pull out huge amounts of data with no performance penalty just because you've reduced
     # the number of queries. The database still needs to send all the data to Active Record and it still needs to be processed. So its no
     # catch-all for performance problems, but its a great way to cut down on the number of queries in a situation as the one described above.
     #
+    # Please note that because eager loading is fetching both models and associations in the same grab, it doesn't make sense to use the
+    # :limit property and it will be ignored if attempted.
+    #
+    # Also have in mind that since the eager loading is pulling from multiple tables, you'll have to disambiguate any column references
+    # in both conditions and orders. So :order => "posts.id DESC" will work while :order => "id DESC" will not. This may require that
+    # you alter the :order and :conditions on the association definitions themselves.
+    #
+    # It's currently not possible to use eager loading on multiple associations from the same table.
+    #
     # == Modules
     #
     # By default, associations will look for objects within the current module scope. Consider:
@@ -684,24 +693,28 @@ module ActiveRecord
           primary_key_table    = generate_primary_key_table(reflections, schema_abbreviations)
 
           rows        = select_all_rows(options, schema_abbreviations, reflections)
-          records     = { }        
+          records, records_in_order     = { }, []
           primary_key = primary_key_table[table_name]
           
           for row in rows
             id = row[primary_key]
-            records[id] ||= instantiate(extract_record(schema_abbreviations, table_name, row))
-          
+            records_in_order << (records[id] = instantiate(extract_record(schema_abbreviations, table_name, row))) unless records[id]
+            record = records[id]
+
             reflections.each do |reflection|
-              next unless row[primary_key_table[reflection.table_name]]
-              
               case reflection.macro
                 when :has_many, :has_and_belongs_to_many
-                  records[id].send(reflection.name)
-                  records[id].instance_variable_get("@#{reflection.name}").target.push(
-                    reflection.klass.send(:instantiate, extract_record(schema_abbreviations, reflection.table_name, row))
-                  )
+                  collection = record.send(reflection.name)
+                  collection.loaded
+
+                  next unless row[primary_key_table[reflection.table_name]]
+
+                  association = reflection.klass.send(:instantiate, extract_record(schema_abbreviations, reflection.table_name, row))                  
+                  collection.target.push(association) unless collection.target.include?(association)
                 when :has_one, :belongs_to
-                  records[id].send(
+                  next unless row[primary_key_table[reflection.table_name]]
+
+                  record.send(
                     "#{reflection.name}=", 
                     reflection.klass.send(:instantiate, extract_record(schema_abbreviations, reflection.table_name, row))
                   )
@@ -709,9 +722,10 @@ module ActiveRecord
             end
           end
           
-          return records.values
+          return records_in_order
         end
 
+
         def reflect_on_included_associations(associations)
           [ associations ].flatten.collect { |association| reflect_on_association(association) }
         end

data/lib/active_record/associations/association_proxy.rb

@@ -32,6 +32,10 @@ module ActiveRecord
         @loaded
       end
       
+      def loaded
+        @loaded = true
+      end
+      
       def target
         @target
       end

data/lib/active_record/associations/has_many_association.rb

@@ -67,7 +67,13 @@ module ActiveRecord
           end
         else
           options[:conditions] = @finder_sql + (options[:conditions] ? " AND #{options[:conditions]}" : "")
-          options[:order] = options[:order] ? "#{options[:order]}, #{@options[:order]}" : @options[:order]
+
+          if options[:order] && @options[:order]
+            options[:order] = "#{options[:order]}, #{@options[:order]}"
+          elsif @options[:order]
+            options[:order] = @options[:order]
+          end
+
           @association_class.find(args.size == 1 ? args.first : args, options)
         end
       end

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.10.0' + PKG_BUILD
+PKG_VERSION   = '1.10.1' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"

data/test/associations_go_eager_test.rb

@@ -17,6 +17,13 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert post.comments.include?(@greetings)
   end
 
+  def test_with_ordering
+    posts = Post.find(:all, :include => :comments, :order => "posts.id DESC")
+    assert_equal @authorless, posts[0]
+    assert_equal @thinking, posts[1]
+    assert_equal @welcome, posts[2]
+  end
+  
   def test_loading_with_multiple_associations
     posts = Post.find(:all, :include => [ :comments, :author, :categories ], :order => "posts.id")
     assert_equal 2, posts.first.comments.size
@@ -25,7 +32,7 @@ class EagerAssociationTest < Test::Unit::TestCase
   end
 
   def test_loading_from_an_association
-    posts = @david.posts.find(:all, :include => :comments)
+    posts = @david.posts.find(:all, :include => :comments, :order => "posts.id")
     assert_equal 2, posts.first.comments.size
   end
 

data/test/fixtures/db_definitions/oci.sql

@@ -199,8 +199,8 @@ create table categories (
 );
 
 create table categories_posts (
-  category_id integer not null references developers initially deferred disable,
-  post_id int integer not null references developers initially deferred disable
+  category_id integer not null references categories initially deferred disable,
+  post_id integer not null references posts initially deferred disable
 );
 
 create table fk_test_has_pk (
@@ -209,5 +209,5 @@ create table fk_test_has_pk (
 
 create table fk_test_has_fk (
   id integer not null primary key,
-  fk_id integer not null references fk_test_has_fk initially deferred disable,
+  fk_id integer not null references fk_test_has_fk initially deferred disable
 );

data/test/fixtures/post.rb

@@ -1,6 +1,6 @@
 class Post < ActiveRecord::Base
   belongs_to :author
-  has_many   :comments
+  has_many   :comments, :order => "body"
   has_and_belongs_to_many :categories
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.8
 specification_version: 1
 name: activerecord
 version: !ruby/object:Gem::Version 
-  version: 1.10.0
-date: 2005-04-19
+  version: 1.10.1
+date: 2005-04-20
 summary: Implements the ActiveRecord pattern for ORM.
 require_paths: 
   - lib