lore 0.4.8 → 0.9.2

data/lib/lore/adapters/postgres/result.rb

@@ -0,0 +1,82 @@
+
+require('postgres')
+
+module Lore
+  
+class Result
+
+  attr_reader :query_hashval, :field_names, :field_types
+
+  # expects PGresult
+  def initialize(query, result) 
+    @result = result
+    @field_types      = nil
+    @result_rows      = Array.new
+    @num_fields       = @result.num_fields
+    @num_tuples       = @result.num_tuples
+    @field_counter    = 0
+    @field_names      = @result.fields
+  end # def initialize
+  
+  def get_field_value(row_index, field_name)
+    field_index = @result.fieldnum(field_name)
+    return @result.getvalue(row_index, field_index)
+  end # def get_field_value
+  
+  def get_field_types()
+    
+    return @field_types unless @field_types.nil?
+    
+    @field_types = Hash.new
+    for field_index in 0...get_field_num()
+      @field_types[@result.fields[field_index]] = @result.type(field_index)
+    end
+    
+    return @field_types
+  end
+  alias field_types get_field_types
+  alias get_field_names field_names
+  
+  def get_field_num()
+    @num_fields
+  end
+  
+  def get_tuple_num()
+    @num_tuples
+  end
+  
+  def get_row(row_num=0)
+    @result[row_num]
+  end
+  def get_row_with_field_names(row_num=0)
+
+    return if @result.num_tuples == 0
+
+    row_result = Array.new
+    
+    @field_counter = 0
+    for @field_counter in 0...@num_fields do
+      row_result << @result.getvalue(row_num, @field_counter)
+    end
+    @fieldnames = []
+    for @field_counter in 0...@num_fields do
+      @fieldnames << @result.fieldname(@field_counter)
+    end
+    return { :values => row_result, :fields => @fieldnames }
+  end
+  
+  def get_rows()
+    rows = []
+    for tuple_count in 0...@result.num_tuples do
+      rows << @result[tuple_count]
+    end
+    return rows
+  end
+  
+  def fieldname(index)
+    return @result.fieldname(index)
+  end
+  
+end # class Result
+
+end # module Lore

data/lib/lore/adapters/postgres/types.rb

