record-cache 0.1.2 → 0.1.3

data/lib/record_cache/datastore/active_record_32.rb

@@ -0,0 +1,444 @@
+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
+        end
+      end
+
+      module ClassMethods
+        # the tests are always run within a transaction, so the threshold is one higher
+        RC_TRANSACTIONS_THRESHOLD = ENV['RAILS_ENV'] == 'test' ? 1 : 0
+
+        # add cache invalidation hooks on initialization
+        def record_cache_init
+          after_commit :record_cache_create,  :on => :create,  :prepend => true
+          after_commit :record_cache_update,  :on => :update,  :prepend => true
+          after_commit :record_cache_destroy, :on => :destroy, :prepend => true
+        end
+
+        # Retrieve the records, possibly from cache
+        def find_by_sql_with_record_cache(sql, binds = [])
+          # shortcut, no caching please
+          return find_by_sql_without_record_cache(sql, binds) unless record_cache?
+
+          # check the piggy-back'd ActiveRelation record to see if the query can be retrieved from cache
+          arel = sql.is_a?(String) ? sql.instance_variable_get(:@arel) : sql
+
+          sanitized_sql = sanitize_sql(sql)
+          sanitized_sql = connection.to_sql(sanitized_sql, binds) if sanitized_sql.respond_to?(:ast)
+
+          records = if connection.query_cache_enabled
+                      query_cache = connection.instance_variable_get(:@query_cache)
+                      query_cache["rc/#{sanitized_sql}"][binds] ||= try_record_cache(arel, sanitized_sql, binds)
+                    elsif connection.open_transactions > RC_TRANSACTIONS_THRESHOLD
+                      connection.send(:select, sanitized_sql, "#{name} Load", binds)
+                    else
+                      try_record_cache(arel, sanitized_sql, binds)
+                    end
+          records.collect! { |record| instantiate(record) } if records[0].is_a?(Hash)
+
+          records
+        end
+
+        def try_record_cache(arel, sql, binds)
+          query = arel && arel.respond_to?(:ast) ? RecordCache::Arel::QueryVisitor.new(binds).accept(arel.ast) : nil
+          record_cache.fetch(query) do
+            connection.send(:select, sql, "#{name} Load", binds)
+          end
+        end
+
+      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
+      DESC = "DESC".freeze
+      COMMA = ",".freeze
+
+      def initialize(bindings)
+        super()
+        @bindings = (bindings || []).inject({}){ |h, cv| column, value = cv; h[column.name] = value; h}
+        @cacheable  = true
+        @query = ::RecordCache::Query.new
+      end
+
+      def accept ast
+        super
+        @cacheable && !ast.lock ? @query : nil
+      end
+
+      private
+
+      def not_cacheable o
+        @cacheable = false
+      end
+
+      def skip o
+      end
+
+      alias :visit_Arel_Nodes_TableAlias :not_cacheable
+
+      alias :visit_Arel_Nodes_Lock :not_cacheable
+
+      alias :visit_Arel_Nodes_Sum            :not_cacheable
+      alias :visit_Arel_Nodes_Max            :not_cacheable
+      alias :visit_Arel_Nodes_Min            :not_cacheable
+      alias :visit_Arel_Nodes_Avg            :not_cacheable
+      alias :visit_Arel_Nodes_Count          :not_cacheable
+      alias :visit_Arel_Nodes_Addition       :not_cacheable
+      alias :visit_Arel_Nodes_Subtraction    :not_cacheable
+      alias :visit_Arel_Nodes_Multiplication :not_cacheable
+      alias :visit_Arel_Nodes_NamedFunction  :not_cacheable
+
+      alias :visit_Arel_Nodes_Bin :not_cacheable
+      alias :visit_Arel_Nodes_Distinct :not_cacheable
+      alias :visit_Arel_Nodes_DistinctOn :not_cacheable
+      alias :visit_Arel_Nodes_Division :not_cacheable
+      alias :visit_Arel_Nodes_Except :not_cacheable
+      alias :visit_Arel_Nodes_Exists :not_cacheable
+      alias :visit_Arel_Nodes_InfixOperation :not_cacheable
+      alias :visit_Arel_Nodes_Intersect :not_cacheable
+      alias :visit_Arel_Nodes_Union :not_cacheable
+      alias :visit_Arel_Nodes_UnionAll :not_cacheable
+      alias :visit_Arel_Nodes_With :not_cacheable
+      alias :visit_Arel_Nodes_WithRecursive :not_cacheable
+
+      def visit_Arel_Nodes_JoinSource o
+        # left and right are array, but using blank as it also works for nil
+        @cacheable = o.left.blank? || o.right.blank?
+      end
+
+      alias :visit_Arel_Nodes_CurrentRow :not_cacheable
+      alias :visit_Arel_Nodes_Extract :not_cacheable
+      alias :visit_Arel_Nodes_Following :not_cacheable
+      alias :visit_Arel_Nodes_NamedWindow :not_cacheable
+      alias :visit_Arel_Nodes_Over :not_cacheable
+      alias :visit_Arel_Nodes_Preceding :not_cacheable
+      alias :visit_Arel_Nodes_Range :not_cacheable
+      alias :visit_Arel_Nodes_Rows :not_cacheable
+      alias :visit_Arel_Nodes_Window :not_cacheable
+
+      alias :visit_Arel_Nodes_As :skip
+      alias :visit_Arel_Nodes_Ascending :skip
+      alias :visit_Arel_Nodes_Descending :skip
+      alias :visit_Arel_Nodes_False :skip
+      alias :visit_Arel_Nodes_True :skip
+
+      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
+
+      GROUPING_EQUALS_REGEXP = /^\W?(\w*)\W?\.\W?(\w*)\W?\s*=\s*(\d+)$/        # `calendars`.account_id = 5
+      GROUPING_IN_REGEXP = /^^\W?(\w*)\W?\.\W?(\w*)\W?\s*IN\s*\(([\d\s,]+)\)$/ # `service_instances`.`id` IN (118,80,120,82)
+      def visit_Arel_Nodes_Grouping o
+        return unless @cacheable
+        if @table_name && o.expr =~ GROUPING_EQUALS_REGEXP && $1 == @table_name
+          @cacheable = @query.where($2, $3.to_i)
+        elsif @table_name && o.expr =~ GROUPING_IN_REGEXP && $1 == @table_name
+          @cacheable = @query.where($2, $3.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
+        visit o.source 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
+
+      ORDER_BY_REGEXP = /^\s*([\w\.]*)\s*(|ASC|asc|DESC|desc)\s*$/ # people.id DESC
+      def handle_order_by(order)
+        order.to_s.split(COMMA).each do |o|
+          # simple sort order (+people.id+ can be replaced by +id+, as joins are not allowed anyways)
+          if o.match(ORDER_BY_REGEXP)
+            asc = $2.upcase == 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_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
+      alias :visit_Arel_Attributes_Decimal   :visit_Arel_Attributes_Attribute
+
+      def visit_Arel_Nodes_Equality o
+        key, value = visit(o.left), visit(o.right)
+        # several different binding markers exist depending on the db driver used (MySQL, Postgress supported)
+        if value.to_s =~ /^(\?|\u0000|\$\d+)$/
+          # puts "bindings: #{@bindings.inspect}, key = #{key.to_s}"
+          value = @bindings[key.to_s] || value
+        end
+        # puts "  =====> equality found: #{key.inspect}@#{key.class.name} => #{value.inspect}@#{value.class.name}"
+        @query.where(key, value)
+      end
+      alias :visit_Arel_Nodes_In                 :visit_Arel_Nodes_Equality
+
+      def visit_Arel_Nodes_And o
+        visit(o.children)
+      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_Nodes_BindParam :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
+
+end
+
+module RecordCache
+
+  # 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 __find_in_clause(sub_select)
+          return nil unless sub_select.arel.constraints.count == 1
+          constraint = sub_select.arel.constraints.first
+          return constraint if constraint.is_a?(::Arel::Nodes::In) # directly an IN clause
+          return nil unless constraint.respond_to?(:children) && constraint.children.count == 1
+          constraint = constraint.children.first
+          return constraint if constraint.is_a?(::Arel::Nodes::In) # AND with IN clause
+          nil
+        end
+
+        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?
+              # get all attributes that contain a unique index for this model
+              unique_index_attributes = RecordCache::Strategy::UniqueIndexCache.attributes(self)
+              # go straight to SQL result (without instantiating records) for optimal performance
+              RecordCache::Base.version_store.multi do
+                sub_select = select(unique_index_attributes.map(&:to_s).join(','))
+                in_clause = __find_in_clause(sub_select)
+                if unique_index_attributes.size == 1 && in_clause &&
+                  in_clause.left.try(:name).to_s == unique_index_attributes.first.to_s
+                  # common case where the unique index is the (only) constraint on the query: SELECT id FROM people WHERE id in (...)
+                  attribute = unique_index_attributes.first
+                  in_clause.right.each do |value|
+                    record_cache.invalidate(attribute, value)
+                  end
+                else
+                  connection.execute(sub_select.to_sql).each do |row|
+                    # invalidate the unique index for all attributes
+                    unique_index_attributes.each_with_index do |attribute, index|
+                      record_cache.invalidate(attribute, (row.is_a?(Hash) ? row[attribute.to_s] : row[index]))
+                    end
+                  end
+                end
+              end
+            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, method)
+          # 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.foreign_key.to_sym, @owner.id) if @reflection.klass.record_cache?
+          delete_records_without_record_cache(records, method)
+        end
+      end
+    end
+
+    module HasOne
+      class << self
+        def included(klass)
+          klass.extend ClassMethods
+          klass.send(:include, InstanceMethods)
+          klass.class_eval do
+            alias_method_chain :delete, :record_cache
+          end
+        end
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        def delete_with_record_cache(method = options[:dependent])
+          # invalidate :id cache for all record
+          if load_target
+            target.class.record_cache.invalidate(target.id) if target.class.record_cache? unless target.new_record?
+          end
+          # invalidate the referenced class for the attribute/value pair on the index cache
+          @reflection.klass.record_cache.invalidate(@reflection.foreign_key.to_sym, @owner.id) if @reflection.klass.record_cache?
+          delete_without_record_cache(method)
+        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)
+ActiveRecord::Associations::HasOneAssociation.send(:include, RecordCache::ActiveRecord::HasOne)

