lore 0.4.8 → 0.9.2

data/lib/lore/table_deleter.rb

@@ -1,116 +0,0 @@
-
-require('lore/connection')
-require('lore/bits')
-
-module Lore
-
-module Table_Deleter # :nodoc:
-
-  @logger = Lore.logger
-  
-  private
-  
-  def self.atomic_delete_query(table_name, primary_keys, value_keys)
-    
-    query_string = 'DELETE FROM '+table_name+' WHERE '
-    
-    field_counter=0
-    primary_keys.each { |field|
-      
-      query_string << field + '=\'' 
-      internal_attribute_name = field[0..27]
-      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, field)
-#     value = attrib[:value]
-#     internal_attribute_name = attrib[:field]
-      query_string << value + '\' '
-      if field_counter < primary_keys.length-1
-        query_string += 'AND '
-      end
-      field_counter += 1
-    }
-    query_string += '; '
-			
-    query_string
-    
-  end #def
-  
-  def self.block_delete(accessor, 
-                        &block)
-    
-    query_string = 'DELETE FROM '+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.where_part
-    
-    Context.enter(accessor.get_context) unless accessor.get_context.nil?
-    begin
-      Lore::Connection.perform(query_string)
-    ensure
-      Context.leave unless accessor.get_context.nil?
-    end
-    
-  end
-  
-  def self.delete_query(table_name, is_a_hierarchy, primary_keys, value_keys, query_string='')
-    
-    query_string += atomic_delete_query(table_name, 
-                                        primary_keys[table_name], 
-                                        value_keys[table_name]
-                                        ).to_s
-    is_a_hierarchy.each_pair { |table, base_tables| 
-      
-      # pass base tables afterwards, recursively, as IS_A-based deletion has
-      # to be done top-down (derived tabled first): 
-      query_string = delete_query(table, 
-                                  base_tables, 
-                                 
-                                  primary_keys, 
-                                  value_keys, 
-                                 
-                                  query_string
-                                 ).to_s
-    }
-    
-    query_string
-    
-  end # def
-  
-  public 
-  
-  
-  
-  protected
-  
-  def self.perform_delete(accessor, 
-                          value_keys)
-    
-    query_string = delete_query(accessor.get_table_name, 
-                                accessor.get_is_a, 
-                                accessor.get_primary_keys, 
-                                value_keys)
-    
-    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/table_inserter.rb

