cacheAR 0.9.0

data/lib/cachear.rb

@@ -0,0 +1,218 @@
+########################################
+#
+# Author:: Dmitry V. Sabanin <dmitry@sabanin.ru>
+# Copyright:: Copyright (c) 2005 MuraveyLabs, Ltd
+# URL:: http://muravey.net/opensource/
+# Revision:: $Date: 2004/11/17 07:37:13 $ $Revision: 1.7 $
+# License:: MIT
+#
+########################################
+
+require_gem 'ruby-cache'
+
+# ActiveRecord::MemoryCache.logger = ActiveRecord::Base.logger
+# ActiveRecord::Base.cacher = ActiveRecord::MemoryCache.instance
+module ActiveRecord::Caching
+
+  def self.append_features(base)    
+     super     
+     base.class_eval do     
+       cattr_accessor :cacher              
+       class << self
+         alias_method :ar_find_by_sql, :find_by_sql
+         alias_method :ar_count_by_sql, :count_by_sql
+         undef :find_by_sql, :count_by_sql
+         
+         def find_by_sql(sql)
+           cacher.cache_query( self, sanitize_sql(sql) ) do |s|
+             ar_find_by_sql(s)
+           end
+         end  
+         
+         def count_by_sql(sql)
+            cacher.cache_query( self, sanitize_sql(sql) ) do |s|
+              ar_count_by_sql(s)
+            end
+         end
+         
+         def ===(inst)
+           i = 0
+           while( (kl = inst.class.ancestors[i]) != Object )
+            return true if self.to_s == kl.to_s
+            i += 1
+           end
+           super
+         end
+                           
+       end            
+       
+     end
+     
+  end
+  
+  def kind_of?(klass)
+     return true if klass === self
+     super
+  end
+  
+  def is_a?(klass)
+    kind_of?(klass)
+  end
+  
+  def after_save
+    self.class.cacher.expire(self.class)
+  end
+  
+end
+
+ActiveRecord::Base.class_eval do
+  include ActiveRecord::Caching
+end
+
+class ActiveRecord::CacheSQLQuery
+    
+    RE_TABLES = /FROM(.+?)(?:(WHERE)|(LIMIT)|($))/i
+    
+    attr_reader :sql
+    
+    @@queries = Hash.new { |hsh, query| hsh[query] = self.new(query) }
+    
+    def self.create(str)
+      @@queries[str]
+    end
+    
+    def initialize(str)
+      @sql = str.gsub(/[\r\n]/,' ')
+    end
+    
+    def tables
+      return @tables if @tables
+      raw = @sql.scan(RE_TABLES).flatten[0].strip.split(/,/)
+      @tables = raw.map do |r|
+        r.strip.gsub(/\s+.+$/,'').strip
+      end.uniq
+    end
+      
+    def to_s
+      @sql
+    end
+    
+    def to_str
+      to_s
+    end
+    
+    def inspect
+      "<sql: #{to_s.inspect}>"
+    end
+    
+    def == (oth)
+      @sql == oth.sql
+    end
+    
+    def eql?(oth)
+      self == oth
+    end
+    
+end
+
+class ActiveRecord::CacheInstance
+  
+  def initialize(inst)
+    begin
+      @inst = inst.dup
+    rescue TypeError
+      @inst = inst
+    end
+    @expired = false
+  end
+  
+  def instance
+    begin
+      @inst.dup
+    rescue
+      @inst
+    end
+  end
+  
+  def expire!
+    @inst = nil
+    @expired = true
+  end
+  
+  def expired?
+    @expired
+  end
+  
+end
+
+class ActiveRecord::MemoryCache
+  
+  include Singleton
+  
+  cattr_accessor :max_size
+  
+  # Maximal cache size for one model is 10MB by default
+  @@max_size = 10 * 1024 * 1024 
+  
+  cattr_accessor :log
+  @@log = false
+  
+  cattr_accessor :logger
+  
+  def initialize
+    @tables = Hash.new do |hsh, table|
+      hsh[table] = Cache.new
+    end
+  end
+  
+  def cache_query(klass, sql, &blk)
+    sql = ActiveRecord::CacheSQLQuery.create(sql)
+    tbl = klass.table_name()
+    if @tables[tbl].cached?(sql) and !@tables[tbl][sql].expired?
+      log_hit(sql) 
+      inst = @tables[tbl][sql].instance
+      inst
+    else      
+      log_miss(sql)      
+      inst = store_result( sql, blk.call(sql.to_s) ).instance      
+      inst      
+    end    
+  end
+  
+  def expire(klass)
+    if(cache = @tables[ klass.table_name() ])
+      cache.each do |key, inst|
+        inst.expire!
+        cache.delete(key)
+      end
+    end
+  end
+  
+private
+
+  def store_result(sql, obj)
+      inst = ActiveRecord::CacheInstance.new( obj )
+      sql.tables.each do |tbl|      
+        @tables[tbl].store(sql, inst)
+      end
+      inst
+  end
+  
+  def log_hit(sql)
+    do_log("Cache hit for tables #{sql.tables.inspect}: #{sql.inspect}")
+  end
+  
+  def log_miss(sql)
+      do_log("Cache miss for tables #{sql.tables.inspect}: #{sql.inspect}")
+  end
+  
+  def log_stats
+    size, num, hits, misses = @cache[tbl].statistics
+    do_log("Cache stat for #{tbl}: size=#{size}B; num=#{num}; hits=#{hits}; misses=#{misses}")
+  end
+  
+  def do_log(str)
+    logger.info(str) if log
+  end
+  
+end

metadata

@@ -0,0 +1,38 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.6
+specification_version: 1
+name: cacheAR
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+date: 2005-04-09
+summary: cacheAR is a tiny Ruby on Rails add-on to enable support of caching ActiveRecord lookup results.
+require_paths: 
+  - lib
+email: dmitry@sabanin.ru
+homepage: http://rubyforge.org/projects/muravey-tools
+rubyforge_project: muravey-tools
+description: 
+autorequire: cachear
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Dmitry V. Sabanin
+files: 
+  - lib/cachear.rb
+  - cacheAR-CHANGES
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []