identity_cache 0.0.3 → 0.0.4

data/lib/identity_cache/query_api.rb

@@ -4,6 +4,11 @@ module IdentityCache
 
     included do |base|
       base.private_class_method :require_if_necessary
+      base.private_class_method :coder_from_record
+      base.private_class_method :record_from_coder
+      base.private_class_method :set_embedded_association
+      base.private_class_method :get_embedded_association
+      base.private_class_method :add_cached_associations_to_coder
       base.instance_eval(ruby = <<-CODE, __FILE__, __LINE__)
         private :expire_cache, :was_new_record?, :fetch_denormalized_cached_association,
                 :populate_denormalized_cached_association
@@ -27,7 +32,9 @@ module IdentityCache
         if IdentityCache.should_cache?
 
           require_if_necessary do
-            object = IdentityCache.fetch(rails_cache_key(id)){ resolve_cache_miss(id) }
+            object = nil
+            coder = IdentityCache.fetch(rails_cache_key(id)){ coder_from_record(object = resolve_cache_miss(id)) }
+            object ||= record_from_coder(coder)
             IdentityCache.logger.error "[IDC id mismatch] fetch_by_id_requested=#{id} fetch_by_id_got=#{object.id} for #{object.inspect[(0..100)]} " if object && object.id != id.to_i
             object
           end
@@ -41,7 +48,7 @@ module IdentityCache
       # ActiveRecord::Base.find, will raise ActiveRecord::RecordNotFound exception
       # if id is not in the cache or the db.
       def fetch(id)
-        fetch_by_id(id) or raise(ActiveRecord::RecordNotFound, "Couldn't find #{self.class.name} with ID=#{id}")
+        fetch_by_id(id) or raise(ActiveRecord::RecordNotFound, "Couldn't find #{self.name} with ID=#{id}")
       end
 
       # Default fetcher added to the model on inclusion, if behaves like
@@ -55,14 +62,14 @@ module IdentityCache
             cache_keys = ids.map {|id| rails_cache_key(id) }
             key_to_id_map = Hash[ cache_keys.zip(ids) ]
 
-            objects_by_key = IdentityCache.fetch_multi(*cache_keys) do |unresolved_keys|
+            coders_by_key = IdentityCache.fetch_multi(*cache_keys) do |unresolved_keys|
               ids = unresolved_keys.map {|key| key_to_id_map[key] }
               records = find_batch(ids, options)
               records.compact.each(&:populate_association_caches)
-              records
+              records.map {|record| coder_from_record(record) }
             end
 
-            records = cache_keys.map {|key| objects_by_key[key] }.compact
+            records = cache_keys.map {|key| record_from_coder(coders_by_key[key]) }.compact
             prefetch_associations(options[:includes], records) if options[:includes]
 
             records
@@ -73,6 +80,82 @@ module IdentityCache
         end
       end
 
