lore 0.4.2

data/table_selector.rb

@@ -0,0 +1,314 @@
+
+require('lore/cache/cached_entities')
+require('lore/connection')
+require('lore/clause')
+
+module Lore
+
+module Table_Selector # :nodoc:
+
+  @@logger = Lore.logger
+  
+public
+
+  # Extracted, recursive method for building the JOIN-part of 
+  # a SELECT query. 
+  def self.build_joined_query(accessor, query_string='', joined_tables=[])
+
+    top_table        = accessor.table_name
+    is_a_hierarchy   = accessor.get_joins()
+    own_primary_keys = accessor.get_primary_keys()
+    own_foreign_keys = accessor.get_foreign_keys()
+
+    joined_accessors = (accessor.get_is_a_klasses).dup
+    joined_accessors.update(accessor.get_aggregate_klasses)
+
+    # predefine
+    own_p_keys     = Hash.new
+    foreign_p_keys = Hash.new
+    on_string      = String.new
+    field_counter  = 0
+
+    is_a_hierarchy.each_pair { |foreign_table, foreign_base_tables|
+      # JOIN base.table ON ( 
+      if !(joined_tables.include?(foreign_table)) then
+
+           foreign_p_keys = own_primary_keys[foreign_table]
+           
+           own_p_keys = own_foreign_keys[foreign_table]
+
+           if !own_p_keys.nil? then
+             
+             joined_tables << foreign_table
+             query_string << "\n JOIN #{foreign_table} on ("
+             
+             field_counter = 0
+             on_string = ''
+             foreign_p_keys.uniq.each { |foreign_field|
+               
+               # base.table.foreign_field = 
+               on_string << "#{foreign_table}.#{foreign_field} = #{top_table}.#{own_p_keys[field_counter]}"
+               # this.table.own_field
+               
+               if field_counter > 0 then   query_string << ", #{on_string}"
+               else                        query_string << on_string
+               end
+               
+               field_counter += 1
+             } 
+             
+             query_string << ')'
+
+           end
+           
+           # sub-joins of joined table:   
+           query_string = build_joined_query(joined_accessors["#{top_table}.#{own_p_keys.first}"], 
+                                             query_string, 
+                                             joined_tables)
+         end
+    }
+    return query_string
+  end # def
+
+public
+
+  # Extracted, recursive method for building the AS-part of 
+  # a SELECT query. 
+  def self.build_as_query(table_fields, 
+                          query_string='')
+
+    return '*' 
+
+    first = query_string == ''
+              
+    table_fields.each_pair { |table_name, fields|
+
+      fields.each { |foreign_field|
+      
+        # base.table.foreign_field = 
+        query_string << ', ' unless first
+        query_string << "\n #{table_name}.#{foreign_field} AS "
+        query_string << "\"#{table_name}.#{foreign_field}\""
+
+        first = false
+      }
+      
+    }
+
+    query_string
+
+  end #def
+  
+protected
+
+  def self.build_select_query(accessor,
+                              value_keys)
+  # this is to be wrapped in an adapter to provide DB abstraction: 
+
+    table_name = accessor.get_table_name
+    query_string = 'SELECT '
+    query_string << build_as_query(accessor.get_attributes)
+    query_string << ' FROM ' << table_name + ' '
+    query_string << build_joined_query(accessor)
+    query_string << "\n WHERE "
+  
+    operator = '='
+    field    = String.new
+    value_keys[0].each_pair { |field, value|
+    # Filtering values is not necessary when feeded with 
+    # Lore::Attributes instance
+      field = field.to_s
+      if value.instance_of? Hash then
+        value.each_pair { |attrib_name, attrib_value|
+          query_string << "#{field}.#{attrib_name} #{operator} '#{attrib_value.to_s.lore_escape}' AND "
+        }
+      else
+        query_string << "#{table_name}." if field.split('.')[2].nil?
+        query_string << "#{field} #{operator} '#{value.to_s.lore_escape}' AND "
+      end
+    }
+    # remove trailing AND: 
+    query_string.chomp!(' AND ')
+    
+    return query_string
+
+  end # def
+
+
+protected
+
+  def self.select_query(what, 
+                        accessor, 
+                        clause = nil, 
+                        &block)
+                        
+    query_string = 'SELECT '
+    
+    # Example: 
+    # select(Car.name) -> SELECT public.car.name AS "value"
+    if what.instance_of? Lore::Clause then
+      what = what.to_s + ' AS "value" '
+    end
+    
+    if(what.nil? || what == '*' || what == '') then
+      query_as_part = build_as_query(accessor.get_attributes)
+    else 
+      query_as_part = what.to_s      
+    end
+    query_from_part = " FROM #{accessor.get_table_name} "
+    # Add JOIN part for system defined type (user defined 
+    # joins will be set in Clause_Parser object in later 
+    # yield): 
+    query_join_part = build_joined_query(accessor)
+
+    clause_string = ''
+    if block_given? then
+      yield_obj  = Lore::Clause_Parser.new(accessor.table_name, *(accessor.get_attributes))
+      clause  = yield *yield_obj
+    end
+    # Extend AS part by attributes that have been added in clause
+    query_parts = clause.parts
+    query_as_part      << ' ' << query_parts[:as].to_s
+    # Extend JOIN part by joins that have been added in clause
+    query_join_part    << ' ' << query_parts[:join].to_s
+    # Set WHERE part to conditions defined in clause
+    query_where_part    = ' ' << query_parts[:where].to_s
+    # Set GROUP BY part
+    query_group_by_part = ' ' << query_parts[:group_by].to_s
+    # Set HAVING part
+    query_having_part   = ' ' << query_parts[:having].to_s
+    # Set LIMIT, OFFSET
+    query_filter_part   = ' ' << query_parts[:filter].to_s
+    query_order_by_part = ' ' << query_parts[:order_by].to_s
+    query_limit_part    = ' ' << query_parts[:limit].to_s
+    query_limit_part   << ' ' << query_parts[:offset].to_s
+
+    query_string << query_as_part << query_from_part << query_join_part << query_where_part << query_group_by_part << query_having_part << query_filter_part << query_order_by_part << query_limit_part
+
+    # TODO: 
+    #  Implement class Plan_Clause, offering exactly the same methods as Clause, 
+    #  but generating a Plan instead the query. 
+    #  Pass block& to Plan_Clause, too, only in case a plan is needed. 
+
+    return query_string
+    
+  end
+
+  def self.plan_select_query(what, accessor, &block)
+
+    auto_plan = Lore::Plan.new(clause, select_query(what, accessor, &block), accessor)
+
+  end
+ 
+protected
+  
+  def self.select(what, 
+                  accessor,
+                  &block)
+
+    query_string = select_query(what, 
+                                accessor, 
+                                &block)
+
+    return perform_select(accessor, query_string)
+  
+  end # def 
+
+  def self.select_cached(what, 
+                         accessor,
+                         &block)
+
+    query_string = select_query(what, 
+                                accessor, 
+                                &block)
+
+    @@logger.debug { 'Select on ' << accessor.to_s }
+
+    result = Array.new
+    if Lore.cache_enabled? && accessor.entity_cache && accessor.entity_cache.include?(accessor, query_string) then
+      result = accessor.entity_cache.read(accessor, query_string)
+      result = nil if result == ''
+      @@logger.debug { "cache contents for #{accessor.table_name} found: #{result.to_s != ''}" } 
+    else
+      db_result = perform_select(accessor, query_string)
+      db_result.get_rows[:values].each { |row|
+        result.push(accessor.new(row))
+      }
+      if Lore.cache_enabled? && accessor.entity_cache then
+        accessor.entity_cache.create(accessor, query_string, result)
+      end
+    end
+    return result
+  end # def
+
+  def self.select_on_keys(accessor, 
+                          value_keys)
+
+    query_string = build_select_query(accessor,
+                                      value_keys)
+
+    return perform_select(accessor, query_string)
+    
+  end #def
+
+  def self.prepare(plan_name, accessor, args, &block)
+    args_string = ''
+    args.map { |a| a = Lore::TYPE_NAMES[a] } 
+    if args.to_s != '' && args.length > 0 then args_string = "(#{args.join(',')})" end
+    query_string = "PREPARE #{accessor.table_name.gsub('.','_')}__#{plan_name.to_s}#{args_string} AS " << select_query(nil, accessor, &block)
+    begin
+      result = Lore::Connection.perform(query_string)
+    rescue ::Exception => excep
+      @@logger.debug("Exception when preparing #{plan_name.to_s}: #{excep.message}. Already prepared before?")
+    end
+  end
+
+  def self.select_prepared(plan_name, accessor, *args)
+    args_string = ''
+    if args.to_s != '' && args.length > 0 then args_string = "(#{args.join(',')})" end
+    query_string = "EXECUTE #{plan_name.to_s} #{args_string}; "
+    result = Array.new
+    if Lore.cache_enabled? && accessor.entity_cache && accessor.entity_cache.include?(accessor, query_string) then
+      result = accessor.read_entity_cache(query_string)
+      result = nil if result == ''
+      @@logger.debug { "cache contents for prepared #{accessor.table_name}: #{result.to_s.inspect}" } 
+    else
+      db_result = perform_select(accessor, query_string)
+      db_result.get_rows[:values].each { |row|
+        result.push(accessor.new(row))
+      }
+      if Lore.cache_enabled? && accessor.entity_cache then
+        accessor.create_entity_cache(query_string, result)
+      end
+    end
+    return result
+  end 
+
+
+  def self.deallocate(plan_name, accessor)
+    begin
+      query_string = "DEALLOCATE #{accessor.table_name.gsub('.','_')}__#{plan_name.to_s}; "
+      result = Lore::Connection.perform(query_string)
+    rescue ::Exception => excep
+    end
+  end
+
+private
+
+  def self.perform_select(accessor, query_string)
+
+    Context.enter(accessor.get_context) unless accessor.get_context.nil?
+    begin 
+      result = Lore::Connection.perform(query_string)
+      return result
+    rescue PGError => pge
+      raise pge
+    ensure
+      Context.leave unless accessor.get_context.nil?
+      GC.start
+    end
+ end
+
+
+end # module
+end # module

