record-cache 0.1.2 → 0.1.3

data/lib/record_cache/strategy/id_cache.rb

@@ -1,93 +0,0 @@
-module RecordCache
-  module Strategy
-    class IdCache < Base
-  
-      # Can the cache retrieve the records based on this query?
-      def cacheable?(query)
-        ids = query.where_ids(:id)
-        ids && (query.limit.nil? || (query.limit == 1 && ids.size == 1))
-      end
-  
-      # Update the version store and the record store
-      def record_change(record, action)
-        key = cache_key(record.id)
-        if action == :destroy
-          version_store.delete(key)
-        else
-          # update the version store and add the record to the cache
-          new_version = version_store.increment(key)
-          record_store.write(versioned_key(key, new_version), Util.serialize(record))
-        end
-      end
-
-      # Handle invalidation call
-      def invalidate(id)
-        version_store.delete(cache_key(id))
-      end
-  
-      protected
-  
-      # retrieve the record(s) with the given id(s) as an array
-      def fetch_records(query)
-        ids = query.where_ids(:id)
-        query.wheres.delete(:id) # make sure CacheCase.filter! does not see this where anymore
-        id_to_key_map = ids.inject({}){|h,id| h[id] = cache_key(id); h }
-        # retrieve the current version of the records
-        current_versions = version_store.current_multi(id_to_key_map)
-        # get the keys for the records for which a current version was found
-        id_to_version_key_map = Hash[id_to_key_map.map{ |id, key| current_versions[id] ? [id, versioned_key(key, current_versions[id])] : nil }]
-        # retrieve the records from the cache
-        records = id_to_version_key_map.size > 0 ? from_cache(id_to_version_key_map) : []
-        # query the records with missing ids
-        id_to_key_map.except!(*records.map(&:id))
-        # logging (only in debug mode!) and statistics
-        log_id_cache_hit(ids, id_to_key_map.keys) if RecordCache::Base.logger.debug?
-        statistics.add(ids.size, records.size) if statistics.active?
-        # retrieve records from DB in case there are some missing ids
-        records += from_db(id_to_key_map, id_to_version_key_map) if id_to_key_map.size > 0
-        # return the array
-        records
-      end
-  
-      private
-  
-      # ---------------------------- Querying ------------------------------------
-
-      # retrieve the records from the cache with the given keys
-      def from_cache(id_to_versioned_key_map)
-        records = record_store.read_multi(*(id_to_versioned_key_map.values)).values.compact
-        records.map{ |record| Util.deserialize(record) }
-      end
-    
-      # retrieve the records with the given ids from the database
-      def from_db(id_to_key_map, id_to_version_key_map)
-        RecordCache::Base.without_record_cache do
-          # retrieve the records from the database
-          records = @base.where(:id => id_to_key_map.keys).to_a
-          records.each do |record|
-            versioned_key = id_to_version_key_map[record.id]
-            unless versioned_key
-              # renew the key in the version store in case it was missing
-              key = id_to_key_map[record.id]
-              versioned_key = versioned_key(key, version_store.renew(key))
-            end
-            # store the record based on the versioned key
-            record_store.write(versioned_key, Util.serialize(record))
-          end
-          records
-        end
-      end
-  
-      # ------------------------- Utility methods ----------------------------
-  
-      # log cache hit/miss to debug log
-      def log_id_cache_hit(ids, missing_ids)
-        hit = missing_ids.empty? ? "hit" : ids.size == missing_ids.size ? "miss" : "partial hit"
-        missing = missing_ids.empty? || ids.size == missing_ids.size ? "" : ": missing #{missing_ids.inspect}"
-        msg = "IdCache #{hit} for ids #{ids.size == 1 ? ids.first : ids.inspect}#{missing}"
-        RecordCache::Base.logger.debug(msg)
-      end
-
-    end
-  end
-end

data/lib/record_cache/strategy/request_cache.rb

