lore 0.4.8 → 0.9.2

data/lib/lore/cache/memory_entity_cache.rb

@@ -0,0 +1,77 @@
+
+require 'lore'
+require 'lore/cache/abstract_entity_cache'
+begin
+  require 'mmap'
+  require 'activesupport'
+  require 'active_support/cache/memory_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 MemoryStore
+      end
+    end
+  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 Memory_Entity_Cache < Abstract_Entity_Cache
+  extend Cache_Helpers
+
+    @@logger = Logger.new('/tmp/lore_cache.log')
+
+    @@store = ActiveSupport::Cache::MemoryStore.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 << accessor.new(r, joined_models, :cached)
+    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
+      @@logger.info { 'CACHE MISS on ' << query_obj[:query] } unless hit
+      return hit
+    end
+
+    def self.delete(index)
+      @@logger.debug { "Deleting index #{index}" }
+      @@store.delete(index)
+    end
+
+  end
+
+end
+end
+
+

data/lib/lore/cache/mmap_entity_cache.rb

@@ -34,9 +34,9 @@ module Cache
     end
 
     def self.read(accessor, query_obj)
-      @@logger.debug('Loading from cache: ' << index_for(query_obj[:query]))
+      Lore.log { 'Loading from cache: ' << index_for(query_obj[:query]) }
       store = Mmap.new(storefile_of(accessor.table_name, query_obj[:query]))
-      @@logger.debug('STORE: ' << store.inspect)
+      Lore.log { 'STORE: ' << store.inspect }
       return [] unless store
       result = Marshal::load(store)
       return result['dump']

data/lib/lore/cache/mmap_entity_cache_bork.rb

@@ -0,0 +1,86 @@
+
+require 'lore'
+require 'lore/cache/abstract_entity_cache'
+begin
+  require 'mmap'
+rescue LoadError
+  Lore.log { 'Mmap for Ruby could not be found. You won\'t be able to use Mmap_Entity_Cache. ' }
+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 Mmap_Entity_Cache < Abstract_Entity_Cache
+  extend Cache_Helpers
+
+    @@logger = Logger.new('/tmp/lore_cache.log')
+
+
+    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)
+        begin
+          File.unlink(cache_file)
+        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 = Mmap.new(storefile_of(accessor.table_name, query_obj[:query]))
+      return [] unless store
+      result = Marshal::load(store)
+      return result
+
+      vector = []
+      joined_models   = result['dump'][:joined_models]
+      joined_models ||= []
+      result['dump'][:values].each { |r|
+        vector << accessor.new(r, joined_models, true)
+      }
+      return vector
+
+    # 
+    # return result['dump']
+    end
+
+    def self.create(accessor, query_object, result)
+      storefile = create_mmap(accessor, query_object, result)
+    end
+    def self.create_mmap(accessor, query_object, result)
+      storefile = storefile_of(accessor.table_name, query_object[:query])
+      store = create_store(storefile)
+      store.transaction do
+     #  store['dump'] = { :values => result, 
+     #                    :joined_models => query_object[:joined_models] }
+        store['dump'] = result
+      end
+      @@logger.debug('Creating cache entry for ' << storefile )
+      Mmap.new(storefile)
+      return storefile
+    end
+
+    def self.include?(accessor, query_obj)
+      hit = FileTest.exist?(storefile_of(accessor.table_name, query_obj[:query]))
+      @@logger.debug { 'Cache miss: ' << index_for(query_obj[:query]) } unless hit
+      return hit
+    end
+
+    def self.delete(index)
+      File.rm(storefile_of(accessor.table_name, query_obj[:query]))
+    end
+
+  end
+
+end
+end
+
+

data/lib/lore/clause.rb

@@ -1,8 +1,9 @@
 
-require('lore/table_accessor')
+require('lore/model/table_accessor')
 require('lore/query_shortcuts') # So far, a forward-declaration could do here as well
 
 class String
+  # Poor man's SQL injection prevention ... 
   def lore_escape
     self.gsub!("'","X")
     self.gsub!('"','X')
@@ -10,6 +11,59 @@ class String
   end
 end
 
