record-cache 0.1.2 → 0.1.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjcyYzNmZjBjM2VjZGU4MzMzMGI1YjBkNDdiNmQ5NWZiODNiZjE3OA==
+  data.tar.gz: !binary |-
+    MzU0ZDM3ZjE1YzhmNTY2MTM3M2MwZmU4ZjZhZTI5ZGQ1NWMwNTMwZg==
+SHA512:
+  metadata.gz: !binary |-
+    NDE4MTQxYjA2ZDQ2ZTE1ZWVlOTk1MjY5OGU3ZDJjNThjZGQ4MjIxZTE1MWQy
+    MjMyZmViZmUzZWY2MGU5NDUzOWNhOWFiYWY0MTlmYTAzMTJlOTVjZTA2N2Yz
+    ODgyNDFiMWY5YzU1MzRhYzNjZWM5M2UyMjU1OGFmNzJlMjliMGI=
+  data.tar.gz: !binary |-
+    NDBiNGYyZjIwNDlkMzg5MDU0YjhhNjBjNThiMDhjMzk1YzE1YjgxODUwYTJj
+    ZTk5YzAzNzY1ZmU4MWI2ZjYyYTU1MjQ4NjNkOTEwZmIxMWMzNzAyYWY5NGJj
+    YTc2ZDVlN2UyOTZhMzBhY2NjMmUwMWQ0NDI5MjliYjY5MGZjM2Y=

data/lib/record_cache.rb

@@ -1,6 +1,7 @@
 # Record Cache files
+require "record_cache/version"
 ["query", "version_store", "multi_read",
- "strategy/util", "strategy/base", "strategy/id_cache", "strategy/index_cache", "strategy/request_cache",
+ "strategy/util", "strategy/base", "strategy/unique_index_cache", "strategy/full_table_cache", "strategy/index_cache",
  "statistics", "dispatcher", "base"].each do |file|
   require File.dirname(__FILE__) + "/record_cache/#{file}.rb"
 end

data/lib/record_cache/base.rb

@@ -17,7 +17,16 @@ module RecordCache
 
       # The logger instance (Rails.logger if present)
       def logger
-        @logger ||= defined?(::Rails) ? ::Rails.logger : ::ActiveRecord::Base.logger
+        @logger ||= (rails_logger || ::ActiveRecord::Base.logger)
+      end
+
+      # Provide a different logger for Record Cache related information
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def rails_logger
+        defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
       end
 
       # Set the ActiveSupport::Cache::Store instance that contains the current record(group) versions.
@@ -29,16 +38,17 @@ module RecordCache
       # 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))
+        self.version_store = Rails.cache unless @version_store
+        @version_store
       end
-      
-      # Register a store with a specific id for reference with :store in +cache_records+
+
+      # Register a cache store by id for future reference with the :store option for +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)
+      # The hash of registered record stores (store_id => store)
       def stores
         @stores ||= {}
       end
@@ -56,6 +66,27 @@ module RecordCache
         @status = RecordCache::ENABLED
       end
 
+      # Executes the block with caching enabled.
+      # Useful in testing scenarios.
+      #
+      #   RecordCache::Base.enabled do
+      #     @foo = Article.find(1)
+      #     @foo.update_attributes(:time_spent => 45)
+      #     @foo = Article.find(1)
+      #     @foo.time_spent.should be_nil
+      #     TimeSpent.last.amount.should == 45
+      #   end
+      #
+      def enabled(&block)
+        previous_status = @status
+        begin
+          @status = RecordCache::ENABLED
+          yield
+        ensure
+          @status = previous_status
+        end
+      end
+
       # Retrieve the current status
       def status
         @status ||= RecordCache::ENABLED
@@ -78,57 +109,67 @@ module RecordCache
 
     module ClassMethods
       # Cache the instances of this model
-      # options:
+      # generic 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)
+      # 
+      # cache strategy specific options:
       #   :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}))
+      def cache_records(options = {})
+        unless @rc_dispatcher
+          @rc_dispatcher = RecordCache::Dispatcher.new(self) 
+          # Callback for Data Store specific initialization
+          record_cache_init
+
+          class << self
+            alias_method_chain :inherited, :record_cache
+          end
         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
+        # parse the requested strategies from the given options
+        @rc_dispatcher.parse(options)
       end
 
       # Returns true if record cache is defined and active for this class
       def record_cache?