data/table_updater.rb

@@ -0,0 +1,155 @@
+
+require('lore/connection')
+require('lore/bits')
+
+module Lore
+
+module Table_Updater # :nodoc: 
+
+  @logger = Logger.new(Lore.logfile)
+
+  def self.atomic_update_query(table_name, 
+                               attributes, 
+                               primary_key_values, 
+                               value_keys, 
+                               explicit_fields)
+  
+    @logger.debug('EXPLICIT FIELDS: ' << explicit_fields.inspect)
+
+    query_string = "\n"
+    query_string += 'UPDATE '+table_name+' SET '
+
+    set_string = String.new
+
+    key_counter = 0
+    attributes.each { |attribute_name|
+
+      internal_attribute_name = attribute_name[0..24]
+      value = value_keys[internal_attribute_name].to_s
+      if value == '' then 
+        value = value_keys[table_name+'.'+internal_attribute_name].to_s
+      end
+
+#     attrib = Lore.resolve_passed_value(value_keys, table_name, attribute_name)
+#     value = attrib[:value]
+#     internal_attribute_name = attrib[:field]
+      
+      # only include attribute to update query if 
+      # this attribute is not marked for explicit updating or 
+      # marked as explicit but non-empty: 
+      if(
+         !(explicit_fields && explicit_fields.include?(internal_attribute_name) && value.empty?) &&
+         !(primary_key_values[attribute_name] && value.empty?)
+        )
+      
+        if key_counter > 0
+          set_string += ', '
+        end # if
+        set_string += attribute_name + '=\'' + value.to_s + '\' '
+        
+        key_counter = 1
+        
+      end # if
+    }
+    query_string += set_string
+
+    query_string += 'WHERE '
+
+    field_counter=0
+    primary_key_values.each_pair { |field, value|
+      query_string += field + '=\'' + value.to_s + '\' '
+      if field_counter < primary_key_values.keys.length-1
+        query_string += 'AND '
+      end
+      field_counter += 1
+    }
+    query_string += ';'
+      
+    query_string
+
+  end #def
+
+  def self.block_update(accessor, 
+                        &block)
+    
+    query_string = 'UPDATE '+accessor.get_table_name
+
+    if block_given? then
+      yield_obj = Lore::Clause_Parser.new(accessor.table_name)
+      clause = yield *yield_obj
+    end
+
+    query_string += clause.set_part
+    query_string += clause.where_part
+    
+    Lore::Context.enter(accessor.get_context) unless accessor.get_context.nil?
+
+    begin
+      Lore::Connection.perform(query_string)
+    ensure
+      Lore::Context.leave unless accessor.get_context.nil?
+    end
+
+  end
+
+  # :nodoc
+  def self.update_query(table_name, 
+                        is_a_hierarchy, 
+                        
+                        attributes,
+                        primary_key_values,
+                        value_keys,
+                        explicit_fields,
+                        
+                        query_string='')
+
+    is_a_hierarchy.each_pair { |table, base_tables| 
+      
+      # pass base tables first, recursively, as IS_A-based creation has
+      # to be done bottom-up:
+      query_string += update_query(table, 
+                                   base_tables, 
+
+                                   attributes, 
+                                   primary_key_values, 
+                                   value_keys,
+                                   explicit_fields 
+                                  ).to_s
+    }
+    # finally, add query string for this table: 
+    query_string += atomic_update_query(table_name, 
+                                        attributes[table_name], 
+                                        primary_key_values[table_name], 
+                                        value_keys[table_name], 
+                                      #  value_keys[table_name], 
+                                        explicit_fields[table_name]
+                                       ).to_s
+      
+    query_string
+
+  end #def
+
+  # :nodoc
+  def self.perform_update(accessor, accessor_instance)
+    
+    query_string = update_query(accessor.get_table_name, 
+                                accessor.get_is_a, 
+                                accessor.get_attributes, 
+                                accessor_instance.get_primary_key_values, 
+                                accessor_instance.get_attribute_values, 
+                                accessor.get_explicit)
+    
+    Context.enter(accessor.get_context) unless accessor.get_context.nil?
+    begin
+      Lore::Connection.perform("BEGIN;\n#{query_string}\nCOMMIT;")
+    ensure
+      Context.leave unless accessor.get_context.nil?
+    end
+
+    accessor.flush_entity_cache()
+    
+  end #def
+  
+end # module
+
+end # module

data/test/README

@@ -0,0 +1,31 @@
+
+  How to run tests
+
+  - Create (empty) database test: 
+
+     $ createdb test
+
+  - Create user 'lore' with password 'lore23' 
+    (change this in trunk/lore.rb, if you want to)
+
+     $shell: createuser lore
+     $shell: ...
+     $shell: psql test
+     $psql/test: ALTER USER lore WITH PASSWORD 'lore23'; 
+     $psql/test: \q
+
+  - Insert test schema into database:  
+     $shell: psql test < test/test_db.sql
+
+  - Run tests. No test should fail except those 
+    saying they are supposed to (printing something like 
+    'This will fail')
+    
+    It's best to redirect STDERR to a file. 
+    
+    $shell: ruby test/ts_lore.rb 2>test.log
+  
+  - Check the logfile in case you are interested in 
+    the kinky details. 
+
+

data/test/env.rb

@@ -0,0 +1,5 @@
+
+require('lore')
+
+Lore.add_login_data 'test' => ['lore','lore23']
+Lore::Context.enter :test