lore 0.4.2

data/table_deleter.rb

@@ -0,0 +1,115 @@
+
+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='')
+    
+    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 += delete_query(table, 
+                                   base_tables, 
+                                   
+                                   primary_keys, 
+                                   value_keys, 
+                                   
+                                   query_string
+                                   ).to_s
+    }
+    # finally, add query string for this table: 
+    query_string += atomic_delete_query(table_name, 
+                                        primary_keys[table_name], 
+                                        value_keys[table_name]
+                                        ).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;")
+    ensure
+      Context.leave unless accessor.get_context.nil?
+    end
+
+    accessor.flush_entity_cache()
+    
+  end #def
+  
+end # module
+end # module
+  

data/table_inserter.rb

@@ -0,0 +1,168 @@
+
+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;")
+    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/table_instance.rb

@@ -0,0 +1,384 @@
+
+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
+    }
+  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])
+    return initialize(dump[:values], :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
+  
+end # module
+
+
+end # module