record-cache 0.1.2 → 0.1.3

data/lib/record_cache/strategy/unique_index_cache.rb

@@ -0,0 +1,130 @@
+module RecordCache
+  module Strategy
+    class UniqueIndexCache < Base
+
+      # All attributes with a unique index for the given model
+      def self.attributes(base)
+        (@attributes ||= {})[base.name] ||= []
+      end
+
+      # parse the options and return (an array of) instances of this strategy
+      def self.parse(base, record_store, options)
+        return nil unless base.table_exists?
+        
+        attributes = [options[:unique_index]].flatten.compact
+        # add unique index for :id by default
+        attributes << :id if base.columns_hash['id'] unless base.record_cache[:id]
+        attributes.uniq! # in development mode, do not keep adding 'id' to the list of unique index attributes
+        return nil if attributes.empty?
+        attributes.map do |attribute|
+          type = base.columns_hash[attribute.to_s].try(:type)
+          raise "No column found for unique index '#{index}' on #{base.name}." unless type
+          raise "Incorrect type (expected string or integer, found #{type}) for unique index '#{attribute}' on #{base.name}." unless type == :string || type == :integer
+          UniqueIndexCache.new(base, attribute, record_store, options, type)
+        end
+      end
+
+      def initialize(base, attribute, record_store, options, type)
+        super(base, attribute, record_store, options)
+        # remember the attributes with a unique index
+        UniqueIndexCache.attributes(base) << attribute
+        # for unique indexes that are not on the :id column, use key: rc/<key or model name>/<attribute>:
+        @cache_key_prefix << "#{attribute}:" unless attribute == :id
+        @type = type
+      end
+
+      # Can the cache retrieve the records based on this query?
+      def cacheable?(query)
+        values = query.where_values(@attribute, @type)
+        values && (query.limit.nil? || (query.limit == 1 && values.size == 1))
+      end
+
+      # Update the version store and the record store
+      def record_change(record, action)
+        key = cache_key(record.send(@attribute))
+        if action == :destroy
+          version_store.delete(key)
+        else
+          # update the version store and add the record to the cache
+          new_version = version_store.renew(key, version_opts)
+          record_store.write(versioned_key(key, new_version), Util.serialize(record))
+        end
+      end
+
+      protected
+
+      # retrieve the record(s) with the given id(s) as an array
+      def fetch_records(query)
+        ids = query.where_values(@attribute, @type)
+        query.wheres.delete(@attribute) # 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 }.compact]
+        # 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(&@attribute))
+        # 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 do |record|
+          record = Util.deserialize(record)
+          record.becomes(self.instance_variable_get('@base')) unless record.class == self.instance_variable_get('@base')
+          record
+        end
+      end
+
+      # retrieve the records with the given ids from the database
+      def from_db(id_to_key_map, id_to_version_key_map)
+        # skip record cache itself
+        RecordCache::Base.without_record_cache do
+          # set version store in multi-mode
+          RecordCache::Base.version_store.multi do
+            # set record store in multi-mode
+            record_store.multi do
+              # retrieve the records from the database
+              records = @base.where(@attribute => id_to_key_map.keys).to_a
+              records.each do |record|
+                versioned_key = id_to_version_key_map[record.send(@attribute)]
+                unless versioned_key
+                  # renew the key in the version store in case it was missing
+                  key = id_to_key_map[record.send(@attribute)]
+                  versioned_key = versioned_key(key, version_store.renew(key, version_opts))
+                end
+                # store the record based on the versioned key
+                record_store.write(versioned_key, Util.serialize(record))
+              end
+              records
+            end
+          end
+        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 = "UniqueIndexCache on '#{@base.name}.#{@attribute}' #{hit} for ids #{ids.size == 1 ? ids.first.inspect : ids.inspect}#{missing}"
+        RecordCache::Base.logger.debug{ msg }
+      end
+
+    end
+  end
+end

data/lib/record_cache/strategy/util.rb

