methodmissing-scrooge 2.2.2 → 2.2.3

data/README.textile

@@ -4,49 +4,51 @@ h4. This is a complete rewrite from the initial coverage at "igvita.com":http://
 
 Many thanks to Stephen Sykes ( "pennysmalls.com":http://pennysmalls.com ) for his time spent on shaping, implementing and troubleshooting this release.
 
-An ActiveRecord attribute tracker to ensure production Ruby applications only fetch the database content needed to minimize wire traffic and reduce conversion overheads to native Ruby types.
+An ActiveRecord optimization layer to ensure production Ruby applications only fetch the database content needed to minimize wire traffic, excessive SQL queries and reduce conversion overheads to native Ruby types.
 
 h2. Why bother ?
 
 * Object conversion and moving unnecessary data is both expensive and tax existing infrastructure in high load setups
 * Manually extracting and scoping SELECT clauses is not sustainable in a clean and painless manner with iterative development, even less so in large projects.
+* Preloading associations can be painful - delegate to Scrooge instead.
 
 h2. What it does
 
 <pre>
 <code>
-	Processing HotelsController#show (for 127.0.0.1 at 2009-03-12 14:32:45) [GET]
+	Processing HotelsController#show (for 127.0.0.1 at 2009-03-18 19:29:38) [GET]
 	  Parameters: {"action"=>"show", "id"=>"8699-radisson-hotel-waterfront-cape-town", "controller"=>"hotels"}
 	  Hotel Load Scrooged (0.3ms)   SELECT `hotels`.id FROM `hotels` WHERE (`hotels`.`id` = 8699) 
 	Rendering template within layouts/application
 	Rendering hotels/show
-	  Hotel Load (0.2ms)   SELECT `hotels`.location_id,`hotels`.hotel_name,`hotels`.location,`hotels`.from_price,`hotels`.star_rating,`hotels`.apt,`hotels`.latitude,`hotels`.longitude,`hotels`.distance,`hotels`.narrative,`hotels`.telephone,`hotels`.important_notes,`hotels`.nearest_tube,`hotels`.nearest_rail,`hotels`.created_at,`hotels`.updated_at FROM `hotels` WHERE (`hotels`.`id` = 8699) 
+	  SQL (0.2ms)   SELECT `hotels`.location_id,`hotels`.hotel_name,`hotels`.location,`hotels`.from_price,`hotels`.star_rating,`hotels`.apt,`hotels`.latitude,`hotels`.longitude,`hotels`.distance,`hotels`.narrative,`hotels`.telephone,`hotels`.important_notes,`hotels`.nearest_tube,`hotels`.nearest_rail,`hotels`.created_at,`hotels`.updated_at,`hotels`.id FROM `hotels` WHERE `hotels`.id IN ('8699')
 	  Image Load Scrooged (0.2ms)   SELECT `images`.id FROM `images` WHERE (`images`.hotel_id = 8699) LIMIT 1
-	  Image Load (0.2ms)   SELECT `images`.hotel_id,`images`.title,`images`.url,`images`.width,`images`.height,`images`.thumbnail_url,`images`.thumbnail_width,`images`.thumbnail_height,`images`.has_thumbnail,`images`.created_at,`images`.updated_at FROM `images` WHERE (`images`.`id` = 488) 
+	  SQL (0.2ms)   SELECT `images`.hotel_id,`images`.title,`images`.url,`images`.width,`images`.height,`images`.thumbnail_url,`images`.thumbnail_width,`images`.thumbnail_height,`images`.has_thumbnail,`images`.created_at,`images`.updated_at,`images`.id FROM `images` WHERE `images`.id IN ('488')
 	Rendered shared/_header (0.0ms)
 	Rendered shared/_navigation (0.2ms)
 	  Image Load Scrooged (0.2ms)   SELECT `images`.id FROM `images` WHERE (`images`.hotel_id = 8699) 
-	  CACHE (0.0ms)   SELECT `images`.hotel_id,`images`.title,`images`.url,`images`.width,`images`.height,`images`.thumbnail_url,`images`.thumbnail_width,`images`.thumbnail_height,`images`.has_thumbnail,`images`.created_at,`images`.updated_at FROM `images` WHERE (`images`.`id` = 488) 
-	  Address Columns (44.8ms)   SHOW FIELDS FROM `addresses`
-	  Address Load Scrooged (0.5ms)   SELECT `addresses`.id FROM `addresses` WHERE (`addresses`.hotel_id = 8699) LIMIT 1
-	Rendered hotels/_show_sidebar (49.4ms)
+	  SQL (0.2ms)   SELECT `images`.hotel_id,`images`.title,`images`.url,`images`.width,`images`.height,`images`.thumbnail_url,`images`.thumbnail_width,`images`.thumbnail_height,`images`.has_thumbnail,`images`.created_at,`images`.updated_at,`images`.id FROM `images` WHERE `images`.id IN ('488')
+	  Address Columns (306.2ms)   SHOW FIELDS FROM `addresses`
+	  Address Load Scrooged (3.6ms)   SELECT `addresses`.id FROM `addresses` WHERE (`addresses`.hotel_id = 8699) LIMIT 1
+	Rendered hotels/_show_sidebar (313.2ms)
 	Rendered shared/_footer (0.1ms)
-	Completed in 56ms (View: 8, DB: 46) | 200 OK [http://localhost/hotels/8699-radisson-hotel-waterfront-cape-town]
+	Completed in 320ms (View: 8, DB: 311) | 200 OK [http://localhost/hotels/8699-radisson-hotel-waterfront-cape-town]
 
 
-	Processing HotelsController#show (for 127.0.0.1 at 2009-03-12 14:32:48) [GET]
+	Processing HotelsController#show (for 127.0.0.1 at 2009-03-18 19:29:40) [GET]
 	  Parameters: {"action"=>"show", "id"=>"8699-radisson-hotel-waterfront-cape-town", "controller"=>"hotels"}
 	  Hotel Load Scrooged (0.3ms)   SELECT `hotels`.narrative,`hotels`.from_price,`hotels`.star_rating,`hotels`.hotel_name,`hotels`.id FROM `hotels` WHERE (`hotels`.`id` = 8699) 
+	  Address Load Scrooged (0.2ms)   SELECT `addresses`.id FROM `addresses` WHERE (`addresses`.hotel_id = 8699) 
 	Rendering template within layouts/application
 	Rendering hotels/show
 	  Image Load Scrooged (0.3ms)   SELECT `images`.url,`images`.id,`images`.height,`images`.width FROM `images` WHERE (`images`.hotel_id = 8699) LIMIT 1
-	Rendered shared/_header (0.0ms)
+	Rendered shared/_header (0.1ms)
 	Rendered shared/_navigation (0.2ms)
 	  Image Load Scrooged (0.3ms)   SELECT `images`.thumbnail_width,`images`.id,`images`.thumbnail_height,`images`.thumbnail_url FROM `images` WHERE (`images`.hotel_id = 8699) 
-	  Address Load Scrooged (0.2ms)   SELECT `addresses`.id FROM `addresses` WHERE (`addresses`.hotel_id = 8699) LIMIT 1
-	Rendered hotels/_show_sidebar (1.3ms)
-	Rendered shared/_footer (0.0ms)
-	Completed in 7ms (View: 5, DB: 1) | 200 OK [http://localhost/hotels/8699-radisson-hotel-waterfront-cape-town]	
+	Rendered hotels/_show_sidebar (1.0ms)
+	Rendered shared/_footer (0.1ms)
+	Completed in 8ms (View: 5, DB: 1) | 200 OK [http://localhost/hotels/8699-radisson-hotel-waterfront-cape-town]
+	
 </code>
 </pre>		
 
@@ -184,7 +186,7 @@ Callsites are tracked on a per model ( table name ) basis.
 
 h4. Scope
 
-Only SQL statements that meet the following criteria is considered for optimization :
+Only SQL statements that meet the following criteria is considered for column optimizations :
 
 * A SELECT statement
 
@@ -192,9 +194,16 @@ Only SQL statements that meet the following criteria is considered for optimizat
 
 * The Model has a primary key defined
 
+Only associations that meet the following criteria is associated with a callsite and preloaded
+on subsequent requests :
+
+* Not a polymorphic association
+
+* Not a collection ( has_many etc. )
+
 h4. How it tracks
 
-The ActiveRecord attributes Hash is replaced with a proxy that automatically augments the callsite with any attributes referenced through the Hash lookup keys.
+The ActiveRecord attributes Hash is replaced with a proxy that automatically augments the callsite with any attributes referenced through the Hash lookup keys.We're also able to learn which associations is invoked from a given callsite, for preloading on subsequent requests.
 
 h4. Storage
 
@@ -202,7 +211,7 @@ There's a slight memory hit for each model as the callsites is stored as a class
 
 <pre>
 <code>
-{-113952497=>#<Set: {"User", "Password"}>}	
+#<Scrooge::Callsite:0x3969968 @primary_key="id", @columns=#<Set: {"narrative", "from_price", "star_rating", "hotel_name", "id"}>, @associations=#<Set: {:address}>, @signature=-736202783, @klass=Hotel(id: integer, location_id: integer, hotel_name: string, location: string, from_price: float, star_rating: integer, apt: boolean, latitude: float, longitude: float, distance: float, narrative: text, telephone: string, important_notes: text, nearest_tube: string, nearest_rail: string, created_at: datetime, updated_at: datetime), @inheritance_column="type">
 </code>
 </pre>
 
@@ -216,8 +225,6 @@ h2. Todo
 
 * Test cases for Scrooge::Callsite
 
-* Track both columns AND association invocations off Scrooge::Callsite
-
 * Have invoking Model#attributes not associate all columns with the callsite
 
 * Avoid possible missing attribute exceptions for destroyed objects

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :minor: 2
-:patch: 2
+:patch: 3
 :major: 2

data/lib/callsite.rb

@@ -27,16 +27,34 @@ module Scrooge
       end
     end
     
+    # Diff known associations with given includes
+    #
+    def preload( includes )
+      # Ignore nested includes for the time being
+      #
+      if includes.is_a?(Hash)
+        includes
+      else  
+        @associations.merge( Array(includes) ).to_a
+      end
+    end  
+    
     # Flag an association as seen
     #
     def association!( association )
       Mutex.synchronize do
-        @associations << association
+        @associations << association if preloadable_association?( association )
       end
     end
     
     private
     
+      # Only register associations that isn't polymorphic or a collection
+      #
+      def preloadable_association?( association )
+        @klass.preloadable_associations.include?( association.to_sym )
+      end
+    
       # Is the table a container for STI models ?
       # 
       def inheritable?

data/lib/optimizations/associations/macro.rb

@@ -0,0 +1,129 @@
+module Scrooge
+  module Optimizations 
+    module Associations
+      module Macro
+        
+        class << self
+          
+          # Inject into ActiveRecord
+          #
+          def install!
+            if scrooge_installable?
+              ActiveRecord::Base.send( :extend,  SingletonMethods )
+              ActiveRecord::Base.send( :include, InstanceMethods )              
+            end  
+          end
+      
+          private
+          
+            def scrooge_installable?
+              !ActiveRecord::Base.included_modules.include?( InstanceMethods )
+            end
+         
+        end
+        
+      end
+      
+      module SingletonMethods
+      
+        @@preloadable_associations = {}
+        FindAssociatedRegex = /find_associated_records/
+      
+        def self.extended( base )
+          eigen = class << base; self; end
+          eigen.instance_eval do
+            # Let :scrooge_callsite be a valid find option
+            #
+            remove_const(:VALID_FIND_OPTIONS)
+            const_set( :VALID_FIND_OPTIONS, [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :having, :from, :lock, :scrooge_callsite ] )
+          end
+          eigen.alias_method_chain :find, :scrooge
+          eigen.alias_method_chain :find_every, :scrooge
+        end
+      
+        # Let .find setup callsite information and preloading.
+        #
+        def find_with_scrooge(*args)
+          options = args.extract_options!
+          validate_find_options(options)
+          set_readonly_option!(options)
+
+          if (_caller = caller).grep( FindAssociatedRegex ).empty?
+            cs_signature = callsite_signature( _caller, options.except(:conditions, :limit, :offset) )
+            options[:scrooge_callsite], options[:include] = cs_signature, scrooge_callsite(cs_signature).preload( options[:include] )
+          end
+
+          case args.first
+            when :first then find_initial(options)
+            when :last  then find_last(options)
+            when :all   then find_every(options)
+            else             find_from_ids(args, options)
+          end
+        end
+      
+        # Override find_ever to pass along the callsite signature
+        #
+        def find_every_with_scrooge(options)
+          include_associations = merge_includes(scope(:find, :include), options[:include])
+
+          if include_associations.any? && references_eager_loaded_tables?(options)
+            records = find_with_associations(options)
+          else
+            records = find_by_sql(construct_finder_sql(options), options[:scrooge_callsite])
+            if include_associations.any?
+              preload_associations(records, include_associations)
+            end
+          end
+
+          records.each { |record| record.readonly! } if options[:readonly]
+
+          records
+        end      
+        
+        # Let's not preload polymorphic associations or collections
+        #      
+        def preloadable_associations
+          @@preloadable_associations[self.name] ||= reflect_on_all_associations.reject{|a| a.options[:polymorphic] || a.macro == :has_many }.map{|a| a.name }
+        end              
+              
+      end
+      
+      module InstanceMethods
+                
+        # Association getter with Scrooge support
+        #
+        def association_instance_get(name)
+          association = instance_variable_get("@#{name}")
+          if association.respond_to?(:loaded?)
+            scrooge_seen_association!( name )
+            association
+          end
+        end
+
+        # Association setter with Scrooge support
+        #
+        def association_instance_set(name, association)
+          scrooge_seen_association!( name )
+          instance_variable_set("@#{name}", association)
+        end
+        
+        # Register an association with Scrooge
+        #
+        def scrooge_seen_association!( association )
+          if scrooged? && !scrooge_seen_association?( association )
+            @attributes.scrooge_associations << association
+            self.class.scrooge_callsite( @attributes.callsite_signature ).association!( association ) 
+          end
+        end
+        
+        private
+        
+          def scrooge_seen_association?( association )
+            @attributes.scrooge_associations.include?( association )
+          end
+        
+      end
+      
+    end
+  end
+end      

data/lib/optimizations/columns/attributes_proxy.rb

@@ -18,6 +18,12 @@ module Scrooge
         end
 
         alias_method :merge!, :update
+        
+        # Don't try to reload one of these
+        #
+        def fully_fetched
+          true
+        end
       end
 
       class ScroogedAttributes < Hash
@@ -25,14 +31,16 @@ module Scrooge
         # Hash container for attributes with scrooge monitoring of attribute access
         #        
 
-        attr_accessor :callsite_signature, :scrooge_columns, :fully_fetched, :klass
+        attr_accessor :callsite_signature, :scrooge_columns, :scrooge_associations, :fully_fetched, :klass, :updateable_result_set
 
-        def self.setup(record, scrooge_columns, klass, callsite_signature)
+        def self.setup(record, scrooge_columns, scrooge_associations, klass, callsite_signature, updateable_result_set)
           hash = new.replace(record)
           hash.scrooge_columns = scrooge_columns.dup
+          hash.scrooge_associations = scrooge_associations.dup
           hash.fully_fetched = false
           hash.klass = klass
           hash.callsite_signature = callsite_signature
+          hash.updateable_result_set = updateable_result_set
           hash
         end
 
@@ -115,18 +123,10 @@ module Scrooge
         protected
 
           def fetch_remaining!( columns_to_fetch )
-            begin
-              remaining_attributes = fetch_record_with_remaining_columns( columns_to_fetch )
-            rescue ActiveRecord::RecordNotFound
-              raise ActiveRecord::MissingAttributeError, "scrooge cannot fetch missing attribute(s) #{columns_to_fetch.to_a.join(', ')} because record went away"
-            end
-            replace(remaining_attributes.merge(self))
+            @updateable_result_set.updaters_attributes = self  # for after_initialize & after_find
+            @updateable_result_set.reload_columns!(columns_to_fetch)
           end
-
-          def fetch_record_with_remaining_columns( columns_to_fetch )
-            @klass.scrooge_reload(self[@klass.primary_key], columns_to_fetch)
-          end
-
+          
           def interesting_for_scrooge?( attr_s )
             has_key?(attr_s) && !@scrooge_columns.include?(attr_s)
           end
@@ -135,11 +135,16 @@ module Scrooge
             @klass.scrooge_seen_column!(callsite_signature, attr_s)
           end
 
+          def primary_key_name
+            @klass.primary_key
+          end
+
           def dup_self
             @scrooge_columns = @scrooge_columns.dup
+            @scrooge_associations = @scrooge_associations.dup
             self
           end
       end
     end
   end
-end    
+end    

data/lib/optimizations/columns/macro.rb

@@ -9,15 +9,15 @@ module Scrooge
           #
           def install!
             if scrooge_installable?
-              ActiveRecord::Base.send( :extend,  Scrooge::Optimizations::Columns::SingletonMethods )
-              ActiveRecord::Base.send( :include, Scrooge::Optimizations::Columns::InstanceMethods )              
+              ActiveRecord::Base.send( :extend,  SingletonMethods )
+              ActiveRecord::Base.send( :include, InstanceMethods )              
             end  
           end
       
           private
           
             def scrooge_installable?
-              !ActiveRecord::Base.included_modules.include?( Scrooge::Optimizations::Columns::InstanceMethods )
+              !ActiveRecord::Base.included_modules.include?( InstanceMethods )
             end
          
         end
@@ -54,9 +54,9 @@ module Scrooge
         # Efficient reloading - get the hash with missing attributes directly from the 
         # underlying connection.
         #
-        def scrooge_reload( p_key, missing_columns )
-          attributes = connection.send( :select, "SELECT #{scrooge_select_sql(missing_columns)} FROM #{quoted_table_name} WHERE #{quoted_table_name}.#{primary_key} = '#{p_key}'" ).first
-          attributes ? attributes : raise( ActiveRecord::RecordNotFound )
+        def scrooge_reload( p_keys, missing_columns )
+          sql_keys = p_keys.collect{|pk| "'#{pk}'"}.join(ScroogeComma)
+          connection.send( :select, "SELECT #{scrooge_select_sql(missing_columns)} FROM #{quoted_table_name} WHERE #{quoted_table_name}.#{primary_key} IN (#{sql_keys})" )
         end
         
         private
@@ -71,34 +71,39 @@ module Scrooge
         
           # Find through callsites.
           #
-          def find_by_sql_with_scrooge( sql )
-            callsite_signature = (caller[ActiveRecord::Base::ScroogeCallsiteSample] << callsite_sql( sql )).hash
-            callsite_set = scrooge_callsite(callsite_signature).columns
-            sql = sql.gsub(scrooge_select_regex, "SELECT #{scrooge_select_sql(callsite_set)} FROM")
-            result = connection.select_all(sanitize_sql(sql), "#{name} Load Scrooged").collect! do |record|
-              instantiate( Scrooge::Optimizations::Columns::ScroogedAttributes.setup(record, callsite_set, self, callsite_signature) )
+          def find_by_sql_with_scrooge( sql, callsite_sig = nil )
+            callsite_sig ||= callsite_signature( caller, callsite_sql( sql ) )
+            callsite_columns = scrooge_callsite(callsite_sig).columns
+            callsite_associations = scrooge_callsite(callsite_sig).associations
+            sql = sql.gsub(scrooge_select_regex, "SELECT #{scrooge_select_sql(callsite_columns)} FROM")
+            results = connection.select_all(sanitize_sql(sql), "#{name} Load Scrooged")
+            result_set = ResultSets::ResultArray.new
+            updateable = ResultSets::UpdateableResultSet.new(result_set, self)
+            results.inject(result_set) do |memo, record|
+              memo << instantiate(ScroogedAttributes.setup(record, callsite_columns, callsite_associations, self, callsite_sig, updateable))
             end
-          end        
+          end
         
-          def find_by_sql_without_scrooge( sql )
-            result = connection.select_all(sanitize_sql(sql), "#{name} Load").collect! do |record|
-              instantiate( Scrooge::Optimizations::Columns::UnscroogedAttributes.setup(record) )
+          def find_by_sql_without_scrooge( sql, callsite = nil )
+            scrooge_unlink_callsite!( callsite ) if callsite
+            connection.select_all(sanitize_sql(sql), "#{name} Load").collect! do |record|
+              instantiate( UnscroogedAttributes.setup(record) )
             end
           end
-          
-            # Generate a regex that respects the table name as well to catch
-            # verbose SQL from JOINS etc.
-            # 
-            def scrooge_select_regex
-              @@scrooge_select_regexes[self.table_name] ||= Regexp.compile( "SELECT (`?(?:#{table_name})?`?.?\\*) FROM" )
-            end
 
-            # Trim any conditions
-            #
-            def callsite_sql( sql )
-              sql.gsub(ScroogeRegexSanitize, ScroogeBlankString)
-            end
-                    
+          # Generate a regex that respects the table name as well to catch
+          # verbose SQL from JOINS etc.
+          # 
+          def scrooge_select_regex
+            @@scrooge_select_regexes[self.table_name] ||= Regexp.compile( "SELECT (`?(?:#{table_name})?`?.?\\*) FROM" )
+          end
+
+          # Trim any conditions
+          #
+          def callsite_sql( sql )
+            sql.gsub(ScroogeRegexSanitize, ScroogeBlankString)
+          end
+
       end
       
       module InstanceMethods
@@ -108,12 +113,13 @@ module Scrooge
           base.alias_method_chain :destroy, :scrooge
           base.alias_method_chain :respond_to?, :scrooge
           base.alias_method_chain :attributes_from_column_definition, :scrooge
+          base.alias_method_chain :becomes, :scrooge
         end
         
         # Is this instance being handled by scrooge?
         #
         def scrooged?
-          @attributes.is_a?(Scrooge::Optimizations::Columns::ScroogedAttributes)
+          @attributes.is_a?(ScroogedAttributes)
         end        
         
         # Delete should fully load all the attributes before the @attributes hash is frozen
@@ -132,17 +138,13 @@ module Scrooge
         
         # Augment callsite info for new model class when using STI
         #
-        def becomes(klass)
-          returning klass.new do |became|
-            became.instance_variable_set("@attributes", @attributes)
-            became.instance_variable_set("@attributes_cache", @attributes_cache)
-            became.instance_variable_set("@new_record", new_record?)
-            if scrooged?
-              self.class.scrooge_callsite(@attributes.callsite_signature).columns.each do |attrib|
-                became.class.scrooge_seen_column!(@attributes.callsite_signature, attrib)
-              end
+        def becomes_with_scrooge(klass)
+          if scrooged?
+            self.class.scrooge_callsite(@attributes.callsite_signature).columns.each do |attrib|
+              klass.scrooge_seen_column!(@attributes.callsite_signature, attrib)
             end
           end
+          becomes_without_scrooge(klass)
         end     
 
         # Marshal
@@ -150,6 +152,7 @@ module Scrooge
         #
         def _dump(depth)
           scrooge_fetch_remaining
+          scrooge_invalidate_updateable_result_set
           scrooge_dump_flag_this
           str = Marshal.dump(self)
           scrooge_dump_unflag_this
@@ -194,6 +197,12 @@ module Scrooge
             @attributes.fetch_remaining if scrooged?
           end
           
+          # Dumped objects should not contain object_ids of old result sets
+          #
+          def scrooge_invalidate_updateable_result_set
+            @attributes.updateable_result_set = ResultSets::UpdateableResultSet.new(nil, self) if scrooged?
+          end
+          
           # New objects should get an UnscroogedAttributes as their @attributes hash
           #
           def attributes_from_column_definition_with_scrooge
@@ -204,4 +213,4 @@ module Scrooge
       
     end
   end
-end
+end

data/lib/optimizations/result_sets/result_array.rb

@@ -0,0 +1,9 @@
+module Scrooge
+  module Optimizations
+    module ResultSets
+      class ResultArray < Array
+        attr_accessor :unique_id
+      end
+    end
+  end
+end

data/lib/optimizations/result_sets/updateable_result_set.rb

@@ -0,0 +1,85 @@
+module Scrooge
+  module Optimizations
+    module ResultSets
+      class UpdateableResultSet
+        
+        # Contains a weak referernce to the result set, and can update from DB
+        #
+        
+        attr_accessor :updaters_attributes
+        
+        def initialize(result_set_array, klass)
+          if result_set_array
+            @result_set_object_id = result_set_array.object_id
+            @unique_id = result_set_array.unique_id ||= "#{Time.now.to_f}#{object_id}"  # avoid recycled object ids
+          end
+          @klass = klass  # expected class of items in the array
+        end
+        
+        def reload_columns!(columns_to_fetch)
+          reloaded_columns = hash_by_primary_key(reload_columns_for_ids(columns_to_fetch, result_set_ids))
+          if !reloaded_columns.has_key?(@updaters_attributes[primary_key_name])
+            raise ActiveRecord::MissingAttributeError, "scrooge cannot fetch missing attribute(s) #{columns_to_fetch.to_a.join(', ')} because record went away"
+          else
+            update_with(reloaded_columns)
+          end
+        end
+
+        def reload_columns_for_ids(columns_to_fetch, result_ids_to_fetch)
+          @klass.scrooge_reload(result_ids_to_fetch, columns_to_fetch + [primary_key_name])
+        end
+
+        def result_set_attributes
+          rs = result_set
+          return default_attributes unless rs
+          rs.inject(default_attributes) do |memo, r|
+            if r.is_a?(@klass)
+              memo << r.instance_variable_get(:@attributes)
+            end
+            memo
+          end.uniq
+        end
+        
+        def result_set
+          return nil unless @result_set_object_id
+          result_set = ObjectSpace._id2ref(@result_set_object_id)
+          result_set.is_a?(ResultArray) && result_set.unique_id == @unique_id ? result_set : nil
+        rescue RangeError
+          nil
+        end
+        
+        def default_attributes
+          [@updaters_attributes]
+        end
+        
+        def result_set_ids
+          result_set_attributes.inject([]) do |memo, attributes|
+            unless attributes.fully_fetched
+              memo << attributes[primary_key_name]
+            end
+            memo
+          end
+        end
+        
+        def update_with(remaining_attributes)
+          current_attributes = hash_by_primary_key(result_set_attributes)
+          remaining_attributes.each do |r_id, r_att|
+            old_attributes = current_attributes[r_id]
+            if old_attributes
+              old_attributes.update(r_att.merge(old_attributes))
+            end
+          end
+        end
+        
+        def hash_by_primary_key(rows)
+          rows.inject({}) {|memo, row| memo[row[primary_key_name]] = row; memo}
+        end
+        
+        def primary_key_name
+          @klass.primary_key
+        end
+        
+      end
+    end
+  end
+end

data/lib/scrooge.rb

@@ -4,6 +4,9 @@ require 'set'
 require 'callsite'
 require 'optimizations/columns/attributes_proxy'
 require 'optimizations/columns/macro'
+require 'optimizations/associations/macro'
+require 'optimizations/result_sets/updateable_result_set'
+require 'optimizations/result_sets/result_array'
 
 module ActiveRecord
   class Base
@@ -12,15 +15,15 @@ module ActiveRecord
     ScroogeCallsiteSample = 0..10
 
     class << self
-
+      
       # Determine if a given SQL string is a candidate for callsite <=> columns
       # optimization.
       #     
-      def find_by_sql(sql)
+      def find_by_sql(sql, callsite_signature = nil)
         if scope_with_scrooge?(sql)
-          find_by_sql_with_scrooge(sql)
+          find_by_sql_with_scrooge(sql, callsite_signature)
         else
-          find_by_sql_without_scrooge(sql)
+          find_by_sql_without_scrooge(sql, callsite_signature)
         end
       end
       
@@ -45,6 +48,12 @@ module ActiveRecord
 
       private
 
+        # Removes a single callsite
+        #
+        def scrooge_unlink_callsite!( callsite_signature )
+          @@scrooge_callsites.delete(callsite_signature)  
+        end 
+
         # Initialize a callsite
         #
         def callsite( signature )
@@ -56,10 +65,18 @@ module ActiveRecord
         def attribute_with_table( attr_name )
           "#{quoted_table_name}.#{attr_name.to_s}"
         end
+        
+        # Computes a unique signature from a given call stack and supplementary
+        # context information.
+        #
+        def callsite_signature( call_stack, supplementary )
+          ( call_stack[ScroogeCallsiteSample] << supplementary ).hash
+        end
 
     end  # class << self
 
   end
 end
 
-Scrooge::Optimizations::Columns::Macro.install!
+Scrooge::Optimizations::Columns::Macro.install!
+Scrooge::Optimizations::Associations::Macro.install!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: methodmissing-scrooge
 version: !ruby/object:Gem::Version 
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors: 
 - "Lourens Naud\xC3\xA9"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-16 00:00:00 -07:00
+date: 2009-03-18 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -20,9 +20,8 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README
-- README.textile
+extra_rdoc_files: []
+
 files: 
 - Rakefile
 - README
@@ -30,9 +29,14 @@ files:
 - VERSION.yml
 - lib/callsite.rb
 - lib/optimizations
+- lib/optimizations/associations
+- lib/optimizations/associations/macro.rb
 - lib/optimizations/columns
 - lib/optimizations/columns/attributes_proxy.rb
 - lib/optimizations/columns/macro.rb
+- lib/optimizations/result_sets
+- lib/optimizations/result_sets/result_array.rb
+- lib/optimizations/result_sets/updateable_result_set.rb
 - lib/scrooge.rb
 - test/helper.rb
 - test/models