record-cache 0.1.0

data/lib/record-cache.rb

@@ -0,0 +1 @@
+require 'record_cache'

data/lib/record_cache/active_record.rb

@@ -0,0 +1,318 @@
+module RecordCache
+  module ActiveRecord
+
+    module Base
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+          klass.class_eval do
+            class << self
+              alias_method_chain :find_by_sql, :record_cache
+            end
+          end
+          include InstanceMethods
+        end
+      end
+
+      module ClassMethods
+
+        # add cache invalidation hooks on initialization
+        def record_cache_init
+          after_commit :record_cache_create,  :on => :create
+          after_commit :record_cache_update,  :on => :update
+          after_commit :record_cache_destroy, :on => :destroy
+        end
+  
+        # Retrieve the records, possibly from cache
+        def find_by_sql_with_record_cache(*args)
+           # no caching please
+          return find_by_sql_without_record_cache(*args) unless record_cache?
+
+          # check the piggy-back'd ActiveRelation record to see if the query can be retrieved from cache
+          sql = args[0]
+          arel = sql.instance_variable_get(:@arel)
+          query = arel ? RecordCache::Arel::QueryVisitor.new.accept(arel.ast) : nil
+          cacheable = query && record_cache.cacheable?(query)
+          # log only in debug mode!
+          RecordCache::Base.logger.debug("#{cacheable ? 'Fetch from cache' : 'Not cacheable'} (#{query}): SQL = #{sql}") if RecordCache::Base.logger.debug?
+          # retrieve the records from cache if the query is cacheable otherwise go straight to the DB
+          cacheable ? record_cache.fetch(query) : find_by_sql_without_record_cache(*args)
+        end
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+
+  module Arel
+
+    # The method <ActiveRecord::Base>.find_by_sql is used to actually
+    # retrieve the data from the DB.
+    # Unfortunately the ActiveRelation record is not accessible from
+    # there, so it is piggy-back'd in the SQL string.
+    module TreeManager
+      def self.included(klass)
+        klass.extend ClassMethods
+        klass.send(:include, InstanceMethods)
+        klass.class_eval do
+          alias_method_chain :to_sql, :record_cache
+        end
+      end
+
+      module ClassMethods
+      end
+  
+      module InstanceMethods
+        def to_sql_with_record_cache
+          sql = to_sql_without_record_cache
+          sql.instance_variable_set(:@arel, self)
+          sql
+        end
+      end
+    end
+    
+    # Visitor for the ActiveRelation to extract a simple cache query
+    # Only accepts single select queries with equality where statements
+    # Rejects queries with grouping / having / offset / etc.
+    class QueryVisitor < ::Arel::Visitors::Visitor
+      def initialize
+        super()
+        @cacheable  = true
+        @query = ::RecordCache::Query.new
+      end
+
+      def accept object
+        super
+        @cacheable ? @query : nil
+      end
+
+      private
+
+      def not_cacheable o
+        @cacheable = false
+      end
+
+      alias :visit_Arel_Nodes_Ordering :not_cacheable
+      
+      alias :visit_Arel_Nodes_TableAlias :not_cacheable
+
+      alias :visit_Arel_Nodes_Sum   :not_cacheable
+      alias :visit_Arel_Nodes_Max   :not_cacheable
+      alias :visit_Arel_Nodes_Avg   :not_cacheable
+      alias :visit_Arel_Nodes_Count :not_cacheable
+
+      alias :visit_Arel_Nodes_StringJoin :not_cacheable
+      alias :visit_Arel_Nodes_InnerJoin  :not_cacheable
+      alias :visit_Arel_Nodes_OuterJoin  :not_cacheable
+
+      alias :visit_Arel_Nodes_DeleteStatement  :not_cacheable
+      alias :visit_Arel_Nodes_InsertStatement  :not_cacheable
+      alias :visit_Arel_Nodes_UpdateStatement  :not_cacheable
+
+
+      alias :unary                              :not_cacheable
+      alias :visit_Arel_Nodes_Group             :unary
+      alias :visit_Arel_Nodes_Having            :unary
+      alias :visit_Arel_Nodes_Not               :unary
+      alias :visit_Arel_Nodes_On                :unary
+      alias :visit_Arel_Nodes_UnqualifiedColumn :unary
+
+      def visit_Arel_Nodes_Offset o
+        @cacheable = false unless o.expr == 0
+      end
+
+      def visit_Arel_Nodes_Values o
+        visit o.expressions if @cacheable
+      end
+
+      def visit_Arel_Nodes_Limit o
+        @query.limit = o.expr
+      end
+      alias :visit_Arel_Nodes_Top :visit_Arel_Nodes_Limit
+
+      def visit_Arel_Nodes_Grouping o
+        return unless @cacheable
+        # "`calendars`.account_id = 5"
+        if @table_name && o.expr =~ /^`#{@table_name}`\.`?(\w*)`?\s*=\s*(\d+)$/
+          @cacheable = @query.where($1, $2.to_i)
+        # "`service_instances`.`id` IN (118,80,120,82)"
+        elsif o.expr =~ /^`#{@table_name}`\.`?(\w*)`?\s*IN\s*\(([\d\s,]+)\)$/
+          @cacheable = @query.where($1, $2.split(',').map(&:to_i))
+        else
+          @cacheable = false
+        end
+      end
+
+      def visit_Arel_Nodes_SelectCore o
+        @cacheable = false unless o.groups.empty?
+        visit o.froms  if @cacheable
+        visit o.wheres if @cacheable
+        # skip o.projections
+      end
+
+      def visit_Arel_Nodes_SelectStatement o
+        @cacheable = false if o.cores.size > 1
+        if @cacheable
+          visit o.offset
+          o.orders.map { |x| handle_order_by(visit x) } if @cacheable && o.orders.size > 0
+          visit o.limit
+          visit o.cores
+        end
+      end
+      
+      def handle_order_by(order)
+        order.to_s.split(",").each do |o|
+          # simple sort order (+peope.id+ can be replaced by +id+, as joins are not allowed anyways)
+          if o.match(/^\s*([\w\.]*)\s*(|ASC|DESC|)\s*$/)
+            asc = $2 == "DESC" ? false : true
+            @query.order_by($1.split('.').last, asc)
+          else
+            @cacheable = false
+          end
+        end
+      end
+
+      def visit_Arel_Table o
+        @table_name = o.name
+      end
+
+      def visit_Arel_Nodes_Ordering o
+        [visit(o.expr), o.descending]
+      end
+
+      def visit_Arel_Attributes_Attribute o
+        o.name.to_sym
+      end
+      alias :visit_Arel_Attributes_Integer   :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_Float     :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_String    :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_Time      :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_Boolean   :visit_Arel_Attributes_Attribute
+
+      def visit_Arel_Nodes_Equality o
+        equality = [visit(o.left), visit(o.right)]
+#        equality.reverse! if equality.last.is_a?(Symbol) || equality.first.is_a?(Fixnum)
+#        p "  =====> equality found: #{equality.first.inspect}@#{equality.first.class.name} => #{equality.last.inspect}@#{equality.last.class.name}"
+        @query.where(equality.first, equality.last)
+      end
+      alias :visit_Arel_Nodes_In                 :visit_Arel_Nodes_Equality
+
+      def visit_Arel_Nodes_And o
+        visit(o.left)
+        visit(o.right)
+      end
+
+      alias :visit_Arel_Nodes_Or                 :not_cacheable
+      alias :visit_Arel_Nodes_NotEqual           :not_cacheable
+      alias :visit_Arel_Nodes_GreaterThan        :not_cacheable
+      alias :visit_Arel_Nodes_GreaterThanOrEqual :not_cacheable
+      alias :visit_Arel_Nodes_Assignment         :not_cacheable
+      alias :visit_Arel_Nodes_LessThan           :not_cacheable
+      alias :visit_Arel_Nodes_LessThanOrEqual    :not_cacheable
+      alias :visit_Arel_Nodes_Between            :not_cacheable
+      alias :visit_Arel_Nodes_NotIn              :not_cacheable
+      alias :visit_Arel_Nodes_DoesNotMatch       :not_cacheable
+      alias :visit_Arel_Nodes_Matches            :not_cacheable
+
+      def visit_Fixnum o
+        o.to_i
+      end
+      alias :visit_Bignum :visit_Fixnum
+
+      def visit_Symbol o
+        o.to_sym
+      end
+
+      def visit_Object o
+        o
+      end
+      alias :visit_Arel_Nodes_SqlLiteral :visit_Object
+      alias :visit_Arel_SqlLiteral :visit_Object # This is deprecated
+      alias :visit_String :visit_Object
+      alias :visit_NilClass :visit_Object
+      alias :visit_TrueClass :visit_Object
+      alias :visit_FalseClass :visit_Object
+      alias :visit_Arel_SqlLiteral :visit_Object
+      alias :visit_BigDecimal :visit_Object
+      alias :visit_Float :visit_Object
+      alias :visit_Time :visit_Object
+      alias :visit_Date :visit_Object
+      alias :visit_DateTime :visit_Object
+      alias :visit_Hash :visit_Object
+
+      def visit_Array o
+        o.map{ |x| visit x }
+      end
+    end
+  end
+
+  # Patch ActiveRecord::Relation to make sure update_all will invalidate all referenced records
+  module ActiveRecord
+    module UpdateAll
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+          klass.send(:include, InstanceMethods)
+          klass.class_eval do
+            alias_method_chain :update_all, :record_cache
+          end
+        end
+      end
+  
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        def update_all_with_record_cache(updates, conditions = nil, options = {})
+          result = update_all_without_record_cache(updates, conditions, options)
+
+          if record_cache?
+            # when this condition is met, the arel.update method will be called on the current scope, see ActiveRecord::Relation#update_all
+            unless conditions || options.present? || @limit_value.present? != @order_values.present?
+              # go straight to SQL result (without instantiating records) for optimal performance
+              connection.execute(select('id').to_sql).each{ |row| record_cache.invalidate(:id, (row.is_a?(Hash) ? row['id'] : row.first).to_i ) }
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+
+  # Patch ActiveRecord::Associations::HasManyAssociation to make sure the index_cache is updated when records are
+  # deleted from the collection
+  module ActiveRecord
+    module HasMany
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+          klass.send(:include, InstanceMethods)
+          klass.class_eval do
+            alias_method_chain :delete_records, :record_cache
+          end
+        end
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        def delete_records_with_record_cache(records)
+          # invalidate :id cache for all records
+          records.each{ |record| record.class.record_cache.invalidate(record.id) if record.class.record_cache? unless record.new_record? }
+          # invalidate the referenced class for the attribute/value pair on the index cache
+          @reflection.klass.record_cache.invalidate(@reflection.primary_key_name.to_sym, @owner.id) if @reflection.klass.record_cache?
+          delete_records_without_record_cache(records)
+        end
+      end
+    end
+  end
+
+end
+
+ActiveRecord::Base.send(:include, RecordCache::ActiveRecord::Base)
+Arel::TreeManager.send(:include, RecordCache::Arel::TreeManager)
+ActiveRecord::Relation.send(:include, RecordCache::ActiveRecord::UpdateAll)
+ActiveRecord::Associations::HasManyAssociation.send(:include, RecordCache::ActiveRecord::HasMany)

