record-cache 0.1.2 → 0.1.3

data/lib/record_cache/multi_read.rb

@@ -6,6 +6,8 @@
 #
 # Important: Because of a bug in Dalli, read_multi is quite slow on some machines.
 #            @see https://github.com/mperham/dalli/issues/106
+require "set"
+
 module RecordCache
   module MultiRead
     @tested = Set.new
@@ -48,4 +50,15 @@ module RecordCache
       end
     end
   end
-end
+end
+
+# Exposes Dalli's +multi+ functionality in ActiveSupport::Cache implementation of Dalli
+module ActiveSupport
+  module Cache
+    class DalliStore
+      def multi(&block)
+        dalli.multi(&block)
+      end
+    end
+  end
+end if defined?(::ActiveSupport::Cache::DalliStore)

data/lib/record_cache/query.rb

@@ -8,7 +8,7 @@ module RecordCache
       @wheres = equality || {}
       @sort_orders = []
       @limit = nil
-      @where_ids = {}
+      @where_values = {}
     end
 
     # Set equality of an attribute (usually found in where clause)
@@ -16,19 +16,23 @@ module RecordCache
       @wheres[attribute.to_sym] = values if attribute
     end
 
-    # Retrieve the ids (array of positive integers) for the given attribute from the where statements
+    # Retrieve the values for the given attribute from the where statements
     # Returns nil if no the attribute is not present
-    def where_ids(attribute)
-      return @where_ids[attribute] if @where_ids.key?(attribute)
-      @where_ids[attribute] ||= array_of_positive_integers(@wheres[attribute])
+    # @param attribute: the attribute name
+    # @param type: the type to be retrieved, :integer or :string (defaults to :integer)
+    def where_values(attribute, type = :integer)
+      return @where_values[attribute] if @where_values.key?(attribute)
+      @where_values[attribute] ||= array_of_values(@wheres[attribute], type)
     end
 
-    # Retrieve the single id (positive integer) for the given attribute from the where statements
-    # Returns nil if no the attribute is not present, or if it contains an array
-    def where_id(attribute)
-      ids = where_ids(attribute)
-      return nil unless ids && ids.size == 1
-      ids.first
+    # Retrieve the single value for the given attribute from the where statements
+    # Returns nil if the attribute is not present, or if it contains multiple values
+    # @param attribute: the attribute name
+    # @param type: the type to be retrieved, :integer or :string (defaults to :integer)
+    def where_value(attribute, type = :integer)
+      values = where_values(attribute, type)
+      return nil unless values && values.size == 1
+      values.first
     end
 
     # Add a sort order to the query
@@ -44,17 +48,18 @@ module RecordCache
       @limit = limit.to_i
     end
 
-    # retrieve a unique key for this Query (used in RequestCache)
+    # DEPRECATED: retrieve a unique key for this Query (used in RequestCache)
     def cache_key
       @cache_key ||= generate_key
     end
 
+    # DEPRECATED
     def to_s
       s = "SELECT "
       s << @wheres.map{|k,v| "#{k} = #{v.inspect}"}.join(" AND ")
-      if @sort_orders.size > 0
-        order_by = @sort_orders.map{|attr,asc| "#{attr} #{asc ? 'ASC' : 'DESC'}"}.join(', ')
-        s << " ORDER_BY #{order_by}"
+      if sorted?
+        order_by_clause = @sort_orders.map{|attr,asc| "#{attr} #{asc ? 'ASC' : 'DESC'}"}.join(', ')
+        s << " ORDER_BY #{order_by_clause}"
       end
       s << " LIMIT #{@limit}" if @limit
       s
@@ -63,20 +68,26 @@ module RecordCache
     private
 
     def generate_key
-      key = @wheres.map{|k,v| "#{k}=#{v.inspect}"}.join("&")
-      if @sort_orders
-        order_by = @sort_orders.map{|attr,asc| "#{attr}=#{asc ? 'A' : 'D'}"}.join('-')
-        key << ".#{order_by}"
+      key = ""
+      key << @limit.to_s if @limit
+      key << @sort_orders.map{|attr,asc| "#{asc ? '+' : '-'}#{attr}"}.join if sorted?
+      if @wheres.any?
+        key << "?"
+        key << @wheres.map{|k,v| "#{k}=#{v.inspect}"}.join("&")
       end
-      key << "L#{@limit}" if @limit
       key
     end
-    
-    def array_of_positive_integers(values)
+
+    def array_of_values(values, type)
       return nil unless values
