ninjudd-record_cache 0.9.4

data/README.rdoc

@@ -0,0 +1,35 @@
+= RecordCache
+
+RecordCache is a simple yet powerful extension to ActiveRecord that caches indexes
+and ActiveRecord models using MemCache. If you use it correctly, it will drastically
+reduce your database load.
+
+== Usage:
+
+  class Foo < ActiveRecord
+    record_cache :by => :id
+    record_cache :id, :by => :owner_id
+  end
+
+  # These will use the cache now.
+  Foo.find(1)
+  Foo.find_by_id(2)
+  Foo.find_all_by_owner_id(3)
+
+Invalidation is handled for you using callbacks.
+
+== Install:
+
+First, install the after_commit plugin from: http://github.com/ninjudd/after_commit
+
+Then install the following gems:
+
+  sudo gem install ninjudd-deferrable -s http://gems.github.com
+  sudo gem install ninjudd-ordered_set -s http://gems.github.com
+  sudo gem install ninjudd-memcache -s http://gems.github.com
+  sudo gem install ninjudd-cache_version -s http://gems.github.com
+  sudo gem install ninjudd-record_cache -s http://gems.github.com
+
+== License:
+
+Copyright (c) 2009 Justin Balthrop, Geni.com; Published under The MIT License, see LICENSE

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 4
+:major: 0
+:minor: 9

data/lib/record_cache/index.rb