data/lib/record_cache/base.rb

@@ -0,0 +1,136 @@
+module RecordCache
+  # Normal mode
+  ENABLED  = 1
+  # Do not fetch queries through the cache (but still update the cache after commit)
+  NO_FETCH = 2
+  # Completely disable the cache (may lead to stale results in case caching for other workers is not DISABLED)
+  DISABLED = 3
+
+  module Base
+    class << self
+      def included(klass)
+        klass.class_eval do 
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+
+      # The logger instance (Rails.logger if present)
+      def logger
+        @logger ||= defined?(::Rails) ? ::Rails.logger : ::ActiveRecord::Base.logger
+      end
+
+      # Set the ActiveSupport::Cache::Store instance that contains the current record(group) versions.
+      # Note that it must point to a single Store shared by all webservers (defaults to Rails.cache)
+      def version_store=(store)
+        @version_store = RecordCache::VersionStore.new(RecordCache::MultiRead.test(store))
+      end
+
+      # The ActiveSupport::Cache::Store instance that contains the current record(group) versions.
+      # Note that it must point to a single Store shared by all webservers (defaults to Rails.cache)
+      def version_store
+        @version_store ||= RecordCache::VersionStore.new(RecordCache::MultiRead.test(Rails.cache))
+      end
+      
+      # Register a store with a specific id for reference with :store in +cache_records+
+      # e.g. RecordCache::Base.register_store(:server, ActiveSupport::Cache.lookup_store(:memory_store))
+      def register_store(id, store)
+        stores[id] = RecordCache::MultiRead.test(store)
+      end
+
+      # The hash of stores (store_id => store)
+      def stores
+        @stores ||= {}
+      end
+
+      # To disable the record cache for all models:
+      #   RecordCache::Base.disabled!
+      # Enable again with:
+      #   RecordCache::Base.enable
+      def disable!
+        @status = RecordCache::DISABLED
+      end
+
+      # Enable record cache
+      def enable
+        @status = RecordCache::ENABLED
+      end
+
+      # Retrieve the current status
+      def status
+        @status ||= RecordCache::ENABLED
+      end
+
+      # execute block of code without using the records cache to fetch records
+      # note that updates are still written to the cache, as otherwise other
+      # workers may receive stale results.
+      # To fully disable caching use +disable!+
+      def without_record_cache(&block)
+        old_status = status
+        begin
+          @status = RecordCache::NO_FETCH
+          yield
+        ensure
+          @status = old_status
+        end
+      end
+    end
+
+    module ClassMethods
+      # Cache the instances of this model
+      # options:
+      #   :store => the cache store for the instances, e.g. :memory_store, :dalli_store* (default: Rails.cache)
+      #             or one of the store ids defined using +RecordCache::Base.register_store+
+      #   :key   => provide a unique shorter key to limit the cache key length (default: model.name)
+      #   :index => one or more attributes (Symbols) for which the ids are cached for the value of the attribute
+      #   :request_cache => Set to true in case the exact same query is executed more than once during a single request
+      #                     If set to true somewhere, make sure to add the following to your application controller:
+      #                     before_filter { |c| RecordCache::Strategy::RequestCache.clear }
+      #
+      # Hints:
+      #   - Dalli is a high performance pure Ruby client for accessing memcached servers, see https://github.com/mperham/dalli
+      #   - use :store => :memory_store in case all records can easily fit in server memory
+      #   - use :index => :account_id in case the records are (almost) always queried as a full set per account
+      #   - use :index => :person_id for aggregated has_many associations
+      def cache_records(options)
+        @rc_dispatcher = RecordCache::Dispatcher.new(self) unless defined?(@rc_dispatcher)
+        store = RecordCache::MultiRead.test(options[:store] ? RecordCache::Base.stores[options[:store]] || ActiveSupport::Cache.lookup_store(options[:store]) : (defined?(::Rails) ? Rails.cache : ActiveSupport::Cache.lookup_store(:memory_store)))
+        # always register an ID Cache
+        record_cache.register(:id, ::RecordCache::Strategy::IdCache, store, options)
+        # parse :index option
+        [options[:index]].flatten.compact.map(&:to_sym).each do |index|
+          record_cache.register(index, ::RecordCache::Strategy::IndexCache, store, options.merge({:index => index}))
+        end
+        # parse :request_cache option
+        record_cache.register(:request_cache, ::RecordCache::Strategy::RequestCache, store, options) if options[:request_cache]
+        # Callback for Data Store specific initialization
+        record_cache_init
+      end
+
+      # Returns true if record cache is defined and active for this class
+      def record_cache?
+        record_cache && RecordCache::Base.status == RecordCache::ENABLED
+      end
+
+      # Returns the RecordCache (class) instance
+      def record_cache
+        @rc_dispatcher
+      end
+    end
+
+    module InstanceMethods
+      def record_cache_create
+        self.class.record_cache.record_change(self, :create) unless RecordCache::Base.status == RecordCache::DISABLED
+      end
+
+      def record_cache_update
+        self.class.record_cache.record_change(self, :update) unless RecordCache::Base.status == RecordCache::DISABLED
+      end
+
+      def record_cache_destroy
+        self.class.record_cache.record_change(self, :destroy) unless RecordCache::Base.status == RecordCache::DISABLED
+      end
+    end
+
+  end
+end