@@ -11,17 +11,17 @@ module RecordCache
         # creates a shallow clone with a version and without associations
         def serialize(record)
           {CLASS_KEY => record.class.name,
-           ATTRIBUTES_KEY => record.instance_variable_get(:@attributes)}.freeze
+           ATTRIBUTES_KEY => record.instance_variable_get(:@attributes).dup}
         end
 
         # deserialize a cached record
         def deserialize(serialized)
-          record = serialized[CLASS_KEY].constantize.new
+          record = serialized[CLASS_KEY].constantize.allocate
           attributes = serialized[ATTRIBUTES_KEY]
-          record.instance_variable_set(:@attributes, Hash[attributes])
-          record.instance_variable_set(:@new_record, false)
-          record.instance_variable_set(:@changed_attributes, {})
-          record.instance_variable_set(:@previously_changed, {})
+          record.class.serialized_attributes.keys.each do |attribute|
+            attributes[attribute] = attributes[attribute].unserialize if attributes[attribute].respond_to?(:unserialize)
+          end
+          record.init_with('attributes' => attributes)
           record
         end
 
@@ -81,23 +81,23 @@ module RecordCache
           # Proc.new{ |x,y| { ([(COLLATER.collate(x.name) || NIL_COMES_FIRST), (y.updated_at || NIL_COMES_FIRST)] <=> [COLLATER.collate(y.name), x.updated_at]) || 1 }
           eval("Proc.new{ |x,y| (#{sort[0]} <=> #{sort[1]}) || 1 }")
         end
-    
+
         # If +x.nil?+ this class will return -1 for +x <=> y+
         NIL_COMES_FIRST = ((class NilComesFirst; def <=>(y); -1; end; end); NilComesFirst.new)
-    
+
         # StringCollator uses the Rails transliterate method for collation
         module Collator
           @collated = []
-    
+
           def self.clear
             @collated.each { |string| string.send(:remove_instance_variable, :@rc_collated) }
             @collated.clear
           end
-    
+
           def self.collate(string)
             collated = string.instance_variable_get(:@rc_collated)
             return collated if collated
-            normalized = ActiveSupport::Multibyte::Unicode.normalize(ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c).mb_chars
+            normalized = ActiveSupport::Multibyte::Unicode.normalize(ActiveSupport::Multibyte::Unicode.tidy_bytes(string || ''), :c).mb_chars
             collated = I18n.transliterate(normalized).downcase.mb_chars
             # transliterate will replace ignored/unknown chars with ? the following line replaces ? with the original character
             collated.chars.each_with_index{ |c, i| collated[i] = normalized[i] if c == '?' } if collated.index('?')
@@ -108,7 +108,7 @@ module RecordCache
           end
         end
       end
-      
+
     end
   end
 end

data/lib/record_cache/test/resettable_version_store.rb

@@ -11,7 +11,6 @@ module RecordCache
         base.extend ClassMethods
         base.send(:include, InstanceMethods)
         base.instance_eval do
-          alias_method_chain :increment, :reset
           alias_method_chain :renew, :reset
         end
       end
@@ -21,18 +20,12 @@ module RecordCache
 
       module InstanceMethods
 
-        def increment_with_reset(key)
+        def renew_with_reset(key, opts = {})
           updated_version_keys << key
-          increment_without_reset(key)
-        end
-        
-        def renew_with_reset(key)
-          updated_version_keys << key
-          renew_without_reset(key)
+          renew_without_reset(key, opts)
         end
 
         def reset!
-          RecordCache::Strategy::RequestCache.clear
           updated_version_keys.each { |key| delete(key) }
           updated_version_keys.clear
         end

data/lib/record_cache/version.rb

@@ -1,5 +1,5 @@
 module RecordCache # :nodoc:
   module Version # :nodoc:
-    STRING = '0.1.2'
+    STRING = '0.1.3'
   end
 end

data/lib/record_cache/version_store.rb

@@ -3,7 +3,9 @@ module RecordCache
     attr_accessor :store
 
     def initialize(store)