@@ -0,0 +1,373 @@
+module RecordCache
+  class Index
+    include Deferrable
+
+    attr_reader :model_class, :index_field, :fields, :order_by, :limit, :cache, :expiry, :name, :prefix
+    
+    NULL = 'NULL'
+    
+    def initialize(opts)
+      raise ':by => index_field required for cache'       if opts[:by].nil?
+      raise 'explicit name or prefix required with scope' if opts[:scope] and opts[:name].nil? and opts[:prefix].nil?
+
+      @auto_name     = opts[:name].nil?      
+      @write_ahead   = opts[:write_ahead]
+      @cache         = opts[:cache] || CACHE
+      @expiry        = opts[:expiry]
+      @model_class   = opts[:class]
+      @set_class     = opts[:set_class] || "#{@model_class}Set"
+      @index_field   = opts[:by].to_s
+      @fields        = opts[:fields].collect {|field| field.to_s}
+      @prefix        = opts[:prefix]
+      @name          = ( opts[:name] || [prefix, 'by', index_field].compact.join('_') ).to_s
+      @order_by      = opts[:order_by]
+      @limit         = opts[:limit]
+      @disallow_null = opts[:null] == false
+      @scope_query   = opts[:scope] || {}
+    end
+
+    def auto_name?;     @auto_name;     end
+    def write_ahead?;   @write_ahead;   end
+    def disallow_null?; @disallow_null; end
+
+    def full_record?
+      fields.empty?
+    end
+    
+    def includes_id?
+      full_record? or fields.include?('id')
+    end
+
+    def set_class
+      @set_class.constantize
+    end
+
+    def namespace
+      "#{model_class.name}_#{model_class.version}_#{RecordCache.version}:#{name}" << ( full_record? ? '' : ":#{fields.join(',')}" )
+    end
+    
+    def fields_hash
+      if @fields_hash.nil?
+        if full_record?
+          @fields_hash ||= model_class.column_names.hash
+        else
+          @fields_hash ||= fields.collect {|field| field.to_s}.hash
+        end
+      end
+      @fields_hash
+    end
+
+    def find_by_ids(ids, model_class)
+      expects_array = ids.first.kind_of?(Array)
+      ids = ids.flatten.compact.collect {|id| id.to_i}
+      ids = stringify(ids)
+
+      if ids.empty?
+        return [] if expects_array
+        raise ActiveRecord::RecordNotFound, "Couldn't find #{model_class} without an ID"
+      end
+      
+      records_by_id = get_records(ids)
+   
+      models = ids.collect do |id|
+        records = records_by_id[id]
+        model   = records.instantiate_first(model_class, full_record?) if records
+
+        # try to get record from db again before we throw an exception
+        if model.nil?
+          invalidate(id)
+          records = get_records([id])[id]
+          model   = records.instantiate_first(model_class, full_record?) if records
+        end
+
+        raise ActiveRecord::RecordNotFound, "Couldn't find #{model_class} with ID #{id}" unless model
+        model
+      end
+      
+      if models.size == 1 and not expects_array
+        models.first
+      else 
+        models
+      end
+    end
+    
+    def find_by_field(keys, model_class, type)
+      keys = [keys] if not keys.kind_of?(Array)
+      keys = stringify(keys)
+      records_by_key = get_records(keys)
+
+      case type
+      when :first
+        keys.each do |key|
+          model = records_by_key[key].instantiate_first(model_class, full_record?)
+          return model if model
+        end
+        return nil
+      when :all
+        models = []
+        keys.each do |key|
+          models.concat( records_by_key[key].instantiate(model_class, full_record?) )
+        end
+        models
+      when :set, :ids
+        ids = []
+        keys.each do |key|
+          ids.concat( records_by_key[key].ids(model_class) )
+        end
+        type == :set ? set_class.new(ids) : ids
+      when :raw
+        raw_records = []
+        keys.each do |key|
+          raw_records.concat( records_by_key[key].records(model_class) )
+        end
+        raw_records
+      end
+    end
+    
+    def field_lookup(keys, model_class, field, flag = nil)
+      keys = [*keys]
+      keys = stringify(keys)
+      field = field.to_s if field
+      records_by_key = get_records(keys)
+
+      field_by_index = {}
+      all_fields = [].to_ordered_set
+      keys.each do |key|
+        records = records_by_key[key]
+        fields = field ? records.fields(field, model_class) : records.all_fields(model_class, :except => index_field)
+        if flag == :all
+          all_fields.concat(fields)
+        elsif flag == :first
+          next if fields.empty?
+          field_by_index[index_column.type_cast(key)] = fields.first
+        else
+          field_by_index[index_column.type_cast(key)] = fields
+        end
+      end
+      if flag == :all
+        all_fields.to_a
+      else
+        field_by_index
+      end
+    end
+    
+    def invalidate(*keys)
+      keys = stringify(keys)
+      cache.in_namespace(namespace) do
+        keys.each do |key|
+          cache.delete(key)
+        end
+      end
+    end
+
+    def invalidate_from_conditions_lambda(conditions)
+      sql = "SELECT #{index_field} FROM #{table_name} "
+      model_class.send(:add_conditions!, sql, conditions, model_class.send(:scope, :find))
+      ids = db.select_values(sql)
+      lambda { invalidate(*ids) }
+    end
+
+    def invalidate_from_conditions(conditions)
+      invalidate_from_conditions_lambda(conditions).call
+    end
+    
+    def invalidate_model(model)
+      attribute     = model.send(index_field)
+      attribute_was = model.attr_was(index_field)
+      if scope.match_previous?(model)
+        if write_ahead?
+          remove_from_cache(model)
+        else
+          now_and_later do
+            invalidate(attribute_was)
+          end
+        end
+      end
+
+      if scope.match_current?(model)
+        if write_ahead?
+          add_to_cache(model)
+        elsif not (scope.match_previous?(model) and attribute_was == attribute)
+          now_and_later do
+            invalidate(attribute)
+          end
+        end
+      end
+    end
+        
+    def scope_query
+      @scope_query[:type] ||= model_class.to_s if sub_class?
+      @scope_query
+    end
+
+    def scope
+      @scope ||= Scope.new(model_class, scope_query)
+    end
+
+    @@disable_db = false
+    def self.disable_db
+      @@disable_db = true
+    end
+
+    def self.enable_db
+      @@disable_db = false
+    end
+       
+    def find_method_name(type)
+      if name =~ /(^|_)by_/
+        if type == :first
+          "find_#{name}"
+        else
+          "find_#{type}_#{name}"
+        end
+      else
+        case type
+        when :all
+          "find_#{name}"
+        when :first
+          "find_#{type}_#{name.singularize}"
+        else
+          "find_#{name.singularize}_#{type}"
+        end
+      end
+    end
+    
+    def cached_set(id)
+      # Used for debugging. Gives you the RecordCache::Set that is currently in the cache.
+      id = stringify([id]).first
+      cache.in_namespace(namespace) do
+        cache.get(id)
+      end
+    end
+
+  private
+
+    MAX_FETCH = 1000
+    def get_records(keys)
+      cache.in_namespace(namespace) do
+        opts = { 
+          :expiry        => expiry,
+          :disable_write => model_class.record_cache_config[:disable_write],
+          :validation    => lambda {|key, record_set| record_set.fields_hash == fields_hash},
+        }
+        cache.get_some(keys, opts) do |keys_to_fetch|
+          raise 'db access is disabled' if @@disable_db
+          fetched_records = {}
+          keys_to_fetch.each do |key|
+            fetched_records[key] = RecordCache::Set.new(model_class, fields_hash)
+          end
+
+          keys_to_fetch.each_slice(MAX_FETCH) do |keys_batch|
+            sql = "SELECT #{select_fields} FROM #{table_name} WHERE (#{in_clause(keys_batch)})"
+            sql << " AND #{scope.conditions}" if not scope.empty?
+            sql << " ORDER BY #{order_by}"    if order_by
+            sql << " LIMIT #{limit}"          if limit
+
+            db.select_all(sql).each do |record|
+              key = record[index_field] || NULL
+              fetched_records[key] << record
+            end
+          end
+          fetched_records
+        end
+      end
+    end
+
+    def model_to_record(model)
+      sql = "SELECT #{select_fields} FROM #{table_name} WHERE id = #{model.id}"
+      db.select_all(sql).first
+    end
+
+    def in_clause(keys)
+      conditions = []
+      conditions << "#{index_field} IS NULL" if keys.delete(NULL)
+
+      if keys.any?
+        values = keys.collect {|value| quote_index_value(value)}.join(',')
+        conditions << "#{index_field} IN (#{values})"
+      end
+      conditions.join(' OR ')
+    end
+
+    def remove_from_cache(model)
+      record = model.attributes
+      key    = model.attr_was(index_field)
+      
+      cache.in_namespace(namespace) do
+        cache.with_lock(key) do
+          now_and_later do
+            if records = cache.get(key)
+              records.delete(record)
+              cache.set(key, records)
+            end
+          end
+        end
+      end
+    end
+
+    def add_to_cache(model)
+      record = model_to_record(model)
+      key    = record[index_field].to_s
+
+      cache.in_namespace(namespace) do
+        cache.with_lock(key) do
+          now_and_later do
+            if records = cache.get(key)
+              records.delete(record)
+              records << record
+              records.sort!(order_by) if order_by
+              records.limit!(limit)   if limit
+              cache.set(key, records)
+            end
+          end
+        end
+      end
+    end
+
+    def select_fields
+      if @select_fields.nil?
+        if full_record?
+          @select_fields = model_class.respond_to?(:default_select, true) ? model_class.send(:default_select, nil) : '*'
+        else
+          @select_fields = [index_field, 'id'] + fields
+          @select_fields << 'type' if base_class?
+          @select_fields = @select_fields.uniq.join(', ')
+        end
+      end
+      @select_fields
+    end
+    
+    def base_class?
+      @base_class ||= single_table_inheritance? and model_class == model_class.base_class
+    end
+    
+    def sub_class?
+      @sub_class ||= single_table_inheritance? and model_class != model_class.base_class
+    end
+
+    def single_table_inheritance?
+      @single_table_inheritance ||= model_class.columns_hash.has_key?(model_class.inheritance_column)
+    end
+
+    def quote_index_value(value)
+      model_class.quote_value(value, index_column)
+    end
+    
+    def index_column
+      @index_column ||= model_class.columns_hash[index_field]
+    end
+        
+    def table_name
+      model_class.table_name
+    end
+        
+    def stringify(keys)
+      keys.compact! if disallow_null?
+      keys.collect {|key| key.nil? ? NULL : key.to_s}.uniq
+    end
+    
+    def db
+      RecordCache.db(model_class)
+    end
+  end
+end