data/lib/record_cache/dispatcher.rb

@@ -1,51 +1,48 @@
 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
+
+    # Retrieve all strategies ordered by fastest strategy first.
+    #
+    # Roll your own cache strategies by extending from +RecordCache::Strategy::Base+,
+    # and registering it here +RecordCache::Dispatcher.strategy_classes << MyStrategy+
+    def self.strategy_classes
+      @strategy_classes ||= [RecordCache::Strategy::UniqueIndexCache, RecordCache::Strategy::FullTableCache, RecordCache::Strategy::IndexCache]
+    end
+
     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 = []
+      @strategy_by_attribute = {}
     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}"
+    # Parse the options provided to the cache_records method and create the appropriate cache strategies.
+    def parse(options)
+      # find the record store, possibly based on the :store option
+      store = record_store(options.delete(:store))
+      # dispatch the parse call to all known strategies
+      Dispatcher.strategy_classes.map{ |klass| klass.parse(@base, store, options) }.flatten.compact.each do |strategy|
+        raise "Multiple record cache definitions found for '#{strategy.attribute}' on #{@base.name}" if @strategy_by_attribute[strategy.attribute]
+        # and keep track of all strategies
+        @strategy_by_attribute[strategy.attribute] = strategy
       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
+      # make sure the strategies are ordered again on next call to +ordered_strategies+
+      @ordered_strategies = nil
     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)
