Changeset 3769

Timestamp:

03/04/06 23:33:10 (3 years ago)

Author:

david

Message:

Added cascading eager loading that allows for queries like Author.find(:all, :include=> { :posts=> :comments }), which will fetch all authors, their posts, and the comments belonging to those posts in a single query (using LEFT OUTER JOIN) #3913 [anna@wota.jp]

Files:

• trunk/activerecord/CHANGELOG (modified) (1 diff)
• trunk/activerecord/lib/active_record/associations.rb (modified) (10 diffs)
• trunk/activerecord/test/associations_cascaded_eager_loading_test.rb (added)
• trunk/activerecord/test/associations_go_eager_test.rb (modified) (1 diff)

trunk/activerecord/CHANGELOG

@@ -1 +1 @@
-*SVN*
-
+* Added cascading eager loading that allows for queries like Author.find(:all, :include=> { :posts=> :comments }), which will fetch all authors, their posts, and the comments belonging to those posts in a single query (using LEFT OUTER JOIN) #3913 [anna@wota.jp]. Examples:
+
+    # cascaded in two levels
+    >> Author.find(:all, :include=>{:posts=>:comments})
+    => authors
+         +- posts
+              +- comments
+    
+    # cascaded in two levels and normal association
+    >> Author.find(:all, :include=>[{:posts=>:comments}, :categorizations])
+    => authors
+         +- posts
+              +- comments
+         +- categorizations
+    
+    # cascaded in two levels with two has_many associations
+    >> Author.find(:all, :include=>{:posts=>[:comments, :categorizations]})
+    => authors
+         +- posts
+              +- comments
+              +- categorizations
+    
+    # cascaded in three levels
+    >> Company.find(:all, :include=>{:groups=>{:members=>{:favorites}}})
+    => companies
+         +- groups
+              +- members
+                   +- favorites
+    
-* Make counter cache work when replacing an association #3245 [eugenol@gmail.com]
-

trunk/activerecord/lib/active_record/associations.rb