data/lib/record_cache/scope.rb

@@ -0,0 +1,64 @@
+module RecordCache
+  class Scope
+    attr_reader :model_class, :query
+    
+    def initialize(model_class, query)
+      @model_class = model_class
+      @query       = query
+    end
+
+    def empty?
+      query.empty?
+    end
+
+    def fields
+      query.keys
+    end
+
+    def match_current?(model)
+      fields.all? do |field|
+        match?( field, model.send(field) )
+      end
+    end
+
+    def match_previous?(model)
+      fields.all? do |field|
+        match?( field, model.attr_was(field) )
+      end
+    end
+
+    def match?(field, value)
+      scope = query[field]
+      if defined?(AntiObject) and scope.kind_of?(AntiObject)
+        scope  = ~scope
+        invert = true
+      end
+
+      match = [*scope].include?(value)
+      invert ? !match : match
+    end
+
+    def conditions
+      @conditions ||= begin
+        query.collect do |field, scope|
+          if defined?(AntiObject) and scope.kind_of?(AntiObject)
+            scope  = ~scope
+            invert = true
+          end
+
+          if scope.nil?
+            op = invert ? 'IS NOT' : 'IS'
+            "#{field} #{op} NULL"
+          elsif scope.is_a?(Array)
+            op = invert ? 'NOT IN' : 'IN'
+            model_class.send(:sanitize_sql, ["#{field} #{op} (?)", scope])
+          else
+            op = invert ? '!=' : '='
+            model_class.send(:sanitize_sql, ["#{field} #{op} ?", scope])
+          end
+        end.join(' AND ')
+      end
+      @conditions
+    end
+  end
+end