-      values = [values] unless values.is_a?(Array)
-      values = values.map{|value| value.to_i} unless values.first.is_a?(Fixnum)
-      return nil unless values.all?{ |value| value > 0 } # all values must be positive integers
+      values = values.is_a?(Array) ? values.dup : [values]
+      values.compact!
+      if type == :integer
+        values = values.map{|value| value.to_i} unless values.first.is_a?(Fixnum)
+        return nil unless values.all?{ |value| value && value > 0 } # all values must be positive integers
+      elsif type == :string
+        values = values.map{|value| value.to_s} unless values.first.is_a?(String)
+      end
       values
     end
 

data/lib/record_cache/statistics.rb

@@ -32,13 +32,13 @@ module RecordCache
         stats.each{ |s| s.reset! }
       end
 
-      # Retrieve the statistics for the given base and strategy_id
-      # Returns a hash {<stategy_id> => <statistics} for a model if no strategy is provided
-      # Returns a hash of hashes { <model_name> => {<stategy_id> => <statistics} } if no parameter is provided
-      def find(base = nil, strategy_id = nil)
+      # Retrieve the statistics for the given base and attribute
+      # Returns a hash {<attribute> => <statistics} for a model if no strategy is provided
+      # Returns a hash of hashes { <model_name> => {<attribute> => <statistics} } if no parameter is provided
+      def find(base = nil, attribute = nil)
         stats = (@stats ||= {})
         stats = (stats[base.name] ||= {}) if base
-        stats = (stats[strategy_id] ||= Counter.new) if strategy_id
+        stats = (stats[attribute] ||= Counter.new) if attribute
         stats
       end
     end

data/lib/record_cache/strategy/base.rb

@@ -2,11 +2,23 @@ module RecordCache
   module Strategy
     class Base
 
-      def initialize(base, strategy_id, record_store, options)
+      # Parse the options and return (an array of) instances of this strategy.
+      def self.parse(base, record_store, options)
+        raise NotImplementedError
+      end
+
+      def initialize(base, attribute, record_store, options)
         @base = base
-        @strategy_id = strategy_id
-        @record_store = record_store
-        @cache_key_prefix = "rc/#{options[:key] || @base.name}/".freeze
+        @attribute = attribute
+        @record_store = with_multi_support(record_store)
+        @cache_key_prefix = "rc/#{options[:key] || @base.name}/"
+        @version_opts = options[:ttl] ? { :ttl => options[:ttl] } : {}
+      end
+
+      # Retrieve the +attribute+ for this strategy (unique per model).
+      # May be a non-existing attribute in case a cache is not based on a single attribute.
+      def attribute
+        @attribute
       end
 
       # Fetch all records and sort and filter locally
@@ -14,57 +26,75 @@ module RecordCache
         records = fetch_records(query)
         Util.filter!(records, query.wheres) if query.wheres.size > 0
         Util.sort!(records, query.sort_orders) if query.sorted?
+        records = records[0..query.limit-1] if query.limit
         records
       end
 
-      # Handle create/update/destroy (use record.previous_changes to find the old values in case of an update)
-      def record_change(record, action)
+      # Can the cache retrieve the records based on this query?
+      def cacheable?(query)
         raise NotImplementedError
       end
 
-      # Can the cache retrieve the records based on this query?
-      def cacheable?(query)
+      # Handle create/update/destroy (use record.previous_changes to find the old values in case of an update)
+      def record_change(record, action)
         raise NotImplementedError
       end
 
       # Handle invalidation call
       def invalidate(id)
-        raise NotImplementedError
+        version_store.renew(cache_key(id), version_opts)
       end
 
       protected
-  
+
       def fetch_records(query)
         raise NotImplementedError
       end
-  
+
       # ------------------------- Utility methods ----------------------------
-  
+
       # retrieve the version store (unique store for the whole application)
       def version_store
         RecordCache::Base.version_store
       end
-      
+
+      # should be used when calling version_store.renew(..., version_opts)
+      def version_opts
+        @version_opts
+      end
+
       # retrieve the record store (store for records for this cache strategy)
       def record_store
         @record_store
       end
-      
+
       # find the statistics for this cache strategy
       def statistics
-        @statistics ||= RecordCache::Statistics.find(@base, @strategy_id)
+        @statistics ||= RecordCache::Statistics.find(@base, @attribute)
       end
 
       # retrieve the cache key for the given id, e.g. rc/person/14
       def cache_key(id)
-        "#{@cache_key_prefix}#{id}".freeze
+        "#{@cache_key_prefix}#{id}"
       end
-  
+
       # retrieve the versioned record key, e.g. rc/person/14v1
       def versioned_key(cache_key, version)