+      def record_from_coder(coder) #:nodoc:
+        if coder.present? && coder.has_key?(:class)
+          record = coder[:class].allocate
+          unless coder[:class].serialized_attributes.empty?
+            coder = coder.dup
+            coder['attributes'] = coder['attributes'].dup
+          end
+          if record.class._initialize_callbacks.empty?
+            record.instance_eval do
+              @attributes = self.class.initialize_attributes(coder['attributes'])
+              @relation = nil
+
+              @attributes_cache, @previously_changed, @changed_attributes = {}, {}, {}
+              @association_cache = {}
+              @aggregation_cache = {}
+              @readonly = @destroyed = @marked_for_destruction = false
+              @new_record = false
+            end
+          else
+            record.init_with(coder)
+          end
+
+          coder[:associations].each {|name, value| set_embedded_association(record, name, value) } if coder.has_key?(:associations)
+          coder[:normalized_has_many].each {|name, ids| record.instance_variable_set(:"@#{record.class.cached_has_manys[name][:ids_variable_name]}", ids) } if coder.has_key?(:normalized_has_many)
+          record
+        end
+      end
+
+      def set_embedded_association(record, association_name, coder_or_array) #:nodoc:
+        value = if IdentityCache.unmap_cached_nil_for(coder_or_array).nil?
+          nil
+        elsif (reflection = record.class.reflect_on_association(association_name)).collection?
+          association = reflection.association_class.new(record, reflection)
+          association.target = coder_or_array.map {|e| record_from_coder(e) }
+          association.target.each {|e| association.set_inverse_instance(e) }
+          association.proxy
+        else
+          record_from_coder(coder_or_array)
+        end
+        variable_name = record.class.all_embedded_associations[association_name][:records_variable_name]
+        record.instance_variable_set(:"@#{variable_name}", IdentityCache.map_cached_nil_for(value))
+      end
+
+      def get_embedded_association(record, association, options) #:nodoc:
+        embedded_variable = record.instance_variable_get(:"@#{options[:records_variable_name]}")
+        if IdentityCache.unmap_cached_nil_for(embedded_variable).nil?
+          nil
+        elsif record.class.reflect_on_association(association).collection?
+          embedded_variable.map {|e| coder_from_record(e) }
+        else
+          coder_from_record(embedded_variable)
+        end
+      end
+
+      def coder_from_record(record) #:nodoc:
+        unless record.nil?
+          coder = {:class => record.class }
+          record.encode_with(coder)
+          add_cached_associations_to_coder(record, coder)
+          coder
+        end
+      end
+
+      def add_cached_associations_to_coder(record, coder)
+        if record.class.respond_to?(:all_embedded_associations) && record.class.all_embedded_associations.present?
+          coder[:associations] = record.class.all_embedded_associations.each_with_object({}) do |(name, options), hash|
+            hash[name] = IdentityCache.map_cached_nil_for(get_embedded_association(record, name, options))
+          end
+        end
+        if record.class.respond_to?(:cached_has_manys) && record.class.cached_has_manys.present?
+          coder[:normalized_has_many] = record.class.cached_has_manys.each_with_object({}) do |(name, options), hash|
+            hash[name] = record.instance_variable_get(:"@#{options[:ids_variable_name]}") unless options[:embed]
+          end
+        end
+      end
+
       def require_if_necessary #:nodoc:
         # mem_cache_store returns raw value if unmarshal fails
         rval = yield
@@ -97,6 +180,12 @@ module IdentityCache
         end
       end
 
+      def all_embedded_associations
+        all_cached_associations.select do |cached_association, options|
+          options[:embed].present?
+        end
+      end
+
       def all_cached_associations
         (cached_has_manys || {}).merge(cached_has_ones || {}).merge(cached_belongs_tos || {})
       end
@@ -264,13 +353,18 @@ module IdentityCache
 
     def expire_primary_index # :nodoc:
       return unless self.class.primary_cache_index_enabled
-      extra_keys = if respond_to? :updated_at
-        old_updated_at = old_values_for_fields([:updated_at]).first
-        "expiring_last_updated_at=#{old_updated_at}"
-      else
-        ""
+
+      IdentityCache.logger.debug do
+        extra_keys =
+          if respond_to?(:updated_at)
+            old_updated_at = old_values_for_fields([:updated_at]).first
+            "expiring_last_updated_at=#{old_updated_at}"
+          else
+            ""
+          end
+
+        "[IdentityCache] expiring=#{self.class.name} expiring_id=#{id} #{extra_keys}"
       end
-      IdentityCache.logger.debug { "[IdentityCache] expiring=#{self.class.name} expiring_id=#{id} #{extra_keys}" }
 
       IdentityCache.cache.delete(primary_cache_index_key)
     end

data/lib/identity_cache/version.rb

@@ -1,3 +1,4 @@
 module IdentityCache
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
+  CACHE_VERSION = 3
 end

data/performance/cache_runner.rb

@@ -37,6 +37,7 @@ def create_database(count)
   # set up associations
   Record.cache_has_one :associated
   Record.cache_has_many :associated_records, :embed => true
+  Record.cache_has_many :normalized_associated_records, :embed => false
   Record.cache_index :title, :unique => :true
   AssociatedRecord.cache_has_many :deeply_associated_records, :embed => true
 
@@ -54,6 +55,7 @@ def create_database(count)
       a.associated_records
       (1..5).each do |j|
         a.associated_records << AssociatedRecord.new(name: "Has Many #{j} for #{i}")
+        a.normalized_associated_records << NormalizedAssociatedRecord.new(name: "Normalized Has Many #{j} for #{i}")
       end
       a.save
     end
@@ -74,49 +76,76 @@ end
 
 class FindRunner < CacheRunner
   def run
-    i = 1
-    @count.times do
+    (1..@count).each do |i|
       ::Record.find(i)
-      i+=1
     end
   end
 end
 
-class FetchMissRunner < CacheRunner
+module MissRunner
   def prepare
     IdentityCache.cache.clear
   end
+end
+
+class FetchMissRunner < CacheRunner
+  include MissRunner
 
   def run