-      raise "Must be an ActiveSupport::Cache::Store" unless store.is_a?(ActiveSupport::Cache::Store)
+      [:write, :read, :read_multi, :delete].each do |method|
+        raise "Store #{store.class.name} must respond to #{method}" unless store.respond_to?(method)
+      end
       @store = store
     end
 
@@ -22,31 +24,36 @@ module RecordCache
       Hash[id_key_map.map{ |id, key| [id, current_versions[key]] }]
     end
 
-    # In case the version store did not have a key anymore, call this methods
-    # to reset the key with a (unique) new version
-    def renew(key)
+    # Call this method to reset the key to a new (unique) version
+    def renew(key, options = {})
       new_version = (Time.current.to_f * 10000).to_i
-      @store.write(key, new_version)
-      RecordCache::Base.logger.debug("Version Store: renew #{key}: nil => #{new_version}") if RecordCache::Base.logger.debug?
+      seconds = options[:ttl] ? options[:ttl] + (rand(options[:ttl] / 2) * [1, -1].sample) : nil
+      @store.write(key, new_version, {:expires_in => seconds})
+      RecordCache::Base.logger.debug{ "Version Store: renew #{key}: nil => #{new_version}" }
       new_version
     end
 
-    # Increment the current version for the given key, in case of record updates
-    def increment(key)
-      version = @store.increment(key, 1)
-      # renew key in case the version store already purged the key
-      if version.nil? || version == 1
-        version = renew(key)
+    # perform several actions on the version store in one go
+    # Dalli: Turn on quiet aka noreply support. All relevant operations within this block will be effectively pipelined using 'quiet' operations where possible.
+    #        Currently supports the set, add, replace and delete operations for Dalli cache.
+    def multi(&block)
+      if @store.respond_to?(:multi)
+        @store.multi(&block)
       else
-        RecordCache::Base.logger.debug("Version Store: incremented #{key}: #{version - 1} => #{version}") if RecordCache::Base.logger.debug?
+        yield
       end
-      version
     end
-    
+
+    # @deprecated: use renew instead
+    def increment(key)
+      RecordCache::Base.logger.debug{ "increment is deprecated, use renew instead. Called from: #{caller[0]}" }
+      renew(key)
+    end
+
     # Delete key from the version store (records cached in the Record Store belonging to this key will become unreachable)
     def delete(key)
       deleted = @store.delete(key)
-      RecordCache::Base.logger.debug("Version Store: deleted #{key}") if RecordCache::Base.logger.debug?
+      RecordCache::Base.logger.debug{ "Version Store: deleted #{key}" }
       deleted
     end
 

data/spec/db/schema.rb

@@ -39,4 +39,16 @@ ActiveRecord::Schema.define :version => 0 do
     t.integer :person_id
   end
 
+  create_table :addresses, :force => true do |t|
+    t.integer :id
+    t.string  :name
+    t.integer :store_id
+    t.string  :location
+  end
+
+  create_table :languages, :force => true do |t|
+    t.string  :name
+    t.string  :locale
+  end
+
 end

data/spec/db/seeds.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 ActiveRecord::Schema.define :version => 1 do
   
   # Make sure that at the beginning of the tests, NOTHING is known to Record Cache
@@ -11,6 +12,10 @@ ActiveRecord::Schema.define :version => 1 do
   @blue_fruits = Store.create!(:name => "Blue Fruits", :owner => @blue)
   @cris_bananas = Store.create!(:name => "Chris Bananas", :owner => @cris)
 