-        "#{cache_key}v#{version.to_s}".freeze
+        "#{cache_key}v#{version.to_s}"
+      end
+
+      private
+
+      # add default implementation for multi support to perform multiple cache calls in a pipelined fashion
+      def with_multi_support(cache_store)
+        unless cache_store.respond_to?(:multi)
+          cache_store.send(:define_singleton_method, :multi) do |&block|
+            block.call
+          end
+        end
+        cache_store
       end
-  
+
     end
   end
 end

data/lib/record_cache/strategy/full_table_cache.rb

@@ -0,0 +1,81 @@
+module RecordCache
+  module Strategy
+    class FullTableCache < Base
+      FULL_TABLE = 'full-table'
+
+      # parse the options and return (an array of) instances of this strategy
+      def self.parse(base, record_store, options)
+        return nil unless options[:full_table]
+        return nil unless base.table_exists?
+        
+        FullTableCache.new(base, :full_table, record_store, options)
+      end
+
+      # Can the cache retrieve the records based on this query?
+      def cacheable?(query)
+        true
+      end
+
+      # Clear the cache on any record change
+      def record_change(record, action)
+        version_store.delete(cache_key(FULL_TABLE))
+      end
+
+      protected
+
+      # retrieve the record(s) with the given id(s) as an array
+      def fetch_records(query)
+        key = cache_key(FULL_TABLE)
+        # retrieve the current version of the records
+        current_version = version_store.current(key)
+        # get the records from the cache if there is a current version
+        records = current_version ? from_cache(key, current_version) : nil
+        # logging (only in debug mode!) and statistics
+        log_full_table_cache_hit(key, records) if RecordCache::Base.logger.debug?
+        statistics.add(1, records ? 1 : 0) if statistics.active?
+        # no records found?
+        unless records
+          # renew the version in case the version was not known
+          current_version ||= version_store.renew(key, version_opts)
+          # retrieve all records from the DB
+          records = from_db(key, current_version)
+        end
+        # return the array
+        records
+      end
+
+      def cache_key(id)
+        super(FULL_TABLE)
+      end
+
+      private
+
+      # ---------------------------- Querying ------------------------------------
+
+      # retrieve the records from the cache with the given keys
+      def from_cache(key, version)
+        records = record_store.read(versioned_key(key, version))
+        records.map{ |record| Util.deserialize(record) } if records
+      end
+
+      # retrieve the records with the given ids from the database
+      def from_db(key, version)
+        RecordCache::Base.without_record_cache do
+          # retrieve the records from the database
+          records = @base.all.to_a
+          # write all records to the cache
+          record_store.write(versioned_key(key, version), records.map{ |record| Util.serialize(record) })
+          records
+        end
+      end
+
+      # ------------------------- Utility methods ----------------------------
+
+      # log cache hit/miss to debug log
+      def log_full_table_cache_hit(key, records)
+        RecordCache::Base.logger.debug{ "FullTableCache #{records ? 'hit' : 'miss'} for model #{@base.name}" }
+      end
+
+    end
+  end
+end

data/lib/record_cache/strategy/index_cache.rb

@@ -2,53 +2,59 @@ module RecordCache
   module Strategy
     class IndexCache < Base
   
-      def initialize(base, strategy_id, record_store, options)
+      # parse the options and return (an array of) instances of this strategy
+      def self.parse(base, record_store, options)
+        return nil unless options[:index]
+        return nil unless base.table_exists?
+        
+        raise "Index cache '#{options[:index].inspect}' on #{base.name} is redundant as index cache queries are handled by the full table cache." if options[:full_table]
+        raise ":index => #{options[:index].inspect} option cannot be used unless 'id' is present on #{base.name}" unless base.columns_hash['id']
+        [options[:index]].flatten.compact.map do |attribute|
+          type = base.columns_hash[attribute.to_s].try(:type)
+          raise "No column found for index '#{attribute}' on #{base.name}." unless type
+          raise "Incorrect type (expected integer, found #{type}) for index '#{attribute}' on #{base.name}." unless type == :integer
+          IndexCache.new(base, attribute, record_store, options)
+        end
+      end
+
+      def initialize(base, attribute, record_store, options)
         super
-        @index = options[:index]
-        # check the index
-        type = @base.columns_hash[@index.to_s].try(:type)
-        raise "No column found for index '#{@index}' on #{@base.name}." unless type
-        raise "Incorrect type (expected integer, found #{type}) for index '#{@index}' on #{@base.name}." unless type == :integer
-        @index_cache_key_prefix = cache_key(@index) # "/rc/<model>/<index>"
+        @cache_key_prefix << "#{attribute}="
       end
 
       # Can the cache retrieve the records based on this query?
       def cacheable?(query)