-    i = 1
-    @count.times do
+    (1..@count).each do |i|
       rec = ::Record.fetch(i)
       rec.fetch_associated
       rec.fetch_associated_records
+    end
+  end
+end
 
-      i+=1
+class DoubleFetchMissRunner < CacheRunner
+  include MissRunner
+
+  def run
+    (1..@count).each do |i|
+      rec = ::Record.fetch(i)
+      rec.fetch_associated
+      rec.fetch_associated_records
+      rec.fetch_normalized_associated_records
     end
   end
 end
 
-class FetchHitRunner < CacheRunner
+module HitRunner
   def prepare
     IdentityCache.cache.clear
-    i = 1
-    @count.times do
-      ::Record.fetch(i)
-      i+=1
+    (1..@count).each do |i|
+      rec = ::Record.fetch(i)
+      rec.fetch_normalized_associated_records
     end
   end
+end
+
+class FetchHitRunner < CacheRunner
+  include HitRunner
+
+  def run
+    (1..@count).each do |i|
+      rec = ::Record.fetch(i)
+      # these should all be no cost
+      rec.fetch_associated
+      rec.fetch_associated_records
+    end
+  end
+end
+
+class DoubleFetchHitRunner < CacheRunner
+  include HitRunner
 
   def run
-    i = 1
-    @count.times do
+    (1..@count).each do |i|
       rec = ::Record.fetch(i)
       # these should all be no cost
       rec.fetch_associated
       rec.fetch_associated_records
-      i+=1
+      rec.fetch_normalized_associated_records
     end
   end
 end

data/performance/cpu.rb

@@ -25,4 +25,7 @@ Benchmark.bmbm do |x|
 
   run(FetchHitRunner.new(RUNS), x)
 
+  run(DoubleFetchHitRunner.new(RUNS), x)
+
+  run(DoubleFetchMissRunner.new(RUNS), x)
 end

data/performance/externals.rb

@@ -43,3 +43,7 @@ run(FindRunner.new(RUNS))
 run(FetchHitRunner.new(RUNS))
 
 run(FetchMissRunner.new(RUNS))
+
+run(DoubleFetchHitRunner.new(RUNS))
+
+run(DoubleFetchMissRunner.new(RUNS))

data/performance/profile.rb

@@ -24,3 +24,7 @@ run(FindRunner.new(RUNS))
 run(FetchMissRunner.new(RUNS))
 
 run(FetchHitRunner.new(RUNS))
+
+run(DoubleFetchHitRunner.new(RUNS))
+
+run(DoubleFetchMissRunner.new(RUNS))

data/test/attribute_cache_test.rb

@@ -1,6 +1,8 @@
 require "test_helper"
 
 class AttributeCacheTest < IdentityCache::TestCase
+  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE
+
   def setup
     super
     AssociatedRecord.cache_attribute :name
@@ -8,8 +10,8 @@ class AttributeCacheTest < IdentityCache::TestCase
 
     @parent = Record.create!(:title => 'bob')
     @record = @parent.associated_records.create!(:name => 'foo')
-    @name_attribute_key = "IDC:attribute:AssociatedRecord:name:id:#{cache_hash(@record.id.to_s)}"
-    @blob_key = "IDC:blob:AssociatedRecord:#{cache_hash("id:integer,name:string,record_id:integer")}:1"
+    @name_attribute_key = "#{NAMESPACE}attribute:AssociatedRecord:name:id:#{cache_hash(@record.id.to_s)}"
+    @blob_key = "#{NAMESPACE}blob:AssociatedRecord:#{cache_hash("id:integer,name:string,record_id:integer")}:1"
   end
 
   def test_attribute_values_are_returned_on_cache_hits
@@ -57,7 +59,7 @@ class AttributeCacheTest < IdentityCache::TestCase
   end
 
   def test_cached_attribute_values_are_expired_from_the_cache_when_a_new_record_is_saved
-    IdentityCache.cache.expects(:delete).with("IDC:blob:AssociatedRecord:#{cache_hash("id:integer,name:string,record_id:integer")}:2")
+    IdentityCache.cache.expects(:delete).with("#{NAMESPACE}blob:AssociatedRecord:#{cache_hash("id:integer,name:string,record_id:integer")}:2")
     @parent.associated_records.create(:name => 'bar')
   end
 