@@ -0,0 +1,91 @@
+
+module Lore
+
+  PG_BOOL                = 16
+  PG_BYTEA               = 17
+  PG_SMALLINT            = 21
+  PG_CHAR                = 18
+  PG_INT                 = 23
+  PG_TEXT                = 25
+  PG_FLOAT               = 701
+  PG_CHARACTER           = 1042
+  PG_VARCHAR             = 1043
+  PG_TIME                = 1083
+  PG_TIMESTAMP_TIMEZONE  = 1184
+  PG_TIMESTAMP           = 1114
+  PG_DATE                = 1082
+  PG_VCHAR_LIST          = 1015
+  PG_DECIMAL             = 1700
+
+  TYPE_NAMES = { 
+    PG_BYTEA               => 'bytea',
+    PG_BOOL                => 'boolean',
+    PG_SMALLINT            => 'small int',
+    PG_CHAR                => 'char',
+    PG_INT                 => 'integer',
+    PG_TEXT                => 'text',
+    PG_FLOAT               => 'float', 
+    PG_CHARACTER           => 'character',
+    PG_VARCHAR             => 'character varying(1000)',
+    PG_TIME                => 'time',
+    PG_TIMESTAMP_TIMEZONE  => 'timestamp with timezone',
+    PG_TIMESTAMP           => 'timestamp',
+    PG_DATE                => 'data',
+    PG_VCHAR_LIST          => 'character varying[]', 
+    PG_DECIMAL             => 'decimal'
+  }
+
+  class Type
+
+    def self.integer; 'integer'; end
+    def self.boolean; 'boolean'; end
+    def self.bytea; 'bytea'; end
+    def self.char; 'char'; end
+    def self.varchar(length=255); 'character varying(' << length.to_s + ')'; end
+    def self.time; 'time'; end
+    def self.timestamp; 'timestamp'; end
+    def self.date; 'date'; end
+    def self.text; 'text'; end
+    def self.decimal; 'decimal'; end
+
+    def self.type_name(int)
+      TYPE_NAMES[int]
+    end
+
+  end
+
+  class Type_Filters
+
+    @@input_filters = { 
+      PG_VCHAR_LIST          => lambda { |v| "{#{v.join(',')}}" }, 
+      PG_BOOL                => lambda { |v| if (v && v != 'f' || v == 't') then 'f' elsif (v.instance_of?(FalseClass) || v == 'f') then 'f' else nil end }, 
+      PG_DATE                => lambda { |v| v.to_s }, 
+      PG_TIME                => lambda { |v| v.to_s }, 
+      PG_TIMESTAMP_TIMEZONE  => lambda { |v| v.to_s }, 
+      PG_TIMESTAMP           => lambda { |v| v.to_s }, 
+    }
+    @@output_filters = { 
+      PG_VCHAR_LIST          => lambda { |v| v[1..-2].split(',') }, 
+      PG_INT                 => lambda { |v| if v then v.to_i else nil end }, 
+      PG_SMALLINT            => lambda { |v| if v then v.to_i else nil end },
+      PG_FLOAT               => lambda { |v| if v && v.length > 0 then v.to_f else nil end }, 
+      PG_DECIMAL             => lambda { |v| if v && v.length > 0 then v.to_f else nil end }, 
+      PG_BOOL                => lambda { |v| if v == 't' then true elsif v == 'f' then false else nil end }
+# SLOW!
+#     PG_DATE                => lambda { |v| Date.parse(v) if v }, 
+#     PG_TIME                => lambda { |v| Time.parse(v) if v }, 
+#     PG_TIMESTAMP_TIMEZONE  => lambda { |v| DateTime.parse(v) if v }, 
+#     PG_TIMESTAMP           => lambda { |v| DateTime.parse(v) if v }
+    }
+
+    def self.in
+      @@input_filters
+    end
+
+    def self.out
+      @@output_filters
+    end
+
+  end
+
+end # module

data/lib/lore/bits.rb

@@ -50,3 +50,21 @@ class Hash
   end
 
 end
+
+class Object
+  def empty? 
+    false
+  end
+end
+
+class String
+  def empty? 
+    return self == ''
+  end
+end
+
+class Nil
+  def empty?
+    true
+  end
+end

data/lib/lore/cache/abstract_entity_cache.rb

@@ -2,6 +2,7 @@
 require('logger')
 require('pstore')
 require('digest/md5')
+require('lore/exceptions/cache_exception')
 
 module Lore
 module Cache
@@ -69,7 +70,7 @@ module Cache
     end
 
     def storefile_of(model_name, query)
-      '/tmp/lore_cache__' << model_name + '_' << Digest::MD5.hexdigest(query)
+      "/tmp/lore_cache__#{model_name}_#{Digest::MD5.hexdigest(query)}"
     end
 
     def create_store(storefile_name)

data/lib/lore/cache/cacheable.rb

@@ -2,198 +2,33 @@
 require('pstore')
 
 require('lore/cache/bits')
-require('lore/exception/cache_exception')
+require('lore/exceptions/cache_exception')
 
 module Lore
 module Cache
 
   module Cacheable
 
-    @@cache_control      = Hash.new
-    @@cache_on_pkeys     = Hash.new
-    @@distinctive_params = Hash.new
-    @@cache_entities     = false
+    @@cache_impl = false
 
-    @@logger = Lore.logger
-    
-  public
-  
-    def is_cacheable(controller)
-      controller = controller.intern unless controller.instance_of? Symbol
-      return !@@cache_control[controller].nil? && @@cache_control[controller]
+    def entity_cache
+      @@cache_impl 
     end
 
