lore 0.4.2

data/clause.rb

@@ -0,0 +1,528 @@
+
+require('lore/table_accessor')
+require('lore/query_shortcuts') # So far, a forward-declaration could do here as well
+
+class String
+  def lore_escape
+    self.gsub!("'","X")
+    self.gsub!('"','X')
+    self
+  end
+end
+
+module Lore
+
+  def self.parse_field_value(value)
+      if value.instance_of? Clause then
+        value = value.field_name
+      else 
+        value = value.to_s.lore_escape
+        value = '\'' << value << '\''
+      end
+      value
+  end
+
+  # Usage: 
+  # 
+  #   Some_Klass.select { |k|
+  #     k.join(Other_Klass).on(Some_Klass.foo == Other_Klass.bar) { |o|
+  #       k.where(
+  #         (o['foo'] == 1) & (o['bar'] <=> 2)
+  #       )
+  #       k.limit(10)
+  #     }
+  #
+  class Join # :nodoc:
+  # {{{
+
+    def initialize(clause, join_klass, type=:natural)
+      @type = type
+      @clause_parser = clause
+      @join_klass = join_klass
+      @string = ''
+      # 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)
+    end
+
+    def implicit_joins
+      @implicit_joins
+    end
+
+    def plan_name
+      @plan_name
+    end
+
+    def string
+      @string
+    end
+
+    def using(key, &block)
+      if @type == :natural then cmd = 'JOIN '
+      elsif @type == :left then cmd = 'LEFT JOIN '
+      elsif @type == :right then cmd = 'RIGHT JOIN '
+      end
+      @string = "\n" << cmd << @join_klass.table_name << ' USING (' << key.to_s << ') '
+      @clause_parser.append_join(self)
+      yield @clause_parser # use extended clause parser for inner block argument
+    end
+
+    def on(clause, &block)
+      if @type == :natural then cmd = 'JOIN '
+      elsif @type == :left then cmd = 'LEFT JOIN '
+      elsif @type == :right then cmd = 'RIGHT JOIN '
+      end
+      @string = cmd << @join_klass.table_name << ' ON (' << clause.to_sql << ') ' 
+      @clause_parser.append_join(self)
+      yield @clause_parser # use extended clause parser for inner block argument
+    end
+
+  end # class }}}
+  
+  class Clause < String # :nodoc:
+  # {{{
+
+    attr_reader :field_name, :value_string, :left_side, :plan
+    
+    def initialize(field_name, left_side='', value_string='', plan={})
+      @value_string  = value_string
+      @left_side     = left_side
+      @field_name    = field_name
+    end
+
+    def self.for(accessor)
+      Clause_Parser.new(accessor.table_name, accessor.get_attributes)
+    end
+
+    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
+        @value_string = @field_name << ' NOT IN (' << "\n" << nested_query_string.to_s << ') '
+        Clause.new(@value_string, @left_side+@value_string)
+      end
+    end
+
+    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(',')
+      elsif nested_query_string.instance_of? Range then
+        return between(nested_query_string.first, nested_query_string.last)
+      end
+      @value_string = @field_name << ' IN (' << "\n" << nested_query_string.to_s << ') '
+      Clause.new(@value_string, @left_side+@value_string)
+    
+    end
+
+    def between(range_begin, range_end)
+      @value_string = @field_name << " BETWEEN #{range_begin} AND #{range_end} "
+      Clause.new(@value_string, @left_side+@value_string)
+    end
+
+    def +(value)
+      if value.instance_of? String then 
+        value = '\''+value.lore_escape+'\'::text'
+      else 
+        value = value.to_s.lore_escape
+      end
+      @value_string = @field_name.to_s + '+'+value
+      return Clause.new(@value_string, @left_side.to_s+@value_string.to_s)
+    end
+    def -(value)
+      if value.instance_of? String then 
+        value = '\''+value.lore_escape+'\'::text'
+      else 
+        value = value.to_s.lore_escape
+      end
+      @value_string = @field_name + '-'+ value
+      return Clause.new(@value_string, @left_side+@value_string)
+    end
+
+    def is_null()
+      @value_string = @field_name + ' IS NULL'
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+
+    def is_not_null()
+      @value_string = @field_name + ' IS NOT NULL'
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+	
+    def <(value) 
+      @value_string = @field_name + ' < ' << Lore.parse_field_value(value)
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+    def <=(value) 
+      @value_string = @field_name + ' <= ' << Lore.parse_field_value(value)
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+    def >(value) 
+      @value_string = @field_name + ' > ' << Lore.parse_field_value(value)
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+    def >=(value) 
+      @value_string = @field_name + ' >= ' << Lore.parse_field_value(value)
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+    def like(value) 
+      value = value.to_s.lore_escape
+      @value_string = @field_name + ' LIKE ' << Lore.parse_field_value(value)
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+    def ilike(value) 
+      value = value.to_s.lore_escape
+      @value_string = @field_name + ' ILIKE ' << Lore.parse_field_value(value)
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+    def posreg_like(value) 
+      value = value.to_s.lore_escape
+      @value_string = @field_name + ' ~* ' << Lore.parse_field_value(value)
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+    def ==(value) 
+      if value.instance_of? Clause then
+        value = value.field_name
+      else 
+        value = value.to_s.lore_escape
+        value = '\'' << value << '\''
+      end
+      if(value != :NULL)
+        @value_string = @field_name << ' = ' << value
+      else
+        @value_string = @field_name << ' IS NULL' 
+      end
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+
+    def <=>(value) 
+      if(value != :NULL)
+        @value_string = @field_name << ' != ' << Lore.parse_field_value(value)
+      else 
+        @value_string = @field_name << ' NOT NULL '
+      end
+      Clause.new(@field_name, @left_side+@value_string, '', @plan)
+    end
+    def |(value) 
+      @value_string = ' OR ' << value.left_side 
+      Clause.new(@value_string, '(' << @left_side+@value_string + ')', '', @plan)
+    end
+    alias or |
+    def &(value) 
+      return unless value
+      if @left_side.gsub(' ','') != '' then
+        @value_string = ' AND ' << value.left_side 
+      else 
+        @value_string = value.left_side
+      end
+      Clause.new(@field_name, @left_side+@value_string, '', @plan)
+    end
+    alias and &
+    
+    def has_element(element)
+      element = element.to_s if element.kind_of? Clause
+      element = '\''+element.lore_escape+'\'' if element.kind_of? String
+      @value_string = element + ' = ANY ('  << @field_name+ ')'
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+
+    # This query requires a custom operator, defined by: 
+    #
+    #  create function rlike(text,text) returns bool as 'select $2 like $1' language sql strict immutable; 
+    #  create operator ~~~ (procedure = rlike, leftarg = text, rightarg = text, commutator = ~~);
+    #
+    def has_element_like(element)
+      element = element.to_s if element.kind_of? Clause
+      element = '\''+element.lore_escape+'\'' if element.kind_of? String
+      @value_string = element + ' ~~~ ANY ('  << @field_name+ ')'
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+
+    # This query requires a custom operator, defined by: 
+    #
+    #  create function irlike(text,text) returns bool as 'select $2 ilike $1' language sql strict immutable; 
+    #  create operator ~~~~ (procedure = irlike, leftarg = text, rightarg = text, commutator = ~~);
+    #
+    def has_element_ilike(element)
+      element = element.to_s if element.kind_of? Clause
+      element = '\'' + element.lore_escape + '\'' if element.kind_of? String
+      @value_string = element + ' ~~~~ ANY (' << @field_name+ ')'
+      Clause.new(@value_string, @left_side+@value_string, '', @plan)
+    end
+
+    # Important to return @field_name here, as 
+    # Table_Accessor.attribute should return 
+    # schema.table_name.attribute. 
+    # See Table_Accessor.load_attribute_fields
+    def to_s
+      @field_name.to_s
+    end
+
+    def tag 
+      @field_name.gsub('.','--')
+    end
+    
+    def inspect
+      return 'Clause('+to_s+')'
+    end
+
+    def to_sql
+      @left_side + @value_string
+    end
+
+    def plan_name
+
+    end
+    
+  end # class }}}
+  
+  # parses / builds WHERE, GROUP BY, ORDER BY, LIMIT, ... 
+  # part of the query: 
+  class Clause_Parser # :nodoc
+  # {{{
+
+    def initialize(base_table, *table_fields)
+
+      @clause            = Hash.new
+      @clause[:limit]    = ''
+      @clause[:offset]   = ''
+      @clause[:group_by] = ''
+      @clause[:order_by] = ''
+      @clause[:join]     = ''
+      @clause[:as]       = ''
+      @clause[:set]      = ''
+      @clause[:filter]   = ''
+      @clause[:where]    = 't'
+      @base_table = base_table
+
+    end # def
+
+    def self.for(accessor)
+      Clause_Parser.new(accessor.table_name, accessor.get_attributes)
+    end
+
+    def parts
+      @clause
+    end
+
+    def where_part
+      @clause[:where]
+    end
+    def as_part
+      @clause[:as]
+    end
+    def join_part
+      @clause[:join] 
+    end
+    def having_part
+      @clause[:having] 
+    end
+
+    def filter_part
+      return @clause[:order_by] << @clause[:limit] << @clause[:offset] << @clause[:group_by] << @clause[:having]
+    end
+    def set_part
+      @clause[:set].chomp!(',')
+      return ' SET ' << @clause[:set]
+    end
+
+    def plan_args
+      @clause[:plan_args]
+    end
+
+    def plan_types
+      @clause[:plan_types]
+    end
+
+    def plan_values
+      @clause[:plan_values]
+    end
+
+    def plan_name
+      @clause[:plan_name]
+    end
+
+    def set(attrib_value_hash)
+    
+      attrib_value_hash.each_pair { |attr_name, value|
+
+        attr_name = attr_name.to_s unless attr_name.instance_of? String
+        if value.instance_of? Clause then
+          value = value.to_s.lore_escape
+        else
+          value = '\'' << value.to_s.lore_escape+'\'' 
+        end
+        # Postgres disallows full attribute names in UPDATE 
+        # queries, so use field name only:
+        Lore.log { 'Set Attrib: ' << attr_name.to_s }
+        Lore.log { 'Set Value: ' << value.to_s }
+        @clause[:set] << attr_name.to_s.split('.').at(-1).to_s + ' = ' << value.to_s + ','
+      }
+      return self
+
+    end
+      
+    def to_sql
+      clause = ''
+      clause << @clause[:join].to_s 
+      clause << @clause[:where].to_s 
+      clause << @clause[:group_by].to_s 
+      clause << @clause[:order_by].to_s 
+      clause << @clause[:limit].to_s 
+    end # def
+
+    def where(where_clause)
+      if where_clause.instance_of? Clause then
+        where_clause = where_clause.to_sql
+      elsif where_clause.instance_of? TrueClass then
+        where_clause = '\'t\''
+      elsif where_clause.instance_of? FalseClass then
+        where_clause = '\'f\''
+      end
+      @clause[:where] = ' WHERE ' << where_clause.to_s
+      return self
+    end # def
+
+    # For usage in class Join only
+    def add_join(join)
+      @clause[:final_join] = join.implicit_joins
+    end
+
+    # TODO: Check if this is ever needed at all. Currently unused and untested. 
+    def prepend_join(join)
+      @clause[:join] = join.string << @clause[:join]
+      @clause[:join] << join.implicit_joins
+
+    end
+    def append_join(join)
+      @clause[:join] << join.string 
+      @clause[:join] << join.implicit_joins
+    end
+
+    def add_as(string)
+      @clause[:as] << string
+    end
+
+    def join(join_klass)
+      # this Join instance also will update this Clause_Parser's 
+      # as_part (so passing self is crucial): 
+      j = Join.new(self, join_klass)
+      return j
+    end
+    def left_join(join_klass)
+      # this Join instance also will update this Clause_Parser's 
+      # as_part (so passing self is crucial): 
+      j = Join.new(self, join_klass, :left)
+      return j
+    end
+    def right_join(join_klass)
+      # this Join instance also will update this Clause_Parser's 
+      # as_part (so passing self is crucial): 
+      j = Join.new(self, join_klass, :right)
+      return j
+    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
+
+    def having(having_clause)
+      @clause[:having] = ' HAVING ' << having_clause.to_sql
+      return self
+    end
+
+    def group_by(*absolute_field_names)
+      absolute_field_names.map! { |field|
+        if field.instance_of? Clause then
+          field = field.field_name.to_s
+        else 
+          field = field.to_s
+        end
+      }
+      @clause[:group_by] = ' GROUP BY ' << absolute_field_names.join(',')
+      p @clause
+      return self
+    end # def
+
+    def order_by(order_field, dir=:asc)
+      (dir == :desc)? dir_s = 'DESC' : dir_s = 'ASC'
+      if @clause[:order_by]  == '' then
+        @clause[:order_by] = ' ORDER BY ' 
+      else
+        @clause[:order_by] << ', '
+      end
+      @clause[:order_by] << order_field.to_s + ' ' << dir_s
+      return self
+    end # def
+
+    def [](absolute_field_name)
+      if absolute_field_name.instance_of? Clause then
+        field_name = absolute_field_name.field_name.to_s
+      else 
+        field_name = absolute_field_name.to_s
+      end
+      
+      return Clause.new(field_name)
+    end # def
+
+    def max(absolute_field_name)
+      if absolute_field_name.instance_of? Clause then
+        field_name = absolute_field_name.field_name.to_s
+      else 
+        field_name = absolute_field_name.to_s
+      end
+      return Clause.new("max(#{field_name})")
+    end
+
+    def method_missing(absolute_field_name)
+      if absolute_field_name.instance_of? Clause then
+        field_name = absolute_field_name.field_name.to_s
+      else 
+        field_name = absolute_field_name.to_s
+      end
+      
+      return Clause.new("#{@base_table}.#{field_name}")
+    end
+
+    def id()
+      return Clause.new("#{@base_table}.id")
+    end
+
+    def perform
+      
+    end
+
+  # }}}
+  end # class
+
+end # module

