lore 0.4.8 → 0.9.2

data/lib/lore/table_selector.rb

@@ -1,285 +0,0 @@
-
-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
-
-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 << ' 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 = '*'
-    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)
-      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 => query_string, :joined_models => clause.parts[:joined] }
-    
-  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[:query])
-  
-  end # def 
-
-  def self.select_cached(what, 
-                         accessor,
-                         &block)
-
-    query_string = select_query(what, 
-                                accessor, 
-                                &block)
-
-    Lore.log { '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[:query]).get_rows()
-      db_result[:values].each { |row|
-        result.push(accessor.new(row, query_string[:joined_models]))
-      }
-      if Lore.cache_enabled? && accessor.entity_cache then
-        accessor.entity_cache.create(accessor, query_string, result)
-      end
-    end
-    return result
-  end # def
-
-  # DELETE ME
-  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)[:query]
-    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).get_rows()
-      db_result[: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/lib/lore/table_updater.rb

@@ -1,157 +0,0 @@
-
-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;")
-    rescue ::Exception => excep
-      Lore::Connection.perform("ROLLBACK;")
-    ensure
-      Context.leave unless accessor.get_context.nil?
-    end
-
-    accessor.flush_entity_cache()
-    
-  end #def
-  
-end # module
-
-end # module

data/lib/lore/validation.rb

@@ -1,65 +0,0 @@
-
-
-module Lore
-module Validation
-
-    
-  def validates(attrib, constraints)
-  # {{{
-    if attrib.kind_of? Clause then
-      attrib_split = attrib.to_s.split('.')
-      table = attrib_split[0..-2]
-      attrib = attrib_split[-1]
-    else
-      table = get_table_name
-    end
-    attrib = attrib.intern unless attrib.instance_of? Symbol
-
-    @constraints = Hash.new if @constraints.nil?
-    @constraints[table] = Hash.new if @constraints[table].nil?
-    @constraints[table][attrib] = Hash.new
-
-    if constraints[:mandatory] then
-      add_explicit_attribute(table, attrib.to_s)
-    end
-    if constraints[:type] then
-    # @attribute_types[table][attrib] = constraints[:type]
-      @constraints[table][attrib][:type] = constraints[:type]
-    end
-    if constraints[:format] then
-      @constraints[table][attrib][:format] = constraints[:format]
-    end
-    if constraints[:length] then
-      if constraints[:length].kind_of? Range then
-        @constraints[table][attrib][:minlength] = constraints[:length].first
-        @constraints[table][attrib][:maxlength] = constraints[:length].last
-      else 
-        @constraints[table][attrib][:minlength] = constraints[:length]
-        @constraints[table][attrib][:maxlength] = constraints[:length]
-      end
-    end
-    if constraints[:minlength] then
-      @constraints[table][attrib][:minlength] = constraints[:minlength]
-    end
-    if constraints[:maxlength] then
-      @constraints[table][attrib][:maxlength] = constraints[:maxlength]
-    end
-  end # }}}
-
-
-  def get_constraints
-  # {{{
-
-    @constraints = Hash.new if @constraints.nil?
-    if !@is_a_klasses.nil? then
-      @is_a_klasses.each_pair { |foreign_key, klass|
-        @constraints.update(klass.get_constraints)
-      }
-    end
-    @constraints
-
-  end # }}}
-
-  
-end 
-end