-    # Returns whether a Table_Accessor state 
-    # is cached or not. 
-    def is_cached(controller, mode, keys)
-      
-      store_filename = Lore::Cache::store_name(self.name.to_s, controller, mode, keys)
-      if store_filename.nil? then
-        excep_mesg  = 'Cannot resolve store filename for ['+self.name.to_s+'|'+controller+'|'+mode+']'
-        excep_mesg += ' Keys: '+keys.to_s
-        raise ::Exception.new(excep_mesg)
-      end
-
-      if FileTest.exist?(store_filename) then
-        true
-      else 
-        false
-      end
-
+    def use_entity_cache(entity_cache_class)
+      @@cache_impl = entity_cache_class 
     end
 
-  protected
-
-    def cache(controller, additional_params=nil)
-      controller = controller.intern unless controller.instance_of? Symbol
-      @@cache_control[controller] = true
-      if !additional_params.nil? then
-        @@distinctive_params[controller] = Array.new unless !@@distinctive_params[controller].nil?
-        @@distinctive_params[controller] += additional_params
-      end
-
+    def flush_entity_cache
+      @@cache_impl.flush(self) if @@cache_impl
     end
 
-    def cache_select_entities
-      @@cache_entities = true
+    def create_entity_cache(query_string, result) 
+      @@cache_impl.create(self, query_string, result) if @@cache_impl
     end
 
-    def cache_entities
-      @@cache_entities
-    end
-
-    def cache_on_pkeys(controller, additional_params=nil)
-      @@logger.log('Caching depending from pkeys only, controller: ' << controller.to_s << ', params: ' << additional_params.to_s)
-      cache(controller, additional_params)
-      @@cache_on_pkeys[controller] = true
-    end
-
-    def cache_pkeys_only?(controller)
-      !@@cache_on_pkeys[controller].nil? && @@cache_on_pkeys[controller]
-    end
-    
-    def nocache(controller)
-      controller = controller.intern unless controller.instance_of? Symbol
-      @@cache_control[controller] = false
-    end
-    
-  public
-
-    def cache_params(controller)
-      return @@distinctive_params[controller] unless @@distinctive_params[controller].nil?
-      return Hash.new
-    end
-
-    def create_cache(controller, mode, keys, output)
-
-      @@logger.log('cache_on_pkeys: '+@@cache_on_pkeys.inspect)
-      if !@@cache_on_pkeys[controller.intern].nil? && 
-         @@cache_on_pkeys[controller.intern] 
-      then
-        keys = filter_pkeys(self, controller, keys)
-        @@logger.log('Filtered keys: '+keys.inspect)
-      end
-
-      if !@@cache_control[controller.intern].nil? && 
-         @@cache_control[controller.intern] 
-      then
-      
-        if !@@cache_control[:self].nil? && 
-           @@cache_control[:self]
-        then 
-          class_copy = self
-        end
-
-        if is_cached(controller, mode, keys) then 
-          return 
-        end
-
-        store = create_store(controller, mode, keys, output)
-        store.transaction do
-          store['klass']      = class_copy unless class_copy.nil?
-          store['controller'] = controller
-          store['mode']       = mode
-          store['keys']       = keys
-          store['output']     = output
-        end
-        
-      else 
-        raise Cache_Write_Exception.new(self.name.to_s, controller, mode, keys)
-      end
-      
-    end
-
-  public
-
-    def create_cache!(controller, mode, keys, output)
-      invalidate(controller, mode, keys)
-      create_cache(controller, mode, keys)
-    end
-
-  public
-    
-    def read_cache(controller, mode, keys)
-      
-      if !@@cache_control[controller.intern].nil? && 
-         @@cache_control[controller.intern] &&
-         is_cached(controller, mode, keys) 
-      then
-      
-        output = ''
-        store = create_store(controller, mode, keys, output)
-        store.transaction do
-          output = store['output']
-        end
-
-        return output
-
-      else 
-        raise Cache_Read_Exception.new(self.name.to_s, controller, mode, keys)
-      end
-
-    end
-    
-    def invalidate(controller, mode, keys)
-      File.unlink(Lore::Cache::store_name(self.name.to_s, controller, mode, keys))
-    end
-    def invalidate_all(controller=:all, mode=:all, keys=:all)
-      cwd = Dir.getwd
-      Dir.chdir('/tmp/')
-      if keys == :all then keys = Hash.new end
-      invalid_cache_pattern = Lore::Cache::store_name(self.name.to_s, controller, mode, keys)
-      @@logger.log('Deleting cache for: '+invalid_cache_pattern)
-      invalid_cache_files = Dir.glob(invalid_cache_pattern)
-      invalid_cache_files.each { |cache_file|
-        @@logger.log('Deleting '+cache_file)
-        File.delete(cache_file)
-      }
-      Dir.chdir(cwd)
-    end
-
-  private
-
-    def create_store(controller, mode, keys, output)
-      store_file = Lore::Cache::store_name(self.to_s, controller, mode, keys)
-      store = PStore.new(store_file) unless store_file.nil?
-      return store
-    end
-
-    def filter_pkeys(model_klass, controller, keys)
-      if !model_klass.respond_to? 'key_array' then
-        @@logger.log('could not filter for pkeys')
-        return keys
-      end
-      result = Hash.new
-      model_klass.key_array.each { |pkey|
-        result[pkey] = keys[pkey]
-      }
-      if !@@distinctive_params[controller].nil? then
-        @@distinctive_params[controller].each { |param|
-          result[param] = keys[param]
-        } 
-      end
-
-      return result
+    def read_entity_cache(query_string)
+      @@cache_impl.read(self, query_string) if @@cache_impl
     end
 
   end