data/lib/record_cache/dispatcher.rb

@@ -0,0 +1,90 @@
+module RecordCache
+  
+  # Every model that calls cache_records will receive an instance of this class
+  # accessible through +<model>.record_cache+
+  #
+  # The dispatcher is responsible for dispatching queries, record_changes and invalidation calls
+  # to the appropriate cache strategies.
+  class Dispatcher
+    def initialize(base)
+      @base = base
+      @strategy_by_id = {}
+      # all strategies except :request_cache, with the :id stategy first (most used and best performing)
+      @ordered_strategies = []
+    end
+
+    # Register a cache strategy for this model
+    def register(strategy_id, strategy_klass, record_store, options)
+      if @strategy_by_id.key?(strategy_id)
+        return if strategy_id == :id
+        raise "Multiple record cache definitions found for '#{strategy_id}' on #{@base.name}"
+      end
+      # Instantiate the cache strategy
+      strategy = strategy_klass.new(@base, strategy_id, record_store, options)
+      # Keep track of all strategies for this model
+      @strategy_by_id[strategy_id] = strategy
+      # Note that the :id strategy is always registered first
+      @ordered_strategies << strategy unless strategy_id == :request_cache
+    end
+
+    # Retrieve the caching strategy for the given attribute
+    def [](strategy_id)
+      @strategy_by_id[strategy_id]
+    end
+
+    # Can the cache retrieve the records based on this query?
+    def cacheable?(query)
+      !!first_cacheable_strategy(query)
+    end
+
+    # retrieve the record(s) with the given id(s) as an array
+    def fetch(query)
+      if request_cache
+        # cache the query in the request
+        request_cache.fetch(query) { fetch_from_first_cacheable_strategy(query) }
+      else
+        # fetch the results using the first strategy that accepts this query
+        fetch_from_first_cacheable_strategy(query)
+      end
+    end
+
+    # Update the version store and the record store (used by callbacks)
+    # @param record the updated record (possibly with
+    # @param action one of :create, :update or :destroy
+    def record_change(record, action)
+      # skip unless something has actually changed
+      return if action == :update && record.previous_changes.empty?
+      # dispatch the record change to all known strategies
+      @strategy_by_id.values.each { |strategy| strategy.record_change(record, action) }
+    end
+
+    # Explicitly invalidate one or more records
+    # @param: strategy: the strategy to invalidate
+    # @param: value: the value to send to the invalidate method of the chosen strategy
+    def invalidate(strategy, value = nil)
+      (value = strategy; strategy = :id) unless strategy.is_a?(Symbol)
+      # call the invalidate method of the chosen strategy
+      @strategy_by_id[strategy].invalidate(value) if @strategy_by_id[strategy]
+      # always clear the request cache if invalidate is explicitly called for this class
+      request_cache.try(:invalidate, value)
+    end
+
+    private
+
+    # retrieve the data from the first strategy that handle the query
+    def fetch_from_first_cacheable_strategy(query)
+      first_cacheable_strategy(query).fetch(query)
+    end
+
+    # find the first strategy that can handle this query
+    def first_cacheable_strategy(query)
+      @ordered_strategies.detect { |strategy| strategy.cacheable?(query) }
+    end
+
+    # retrieve the request cache strategy, if defined for this model
+    def request_cache
+      @strategy_by_id[:request_cache]
+    end
+
+  end
+end

