record-cache 0.1.0 → 0.1.1

data/lib/record_cache/datastore/active_record.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+# basic Record Cache functionality
+ActiveRecord::Base.send(:include, RecordCache::Base)
+
+# To be able to fetch records from the cache and invalidate records in the cache
+# some internal Active Record methods needs to be aliased.
+# The downside of using internal methods, is that they may change in different releases,
+# hence the following code:
+AR_VERSION = ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0 ? 30 : 31
+require File.dirname(__FILE__) + "/active_record_#{AR_VERSION}.rb"

data/lib/record_cache/{active_record.rb → datastore/active_record_30.rb}

@@ -191,10 +191,9 @@ module RecordCache
       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)
+        key, value = visit(o.left), visit(o.right)
+#        p "  =====> 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
 
@@ -247,6 +246,10 @@ module RecordCache
     end
   end
 
+end
+
+module RecordCache
+  
   # Patch ActiveRecord::Relation to make sure update_all will invalidate all referenced records
   module ActiveRecord
     module UpdateAll
@@ -315,4 +318,4 @@ 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::HasManyAssociation.send(:include, RecordCache::ActiveRecord::HasMany)

data/lib/record_cache/datastore/active_record_31.rb

@@ -0,0 +1,330 @@
+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
+          arel = args[0]
+          if arel.is_a?(String)
+            arel = arel.instance_variable_get(:@arel)
+            puts "TODO: RECORD_CACHE !!!!!!!! Found String with arel piggyback: #{arel}"
+          end
+
+          query = arel ? RecordCache::Arel::QueryVisitor.new(args[1]).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 = #{arel.to_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(bindings)
+        super()
+        @bindings = (bindings || []).inject({}){ |h, cv| column, value = cv; h[column.name] = value; h}
+        @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
+        key, value = visit(o.left), visit(o.right)
+        if value.to_s == "?"
+          # puts "bindings: #{@bindings.inspect}, key = #{key.to_s}"
+          value = @bindings[key.to_s] || "?" 
+        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.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
+
+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 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, 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
+  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/version.rb

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

data/lib/record_cache.rb

@@ -1,11 +1,9 @@
-# Record Cache shared files
+# Record Cache files
 ["query", "version_store", "multi_read",
  "strategy/base", "strategy/id_cache", "strategy/index_cache", "strategy/request_cache",
  "statistics", "dispatcher", "base"].each do |file|
   require File.dirname(__FILE__) + "/record_cache/#{file}.rb"
 end
 
-# Support for Active Record
-require 'active_record'
-ActiveRecord::Base.send(:include, RecordCache::Base)
-require File.dirname(__FILE__) + "/record_cache/active_record.rb"
+# Load Data Stores (currently only support for Active Record)
+require File.dirname(__FILE__) + "/record_cache/datastore/active_record.rb"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: record-cache
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Orslumen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-27 00:00:00 Z
+date: 2011-10-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rails
@@ -23,14 +23,13 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">"
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 7
         segments: 
         - 3
         - 0
-        - 10
-        version: 3.0.10
+        version: "3.0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -39,14 +38,13 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">"
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 7
         segments: 
         - 3
         - 0
-        - 10
-        version: 3.0.10
+        version: "3.0"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -158,8 +156,10 @@ extra_rdoc_files: []
 files: 
 - lib/record-cache.rb
 - lib/record_cache.rb
-- lib/record_cache/active_record.rb
 - lib/record_cache/base.rb
+- lib/record_cache/datastore/active_record.rb
+- lib/record_cache/datastore/active_record_30.rb
+- lib/record_cache/datastore/active_record_31.rb
 - lib/record_cache/dispatcher.rb
 - lib/record_cache/multi_read.rb
 - lib/record_cache/query.rb
@@ -223,10 +223,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Record Cache v0.1.0 transparantly stores Records in a Cache Store and retrieve those Records from the store when queried (by ID) using Active Model.
+summary: Record Cache v0.1.1 transparantly stores Records in a Cache Store and retrieve those Records from the store when queried (by ID) using Active Model.
 test_files: 
 - spec/db/database.yml
 - spec/db/schema.rb