-        record_cache && RecordCache::Base.status == RecordCache::ENABLED
+        record_cache && record_cache.instance_variable_get('@base') == self && RecordCache::Base.status == RecordCache::ENABLED
       end
 
       # Returns the RecordCache (class) instance
       def record_cache
         @rc_dispatcher
       end
+
+      def inherited_with_record_cache(subclass)
+        class << subclass
+          def record_cache
+            self.superclass.record_cache
+          end
+        end
+        inherited_without_record_cache(subclass)
+      end
     end
 
     module InstanceMethods
       def record_cache_create
         self.class.record_cache.record_change(self, :create) unless RecordCache::Base.status == RecordCache::DISABLED
+        true
       end
 
       def record_cache_update
         self.class.record_cache.record_change(self, :update) unless RecordCache::Base.status == RecordCache::DISABLED
+        true
       end
 
       def record_cache_destroy
         self.class.record_cache.record_change(self, :destroy) unless RecordCache::Base.status == RecordCache::DISABLED
+        true
       end
     end
 

data/lib/record_cache/datastore/active_record.rb

@@ -4,8 +4,10 @@ require 'active_record'
 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.
+# some internal Active Record methods need 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"
+AR_VERSION = "#{ActiveRecord::VERSION::MAJOR}#{ActiveRecord::VERSION::MINOR}"
+filename =  "#{File.dirname(__FILE__)}/active_record_#{AR_VERSION}.rb"
+abort("No support for Active Record version #{AR_VERSION}") unless File.exists?(filename)
+require filename

data/lib/record_cache/datastore/active_record_30.rb

@@ -10,38 +10,49 @@ module RecordCache
               alias_method_chain :find_by_sql, :record_cache
             end
           end
-          include InstanceMethods
         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
-          after_commit :record_cache_update,  :on => :update
-          after_commit :record_cache_destroy, :on => :destroy
+          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(*args)
-           # no caching please
-          return find_by_sql_without_record_cache(*args) unless record_cache?
+        def find_by_sql_with_record_cache(sql)
+          # shortcut, no caching please
+          return find_by_sql_without_record_cache(sql) 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)
+          sanitized_sql = sanitize_sql(sql)
+
+          records = if connection.instance_variable_get(:@query_cache_enabled)
+                      query_cache = connection.instance_variable_get(:@query_cache)
+                      query_cache["rc/#{sanitized_sql}"] ||= try_record_cache(sanitized_sql, arel)
+                    elsif connection.open_transactions > RC_TRANSACTIONS_THRESHOLD
+                      connection.send(:select, sanitized_sql, "#{name} Load")
+                    else
+                      try_record_cache(sanitized_sql, arel)
+                    end
+          records.collect! { |record| instantiate(record) } if records[0].is_a?(Hash)
+          records
+        end
+
+        def try_record_cache(sql, arel)
+          query = arel && arel.respond_to?(:ast) ? RecordCache::Arel::QueryVisitor.new.accept(arel.ast) : nil
+          record_cache.fetch(query) do
+            connection.send(:select, sql, "#{name} Load")
+          end
         end
-      end
 
-      module InstanceMethods
       end
+
     end
   end
 
@@ -62,7 +73,7 @@ module RecordCache
 
       module ClassMethods
       end
-  
+
       module InstanceMethods
         def to_sql_with_record_cache
           sql = to_sql_without_record_cache
@@ -71,20 +82,23 @@ module RecordCache
         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
         super()
         @cacheable  = true
         @query = ::RecordCache::Query.new
       end
 
-      def accept object
+      def accept ast
         super
-        @cacheable ? @query : nil
+        @cacheable && !ast.lock ? @query : nil
       end
 
       private
@@ -93,12 +107,16 @@ module RecordCache
         @cacheable = false
       end
 
-      alias :visit_Arel_Nodes_Ordering :not_cacheable
-      
+      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
 
@@ -110,6 +128,13 @@ module RecordCache
       alias :visit_Arel_Nodes_InsertStatement  :not_cacheable
       alias :visit_Arel_Nodes_UpdateStatement  :not_cacheable
 
+      alias :visit_Arel_Nodes_Except :not_cacheable
+      alias :visit_Arel_Nodes_Exists :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_As :skip
 
       alias :unary                              :not_cacheable
       alias :visit_Arel_Nodes_Group             :unary