data/lib/record_cache/multi_read.rb

@@ -0,0 +1,51 @@
+# This class will delegate read_multi to sequential read calls in case read_multi is not supported.
+#
+# If a particular Store Class does support read_multi, but is somehow slower because of a bug,
+# you can disable read_multi by calling:
+#   RecordCache::MultiRead.disable(ActiveSupport::Cache::DalliStore)
+#
+# Important: Because of a bug in Dalli, read_multi is quite slow on some machines.
+#            @see https://github.com/mperham/dalli/issues/106
+module RecordCache
+  module MultiRead
+    @tested = Set.new
+    @disabled_klass_names = Set.new
+
+    class << self
+      
+      # Disable multi_read for a particular Store, e.g.
+      #   RecordCache::MultiRead.disable(ActiveSupport::Cache::DalliStore)
+      def disable(klass)
+        @disabled_klass_names << klass.name
+      end
+
+      # Test the store if it supports read_multi calls
+      # If not, delegate multi_read calls to normal read calls
+      def test(store)
+        return store if @tested.include?(store)
+        @tested << store
+        override_read_multi(store) unless read_multi_supported?(store)
+        store
+      end
+
+      private
+
+      def read_multi_supported?(store)
+        return false if @disabled_klass_names.include?(store.class.name)
+        begin
+          store.read_multi('a', 'b')
+          true
+        rescue Exception => ignore
+          false
+        end
+      end
+
+      # delegate read_multi to normal read calls
+      def override_read_multi(store)
+        def store.read_multi(*keys)
+          keys.inject({}){ |h,key| h[key] = self.read(key); h}
+        end
+      end
+    end
+  end
+end

