onyx-cache-money 0.2.5.6 → 0.2.5.7

data/lib/cash/accessor.rb

@@ -11,11 +11,15 @@ module Cash
       def fetch(keys, options = {}, &block)
         case keys
         when Array
-          keys = keys.collect { |key| cache_key(key) }
-          hits = repository.get_multi(keys)
-          if (missed_keys = keys - hits.keys).any?
-            missed_values = block.call(missed_keys)
-            hits.merge!(missed_keys.zip(Array(missed_values)).to_hash)
+          cache_and_actual_keys = keys.inject({}) { |memo, key| memo[cache_key(key)] = key; memo }
+          cache_keys = keys.collect {|key| cache_key(key)}
+          
+          hits = repository.get_multi(cache_keys)
+          if (missed_cache_keys = cache_keys - hits.keys).any?
+            actual_missed_keys = missed_cache_keys.collect {|missed_cache_key| cache_and_actual_keys[missed_cache_key]}
+            missed_values = block.call(actual_missed_keys)
+            
+            hits.merge!(missed_cache_keys.zip(Array(missed_values)).to_hash)
           end
           hits
         else
@@ -26,7 +30,11 @@ module Cash
       def get(keys, options = {}, &block)
         case keys
         when Array
-          fetch(keys, options, &block)
+          fetch(keys, options) do |missed_keys|
+            results = yield(missed_keys)
+            results.each_with_index {|result, index| add(missed_keys[index], result, options)}
+            results
+          end
         else
           fetch(keys, options) do
             if block_given?
@@ -66,7 +74,8 @@ module Cash
       end
 
       def cache_key(key)
-        "#{name}:#{cache_config.version}/#{key.to_s.gsub(' ', '+')}"
+        ready = key =~ /#{name}:#{cache_config.version}/
+        ready ? key : "#{name}:#{cache_config.version}/#{key.to_s.gsub(' ', '+')}"
       end
     end
 

data/lib/cash/finders.rb

@@ -10,7 +10,7 @@ module Cash
       def self.extended(active_record_class)
         class << active_record_class
           alias_method_chain :find_every, :cache
-          alias_method_chain :find_from_ids, :cache
+          # alias_method_chain :find_from_ids, :cache
           alias_method_chain :calculate, :cache
         end
       end
@@ -25,9 +25,9 @@ module Cash
       end
 
       # User.find(1), User.find(1, 2, 3), User.find([1, 2, 3]), User.find([])
-      def find_from_ids_with_cache(ids, options)
-        Query::PrimaryKey.perform(self, ids, options, scope(:find))
-      end
+      # def find_from_ids_with_cache(ids, options)
+      #   Query::PrimaryKey.perform(self, ids, options, scope(:find))
+      # end
 
       # User.count(:all), User.count, User.sum(...)
       def calculate_with_cache(operation, column_name, options = {})

data/lib/cash/query/abstract.rb

@@ -1,7 +1,8 @@
 module Cash
   module Query
     class Abstract
-      delegate :with_exclusive_scope, :get, :table_name, :indices, :find_from_ids_without_cache, :cache_key, :columns_hash, :to => :@active_record
+      delegate :with_exclusive_scope, :get, :quoted_table_name, :connection, :indices, 
+        :find_every_without_cache, :cache_key, :columns_hash, :quote_value, :to => :@active_record
 
       def self.perform(*args)
         new(*args).perform
@@ -51,7 +52,7 @@ module Cash
       def cacheable?(*optionss)
         optionss.each { |options| return unless safe_options_for_cache?(options) }
         partial_indices = optionss.collect { |options| attribute_value_pairs_for_conditions(options[:conditions]) }
-        return if partial_indices.include?(nil)
+        return if partial_indices.flatten.include?(nil)
         attribute_value_pairs = partial_indices.sum.sort { |x, y| x[0] <=> y[0] }
         if index = indexed_on?(attribute_value_pairs.collect { |pair| pair[0] })
           if index.matches?(self)
@@ -70,7 +71,20 @@ module Cash
       end
 
       def cache_keys(attribute_value_pairs)