+class Symbol
+# {{{
+  
+  # Do not overload Symbol#==
+  def eq(other)
+    Lore::Clause.new(self.to_s)==(other)
+  end
+  alias is eq
+  def >=(other)
+    Lore::Clause.new(self.to_s)>=(other)
+  end
+  def <=(other)
+    Lore::Clause.new(self.to_s)<=(other)
+  end
+  def >(other)
+    Lore::Clause.new(self.to_s)>(other)
+  end
+  def <(other)
+    Lore::Clause.new(self.to_s)<=(other)
+  end
+  def <=>(other)
+    Lore::Clause.new(self.to_s)<=>(other)
+  end
+  def not(other)
+    Lore::Clause.new(self.to_s)<=>(other)
+  end
+  def like(other)
+    Lore::Clause.new(self.to_s).like(other)
+  end
+  def ilike(other)
+    Lore::Clause.new(self.to_s).ilike(other)
+  end
+  def has_element(other)
+    Lore::Clause.new(self.to_s).has_element(other)
+  end
+  def has_element_like(other)
+    Lore::Clause.new(self.to_s).has_element_like(other)
+  end
+  def has_element_ilike(other)
+    Lore::Clause.new(self.to_s).has_element_ilike(other)
+  end
+  def in(other)
+    Lore::Clause.new(self.to_s).in(other)
+  end
+  def not_in(other)
+    Lore::Clause.new(self.to_s).not_in(other)
+  end
+  def between(s,e)
+    Lore::Clause.new(self.to_s).between(s,e)
+  end
+
+end # }}}
+
 module Lore
 
   def self.parse_field_value(value)
@@ -32,7 +86,7 @@ module Lore
   #       k.limit(10)
   #     }
   #
-  class Join # :nodoc:
+  class Join 
   # {{{
 
     def initialize(clause, base_klass, join_klass, type=:natural)
@@ -44,21 +98,10 @@ module Lore
       # By joining with another klass, new attributes are added 
       # we have to include in the AS part of the query: 
       new_attributes = ''
-   #  join_klass.get_attributes.each { |attr_set|
-   #    table = attr_set[0]
-   #    attr_set[1].each { |attrib_name|
-   #      new_attributes += ', ' << "\n"
-   #      new_attributes += table + '.' << attrib_name 
-   #      new_attributes += ' AS '
-   #      new_attributes += '"' << table << '.' << attrib_name << '" ' 
-   #    }
-   #  }
       implicit_joins = ''
       @clause_parser.add_as(new_attributes)
 
-      @implicit_joins = Table_Selector.build_joined_query(join_klass)
-      
-      # @clause_parser.add_join(self)
+      @implicit_joins = Table_Select.build_joined_query(join_klass)
     end
 
     def implicit_joins
@@ -99,12 +142,26 @@ module Lore
 
   end # class }}}
   
-  class Clause < String # :nodoc:
+  # Clause objects are responsible for operands on Model attributes, 
+  # as in WHERE parts of a query. 
+  # Model klass methods named like one if its (possibly inherited) 
+  # field names return a preconfigured Clause object on that field. 
+  #
+  # Example: 
+  #
+  #    (Car.num_seats > 100).to_sql  --> "public.vehicle.num_seats > '100'"
+  #
+  class Clause < String 
   # {{{
 
     attr_reader :field_name, :value_string, :left_side, :plan
     
     def initialize(field_name='', left_side='', value_string='', plan={})
+      if field_name.instance_of?(TrueClass) then
+        return (Clause.new('1') == '1')
+      elsif field_name.instance_of?(FalseClass) then
+        return (Clause.new('1') == '0')
+      end
       @value_string  = value_string
       @left_side     = left_side
       @field_name    = field_name
@@ -114,31 +171,32 @@ module Lore
       Clause_Parser.new(accessor)
     end
 
+    # Check for Refined_Select needed for functionality of 
+    # Refined_Select. Example: 
+    # 
+    #   User.all.with(User.user_id.in( Admin.all(:user_id) ))
+    # 
     def not_in(nested_query_string)
-      # Check for Refined_Select needed for functionality of 
-      # Refined_Select. Example: 
-      # 
-      #   User.all.with(User.user_id.in( Admin.all(:user_id) ))
-      # 
       if(nested_query_string.instance_of? Refined_Select) then
         nested_query_string.to_inner_select
       else
+        nested_query_string = nested_query_string.join(',') if nested_query_string.is_a?(Array)
         @value_string = @field_name << ' NOT IN (' << "\n" << nested_query_string.to_s << ') '
         Clause.new(@value_string, @left_side+@value_string)
       end
     end
 