data/lib/record_cache/set.rb

@@ -0,0 +1,141 @@
+module RecordCache
+  class Set
+    attr_reader :model_class, :fields_hash, :created_at, :updated_at, :hostname, :dbhost
+
+    def self.source_tracking?
+      @source_tracking
+    end
+
+    def self.source_tracking=(value)
+      @source_tracking = value
+    end
+
+    def self.hostname
+      @hostname ||= Socket.gethostname
+    end
+
+    def initialize(model_class, fields_hash = nil)
+      raise 'valid model class required' unless model_class
+      @model_class = model_class
+      @fields_hash = fields_hash
+      @records_by_type = {}
+
+      if self.class.source_tracking?
+        @created_at = Time.now
+        @hostname   = self.class.hostname
+        @dbhost     = RecordCache.db(model_class).instance_variable_get(:@config)[:host]
+      end
+    end
+
+    def sort!(order_by)
+      field, order = order_by.strip.squeeze.split
+      descending = (order == 'DESC')
+      @records_by_type.values.each do |records|
+        sorted_records = records.sort_by do |record|
+          type_cast(field, record[field])
+        end
+        sorted_records.reverse! if descending
+        records.replace(sorted_records)
+      end
+    end
+    
+    def limit!(limit)
+      all_records = records
+      if all_records.length > limit
+        removed_records = all_records.slice!(limit..-1)
+        removed_records.each do |record|
+          type = record['type']
+          records_by_type(type).delete(record) if type
+        end
+      end
+    end
+
+    def <<(record)
+      mark_updated!
+      record_type  = record['type']
+      record['id'] = record['id'].to_i if record.has_key?('id')
+      
+      [record_type, model_class.to_s].uniq.each do |type|
+        records_by_type(type) << record
+      end
+    end
+    
+    def delete(record)
+      raise 'cannot delete record without id' unless record.has_key?('id')
+      mark_updated!
+      record_type = record['type']
+      id          = record['id'].to_i
+
+      [record_type, model_class.to_s].uniq.each do |type|
+        records_by_type(type).reject! {|r| r['id'] == id}
+      end
+    end
+
+    def records_by_type(type)
+      @records_by_type[type.to_s] ||= []
+    end
+
+    def records(type = model_class)
+      records_by_type(type)
+    end
+
+    def size
+      records.size
+    end
+    
+    def empty?
+      records.empty?
+    end
+
+    def ids(type = model_class)
+      records(type).collect {|r| r['id']}
+    end
+
+    def fields(field, type)
+      records(type).collect {|r| type_cast(field, r[field])}
+    end
+      
+    def all_fields(type = model_class, opts = {})
+      records(type).collect do |r|
+        record = {}
+        r.each do |field, value|
+          next if field == opts[:except]
+          record[field.to_sym] = type_cast(field, value)
+        end
+        record
+      end
+    end
+
+    def instantiate_first(type = model_class, full_record = false)
+      if full_record
+        record = records(type).first
+        type.send(:instantiate, record) if record
+      else
+        id = ids(type).first
+        type.find_by_id(id) if id
+      end
+    end
+
+    def instantiate(type = model_class, full_record = false)
+      if full_record
+        records(type).collect do |record|
+          type.send(:instantiate, record)
+        end
+      else
+        type.find_all_by_id(ids(type))
+      end
+    end
+
+  private
+    
+    def mark_updated!
+      @updated_at = Time.now if self.class.source_tracking?
+    end
+
+    def type_cast(field, value)
+      column = model_class.columns_hash[field.to_s]
+      raise 'column not found in #{model_class} for field #{field}' unless column
+      column.type_cast(value)
+    end
+  end
+end

data/lib/record_cache.rb