@@ -1,49 +0,0 @@
-# Remembers the queries performed during a single Request.
-# If the same query is requested again the result is provided straight from local memory.
-#
-# Records are invalidated per model-klass, when any record is created, updated or destroyed.
-module RecordCache
-  module Strategy
-    
-    class RequestCache < Base
-      @@request_store = {}
-
-      # call before each request: in application_controller.rb
-      # before_filter { |c| RecordCache::Strategy::RequestCache.clear }
-      def self.clear
-        @@request_store.clear
-      end
-
-      # Handle record change
-      def record_change(record, action)
-        @@request_store.delete(@base.name)
-      end
-
-      # Handle invalidation call
-      def invalidate(value)
-        @@request_store.delete(@base.name)
-      end
-
-      # return the records from the request cache, execute block in case
-      # this is the first time this query is performed during this request
-      def fetch(query, &block)
-        klass_store = (@@request_store[@base.name] ||= {})
-        key = query.cache_key
-        # logging (only in debug mode!) and statistics
-        log_cache_hit(key, klass_store.key?(key)) if RecordCache::Base.logger.debug?
-        statistics.add(1, klass_store.key?(key) ? 1 : 0) if statistics.active?
-        klass_store[key] ||= yield
-      end
-
-      private
-
-      # ------------------------- Utility methods ----------------------------
-  
-      # log cache hit/miss to debug log
-      def log_cache_hit(key, hit)
-        RecordCache::Base.logger.debug("RequestCache #{hit ? 'hit' : 'miss'} for #{key}")
-      end
-
-    end
-  end
-end

data/spec/lib/strategy/id_cache_spec.rb

