Ticket #9640: preload_ar.diff

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:
@@ -1640 +1645 @@
-          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 preload_collection_object(id_to_object_map, reflection_name, associated_object, key)
+          association_proxy = id_to_object_map[associated_object[key].to_i].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_single_object(id_to_object_map, reflection_name, associated_object, key)
+          id_to_object_map[associated_object[key].to_i].send("set_#{reflection_name}_target",associated_object)
+        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
+                    
+          id_to_object_map = top_objects.index_by &:id
+          ids = top_objects.collect &:id
+          
+          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|
+                  association_proxy = id_to_object_map[through_object[through_primary_key].to_i].send(reflection_name)
+                  association_proxy.loaded
+                  associated_object = through_object.send(source)
+                  if associated_object.is_a? Array
+                    association_proxy.target.push(*associated_object)
+                  else
+                    association_proxy.target << 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