+    # Check for Refined_Select needed for functionality of 
+    # Refined_Select. Example: 
+    # 
+    #   User.all.with(User.user_id.in( Admin.all(:user_id) ))
+    # 
     def in(nested_query_string)
-      # Check for Refined_Select needed for functionality of 
-      # Refined_Select. Example: 
-      # 
-      #   User.all.with(User.user_id.in( Admin.all(:user_id) ))
-      # 
       if(nested_query_string.instance_of? Refined_Select) then
         nested_query_string = nested_query_string.to_select
       elsif nested_query_string.instance_of? Array then
-        raise ::Exception.new('IN field expects at least one element. ') if nested_query_string.length == 0
         nested_query_string = nested_query_string.join(',')
+        nested_query_string = 'NULL' if nested_query_string.length == 0
       elsif nested_query_string.instance_of? Range then
         return between(nested_query_string.first, nested_query_string.last)
       end
@@ -226,6 +284,7 @@ module Lore
       end
       Clause.new(@value_string, @left_side+@value_string, '', @plan)
     end
+    alias is ==
 
     def <=>(value) 
       if(value != :NULL)
@@ -235,19 +294,25 @@ module Lore
       end
       Clause.new(@field_name, @left_side+@value_string, '', @plan)
     end
+    alias is_not <=>
+
     def |(value) 
-      @value_string = ' OR ' << value.left_side 
-      Clause.new(@value_string, '(' << @left_side+@value_string + ')', '', @plan)
+      return Clause.new('1') == '1' if value.instance_of?(TrueClass)
+      return Clause.new('1') == '0' if value.instance_of?(FalseClass)
+      @value_string = " OR #{value.left_side}"
+      Clause.new(@value_string, "(#{@left_side+@value_string})", '', @plan)
     end
     alias or |
     def &(value) 
       return unless value
+      return Clause.new('1') == '1' if value.instance_of?(TrueClass)
+      return Clause.new('1') == '0' if value.instance_of?(FalseClass)
       if @left_side.gsub(' ','') != '' then
-        @value_string = ' AND ' << value.left_side 
+        @value_string = " AND #{value.left_side}"
       else 
         @value_string = value.left_side
       end
-      Clause.new(@field_name, @left_side+@value_string, '', @plan)
+      Clause.new(@field_name, "(#{@left_side+@value_string})", '', @plan)
     end
     alias and &
     
@@ -306,8 +371,10 @@ module Lore
   
   # parses / builds WHERE, GROUP BY, ORDER BY, LIMIT, ... 
   # part of the query: 
-  class Clause_Parser # :nodoc
+  class Clause_Parser 
   # {{{
+    
+    attr_reader :unions
 
     def initialize(base_accessor)
 
@@ -322,6 +389,7 @@ module Lore
       @clause[:filter]   = ''
       @clause[:where]    = 't'
       @clause[:joined]   = []
+      @unions = false
       @base_accessor = base_accessor
 
     end # def
@@ -398,6 +466,7 @@ module Lore
       clause << @clause[:group_by].to_s 
       clause << @clause[:order_by].to_s 
       clause << @clause[:limit].to_s 
+      return clause
     end # def
 
     def where(where_clause)
@@ -408,7 +477,7 @@ module Lore
       elsif where_clause.instance_of? FalseClass then
         where_clause = '\'f\''
       end
-      @clause[:where] = ' WHERE ' << where_clause.to_s
+      @clause[:where] = "\nWHERE #{where_clause.to_s}"
       return self
     end # def
 
@@ -452,10 +521,15 @@ module Lore
       return j
     end
 
+    def union(select_query)
+      @unions ||= []
+      @unions << select_query
+      return self
+    end
+
     def limit(limit_val, offset_val=0)
       @clause[:limit] = ' LIMIT ' << limit_val.to_s
       @clause[:offset] = ' OFFSET ' << offset_val.to_s
-
       return self
     end # def
 
@@ -473,7 +547,6 @@ module Lore
         end
       }
       @clause[:group_by] = ' GROUP BY ' << absolute_field_names.join(',')
-      p @clause
       return self
     end # def
 
@@ -523,7 +596,6 @@ module Lore
     end
 
     def perform
-      
     end
 
   # }}}