@@ -1,168 +0,0 @@
-require 'spec_helper'
-
-describe RecordCache::Strategy::IdCache do
-
-  it "should retrieve an Apple from the cache" do
-    lambda{ Apple.find(1) }.should miss_cache(Apple).on(:id).times(1)
-    lambda{ Apple.find(1) }.should hit_cache(Apple).on(:id).times(1)
-  end
-
-  it "should retrieve cloned records" do
-    @apple_1a = Apple.find(1)
-    @apple_1b = Apple.find(1)
-    @apple_1a.should == @apple_1b
-    @apple_1a.object_id.should_not == @apple_1b.object_id
-  end
-
-  context "logging" do
-    before(:each) do
-      Apple.find(1)
-    end
-
-    it "should write full hits to the debug log" do
-      mock(RecordCache::Base.logger).debug(/IdCache hit for ids 1|^(?!IdCache)/).times(any_times)
-      Apple.find(1)
-    end
-
-    it "should write full miss to the debug log" do
-      mock(RecordCache::Base.logger).debug(/IdCache miss for ids 2|^(?!IdCache)/).times(any_times)
-      Apple.find(2)
-    end
-    
-    it "should write partial hits to the debug log" do
-      mock(RecordCache::Base.logger).debug(/IdCache partial hit for ids \[1, 2\]: missing \[2\]|^(?!IdCache)/).times(any_times)
-      Apple.where(:id => [1,2]).all
-    end
-  end
-
-  context "cacheable?" do
-    before(:each) do
-      # fill cache
-      @apple1 = Apple.find(1)
-      @apple2 = Apple.find(2)
-    end
-
-    it "should use the cache when a single id is requested" do
-      lambda{ Apple.where(:id => 1).all }.should hit_cache(Apple).on(:id).times(1)
-    end
-
-    it "should use the cache when a multiple ids are requested" do
-      lambda{ Apple.where(:id => [1, 2]).all }.should hit_cache(Apple).on(:id).times(2)
-    end
-
-    it "should use the cache when a single id is requested and the limit is 1" do
-      lambda{ Apple.where(:id => 1).limit(1).all }.should hit_cache(Apple).on(:id).times(1)
-    end
-
-    it "should not use the cache when a single id is requested and the limit is > 1" do
-      lambda{ Apple.where(:id => 1).limit(2).all }.should_not use_cache(Apple).on(:id)
-    end
-
-    it "should not use the cache when multiple ids are requested and the limit is 1" do
-      lambda{ Apple.where(:id => [1, 2]).limit(1).all }.should_not use_cache(Apple).on(:id)
-    end
-
-    it "should use the cache when a single id is requested together with other where clauses" do
-      lambda{ Apple.where(:id => 1).where(:name => "Adams Apple x").all }.should hit_cache(Apple).on(:id).times(1)
-    end
-
-    it "should use the cache when a multiple ids are requested together with other where clauses" do
-      lambda{ Apple.where(:id => [1,2]).where(:name => "Adams Apple x").all }.should hit_cache(Apple).on(:id).times(2)
-    end
-
-    it "should use the cache when a single id is requested together with (simple) sort clauses" do
-      lambda{ Apple.where(:id => 1).order("name ASC").all }.should hit_cache(Apple).on(:id).times(1)
-    end
-
-    it "should use the cache when a multiple ids are requested together with (simple) sort clauses" do
-      lambda{ Apple.where(:id => [1,2]).order("name ASC").all }.should hit_cache(Apple).on(:id).times(2)
-    end
-  end
-  
-  context "record_change" do
-    before(:each) do
-      # fill cache
-      @apple1 = Apple.find(1)
-      @apple2 = Apple.find(2)
-    end
-
-    it "should invalidate destroyed records" do
-      lambda{ Apple.where(:id => 1).all }.should hit_cache(Apple).on(:id).times(1)
-      @apple1.destroy
-      lambda{ @apples = Apple.where(:id => 1).all }.should miss_cache(Apple).on(:id).times(1)
-      @apples.should == []
-      # try again, to make sure the "missing record" is not cached
-      lambda{ Apple.where(:id => 1).all }.should miss_cache(Apple).on(:id).times(1)
-    end
-
-    it "should add updated records directly to the cache" do
-      @apple1.name = "Applejuice"
-      @apple1.save!
-      lambda{ @apple = Apple.find(1) }.should hit_cache(Apple).on(:id).times(1)
-      @apple.name.should == "Applejuice"
-    end
-
-    it "should add created records directly to the cache" do
-      @new_apple = Apple.create!(:name => "Fresh Apple", :store_id => 1)
-      lambda{ @apple = Apple.find(@new_apple.id) }.should hit_cache(Apple).on(:id).times(1)
-      @apple.name.should == "Fresh Apple"
-    end
-
-    it "should add updated records to the cache, also when multiple ids are queried" do
-      @apple1.name = "Applejuice"
-      @apple1.save!
-      lambda{ @apples = Apple.where(:id => [1, 2]).order('id ASC').all }.should hit_cache(Apple).on(:id).times(2)
-      @apples.map(&:name).should == ["Applejuice", "Adams Apple 2"]
-    end
-    
-  end
-  
-  context "invalidate" do
-    before(:each) do
-      @apple1 = Apple.find(1)
-      @apple2 = Apple.find(2)
-    end
-
-    it "should invalidate single records" do
-      Apple.record_cache[:id].invalidate(1)
-      lambda{ Apple.find(1) }.should miss_cache(Apple).on(:id).times(1)
-    end
-
-    it "should only miss the cache for the invalidated record when multiple ids are queried" do
-      # miss on 1
-      Apple.record_cache[:id].invalidate(1)
-      lambda{ Apple.where(:id => [1, 2]).all }.should miss_cache(Apple).on(:id).times(1)
-      # hit on 2
-      Apple.record_cache[:id].invalidate(1)
-      lambda{ Apple.where(:id => [1, 2]).all }.should hit_cache(Apple).on(:id).times(1)
-      # nothing invalidated, both hit
-      lambda{ Apple.where(:id => [1, 2]).all }.should hit_cache(Apple).on(:id).times(2)
-    end
-
-    it "should invalidate records when using update_all" do
-      Apple.where(:id => [3,4,5]).all # fill id cache on all Adam Store apples
-      lambda{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').all }.should hit_cache(Apple).on(:id).times(5)
-      @apples.map(&:name).should == ["Adams Apple 1", "Adams Apple 2", "Adams Apple 3", "Adams Apple 4", "Adams Apple 5"]
-      # update 3 of the 5 apples in the Adam Store
-      Apple.where(:id => [1,2,3]).update_all(:name => "Uniform Apple")
-      lambda{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').all }.should hit_cache(Apple).on(:id).times(2)
-      @apples.map(&:name).should == ["Uniform Apple", "Uniform Apple", "Uniform Apple", "Adams Apple 4", "Adams Apple 5"]
-    end
-
-    it "should invalidate reflection indexes when a has_many relation is updated" do
-      # assign different apples to store 2
-      lambda{ Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:id).times(2)
-      store2_apple_ids = Apple.where(:store_id => 2).map(&:id)
-      store1 = Store.find(1)
-      store1.apple_ids = store2_apple_ids
-      store1.save!
-      # the apples that used to belong to store 2 are now in store 1 (incremental update)
-      lambda{ @apple1 = Apple.find(store2_apple_ids.first) }.should hit_cache(Apple).on(:id).times(1)
-      @apple1.store_id.should == 1
-      # the apples that used to belong to store 1 are now homeless (cache invalidated)
-      lambda{ @homeless_apple = Apple.find(1) }.should miss_cache(Apple).on(:id).times(1)
-      @homeless_apple.store_id.should == nil
-    end
-  end
-
-end

data/spec/lib/strategy/request_cache_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe RecordCache::Strategy::RequestCache do
-
-  it "should retrieve a record from the Request Cache" do
-    lambda{ Store.find(1) }.should miss_cache(Store)
-    lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
-  end
-
-  it "should retrieve the same record when the same query is used" do
-    @store_1 = Store.find(1)
-    @store_2 = Store.find(1)
-    @store_1.should == @store_2
-    @store_1.object_id.should == @store_2.object_id
-  end
-
-  context "logging" do
-    before(:each) do
-      Store.find(1)
-    end
-
-    it "should write hit to the debug log" do
-      mock(RecordCache::Base.logger).debug(/RequestCache hit for id=1\.L1|^(?!RequestCache)/).times(any_times)
-      Store.find(1)
-    end
-
-    it "should write miss to the debug log" do
-      mock(RecordCache::Base.logger).debug(/^RequestCache miss for id=2.L1|^(?!RequestCache)/).times(any_times)
-      Store.find(2)
-    end
-  end
-
-  context "record_change" do
-    before(:each) do
-      # cache query in request cache
-      @store1 = Store.find(1)
-      @store2 = Store.find(2)
-    end
-    
-    it "should remove all records from the cache for a specific model when one record is destroyed" do
-      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
-      lambda{ Store.find(2) }.should hit_cache(Store).on(:request_cache).times(1)
-      @store1.destroy
-      lambda{ Store.find(2) }.should miss_cache(Store).on(:request_cache).times(1)
-    end
-
-    it "should remove all records from the cache for a specific model when one record is updated" do
-      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
-      lambda{ Store.find(2) }.should hit_cache(Store).on(:request_cache).times(1)
-      @store1.name = "Store E"
-      @store1.save!
-      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
-      lambda{ Store.find(2) }.should miss_cache(Store).on(:request_cache).times(1)
-    end
-
-    it "should remove all records from the cache for a specific model when one record is created" do
-      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
-      lambda{ Store.find(2) }.should hit_cache(Store).on(:request_cache).times(1)
-      Store.create!(:name => "New Apple Store")
-      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
-      lambda{ Store.find(2) }.should miss_cache(Store).on(:request_cache).times(1)
-    end
-
-  end
-
-  context "invalidate" do
-    before(:each) do
-      # cache query in request cache
-      @store1 = Store.find(1)
-      @store2 = Store.find(2)
-    end
-    
-    it "should remove all records from the cache when clear is explicitly called" do
-      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
-      RecordCache::Strategy::RequestCache.clear
-      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
-    end
-
-    it "should remove all records from the cache when invalidate is called" do
-      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
-      Store.record_cache.invalidate(:request_cache, @store2)
-      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
-    end
-  end
-end