-        attribute_value_pairs.flatten.join('/')
+        cache_keys = collect_cache_keys(attribute_value_pairs)
+        cache_keys.size == 1 ? cache_keys.first : cache_keys
+      end
+      
+      def collect_cache_keys(pairs)
+        return [] if pairs.empty?
+        key, values = pairs.shift
+        Array(values).inject([]) do |memo,value|
+          partial_keys = collect_cache_keys(pairs.clone)
+
+          memo << "#{key}/#{value}" if partial_keys.empty?
+          partial_keys.each { |partial_key| memo << "#{key}/#{value}/#{partial_key}" }
+          memo
+        end
       end
 
       def safe_options_for_cache?(options)
@@ -85,6 +99,7 @@ module Cash
         when String
           parse_indices_from_condition(conditions)
         when Array
+          return nil if conditions.last.is_a?(Hash)
           parse_indices_from_condition(*conditions)
         when NilClass
           []
@@ -93,17 +108,19 @@ module Cash
 
       AND = /\s+AND\s+/i
       TABLE_AND_COLUMN = /(?:(?:`|")?(\w+)(?:`|")?\.)?(?:`|")?(\w+)(?:`|")?/              # Matches: `users`.id, `users`.`id`, users.id, id
-      VALUE = /'?(\d+|\?|(?:(?:[^']|'')*))'?/                     # Matches: 123, ?, '123', '12''3'
-      KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+=\s+#{VALUE}\)?$/ # Matches: KEY = VALUE, (KEY = VALUE)
-      ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i              # Matches: COLUMN ASC, COLUMN DESC, COLUMN
+      VALUE = /'?(\d+|\?|(?:(?:[^']|'')*?))'?/                                            # Matches: 123, ?, '123', '12 ''3'
+      KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+(?:=|IN)\s+\(?(?:#{VALUE})\)?\)?$/      # Matches: KEY = VALUE, (KEY = VALUE), KEY IN (VALUE,VALUE,..)
+      ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i                                      # Matches: COLUMN ASC, COLUMN DESC, COLUMN
 
       def parse_indices_from_condition(conditions = '', *values)
         values = values.dup
         conditions.split(AND).inject([]) do |indices, condition|
-          matched, table_name, column_name, sql_value = *(KEY_EQ_VALUE.match(condition))
+          matched, table_name, column_name, sql_values = *(KEY_EQ_VALUE.match(condition))
           if matched
-            value = sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
-            indices << [column_name, value]
+            actual_values = sql_values.split(',').collect do |sql_value|
+              sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
+            end
+            indices << [column_name, actual_values]
           else
             return nil
           end
@@ -148,14 +165,30 @@ module Cash
           objects
         else
           cache_keys = objects.collect { |id| "id/#{id}" }
-          objects = get(cache_keys, &method(:find_from_keys))
+          objects = get(cache_keys) {|missed_keys| find_from_keys(missed_keys)}
           convert_to_array(cache_keys, objects)
         end
       end
 
-      def find_from_keys(*missing_keys)
-        missing_ids = Array(missing_keys).flatten.collect { |key| key.split('/')[2].to_i }
-        find_from_ids_without_cache(missing_ids, {})
+      def find_from_keys(missing_keys, options = {})
+        missing_keys_pairs = Array(missing_keys).flatten.collect { |key| key.split('/') }
+
+        keys_values = missing_keys_pairs.inject({}) do |memo, missing_keys_pair|
+          while missing_keys_pair.any?
+            key = missing_keys_pair.shift
+            memo[key] ||= []
+            memo[key] << missing_keys_pair.shift
+          end
+          memo
+        end
+
+        conditions = keys_values.collect do |key,values|
+          converted_values = values.collect {|value| quote_value(value, columns_hash[key])}
+          quoted_table_and_column_name = "#{quoted_table_name}.#{connection.quote_column_name(key)}"
+          converted_values.size == 1 ? "#{quoted_table_and_column_name} = #{converted_values}" : "#{quoted_table_and_column_name} IN (#{converted_values.join(',')})"
+        end
+
+        find_every_without_cache(options.merge(:conditions => conditions.join(" AND ")))
       end
     end
   end

data/lib/cash/query/select.rb

@@ -4,8 +4,9 @@ module Cash
       delegate :find_every_without_cache, :to => :@active_record
 
       protected
-      def miss(_, miss_options)
-        find_every_without_cache(miss_options)
+      def miss(missed_keys, miss_options)
+        # find_every_without_cache(miss_options)
+        misses = find_from_keys(missed_keys, miss_options)
       end
 
       def uncacheable

data/spec/cash/finders_spec.rb

@@ -170,8 +170,9 @@ module Cash
 
               describe '#find(1, :conditions => ...)' do
                 it "does not use the database" do
+                  Story.create!
                   story = Story.create!
-                  character = Character.create!(:name => name = 'barbara', :story_id => story)
+                  character = Character.create!(:name => name = 'barbara', :story_id => story.id)
                   mock(Character.connection).execute.never
                   Character.send :with_scope, :find => { :conditions => { :story_id => story.id } } do
                     Character.find(character.id, :conditions => { :name => name }).should == character
@@ -335,13 +336,101 @@ module Cash
           end
         end
 
+        describe '#find(:conditions => ["... :attr", {:attr => 1}])' do
+          it 'retrieves story from database - no support yet for retrieving from cache' do
+            Story.find(:all, :conditions => ["id = :id", {:id => @story.id}]).should == [@story]
+          end
+        end
+        
         describe '#find(1)' do
           it 'populates the cache' do
             Story.find(@story.id)
             Story.fetch("id/#{@story.id}").should == [@story]
           end
         end
+        
+        describe '#find(1,2)' do
+          it 'populates the cache' do
+            another_story = Story.create!
+            $memcache.flush_all
+            
+            Story.find(@story.id, another_story.id).should == [@story, another_story]
+            Story.fetch("id/#{@story.id}").should == @story
+            Story.fetch("id/#{another_story.id}").should == another_story
+          end
+          
+          it "populates the cache and retrieves from the cache" do
+            story1 = Story.create!
+            story2 = Story.create!
+            story3 = Story.create!
+            $memcache.flush_all
+
+            Story.find(story1.id, story2.id, story3.id).should == [story1, story2, story3]
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id).should == [story1, story2]
+          end
+          
+          it "uses database for missing keys" do
+            story1 = Story.create!
+            story2 = Story.create!
+            story3 = Story.create!
+            $memcache.flush_all
+
+            Story.find(story1.id, story3.id).should == [story1, story3]
+            Story.fetch("id/#{story2.id}").should be_nil
+
+            mock(Story).find_every_without_cache(:limit => nil, :conditions => "\"stories\".\"id\" = #{story2.id}") do 
+              story2
+            end
+            Story.find(story1.id, story2.id)
+          end
+          
+          it "populates and retrieves from cache when passing in a hash" do
+            story1 = Story.create!
+            story2 = Story.create!
+            $memcache.flush_all
+
+            Story.find(:all, :conditions => {:id => [story1.id, story2.id]})
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id)
+          end
 
+          it "populates and retrieves from cache when passing in a parametrized conditions" do
+            story1 = Story.create!
+            story2 = Story.create!
+            $memcache.flush_all
+
+            Story.find(:all, :conditions => ["id IN (?,?)", story1.id, story2.id])
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id)
+          end
+
+          it "populates and retrieves from cache when passing in a list of non-numeric keys" do
+            pending "need to fix regex to properly parse this"
+            story1 = Story.create! :title => 'one'
+            story2 = Story.create! :title => 'two'
+            $memcache.flush_all
+
+            Story.find(:all, :conditions => ["title IN ('one', 'two')"])
+            # We need to add this extra call as cache money will always go to the database
+            #  one more time when finding by a non-id field first
+            Story.find_all_by_title(['one', 'two'])
+            mock(Story.connection).execute.never
+            Story.find(story1.id, story2.id)
+          end
+          
+          it "should not create a key over 250 characters on a find_all_by_ids" do
+            75.times do
+              Story.create!
+            end
+            ids = Story.find(:all).map(&:id)
+            $memcache.flush_all
+            lambda do 
+              Story.find(:all, :conditions => {:id => ids})
+            end.should_not raise_error(ArgumentError)
+          end
+        end
+        
         describe 'when there is a with_scope' do
           it "uses the database, not the cache" do
             Story.send :with_scope, :find => { :conditions => { :title => @story.title }} do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: onyx-cache-money
 version: !ruby/object:Gem::Version 
-  version: 0.2.5.6
+  version: 0.2.5.7
 platform: ruby
 authors: 
 - Nick Kallen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-24 00:00:00 -08:00
+date: 2009-05-26 00:00:00 -07:00
 default_executable: 
 dependencies: []