@@ -0,0 +1,265 @@
+require 'rubygems'
+require 'active_record'
+require 'ordered_set'
+require 'memcache_extended'
+require 'cache_version'
+require 'deferrable'
+
+$:.unshift(File.dirname(__FILE__))
+require 'record_cache/index'
+require 'record_cache/set'
+require 'record_cache/scope'
+
+module RecordCache
+  def self.config(opts = nil)
+    if opts
+      config.merge!(opts)
+    else
+      @config ||= {}
+    end
+  end
+
+  def self.db(model_class)
+    # Always use the master connection since we are caching.
+    db = model_class.connection
+    if defined?(DataFabric::ConnectionProxy) and db.kind_of?(DataFabric::ConnectionProxy)
+      model_class.record_cache_config[:use_slave] ? db.send(:connection) : db.send(:master)
+    else
+      db
+    end
+  end
+
+  module InstanceMethods
+    def invalidate_record_cache
+      self.class.each_cached_index do |index|
+        index.invalidate_model(self) 
+        index.clear_deferred
+      end
+    end
+
+    def invalidate_record_cache_deferred
+      self.class.each_cached_index do |index|
+        # Have to invalidate both before and after commit.
+        index.invalidate_model(self)
+      end
+    end
+
+    def complete_deferred_record_cache_invalidations
+      self.class.each_cached_index do |index|
+        index.complete_deferred
+      end
+    end
+
+    def attr_was(attr)
+      attr = attr.to_s
+      ['id', 'type'].include?(attr) ? send(attr) : send(:attribute_was, attr)
+    end
+  end
+    
+  module ClassMethods    
+    def find_with_caching(*args, &block)
+      if args.last.is_a?(Hash)
+        args.last.delete_if {|k,v| v.nil?}
+        args.pop if args.last.empty?
+      end
+      
+      if [:all, :first, :last].include?(args.first)
+        opts = args.last
+        if opts.is_a?(Hash) and opts.keys == [:conditions]
+          # Try to match the SQL.
+          if opts[:conditions] =~ /^"?#{table_name}"?.(\w*) = (\d*)$/
+            field, value = $1, $2
+            index = cached_index("by_#{field}")
+            return index.find_by_field([value], self, args.first) if index
+          end
+        end
+      elsif not args.last.is_a?(Hash)
+        # This is a find with just ids.
+        index = cached_index('by_id')
+        return index.find_by_ids(args, self) if index
+      end
+
+      find_without_caching(*args, &block)
+    end
+    
+    def update_all_with_invalidate(updates, conditions = nil)
+      invalidate_from_conditions(conditions, :update) do |conditions|
+        update_all_without_invalidate(updates, conditions)
+      end
+    end
+
+    def delete_all_with_invalidate(conditions = nil)
+      invalidate_from_conditions(conditions) do |conditions|
+        delete_all_without_invalidate(conditions)
+      end
+    end
+    
+    def invalidate_from_conditions(conditions, flag = nil)
+      if conditions.nil?
+        # Just invalidate all indexes.
+        result = yield(nil)
+        self.increment_version
+        return result
+      end
+
+      # Freeze ids to avoid race conditions.
+      sql = "SELECT id FROM #{table_name} "
+      self.send(:add_conditions!, sql, conditions, self.send(:scope, :find))
+      ids = RecordCache.db(self).select_values(sql)
+
+      return if ids.empty?
+      conditions = "id IN (#{ids.join(',')})"
+
+      if block_given?
+        # Capture the ids to invalidate in lambdas.
+        lambdas = []
+        each_cached_index do |index|
+          lambdas << index.invalidate_from_conditions_lambda(conditions)
+        end
+
+        result = yield(conditions)
+
+        # Finish invalidating with prior attributes.
+        lambdas.each {|l| l.call}      
+      end
+    
+      # Invalidate again afterwards if we are updating (or for the first time if no block was given).
+      if flag == :update or not block_given?
+        each_cached_index do |index|
+          index.invalidate_from_conditions(conditions)
+        end
+      end
+
+      result
+    end
+
+    def cached_indexes
+      @cached_indexes ||= {}
+    end
+
+    def cached_index(name)
+      name = name.to_s
+      index = cached_indexes[name]
+      index ||= base_class.cached_index(name) if base_class != self and base_class.respond_to?(:cached_index)
+      index
+    end
+
+    def add_cached_index(index)
+      name  = index.name
+      count = nil
+      # Make sure the key is unique.
+      while cached_indexes["#{name}#{count}"]
+        count ||= 0
+        count += 1
+      end
+      cached_indexes["#{name}#{count}"] = index
+    end
+
+    def each_cached_index
+      cached_index_names.each do |index_name|
+        yield cached_index(index_name)
+      end      
+    end
+
+    def cached_index_names
+      names = cached_indexes.keys
+      names.concat(base_class.cached_index_names) if base_class != self and base_class.respond_to?(:cached_index_names)
+      names.uniq
+    end
+
+    def record_cache_config(opts = nil)
+      if opts
+        record_cache_config.merge!(opts)
+      else
+        @record_cache_config ||= RecordCache.config.clone
+      end
+    end
+  end
+
+  module ActiveRecordExtension
+    def self.extended(mod)
+      mod.send(:class_inheritable_accessor, :cached_indexes)
+    end
+
+    def record_cache(*args)
+      extend  RecordCache::ClassMethods
+      include RecordCache::InstanceMethods
+
+      opts = args.pop
+      opts[:fields] = args
+      opts[:class]  = self
+      field_lookup  = opts.delete(:field_lookup) || []
+
+      index = RecordCache::Index.new(opts)
+      add_cached_index(index)
+      first_index = (cached_indexes.size == 1)
+
+      (class << self; self; end).module_eval do
+        if index.includes_id?
+          [:first, :all, :set, :raw, :ids].each do |type|
+            next if type == :ids and index.name == 'by_id'
+            define_method( index.find_method_name(type) ) do |keys|
+              if self.send(:scope,:find) and self.send(:scope,:find).any?
+                self.method_missing(index.find_method_name(type), keys)
+              else
+                index.find_by_field(keys, self, type)
+              end
+            end
+          end
+        end
+
+        if not index.auto_name? and not index.full_record?
+          field = index.fields.first if index.fields.size == 1
+
+          define_method( "all_#{index.name.pluralize}_by_#{index.index_field}" ) do |keys|
+            index.field_lookup(keys, self, field, :all)
+          end
+          
+          define_method( "#{index.name.pluralize}_by_#{index.index_field}" ) do |keys|
+            index.field_lookup(keys, self, field)
+          end
+
+          define_method( "#{index.name.singularize}_by_#{index.index_field}" ) do |keys|
+            index.field_lookup(keys, self, field, :first)
+          end
+        end
+        
+        if index.auto_name?
+          (field_lookup + index.fields).each do |field|
+            next if field == index.index_field
+            plural_field = field.pluralize
+            prefix = index.prefix
+            prefix = "#{prefix}_" if prefix
+
+            define_method( "all_#{prefix}#{plural_field}_by_#{index.index_field}"  ) do |keys|
+              index.field_lookup(keys, self, field, :all)
+            end
+
+            define_method( "#{prefix}#{plural_field}_by_#{index.index_field}"  ) do |keys|
+              index.field_lookup(keys, self, field)
+            end
+            
+            define_method( "#{prefix}#{field}_by_#{index.index_field}"  ) do |keys|
+              index.field_lookup(keys, self, field, :first)
+            end
+          end
+        end
+              
+        if first_index
+          alias_method_chain :find, :caching
+          alias_method_chain :update_all, :invalidate
+          alias_method_chain :delete_all, :invalidate
+        end
+      end
+      
+      if first_index
+        after_save     :invalidate_record_cache_deferred
+        after_destroy  :invalidate_record_cache_deferred
+        after_commit   :complete_deferred_record_cache_invalidations
+        after_rollback :complete_deferred_record_cache_invalidations
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend,  RecordCache::ActiveRecordExtension)