data/lib/lore/cache/memcache_entity_cache.rb

@@ -0,0 +1,89 @@
+
+require 'lore'
+require 'lore/cache/abstract_entity_cache'
+begin
+  require 'mmap'
+  require 'activesupport'
+  require 'active_support/cache/mem_cache_store'
+rescue LoadError
+  Lore.log { 'Mmap or ActiveSupport for Ruby could not be loaded. You won\'t be able to use Mmap_Entity_Cache. ' }
+
+  module ActiveSupport
+    module Cache
+      class MemCacheStore
+      end
+    end
+  end
+end
+
+class Object
+  def logger
+    Lore.logger
+  end
+end
+
+module Lore
+module Cache
+
+
+  # Implementation of entity cache using MMapped PStor files. 
+  # Derived from Abstract_Entity_Cache. 
+  # Uses Lore::Cache::Cache_Helpers for generating PStor files. 
+  class Memcache_Entity_Cache < Abstract_Entity_Cache
+  extend Cache_Helpers
+
+    @@logger = Logger.new('/tmp/lore_cache.log')
+
+    @@store = ActiveSupport::Cache::MemCacheStore.new()
+
+
+    def self.flush(accessor)
+      index = accessor.table_name
+      return unless Lore.cache_enabled? 
+      Dir.glob("/tmp/lore_cache__#{index}*").each { |cache_file|
+        @@logger.debug('Clearing cache file ' << cache_file.to_s.split('_').last)
+        begin
+          @@store.delete(cache_file.to_s.split('_').last)
+        rescue ::Exception => excep
+          # Another process already killed this file
+        end
+      }
+    end
+
+    def self.read(accessor, query_obj)
+      @@logger.debug { 'Loading from cache: ' << index_for(query_obj[:query]) }
+      store = @@store.read("#{accessor.table_name}--#{index_for(query_obj[:query])}")
+      return [] unless store
+      return store[:values]
+      
+      result = []
+      store.each { |r|
+        joined_models   = r[:joined_models]
+        joined_models ||= []
+        result <<  accessor.new(r[:values].dup, joined_models, true)
+      }
+      return result
+    end
+
+    def self.create(accessor, query_object, result)
+      entry = query_object.update({ :values => result })
+      @@store.write("#{accessor.table_name}--#{index_for(query_object[:query])}", entry) 
+    end
+
+    def self.include?(accessor, query_obj)
+      hit = @@store.exist?("#{accessor.table_name}--#{index_for(query_obj[:query])}")
+      @@logger.debug { 'Cache miss: ' << index_for(query_obj[:query]) } unless hit
+      return hit
+    end
+
+    def self.delete(index)
+      @@logger.debug { "Deleting index #{index}" }
+      @@store.delete(index)
+    end
+
+  end
+
+end
+end
+
+