data/lib/record_cache/query.rb

@@ -0,0 +1,85 @@
+module RecordCache
+
+  # Container for the Query parameters
+  class Query
+    attr_reader :wheres, :sort_orders, :limit
+
+    def initialize(equality = nil)
+      @wheres = equality || {}
+      @sort_orders = []
+      @limit = nil
+      @where_ids = {}
+    end
+
+    # Set equality of an attribute (usually found in where clause)
+    # Returns false if another attribute values was already set (making this query uncachable)
+    def where(attribute, values)
+      @wheres[attribute.to_sym] = values if attribute
+    end
+
+    # Retrieve the ids (array of positive integers) 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])
+    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
+    end
+
+    # Add a sort order to the query
+    def order_by(attribute, ascending = true)
+      @sort_orders << [attribute.to_s, ascending]
+    end
+
+    def sorted?
+      @sort_orders.size > 0
+    end
+
+    def limit=(limit)
+      @limit = limit.to_i
+    end
+
+    # retrieve a unique key for this Query (used in RequestCache)
+    def cache_key
+      @cache_key ||= generate_key
+    end
+
+    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}"
+      end
+      s << " LIMIT #{@limit}" if @limit
+      s
+    end
+
+    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}"
+      end
+      key << "L#{@limit}" if @limit
+      key
+    end
+    
+    def array_of_positive_integers(values)
+      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
+    end
+
+  end
+end