@@ -1,170 +0,0 @@
-
-require('lore/connection')
-
-module Lore
-
-module Table_Inserter # :nodoc:
-      
-  @logger = Lore.logger
-
-  protected
-  
-  def self.load_sequence_values(sequences)
-    
-    sequence_values = Hash.new
-
-    sequences.each_pair { |table_name, field| 
-      field.each_pair { |field_name, sequence_name|
-        
-        pure_schema_name 	  = table_name.split('.')[0]
-        pure_table_name 	  = table_name.split('.')[1]
-        temp_sequence_name 	  = sequence_name+'_temp'
-        
-        sequence_query_string = 'SELECT nextval(\''+pure_schema_name+'.'+sequence_name+'\'::text) as '+temp_sequence_name+'; '
-        sequence_value_result = Lore::Connection.perform(sequence_query_string)
-        
-        sequence_values[table_name] = Hash.new if sequence_values[table_name] == nil
-        sequence_values[table_name][field_name.to_s] = sequence_value_result.get_field_value(0, temp_sequence_name)
-      }
-    }
-    
-    return sequence_values 
-
-  end
-  
-  def self.atomic_insert_query(table_name, value_keys)
-
-    query_string = "\n"
-    query_string += 'INSERT INTO '+table_name
-    
-    value_string = String.new
-    field_string = String.new
-    key_counter = 0
-    value_keys.each_pair { |field, value|
-      
-      field_string += field
-      value_string += '\''+value.to_s+'\''
-      if key_counter < value_keys.length-1
-        field_string += ', '
-        value_string += ', '
-      end
-      key_counter += 1
-    }
-    query_string += '('+field_string+') VALUES '
-    query_string += '('+value_string+'); '
-    
-    query_string
-    
-  end #def
-  
-  def self.insert_query(table_name, 
-                        is_a_hierarchy, 
-                        sequence_values, 
-                        value_keys, 
-                        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 += insert_query(table, base_tables, sequence_values, value_keys).to_s
-    }
-    # finally, add query string for this table: 
-    if(value_keys[table_name] != nil)
-      query_string += atomic_insert_query(table_name, value_keys[table_name]).to_s
-    else 
-      @logger.debug { "No initial attribute for IS_A related table #{table_name} given. " } 
-    end
-    
-    query_string
-    
-  end # def
-  
-  def self.update_sequence_values_deps(	table_names, 
-                                        is_a_hierarchy, 
-                                        foreign_keys, 
-                                        sequence_values, 
-                                        value_keys,
-                                        allowed_attributes)
-
-    is_a_hierarchy.each_pair { |table, basetables| 
-      table_names.each { |table_name|
-        # extend each value_key with primary keys of its base table: 
-        if sequence_values.has_key?(table) then
-          # We only want a inherited sequence value update if this table (table_name)
-          # has a field for it at all: 
-          sequence_values[table].each_pair { |attrib, seq_val|
-            # Set own foreign keys to value of primary key in 
-            # referenced table. 
-            # Example:   public.car.*vehicle_id* => public.vehicle.id
-            # (Note that own and foreign attribute names differ)
-            if foreign_keys[table].first && allowed_attributes[table_name].include?(foreign_keys[table].first.to_s) then
-            #  puts 'setting seq val: ' << table_name.to_s + '.' << foreign_keys[table].first.to_s + ' = ' << seq_val
-              value_keys[table_name][foreign_keys[table].first.to_s] = seq_val
-            end
-          }   
-        end
-      }
-      table_names << table
-      value_keys = update_sequence_values_deps(table_names, basetables, foreign_keys, sequence_values, value_keys, allowed_attributes)
-    }
-
-    return value_keys
-    
-  end #def
-  
-  def self.perform_insert(accessor, value_keys)
-    
-    table_name     = accessor.get_table_name
-    is_a_hierarchy = accessor.get_is_a.dup
-    foreign_keys   = accessor.get_foreign_keys
-    sequences      = accessor.get_sequences
-
-    accessor.get_aggregates.each_pair { |table, subtable|
-      is_a_hierarchy.delete(table)
-    }
-    
-    Context.enter(accessor.get_context) unless accessor.get_context.nil?
-    @logger.debug('PERFORM INSERT on '+table_name)
-
-    sequence_values = load_sequence_values(sequences)
-    
-    # Parse sequence_values into value_keys where entries match the exact table: 
-    # (thus, there is an explicit call like primary_key :this_field, :this_sequence)
-    sequence_values.each_pair { |table, fields|
-      
-      # TODO: Support different attribute names here, like: 
-      #		value_keys[table_name][my_field_name] = Hash.new(sequence_values[table][foreign_field_name]
-      # Currently it's
-      # 		value_keys[table_name][foreign_field_name] = Hash.new(sequence_values[table][foreign_field_name]
-      value_keys[table].update(sequence_values[table])
-    }
-    # Parse sequence_values into value_keys where a table depends from a 
-    # sequence field by IS_A
-    value_keys 	 = update_sequence_values_deps([table_name], 
-                                               is_a_hierarchy, 
-                                               foreign_keys, 
-                                               sequence_values, 
-                                               value_keys, 
-                                               accessor.get_attributes)
-    query_string = insert_query(table_name, 
-                                is_a_hierarchy, 
-                                sequence_values, 
-                                value_keys)
-    
-    begin
-      Lore::Connection.perform("BEGIN;\n#{query_string}\nCOMMIT;")
-    rescue ::Exception => excep
-      Lore::Connection.perform("ROLLBACK;")
-    ensure
-      Lore::Context.leave unless accessor.get_context.nil?
-    end
-
-    accessor.flush_entity_cache()
-
-    # value_keys now are extended by sequence values: 
-    return value_keys
-  end # def
-
-end # module
-end # module