data/connection.rb

@@ -0,0 +1,155 @@
+
+$:.push('/opt/local/lib/ruby/1.8/postgres')
+
+require('postgres')
+require('logger')
+require('lore/lore')
+require('lore/result')
+
+module Lore
+
+class Connection_Error < ::Exception
+
+end
+
+class Context 
+  
+  @@logger = Lore.logger
+  @@context_stack = Array.new
+  
+  def self.get_connection()
+    if @@context_stack.empty? then
+      raise ::Exception.new('No context given. ')
+    end
+    return Connection_Pool.get_connection(@@context_stack.last)
+  end
+
+  def self.inspect
+    @@context_stack.inspect
+  end
+  
+  def self.enter(context_name)
+    @@logger.debug('Entering context ' + context_name.to_s)
+    @@context_stack.push(context_name)
+  end
+  
+  def self.leave()
+    context_name = @@context_stack.pop
+    @@logger.debug('Leaving context ' << context_name.to_s)
+  end
+  
+  def self.clear()
+    @@context_stack = Array.new
+    $cb__project = nil
+  end
+    
+  def self.switch_to(project)
+    clear()
+    enter(project.context)
+    $cb__project = project
+  end
+  
+end
+  
+class Connection_Pool 
+
+  @@pool = Hash.new
+
+  def self.get_connection(db_name)
+    
+    db_name = db_name.intern unless db_name.instance_of? Symbol
+    
+    # If requested connection is not in pool yet: 
+    if !@@pool.has_key? db_name then
+      # Try to establish connection
+      begin
+        connection = PGconn.connect(Lore.pg_server, Lore.pg_port, '', '', db_name.to_s, Lore.user_for(db_name), Lore.pass_for(db_name.to_s))
+        connection.exec(Lore.on_connect_commands)
+        @@pool[db_name] = connection
+      # Handle errors
+      rescue PGError => pge
+        raise Lore::Connection_Error.new("Could not establish connection to database '#{db_name.to_s}': " << pge.message)
+      rescue ::Exception => excep
+        raise Lore::Connection_Error.new("Could not establish connection to database '#{db_name.to_s}': " << excep.message)
+      end
+    end
+
+    # Return requested connection
+    return @@pool[db_name]
+
+  end
+
+end
+
+class Connection # :nodoc
+  #include Singleton
+
+  @@logger = Lore.logger
+  @@query_count = 0
+  @@result_row_count = 0
+  
+  def initialize
+  end
+  
+  def self.reset_query_count
+    @@query_count = 0
+  end
+  def self.reset_result_row_count
+    @@result_row_count = 0
+  end
+  def self.query_count
+    @@query_count
+  end
+  def self.result_row_count
+    @@result_row_count
+  end
+  
+  def self.perform_cacheable(query)
+    
+    if Lore::Cache::Cached_Entities.include?(query) then
+        result = Lore::Cache::Cached_Entities[query]
+    else
+      result = perform(query)
+      Lore::Cache::Cached_Entities[query] = result
+    end
+    return result
+  end
+  
+  def self.perform(query)
+    
+    begin
+      
+      connection = Context.get_connection
+      
+      @@query_count += 1
+      result = connection.exec(query)
+      @@result_row_count += result.num_tuples
+      
+      # Log database query on low level: 
+      
+      if Lore.log_queries? then
+        query = query.gsub('WHERE', "\nWHERE").gsub('FROM', "\n}}} \nFROM").gsub('JOIN', "\nJOIN")
+        query = query.gsub('SELECT', "\nSELECT \n{{{").gsub("\n\n","\n")
+        query = query.gsub('SET', "SET\n").gsub(' , ', ", \n")
+        query.split("\n").each { |line|
+          @@logger.debug { line }
+        }
+      end
+      
+    rescue ::Exception => pge
+      
+      pge.message << "\n" << query
+      @@logger.error { pge.message }
+      @@logger.error { 'Context: ' << Context.inspect }
+      @@logger.error { 'Query: ' << "\n" << query }
+      raise pge
+      
+    end
+    
+    return Result.new(query, result)
+    
+  end
+  
+end # class Connection
+
+end # module Lore

data/custom_functions.sql

@@ -0,0 +1,14 @@
+
+-- These functions are needed for exotic operations Lore offers, so far
+-- LIKE-operator and ILIKE-operators on array elements. 
+-- If you intend to use custom SQL functions that have to be defined in 
+-- your database, this is where they should be placed. 
+
+-- Provide LIKE-operator for arrays: (Model.an_array_attribute.has_element_like('%'+foo)
+--
+create function rlike(text,text) returns bool as 'select $2 like $1' language sql strict immutable; 
+create operator ~~~ (procedure = rlike, leftarg = text, rightarg = text, commutator = ~~);
+create function irlike(text,text) returns bool as 'select $2 ilike $1' language sql strict immutable; 
+create operator ~~~~ (procedure = irlike, leftarg = text, rightarg = text, commutator = ~~);
+
+

data/exception/ambiguous_attribute.rb

@@ -0,0 +1,14 @@
+
+module Lore
+module Exception
+
+	class Ambiguous_Attribute < ::Exception
+
+		def initialize(table_a, table_b, attribute)
+			@message = 'Ambiguous attribute: '+attribute+ ' exists in '+table_a+' and '+table_b+'. '
+		end
+
+	end # class
+
+end # module
+end # module