data/test/record_cache_test.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+RecordCache::Set.source_tracking = true
+
+class CreateTables < ActiveRecord::Migration 
+  def self.up
+    down
+    create_table :pets do |t|
+      t.column :breed_id, :bigint
+      t.column :name, :string
+      t.column :color_id, :bigint
+      t.column :sex, :char
+      t.column :type, :string
+    end
+
+    create_table :breeds do |t|
+      t.column :name, :string
+    end
+
+    create_table :colors do |t|
+      t.column :name, :string
+    end
+  end
+
+  def self.down
+    drop_table :pets   rescue nil
+    drop_table :breeds rescue nil
+    drop_table :colors rescue nil
+  end
+end
+
+CreateTables.up
+
+class Pet < ActiveRecord::Base
+  belongs_to :breed
+  belongs_to :color
+
+  record_cache :by => :id
+  record_cache :id, :by => :breed_id
+  record_cache :id, :by => :color_id, :write_ahead => true
+
+  record_cache :id, :by => :color_id, :scope => {:sex => 'm'}, :prefix => 'male'
+  record_cache :id, :by => :color_id, :scope => {:sex => 'f'}, :prefix => 'female'
+  record_cache :id, :by => :color_id, :scope => {:sex => ['m','f']}, :name => 'all_colors'
+end
+
+class Dog < Pet
+end
+
+class Cat < Pet
+end
+
+class Breed < ActiveRecord::Base
+end
+
+class Color < ActiveRecord::Base
+end
+
+class RecordCacheTest < Test::Unit::TestCase
+  context "With a memcache and db connection" do
+    setup do
+      system('memcached -d')
+      CACHE.servers = ["localhost:11211"]
+      
+      CreateTables.up
+      CacheVersionMigration.up
+    end
+    
+    teardown do
+      system('killall memcached')
+      
+      CreateTables.down
+      CacheVersionMigration.down
+      RecordCache::Index.enable_db
+    end
+    
+    should 'create field lookup functions' do
+      dog   = Breed.new(:name => 'pitbull retriever')
+      cat   = Breed.new(:name => 'house cat')
+      willy = Cat.create(:name => 'Willy', :breed => cat)
+      daisy = Dog.create(:name => 'Daisy', :breed => dog)
+
+      expected = {dog.id => daisy.id, cat.id => willy.id}
+      assert_equal expected, Pet.id_by_breed_id([dog.id, cat.id, 100, 101])      
+    end
+    
+    should 'return cached values without accessing the database' do
+      color = Color.new(:name => 'black & white')
+      dog   = Breed.new(:name => 'pitbull retriever')
+      cat   = Breed.new(:name => 'house cat')
+      daisy = Dog.create(:name => 'Daisy', :color => color, :breed => dog)
+      willy = Cat.create(:name => 'Willy', :color => color, :breed => cat)
+      
+      Pet.find(daisy.id, willy.id)
+      Dog.find_all_by_color_id(color.id)
+      Dog.find_all_by_breed_id(dog.id)
+
+      RecordCache::Index.disable_db
+
+      assert_equal Dog,     Dog.find(daisy.id).class
+      assert_equal daisy,   Dog.find(daisy.id)
+      assert_equal Cat,     Cat.find(willy.id).class
+      assert_equal willy,   Cat.find(willy.id)
+      assert_equal [daisy], Dog.find_all_by_color_id(color.id)
+      assert_equal [willy], Cat.find_all_by_color_id(color.id)
+      assert_equal [daisy], Dog.find_all_by_breed_id(dog.id)
+
+      RecordCache::Index.enable_db
+
+      assert_raises(ActiveRecord::RecordNotFound) do
+        Dog.find(willy.id)
+      end
+
+      assert_raises(ActiveRecord::RecordNotFound) do
+        Cat.find(daisy.id)
+      end
+    end
+
+    should 'return multiple cached values without accessing the database' do
+      color1 = Color.new(:name => 'black & white')
+      color2 = Color.new(:name => 'speckled')
+      breed1 = Breed.new(:name => 'pitbull retriever')
+      breed2 = Breed.new(:name => 'pitbull terrier')
+      daisy = Dog.create(:name => 'Daisy', :color => color1, :breed => breed1)
+      sammy = Dog.create(:name => 'Sammy', :color => color1, :breed => breed2)
+      
+      Dog.find(daisy.id, sammy.id)
+      Dog.find_all_by_color_id(color1.id)
+      Dog.find_all_by_breed_id([breed1.id, breed2.id])
+
+      RecordCache::Index.disable_db
+
+      assert_equal [daisy, sammy].to_set, Dog.find(daisy.id, sammy.id).to_set
+      assert_equal [daisy, sammy].to_set, Dog.find_all_by_color_id(color1.id).to_set
+      assert_equal [daisy, sammy].to_set, Dog.find_all_by_breed_id([breed1.id, breed2.id]).to_set
+      assert_equal [sammy, daisy].to_set, Dog.find_all_by_breed_id([breed2.id, breed1.id]).to_set
+      assert_equal [daisy].to_set,        Dog.find_all_by_breed_id(breed1.id).to_set
+
+      # Alternate find methods.
+      #assert_equal [sammy.id, daisy.id], Dog.find_set_by_breed_id([breed2.id, breed1.id]).ids
+      assert_equal [sammy.id, daisy.id].to_set, Dog.find_ids_by_breed_id([breed2.id, breed1.id]).to_set
+
+      assert_equal daisy, Dog.find_by_color_id(color1.id)
+      assert_equal daisy, Dog.find_by_breed_id([breed1.id, breed2.id])
+      assert_equal sammy, Dog.find_by_breed_id([breed2.id, breed1.id])
+
+      baseball = Dog.create(:name => 'Baseball', :color => color2, :breed => breed1)
+
+      RecordCache::Index.enable_db
+
+      assert_equal [daisy, baseball], Dog.find_all_by_breed_id(breed1.id)
+    end
+
+    should 'create raw find methods' do
+      daisy = Dog.create(:name => 'Daisy')
+      sammy = Dog.create(:name => 'Sammy')
+      
+      Dog.find(daisy.id, sammy.id)
+      RecordCache::Index.disable_db
+
+      raw_records = Dog.find_raw_by_id([sammy.id, daisy.id])
+      assert_equal ['Sammy', 'Daisy'], raw_records.collect {|r| r['name']}
+    end
+
+    should 'cache indexes using scope' do
+      color  = Color.new(:name => 'black & white')
+      breed1 = Breed.new(:name => 'pitbull retriever')
+      breed2 = Breed.new(:name => 'pitbull terrier')
+      daisy = Dog.create(:name => 'Daisy', :color => color, :breed => breed1, :sex => 'f')
+      sammy = Dog.create(:name => 'Sammy', :color => color, :breed => breed2, :sex => 'm')
+      
+      assert_equal [sammy],        Dog.find_all_male_by_color_id(color.id)
+      assert_equal [daisy],        Dog.find_all_female_by_color_id(color.id)
+      assert_equal [daisy, sammy], Dog.find_all_colors(color.id)
+
+      cousin = Dog.create(:name => 'Cousin', :color => color, :breed => breed2, :sex => 'm')
+
+      assert_equal [sammy, cousin],        Dog.find_all_male_by_color_id(color.id)
+      assert_equal [daisy, sammy, cousin], Dog.find_all_colors(color.id)
+    end
+
+    should 'yield cached indexes' do
+      count = 0
+      Dog.each_cached_index do |index|
+        count += 1
+      end
+      assert_equal 6, count
+    end
+    
+    should 'invalidate indexes on save' do
+      b_w   = Color.new(:name => 'black & white')
+      brown = Color.new(:name => 'brown')
+      breed = Breed.new(:name => 'mutt')
+      daisy = Dog.create(:name => 'Daisy', :color => b_w, :breed => breed, :sex => 'f')
+      
+      assert_equal daisy, Dog.find_by_color_id(b_w.id)
+      
+      daisy.name  = 'Molly'
+      daisy.color = brown
+      daisy.save
+      
+      assert_equal 'Molly', daisy.name
+      assert_equal brown.id, daisy.color_id
+      
+      assert_equal daisy, Dog.find_by_color_id(brown.id)
+      assert_equal nil,   Dog.find_by_color_id(b_w.id)
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+require 'mocha'
+
+require 'active_record'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+['deep_clonable', 'ordered_set', 'cache_version', 'model_set', 'memcache', 'deferrable'].each do |dir|
+  $LOAD_PATH.unshift File.dirname(__FILE__) + "/../../#{dir}/lib"
+end
+
+['lib/after_commit', 'lib/after_commit/active_record', 'lib/after_commit/connection_adapters', 'init'].each do |file|
+  require File.dirname(__FILE__) + "/../../after_commit/#{file}"
+end
+
+require 'record_cache'
+
+class Test::Unit::TestCase
+end
+
+CACHE = MemCache.new(
+  :ttl=>1800,
+  :compression=>false,
+  :readonly=>false,
+  :debug=>false,
+  :c_threshold=>10000,
+  :urlencode=>false
+)
+ActiveRecord::Base.establish_connection(
+  :adapter  => "postgresql",
+  :host     => "localhost",
+  :username => "postgres",
+  :password => "",
+  :database => "record_cache_test"
+)
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.connection.client_min_messages = 'panic'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: ninjudd-record_cache
+version: !ruby/object:Gem::Version 
+  version: 0.9.4
+platform: ruby
+authors: 
+- Justin Balthrop
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-15 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Active Record caching and indexing in memcache
+email: code@justinbalthrop.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/record_cache
+- lib/record_cache/index.rb
+- lib/record_cache/scope.rb
+- lib/record_cache/set.rb
+- lib/record_cache.rb
+- test/record_cache_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/ninjudd/record_cache
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Active Record caching and indexing in memcache. An alternative to cache_fu
+test_files: []
+