@@ -131,14 +156,14 @@ module RecordCache
       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
-        # "`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))
+        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
@@ -160,12 +185,13 @@ module RecordCache
           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(",").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
+        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
@@ -189,6 +215,7 @@ module RecordCache
       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)
@@ -249,7 +276,7 @@ module RecordCache
 end
 
 module RecordCache
-  
+
   # Patch ActiveRecord::Relation to make sure update_all will invalidate all referenced records
   module ActiveRecord
     module UpdateAll
@@ -262,19 +289,49 @@ module RecordCache
           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
-              connection.execute(select('id').to_sql).each{ |row| record_cache.invalidate(:id, (row.is_a?(Hash) ? row['id'] : row.first).to_i ) }
+              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
 

data/lib/record_cache/datastore/active_record_31.rb

@@ -10,42 +10,52 @@ module RecordCache
               alias_method_chain :find_by_sql, :record_cache
             end
           end
-          include InstanceMethods
         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
-          after_commit :record_cache_update,  :on => :update
-          after_commit :record_cache_destroy, :on => :destroy
+          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(*args)
-           # no caching please
-          return find_by_sql_without_record_cache(*args) unless record_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 = args[0]
-          if arel.is_a?(String)
-            arel = arel.instance_variable_get(:@arel)
-            puts "TODO: RECORD_CACHE !!!!!!!! Found String with arel piggyback: #{arel}"
-          end
+          arel = sql.is_a?(String) ? sql.instance_variable_get(:@arel) : sql
+
+          sanitized_sql = sanitize_sql(sql)
+          sanitized_sql = connection.visitor.accept(sanitized_sql.ast) if sanitized_sql.respond_to?(:ast)
+
+          records = if connection.instance_variable_get(:@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
 
-          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)
+        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
 
-      module InstanceMethods
       end
+
     end
   end
 
@@ -66,7 +76,7 @@ module RecordCache
 
       module ClassMethods
       end
-  
+
       module InstanceMethods
         def to_sql_with_record_cache
           sql = to_sql_without_record_cache
@@ -75,11 +85,14 @@ module RecordCache
         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}
@@ -87,9 +100,9 @@ module RecordCache
         @query = ::RecordCache::Query.new
       end
 
-      def accept object
+      def accept ast
         super
-        @cacheable ? @query : nil
+        @cacheable && !ast.lock ? @query : nil
       end
 
       private
@@ -98,14 +111,46 @@ module RecordCache
         @cacheable = false
       end
 
-      alias :visit_Arel_Nodes_Ordering :not_cacheable
-      
+      def skip o
+      end
+
       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_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_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
@@ -136,14 +181,14 @@ module RecordCache
       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
-        # "`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))
+        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
@@ -153,6 +198,7 @@ module RecordCache
         @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
 
@@ -165,12 +211,13 @@ module RecordCache
           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(",").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
+        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
@@ -182,10 +229,6 @@ module RecordCache
         @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
@@ -194,12 +237,14 @@ module RecordCache
       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)
-        if value.to_s == "?"
+        # 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 = @bindings[key.to_s] || value
         end
         # puts "  =====> equality found: #{key.inspect}@#{key.class.name} => #{value.inspect}@#{value.class.name}"
         @query.where(key, value)
@@ -207,8 +252,7 @@ module RecordCache
       alias :visit_Arel_Nodes_In                 :visit_Arel_Nodes_Equality
 
       def visit_Arel_Nodes_And o
-        visit(o.left)
-        visit(o.right)
+        visit(o.children)
       end
 
       alias :visit_Arel_Nodes_Or                 :not_cacheable
@@ -236,6 +280,7 @@ module RecordCache
         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
@@ -258,7 +303,7 @@ module RecordCache
 end
 
 module RecordCache
-  
+
   # Patch ActiveRecord::Relation to make sure update_all will invalidate all referenced records
   module ActiveRecord
     module UpdateAll
@@ -271,19 +316,49 @@ module RecordCache
           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
-              connection.execute(select('id').to_sql).each{ |row| record_cache.invalidate(:id, (row.is_a?(Hash) ? row['id'] : row.first).to_i ) }
+              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
 
@@ -320,6 +395,33 @@ module RecordCache
         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
@@ -328,3 +430,4 @@ 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)