-        query.where_id(@index) && query.limit.nil?
+        # allow limit of 1 for has_one
+        query.where_value(@attribute) && (query.limit.nil? || (query.limit == 1 && !query.sorted?))
       end
 
       # Handle create/update/destroy (use record.previous_changes to find the old values in case of an update)
       def record_change(record, action)
         if action == :destroy
-          remove_from_index(record.send(@index), record.id)
+          remove_from_index(record.send(@attribute), record.id)
         elsif action == :create
-          add_to_index(record.send(@index), record.id)
+          add_to_index(record.send(@attribute), record.id)
         else
-          index_change = record.previous_changes[@index.to_s]
+          index_change = record.previous_changes[@attribute.to_s] || record.previous_changes[@attribute]
           return unless index_change
           remove_from_index(index_change[0], record.id)
           add_to_index(index_change[1], record.id)
         end
       end
 
-      # Explicitly invalidate the record cache for the given value
-      def invalidate(value)
-        version_store.increment(index_cache_key(value))
-      end
-
       protected
 
       # retrieve the record(s) based on the given query
       def fetch_records(query)
-        value = query.where_id(@index)
+        value = query.where_value(@attribute)
         # make sure CacheCase.filter! does not see this where clause anymore
-        query.wheres.delete(@index)
+        query.wheres.delete(@attribute)
         # retrieve the cache key for this index and value
-        key = index_cache_key(value)
+        key = cache_key(value)
         # retrieve the current version of the ids list
         current_version = version_store.current(key)
         # create the versioned key, renew the version in case it was missing in the version store
-        versioned_key = versioned_key(key, current_version || version_store.renew(key))
+        versioned_key = versioned_key(key, current_version || version_store.renew(key, version_opts))
         # retrieve the ids from the local cache based on the current version from the version store
         ids = current_version ? fetch_ids_from_cache(versioned_key) : nil
         # logging (only in debug mode!) and statistics
@@ -59,16 +65,11 @@ module RecordCache
         # use the IdCache to retrieve the records based on the ids
         @base.record_cache[:id].send(:fetch_records, ::RecordCache::Query.new({:id => ids}))
       end
-  
+
       private
   
       # ---------------------------- Querying ------------------------------------
   
-      # key to retrieve the ids for a given value
-      def index_cache_key(value)
-        "#{@index_cache_key_prefix}=#{value}"
-      end
-  
       # Retrieve the ids from the local cache
       def fetch_ids_from_cache(versioned_key)
         record_store.read(versioned_key)
@@ -78,7 +79,7 @@ module RecordCache
       def fetch_ids_from_db(versioned_key, value)
         RecordCache::Base.without_record_cache do
           # go straight to SQL result for optimal performance
-          sql = @base.select('id').where(@index => value).to_sql
+          sql = @base.select('id').where(@attribute => value).to_sql
           ids = []; @base.connection.execute(sql).each{ |row| ids << (row.is_a?(Hash) ? row['id'] : row.first).to_i }
           record_store.write(versioned_key, ids)
           ids
@@ -89,25 +90,26 @@ module RecordCache
   
       # add one record(id) to the index with the given value
       def add_to_index(value, id)
-        increment_version(value.to_i) { |ids| ids << id } if value
+        renew_version(value.to_i) { |ids| ids << id } if value
       end
 
       # remove one record(id) from the index with the given value
       def remove_from_index(value, id)
-        increment_version(value.to_i) { |ids| ids.delete(id) } if value
+        renew_version(value.to_i) { |ids| ids.delete(id) } if value
       end
 
-      # increment the version store and update the local store
-      def increment_version(value, &block)
+      # renew the version store and update the local store
+      def renew_version(value, &block)
         # retrieve local version and increment version store
-        key = index_cache_key(value)
-        version = version_store.increment(key)
+        key = cache_key(value)
+        old_version = version_store.current(key)
+        new_version = version_store.renew(key, version_opts)
         # try to update the ids list based on the last version
-        ids = fetch_ids_from_cache(versioned_key(key, version - 1))
+        ids = fetch_ids_from_cache(versioned_key(key, old_version))
         if ids
           ids = Array.new(ids)
           yield ids
-          record_store.write(versioned_key(key, version), ids)
+          record_store.write(versioned_key(key, new_version), ids)
         end
       end
   
@@ -115,7 +117,7 @@ module RecordCache
   
       # log cache hit/miss to debug log
       def log_cache_hit(key, ids)
-        RecordCache::Base.logger.debug("IndexCache #{ids ? 'hit' : 'miss'} for #{key}: found #{ids ? ids.size : 'no'} ids")
+        RecordCache::Base.logger.debug{ "IndexCache #{ids ? 'hit' : 'miss'} for #{key}: found #{ids ? ids.size : 'no'} ids" }
       end
     end
   end