+  @adam_apples_address = Address.create!(:name => "101 1st street", :store => @adam_apples)
+  @blue_fruits_address = Address.create!(:name => "102 1st street", :store => @blue_fruits)
+  @cris_bananas_address = Address.create!(:name => "103 1st street", :store => @cris_bananas, :location => {latitue: 27.175015, longitude: 78.042155, dms_lat: %(27° 10' 30.0540" N), dms_long: %(78° 2' 31.7580" E)})
+
   @fry = Person.create!(:name => "Fry", :birthday => Date.civil(1985,01,20), :height => 1.69)
   @chase = Person.create!(:name => "Chase", :birthday => Date.civil(1970,07,03), :height => 1.91)
   @penny = Person.create!(:name => "Penny", :birthday => Date.civil(1958,04,16), :height => 1.61)
@@ -36,5 +41,10 @@ ActiveRecord::Schema.define :version => 1 do
   Pear.create!(:name => "Blue Pear 3", :store => @blue_fruits, :person => @chase)
   Pear.create!(:name => "Blue Pear 4", :store => @blue_fruits, :person => @chase)
 
+  Language.create!(:name => "English (US)",    :locale => "en-US")
+  Language.create!(:name => "English (GB)",    :locale => "en-GB")
+  Language.create!(:name => "Nederlands (NL)", :locale => "du-NL")
+  Language.create!(:name => "Magyar",          :locale => "hu")
+
   RecordCache::Base.enable
 end

data/spec/lib/active_record/visitor_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'ActiveRecord Visitor' do
+
+  def find_visit_methods(visitor_class)
+    (visitor_class.instance_methods + visitor_class.private_instance_methods).select{ |method| method.to_s =~ /^visit_Arel_/ }.sort.uniq
+  end
+
+  it 'should implement all visitor methods' do
+    all_visit_methods = find_visit_methods(Arel::Visitors::ToSql)
+    rc_visit_methods = find_visit_methods(RecordCache::Arel::QueryVisitor)
+    expect(all_visit_methods - rc_visit_methods).to be_empty
+  end
+
+  it 'should not implement old visitor methods' do
+    all_visit_methods = find_visit_methods(Arel::Visitors::ToSql)
+    rc_visit_methods = find_visit_methods(RecordCache::Arel::QueryVisitor)
+    expect(rc_visit_methods - all_visit_methods).to be_empty
+  end
+
+end

data/spec/lib/base_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe RecordCache::Base do
+
+  it "should run a block in enabled mode" do
+    RecordCache::Base.disable!
+    RecordCache::Base.enabled do
+      expect(RecordCache::Base.status).to eq(RecordCache::ENABLED)
+    end
+    expect(RecordCache::Base.status).to eq(RecordCache::DISABLED)
+  end
+
+  it "should be possible to provide a different logger" do
+    custom_logger = Logger.new(STDOUT)
+    RecordCache::Base.logger = custom_logger
+    expect(RecordCache::Base.logger).to eq(custom_logger)
+    RecordCache::Base.logger = nil
+    expect(RecordCache::Base.logger).to eq(::ActiveRecord::Base.logger)
+  end
+end

data/spec/lib/dispatcher_spec.rb

@@ -4,55 +4,45 @@ describe RecordCache::Dispatcher do
   before(:each) do
     @apple_dispatcher = Apple.record_cache
   end
-  
-  it "should raise an error when the same index is added twice" do
-    lambda { @apple_dispatcher.register(:store_id, RecordCache::Strategy::IdCache, nil, {}) }.should raise_error("Multiple record cache definitions found for 'store_id' on Apple")
-  end
-  
-  it "should return the Cache for the requested strategy" do
-    @apple_dispatcher[:id].class.should == RecordCache::Strategy::IdCache
-    @apple_dispatcher[:store_id].class.should == RecordCache::Strategy::IndexCache
-  end
 
-  it "should return nil for unknown requested strategies" do
-    @apple_dispatcher[:unknown].should == nil
+  it "should return the (ordered) strategy classes" do
+    expect(RecordCache::Dispatcher.strategy_classes).to eq([RecordCache::Strategy::UniqueIndexCache, RecordCache::Strategy::FullTableCache, RecordCache::Strategy::IndexCache])
   end
 
-  it "should return cacheable? true if there is a cacheable strategy that accepts the query" do
-    query = RecordCache::Query.new
-    mock(@apple_dispatcher).first_cacheable_strategy(query) { Object.new }
-    @apple_dispatcher.cacheable?(query).should == true
+  it "should be able to register a new strategy" do
+    RecordCache::Dispatcher.strategy_classes << Integer
+    expect(RecordCache::Dispatcher.strategy_classes).to include(Integer)
+    RecordCache::Dispatcher.strategy_classes.delete(Integer)
   end
 
-  context "fetch" do
-    it "should delegate fetch to the Request Cache if present" do
-      query = RecordCache::Query.new
-      mock(@apple_dispatcher[:request_cache]).fetch(query)
-      @apple_dispatcher.fetch(query)
-    end
-
-    it "should delegate fetch to the first cacheable strategy if Request Cache is not present" do
-      query = RecordCache::Query.new
-      banana_dispatcher = Banana.record_cache
-      banana_dispatcher[:request_cache].should == nil
-      mock(banana_dispatcher).first_cacheable_strategy(query) { mock(Object.new).fetch(query) }
-      banana_dispatcher.fetch(query)
+  context "parse" do
+    it "should raise an error when the same index is added twice" do
+      expect{ Apple.cache_records(:index => :store_id) }.to raise_error("Multiple record cache definitions found for 'store_id' on Apple")
     end
   end
   
+  it "should return the Cache for the requested strategy" do
+    expect(@apple_dispatcher[:id].class).to eq(RecordCache::Strategy::UniqueIndexCache)
+    expect(@apple_dispatcher[:store_id].class).to eq(RecordCache::Strategy::IndexCache)
+  end
+
+  it "should return nil for unknown requested strategies" do
+    expect(@apple_dispatcher[:unknown]).to be_nil
+  end
+
   context "record_change" do
     it "should dispatch record_change to all strategies" do
       apple = Apple.first
       [:id, :store_id, :person_id].each do |strategy|
-        mock(@apple_dispatcher[strategy]).record_change(apple, :create)
+        expect(@apple_dispatcher[strategy]).to receive(:record_change).with(apple, :create)
       end
       @apple_dispatcher.record_change(apple, :create)
     end
   
     it "should not dispatch record_change for updates without changes" do
       apple = Apple.first
-      [:request_cache, :id, :store_id, :person_id].each do |strategy|
-        mock(@apple_dispatcher[strategy]).record_change(anything, anything).times(0)
+      [:id, :store_id, :person_id].each do |strategy|
+        expect(@apple_dispatcher[strategy]).to_not receive(:record_change)
       end
       @apple_dispatcher.record_change(apple, :update)
     end
@@ -60,27 +50,15 @@ describe RecordCache::Dispatcher do
 
   context "invalidate" do
     it "should default to the :id strategy" do
-      mock(@apple_dispatcher[:id]).invalidate(15)
+      expect(@apple_dispatcher[:id]).to receive(:invalidate).with(15)
       @apple_dispatcher.invalidate(15)
     end
 
     it "should delegate to given strategy" do
-      mock(@apple_dispatcher[:id]).invalidate(15)
-      mock(@apple_dispatcher[:store_id]).invalidate(31)
+      expect(@apple_dispatcher[:id]).to receive(:invalidate).with(15)
+      expect(@apple_dispatcher[:store_id]).to receive(:invalidate).with(31)
       @apple_dispatcher.invalidate(:id, 15)
       @apple_dispatcher.invalidate(:store_id, 31)
     end
-
-    it "should invalidate the request cache" do
-      store_dispatcher = Store.record_cache
-      mock(store_dispatcher[:request_cache]).invalidate(15)
-      store_dispatcher.invalidate(:id, 15)
-    end
-
-    it "should even invalidate the request cache if the given strategy is not known" do
-      store_dispatcher = Store.record_cache
-      mock(store_dispatcher[:request_cache]).invalidate(31)
-      store_dispatcher.invalidate(:unknown_id, 31)
-    end
   end
 end