data/test/cache_hash_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class CacheHashTest < IdentityCache::TestCase
+
+  def test_memcache_hash
+
+    prng = Random.new(Time.now.to_i)
+    3.times do
+      random_str = Array.new(200){rand(36).to_s(36)}.join
+      hash_val = IdentityCache.memcache_hash(random_str)
+      assert hash_val
+      assert_kind_of Numeric, hash_val
+      assert_equal 0, (hash_val >> 64)
+    end
+  end
+end

data/test/fetch_multi_test.rb

@@ -1,26 +1,39 @@
 require "test_helper"
 
 class FetchMultiTest < IdentityCache::TestCase
+  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE unless const_defined?(:NAMESPACE)
+
   def setup
     super
     @bob = Record.create!(:title => 'bob')
     @joe = Record.create!(:title => 'joe')
     @fred = Record.create!(:title => 'fred')
-    @bob_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
-    @joe_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:2"
-    @fred_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:3"
-    @tenth_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:10"
+    @bob_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
+    @joe_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:2"
+    @fred_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:3"
+    @tenth_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:10"
   end
 
   def test_fetch_multi_with_no_records
     assert_equal [], Record.fetch_multi
   end
 
+  def test_fetch_multi_namespace
+    Record.send(:include, SwitchNamespace)
+    bob_blob_key, joe_blob_key, fred_blob_key = [@bob_blob_key, @joe_blob_key, @fred_blob_key].map { |k| "ns:#{k}" }
+    cache_response = {}
+    cache_response[bob_blob_key] = cache_response_for(@bob)
+    cache_response[joe_blob_key] = cache_response_for(@joe)
+    cache_response[fred_blob_key] = cache_response_for(@fred)
+    IdentityCache.cache.expects(:read_multi).with(bob_blob_key, joe_blob_key, fred_blob_key).returns(cache_response)
+    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
+  end
+
   def test_fetch_multi_with_all_hits
     cache_response = {}
-    cache_response[@bob_blob_key] = @bob
-    cache_response[@joe_blob_key] = @joe
-    cache_response[@fred_blob_key] = @fred
+    cache_response[@bob_blob_key] = cache_response_for(@bob)
+    cache_response[@joe_blob_key] = cache_response_for(@joe)
+    cache_response[@fred_blob_key] = cache_response_for(@fred)
     IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @joe_blob_key, @fred_blob_key).returns(cache_response)
     assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
   end
@@ -36,9 +49,9 @@ class FetchMultiTest < IdentityCache::TestCase
 
   def test_fetch_multi_with_mixed_hits_and_misses
     cache_response = {}
-    cache_response[@bob_blob_key] = @bob
+    cache_response[@bob_blob_key] = cache_response_for(@bob)
     cache_response[@joe_blob_key] = nil
-    cache_response[@fred_blob_key] = @fred
+    cache_response[@fred_blob_key] = cache_response_for(@fred)
     IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @joe_blob_key, @fred_blob_key).returns(cache_response)
     assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
   end
@@ -47,7 +60,7 @@ class FetchMultiTest < IdentityCache::TestCase
     cache_response = {}
     cache_response[@bob_blob_key] = nil
     cache_response[@joe_blob_key] = nil
-    cache_response[@fred_blob_key] = @fred
+    cache_response[@fred_blob_key] = cache_response_for(@fred)
     IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @fred_blob_key, @joe_blob_key).returns(cache_response)
     assert_equal [@bob, @fred, @joe], Record.fetch_multi(@bob.id, @fred.id, @joe.id)
   end
@@ -117,8 +130,8 @@ class FetchMultiTest < IdentityCache::TestCase
 
   def test_fetch_multi_doesnt_freeze_keys
     cache_response = {}
-    cache_response[@bob_blob_key] = @bob
-    cache_response[@joe_blob_key] = @fred
+    cache_response[@bob_blob_key] = cache_response_for(@bob)
+    cache_response[@joe_blob_key] = cache_response_for(@fred)
 
     IdentityCache.expects(:fetch_multi).with{ |*args| args.none?(&:frozen?) }.returns(cache_response)
 
@@ -132,6 +145,12 @@ class FetchMultiTest < IdentityCache::TestCase
     @cache_response[@bob_blob_key] = nil
     @cache_response[@joe_blob_key] = nil
     @cache_response[@tenth_blob_key] = nil
-    @cache_response[@fred_blob_key] = @fred
+    @cache_response[@fred_blob_key] = cache_response_for(@fred)
+  end
+
+  def cache_response_for(record)
+    coder = {:class => record.class}
+    record.encode_with(coder)
+    coder
   end
 end