data/lib/lore/table_instance.rb

@@ -1,389 +0,0 @@
-
-require('lore/exception/ambiguous_attribute')
-require('lore/behaviours/movable')
-require('lore/behaviours/versioned')
-require('lore/behaviours/lockable')
-
-module Lore
-
-class Attribute_Hash < Hash # :nodoc: 
-  
-  alias random_access_op []
-  alias random_access_assign_op []=
-  def [](key)
-    if !random_access_op(key).nil? then
-      return random_access_op(key)
-    elsif !random_access_op(key.to_s).nil? then
-      return random_access_op(key.to_s)
-    else
-      skey = key.to_s[0..24].intern
-      return random_access_op(skey)
-    end
-  end
-
-  def []=(key, value)
-    begin
-      key = key.to_s[0..24].intern
-    rescue ::Exception => excep
-      Lore.logger.debug { 'Error when trying to access key ' << key.inspect }
-      raise excep
-    end
-    self.random_access_assign_op(key, value)
-  end
-
-  def method_missing(key) 
-    self[key]
-  end
-  
-end # class
-
-# Used as mixin for Table_Accessor. 
-# This module holds methods provided by Table_Accessor instances. 
-module Table_Instance
-
-  # retreive class instance variables from concrete 
-  # Table_Accessor this object is an instance of: 
-  def setup_instance() # :nodoc: 
-    
-    @touched = false
-
-    @primary_key_values = Hash.new
-    self.class.get_primary_keys.each_pair { |table, attrib_array|
-      @primary_key_values[table] = Hash.new
-      attrib_array.each { |field|
-        begin
-          pk_attrib_value = @attribute_values[table][field]
-          # NOTE: Field length in Postgres is limited to 25 characters normally. 
-          pk_attrib_value = @attribute_values[table][field.to_s[0..24]] unless pk_attrib_value
-          @primary_key_values[table][field] = pk_attrib_value
-        rescue ::Exception => excep
-          # We end here if a coder tried to hack a query. We let him 
-          # continue in his plans, it might make sense after all. 
-        end
-      }
-    }
-
-    # Applying filter to *all* attribute values, including derived attributes. 
-    # This way, an output filter can be added in a derived type that does not 
-    # exist in a base type. 
-    output_filters = self.class.get_output_filters
-    if output_filters then
-      @attribute_values.each_pair { |table,keys|
-        keys.each_pair { |key, value|
-          @attribute_values[table][key] = output_filters[key.intern].call(value) if output_filters[key.intern]
-        }
-      }
-    end
-    
-  end # def
-
-  def table_accessor
-    self.class
-  end
-
-  # Create a marshalled dump of this model instance. 
-  # Returns attribute values as The only difference 
-  # between model instances is their value set. 
-  def marshal_dump
-    { 
-      :klass => self.class.to_s, 
-      :values => get_attribute_values, 
-      :joined => @joined_models
-    }
-  end
-
-  # Returns primary key values of own table
-  def key
-    @primary_key_values[table_accessor.get_table_name]
-  end
-
-  def get_label_string
-    value = ''
-    Lore.logger.debug { 'LABEL ATTRIBS: ' << @attribute_values.inspect }
-    table_accessor.get_labels.each { |label_attrib|
-      Lore.logger.debug { 'LABEL_STRING: ' << label_attrib }
-      label_parts = label_attrib.split('.')
-      value << @attribute_values[label_parts[0..1].join('.')][label_parts[2]].to_s + ' '
-    }
-    value = '[no label given]' if value == ''
-    return value
-  end
-
-  # Creates an instance of self from marshalled value set. 
-  def marshal_load(dump)
-    klass = eval(dump[:klass])
-    dump[:joined].map { |m| m = eval(m) }
-    return initialize(dump[:values], dump[:joined], :cached)
-  end
-
-  # Whether this instance has been loaded from 
-  # cache or live from DB. 
-  def is_cached_entity?
-    # Set in initialize via marshal_load
-    @loaded_from_cache
-  end
-
-  def touched?
-    @touched
-  end
-
-  def method_missing(meth)
-    begin
-      return attr[meth]
-    rescue ::Exception => excep
-      raise excep
-    end
-  end
-
-  def move(sortpos, criteria)
-    Lore::Movable.move(self, table_accessor.get_order_attr, sortpos, criteria)
-  end # def
-  
-  # Set value for given attribute, e.g. for later commit. 
-  # It is recommended to use random access assignment instead: 
-  #
-  #   instance.set_attribute_value(:name, 'Wombat')
-  # is same as
-  #   instance[:name] = 'Wombat'
-  #
-  def set_attribute_value(attrib_name, attrib_value)
-  # {{{
-
-    if @input_filters && (@input_filters.has_key?(attrib_name.intern)) then
-      attrib_value = @input_filters[attrib_name.intern].call(attrib_value)
-    end
-
-    @touched = true
-    # Delete cached value of @flat_attr: 
-    @flat_attr = nil 
-    save_attribute_values = @attribute_values.dup
-    attrib_name = attrib_name.to_s
-    attrib_name_array = attrib_name.split('.')
-    
-    # Attrib name is implicit (no table name given). 
-    # Check for ambiguous attribute name: 
-    if attrib_name_array[2].nil? then
-      changed_table = false
-      @attribute_values.each { |table, attributes|
-        
-        if attributes.has_key?(attrib_name) then
-          @attribute_values[table][attrib_name] = attrib_value
-          changed_table = true
-        elsif attributes.has_key?(attrib_name) && changed_table then
-          raise Lore::Exception::Ambiguous_Attribute.new(table, 
-                                                         changed_table, 
-                                                         attrib_name)
-        end
-      }
-      
-    # Attrib name is explicit (also includes table name). 
-    # No need to check for ambiguous attribute: 
-    else 
-      attrib_name_index = attrib_name_array[2]
-      attrib_table      = attrib_name_array[0]+'.'+attrib_name_array[1]
-
-      @attribute_values[attrib_table][attrib_name_index] = attrib_value
-    end
-
-    begin
-      
-    #  Lore::Validation::Parameter_Validator.invalid_params(
-    #                          self.class, 
-    #                          @attribute_values)
-      
-    rescue Lore::Exception::Invalid_Klass_Parameters => ikp
-    
-      # load saved (stable, validated) attribute_values: 
-      @attribute_values = save_attribute_values
-      # log'n'throw: 
-      ikp.log
-      raise ikp
-
-    rescue Lore::Exception::Ambiguous_Attribute => aa
-      
-      # load saved (stable, validated) attribute_values: 
-      @attribute_values = save_attribute_values
-      # log'n'throw: 
-      raise aa
-      
-    end
-    
-  end # def }}}
-
-  # Sets attribute value. Example: 
-  #   instance[:name] = 'Wombat'
-  #   instance.commit
-  def []=(key, value)
-    set_attribute_value(key, value)
-  end
-
-  # Explicit attribute request. 
-  # Example: 
-  #   Car[Vehicle.name]
-  # In case name is attribute field in Car and Vehicle. 
-  def [](clause)
-    abs_attr(clause)
-  end
-
-  # Returns true if instance points to same records as other instance. 
-  # Only compares primary key values. 
-  def ==(other)
-    result = true
-    return false if self.class.to_s != other.class.to_s
-    return id() == other.id()
-  end
-
-  # Return primary key value. In case primary key is composed, return it as array. 
-  def id
-    key = []
-    table = table_accessor.table_name
-    table_accessor.get_primary_keys[table].each { |attrib_array|
-      attrib_array.each { |field|
-        key << get_attribute_values[table][field]
-      }
-    }
-    return key.first if key.length < 2
-    return key
-  end
-
-  # Returns true if instance points to same records as other instance, 
-  # also compares non-key attribute values. 
-  def ===(other)
-    return false unless (self == other)
-    
-  end
-  # See ==
-  def <=>(other)
-    return !(self.==(other))
-  end
-  
-  # Returns all attribute values as hash. 
-  def get_attribute_values() # :nodoc:
-    @attribute_values
-  end # def
-
-  # Returns value hash of instance attributes like: 
-  #
-  #   {
-  #     'schema.table.id' => 123, 
-  #     'schema.atable.name' => 'example'
-  #   }
-  #
-  # Common usage: 
-  # 
-  #   table_instance.attr[:id]  ->  123
-  #
-  # But it is recommended to use 
-  #
-  #   table_instance.id  -> 123
-  #
-  def attr
-
-    if @flat_attr.nil? then
-      @flat_attr = Attribute_Hash.new
-      get_attribute_values.each_pair { |table, attribs| 
-        attribs.each_pair { |attrib_name, value|
-          @flat_attr[attrib_name] = value unless value.nil?
-        }
-      }
-    end
-    @flat_attr
-    
-  end # def
-
-  # Returns value hash of instance attributes 
-  # of a given subtype like: 
-  #
-  #   {
-  #     'id' => 123, 
-  #     'name' => 'example'
-  #   }
-  #
-  # Common usage: 
-  # 
-  #   table_accessor.abs_attr(Klass_A)[:id]  ->  123
-  #
-  def abs_attr(klass=nil)
-    klass = klass.to_s if klass.instance_of? Symbol
-    return get_attribute_values if klass.nil?
-    return get_attribute_values[klass.table_name] if klass.kind_of? Lore::Table_Accessor
-    return get_attribute_values[klass] if klass.instance_of? String
-    return get_attribute_values[klass.to_s.split('.')[0..1].join('.').to_s][klass.to_s.split('.').at(-1)] if klass.instance_of? Lore::Clause
-
-  end # def
-
-  def get_primary_key_values
-    @primary_key_values
-  end
-
-  
-  # Commit changes on Table_Accessor instance to DB. 
-  # Results in an / several SQL update calls. 
-  #
-  # Common usage: 
-  # 
-  #   unit['name'] = 'changed'
-  #   unit.commit() 
-  # 
-  def commit
-  # {{{
-
-    return unless @touched
-    
-    input_filters = self.class.get_input_filters
-    if input_filters then
-      @attribute_values.each_pair { |table,keys|
-        keys.each_pair { |key, value|
-          @attribute_values[table][key] = input_filters[key.intern].call(value) if input_filters[key.intern]
-        }
-      }
-    end
-
-    begin
-      Lore::Validation::Parameter_Validator.invalid_params(self.class, 
-                                                           @attribute_values)
-    rescue Lore::Exception::Invalid_Klass_Parameters => ikp    
-    # log'n'throw: 
-      ikp.log
-      raise ikp
-    end
-
-    table_accessor.before_commit(self)
-
-    Table_Updater.perform_update(table_accessor, 
-                                 self)
-
-    table_accessor.after_commit(self)
-
-    @touched = false
-    
-  end # def }}}
-  alias save commit
-
-  # Delete this instance from DB. 
-  # Common usage: 
-  #
-  #  unit = Some_Table_Accessor.select { ... }.first
-  #  unit.delete
-  #   
-  #
-  def delete
-
-    # Called before entity_instance.delete
-    table_accessor.before_instance_delete(self)
-
-    Table_Deleter.perform_delete(table_accessor, 
-                                 @attribute_values)
-    # Called after entity_instance.delete
-    table_accessor.after_instance_delete(self)
-
-  end # def
-
-  def inspect
-    get_attribute_values.inspect
-  end # def
-  
-end # module
-
-
-end # module