@@ -782 +782 @@
-        
-        def count_with_associations(options = {})
-reflections = reflect_on_included_associations(
-reflections
+join_dependency = JoinDependency.new(self, 
+join_dependency
-        end
-
-        def find_with_associations(options = {})
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-
-        def configure_dependency_for_has_many(reflection)
@@ -940 +904 @@
-        end
-
-        def guard_against_missing_reflections(reflections, options)
-          reflections.each do |r| 
-            raise(
-              ConfigurationError, 
-              "Association was not found; perhaps you misspelled it?  " +
-              "You specified :include => :#{[options[:include]].flatten.join(', :')}"
-            ) if r.nil? 
-          end
-        end
-        
-        def guard_against_unlimitable_reflections(reflections, options)
-          if (options[:offset] || options[:limit]) && !using_limitable_reflections?(reflections)
@@ -959 +913 @@
-        end
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-          connection.select_all(
-schema_abbreviations, reflections), 
+join_dependency),
-            "#{name} Load Including Associations"
-          )
-        end
-        
-reflections
+join_dependency
-          sql = "SELECT COUNT(DISTINCT #{table_name}.#{primary_key})"
-          
@@ -1003 +929 @@
-          
-          sql << " FROM #{table_name} "
-reflections.collect { |reflection| association_join(reflection) }.to_s
+join_dependency.join_associations.collect{|join| join.association_join }.join
-          sql << "#{options[:joins]} " if options[:joins]
-
-          add_conditions!(sql, options[:conditions])
-reflections
-reflections) if !using_limitable_reflections?(
-
-
+join_dependency
+join_dependency) if !using_limitable_reflections?(join_dependency.
+
+join_dependency.
-
-          if !Base.connection.supports_count_distinct?
@@ -1019 +945 @@
-        end
-
-schema_abbreviations, reflections
-schema_abbreviations
-reflections.collect { |reflection| association_join(reflection) }.to_s
+join_dependency
+join_dependency
+join_dependency.join_associations.collect{|join| join.association_join }.join
-          sql << "#{options[:joins]} " if options[:joins]
- 
-          add_conditions!(sql, options[:conditions])
-reflections
-reflections) if !using_limitable_reflections?(
+join_dependency
+join_dependency) if !using_limitable_reflections?(join_dependency.
-
-          sql << "ORDER BY #{options[:order]} " if options[:order]
- 
-
+join_dependency.
- 
-          return sanitize_sql(sql)
-        end
- 
-reflections
-reflections
+join_dependency
+join_dependency
-            sql << "#{condition_word(sql)} #{table_name}.#{primary_key} IN (#{id_list}) "
-          end
-        end
- 
-reflections
+join_dependency
-          connection.select_values(
-reflections
+join_dependency
-            "#{name} Load IDs For Limited Eager Loading"
-          ).collect { |id| connection.quote(id) }.join(", ")
-        end
- 
-reflections
+join_dependency
-          #sql = "SELECT DISTINCT #{table_name}.#{primary_key} FROM #{table_name} "
-          sql = "SELECT "
@@ -1055 +981 @@
-          
-          if include_eager_conditions?(options) || include_eager_order?(options)
-reflections.collect { |reflection| association_join(reflection) }.to_s
+join_dependency.join_associations.collect{|join| join.association_join }.join
-            sql << "#{options[:joins]} " if options[:joins]
-          end
@@ -1086 +1012 @@
-        end
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-          sti_conditions = reflections.collect do |reflection|
-reflection.klass.send(:type_condition
+join_depended_type_condition(reflection.klass, join_dependency
-          end.compact
-          
@@ -1096 +1047 @@
-        end
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-        end
-
@@ -1134 +1064 @@
-        end
-
-        def extract_record(schema_abbreviations, table_name, row)
-          record = {}
-          row.each do |column, value|
-            prefix, column_name = schema_abbreviations[column]
-            record[column_name] = value if prefix == table_name
-          end
-          return record
-        end        
-
-        def condition_word(sql)
-          sql =~ /where/i ? " AND " : "WHERE "
@@ -1155 +1076 @@
-          
-          extension_module_name.constantize
+        end
+
+        class JoinDependency
+          attr_reader :joins, :reflections
+
+          def initialize(base, associations)
+            @joins                 = [JoinBase.new(base)]
+            @associations          = associations
+            @reflections           = []
+            @base_records_hash     = {}
+            @base_records_in_order = []
+            build(associations)
+          end
+
+          def join_associations
+            @joins[1..-1].to_a
+          end
+
+          def join_base
+            @joins[0]
+          end
+
+          def instantiate(rows)
+            rows.each_with_index do |row, i|
+              primary_id = join_base.record_id(row)
+              unless @base_records_hash[primary_id]
+                @base_records_in_order << (@base_records_hash[primary_id] = join_base.instantiate(row))
+              end
+              construct(@base_records_hash[primary_id], @associations, join_associations.dup, row)
+            end
+            return @base_records_in_order
+          end
+
+          def aliased_table_names_for(table_name)
+            joins.select{|join| join.table_name == table_name }.collect{|join| join.aliased_table_name}
+          end
+
+          protected
+            def build(associations, parent = nil)
+              parent ||= @joins.last
+              case associations
+                when Symbol, String
+                  reflection = parent.reflections[associations.to_s.intern] or
+                  raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
+                  @reflections << reflection
+                  @joins << JoinAssociation.new(reflection, self, parent)
+                when Array
+                  associations.each do |association|
+                    build(association, parent)
+                  end
+                when Hash
+                  associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
+                    build(name, parent)
+                    build(associations[name])
+                  end
+                else
+                  raise ConfigurationError, associations.inspect
+              end
+            end
+
+            def construct(parent, associations, joins, row)
+              case associations
+                when Symbol, String
+                  while (join = joins.shift).reflection.name.to_s != associations.to_s
+                    raise ConfigurationError, "Not Enough Associations" if joins.empty?
+                  end
+                  construct_association(parent, join, row)
+                when Array
+                  associations.each do |association|
+                    construct(parent, association, joins, row)
+                  end
+                when Hash
+                  associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
+                    association = construct_association(parent, joins.shift, row)
+                    construct(association, associations[name], joins, row) if association
+                  end
+                else
+                  raise ConfigurationError, associations.inspect
+              end
+            end
+
+            def construct_association(record, join, row)
+              case join.reflection.macro
+                when :has_many, :has_and_belongs_to_many
+                  collection = record.send(join.reflection.name)
+                  collection.loaded
+    
+                  return nil if record.id.to_s != join.parent.record_id(row).to_s or row[join.aliased_primary_key].nil?
+                  association = join.instantiate(row)
+                  collection.target.push(association) unless collection.target.include?(association)
+                when :has_one, :belongs_to
+                  return if record.id.to_s != join.parent.record_id(row).to_s or row[join.aliased_primary_key].nil?
+                  association = join.instantiate(row)
+                  record.send("set_#{join.reflection.name}_target", association)
+                else
+                  raise ConfigurationError, "unknown macro: #{join.reflection.macro}"
+              end
+              return association
+            end
+
+          class JoinBase
+            attr_reader :active_record
+            delegate    :table_name, :column_names, :primary_key, :reflections, :to=>:active_record
+
+            def initialize(active_record)
+              @active_record = active_record
+              @cached_record = {}
+            end
+
+            def aliased_prefix
+              "t0"
+            end
+
+            def aliased_primary_key
+              "#{ aliased_prefix }_r0"
+            end
+
+            def aliased_table_name
+              active_record.table_name
+            end
+
+            def column_names_with_alias
+              unless @column_names_with_alias
+                @column_names_with_alias = []
+                ([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
+                  @column_names_with_alias << [column_name, "#{ aliased_prefix }_r#{ i }"]
+                end
+              end
+              return @column_names_with_alias
+            end
+
+            def extract_record(row)
+              column_names_with_alias.inject({}){|record, (cn, an)| record[cn] = row[an]; record}
+            end
+
+            def record_id(row)
+              row[aliased_primary_key]
+            end
+
+            def instantiate(row)
+              @cached_record[record_id(row)] ||= active_record.instantiate(extract_record(row))
+            end
+          end
+
+          class JoinAssociation < JoinBase
+            attr_reader :reflection, :parent, :aliased_table_name, :aliased_prefix
+            delegate    :options, :klass, :to=>:reflection
+
+            def initialize(reflection, join_dependency, parent = nil)
+              super(reflection.klass)
+              @parent             = parent
+              @reflection         = reflection
+              @aliased_prefix     = "t#{ join_dependency.joins.size }"
+              @aliased_table_name = join_dependency.aliased_table_names_for(table_name).empty? ? table_name : @aliased_prefix
+            end
+
+            def association_join
+              case reflection.macro
+                when :has_and_belongs_to_many
+                  join_table_name    =
+                  " LEFT OUTER JOIN %s ON %s.%s = %s.%s " % [
+                     options[:join_table], options[:join_table],
+                     options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key,
+                     reflection.active_record.table_name, reflection.active_record.primary_key] +
+                  " LEFT OUTER JOIN %s ON %s.%s = %s.%s " % [
+                     aliased_table_name, aliased_table_name, klass.primary_key,
+                     options[:join_table], options[:association_foreign_key] || klass.table_name.classify.foreign_key
+                     ]
+                when :has_many, :has_one
+                  " LEFT OUTER JOIN %s AS %s ON %s.%s = %s.%s " % [table_name, aliased_table_name,
+                     aliased_table_name, options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key,
+                     parent.aliased_table_name, parent.primary_key
+                    ]
+                when :belongs_to
+                  " LEFT OUTER JOIN %s AS %s ON %s.%s = %s.%s " % [table_name, aliased_table_name,
+                     aliased_table_name, reflection.klass.primary_key,
+                     parent.aliased_table_name, options[:foreign_key] || reflection.klass.to_s.classify.foreign_key
+                    ]
+                else
+                  ""
+              end
+            end
+          end
-        end
-    end

trunk/activerecord/test/associations_go_eager_test.rb

@@ -93 +93 @@
-
-  def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
-
+
+
+
+
+
+
+
-    assert_equal 1, posts.length
-    assert_equal [4], 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, :include => [:author, :very_special_comment], :limit => 1, :offset => 1)
-    assert_equal 0, posts.length
-    assert_equal [], posts
-  end
-