+    def [](attribute)
+      @strategy_by_attribute[attribute]
     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
+    # retrieve the record(s) based on the given query (check with cacheable?(query) first)
+    def fetch(query, &block)
+      strategy = query && ordered_strategies.detect { |strategy| strategy.cacheable?(query) }
+      strategy ? strategy.fetch(query) : yield
     end
 
     # Update the version store and the record store (used by callbacks)
@@ -55,35 +52,38 @@ module RecordCache
       # 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) }
+      @strategy_by_attribute.values.each { |strategy| strategy.record_change(record, action) }
     end
 
     # Explicitly invalidate one or more records
-    # @param: strategy: the strategy to invalidate
+    # @param: strategy: the id of the strategy to invalidate (defaults to +:id+)
     # @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)
+      @strategy_by_attribute[strategy].invalidate(value) if @strategy_by_attribute[strategy]
     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)
+    # Find the cache store for the records (using the :store option)
+    def record_store(store)
+      store = RecordCache::Base.stores[store] || ActiveSupport::Cache.lookup_store(store) if store.is_a?(Symbol)
+      store ||= Rails.cache if defined?(::Rails)
+      store ||= ActiveSupport::Cache.lookup_store(:memory_store)
+      RecordCache::MultiRead.test(store)
     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]
+    # Retrieve all strategies ordered by the fastest strategy first (currently :id, :unique, :index)
+    def ordered_strategies
+      @ordered_strategies ||= begin
+        last_index = Dispatcher.strategy_classes.size
+        # sort the strategies based on the +strategy_classes+ index
+        ordered = @strategy_by_attribute.values.sort do |x,y|
+          (Dispatcher.strategy_classes.index(x.class) || last_index) <=> (Dispatcher.strategy_classes.index(y.class) || last_index)
+        end
+        ordered
+      end
     end
 
   end