lore 0.4.3 → 0.4.5

data/lib/lore/table_accessor.rb

@@ -21,7 +21,7 @@ class Table_Accessor
 
   attr_reader :constraints, :foreign_keys, :primary_keys, :attributes, :attribute_types
 
-  @@logger = Logger.new(Lore.logfile)
+  @@logger = Lore.logger
 
   def self.log(message, level=:debug)
     @@logger.debug(message)
@@ -397,7 +397,6 @@ protected
   ##########################################################################
   # @has_a getters/setters {{{
   def self.get_has_a # :nodoc:
-    
     if @has_a.nil? then
       if @has_a_klasses.nil? then
         @has_a = Array.new
@@ -409,7 +408,6 @@ protected
     else
       return @has_a
     end
-
   end
   def self.set_has_a(arg) # :nodoc: 
     @has_a = arg
@@ -420,7 +418,6 @@ protected
   # @has_a getters/setters {{{
 
   def self.get_has_n # :nodoc:
-    
     if @has_n.nil? then
       if @has_n_klasses.nil? then
         @has_n = Array.new
@@ -432,7 +429,6 @@ protected
     else
       return @has_n
     end
-
   end
   def self.set_has_n(arg) # :nodoc:
     @has_n = arg
@@ -612,7 +608,6 @@ private
   # 
   def self.add_foreign_keys(args)
   # {{{
-    
     other_table = args.at(0).to_s  # first index is table name (see usage)
   
     new_foreign_keys = Hash.new
@@ -620,7 +615,6 @@ private
     new_foreign_keys[other_table] = args[1...args.length]
   
     set_foreign_keys(new_foreign_keys)
-    
   end # }}}
   
 private
@@ -629,7 +623,6 @@ private
   # Add single or multiple primary keys to @primary_keys[args.at(0)]: 
   def self.add_primary_keys(args)
   # {{{
-    
     other_table = args.at(0)  # first index is table name (see usage)
   
     new_primary_keys = Hash.new
@@ -643,9 +636,7 @@ private
     else
       new_primary_keys[other_table] += foreign_p_keys
     end
-    
     @primary_keys = new_primary_keys
-
   end # }}}
   
 private
@@ -654,17 +645,13 @@ private
   # Add one sequence to @sequences[table_name]: 
   def self.add_sequence(table_name, field_name, sequence_name)
   # {{{
-    
-      new_sequences = Hash.new
-      new_sequences.update(get_sequences)
-    
-      new_sequences[table_name] = Hash.new
-      if sequence_name != nil
-        new_sequences[table_name][field_name] = sequence_name.to_s
-      end
-      
-      set_sequences(new_sequences)
-
+    new_sequences = Hash.new
+    new_sequences.update(get_sequences)
+    new_sequences[table_name] = Hash.new
+    if sequence_name != nil
+      new_sequences[table_name][field_name] = sequence_name.to_s
+    end
+    set_sequences(new_sequences)
   end # }}}
 
 private
@@ -672,14 +659,10 @@ private
   ##########################################################################
   def self.add_attributes(attrib_hash)
   # {{{
-    
     new_attributes = Hash.new
     new_attributes.update(get_attributes)
-    
     new_attributes.update(attrib_hash)
-    
     set_attributes(new_attributes)
-
   end # }}}
   
 private
@@ -687,14 +670,10 @@ private
   ##########################################################################
   def self.add_attribute_types(attrib_hash)
   # {{{
-    
     new_types = Hash.new
     new_types.update(get_attribute_types)
-    
     new_types.update(attrib_hash)
-    
     set_attribute_types(new_types)
-
   end # }}}
   
 private
@@ -702,12 +681,9 @@ private
   ##########################################################################
   def self.add_explicit(explicit_hash)
   # {{{
-  
     new_explicit = explicit_hash
     new_explicit.update(get_explicit)
-
     set_explicit(new_explicit)
-
   end # }}}
 
 private
@@ -715,11 +691,6 @@ private
   ##########################################################################
   def self.add_explicit_attributes(attrib_hash)
   # {{{
-
-#    new_explicit_attributes = attrib_hash
-#    new_explicit_attributes.update(get_explicit_attributes)
-#    set_explicit_attributes(new_explicit_attributes)
-
     attrib_hash.each_pair { |table, attribs| 
       if @explicit_attributes and @explicit_attributes[table] then
         @explicit_attributes[table] = attrib_hash[table] + @explicit_attributes[table]
@@ -728,7 +699,6 @@ private
         @explicit_attributes[table] = attrib_hash[table]
       end
     }
-
   end # }}}
   
 private
@@ -736,7 +706,6 @@ private
   ##########################################################################
   def self.add_implicit_attributes(attrib_hash)
   # {{{
-
     attrib_hash.each_pair { |table, attribs| 
       if @implicit_attributes and @implicit_attributes[table] then
         @implicit_attributes[table] = attrib_hash[table] + @implicit_attributes[table]
@@ -745,11 +714,6 @@ private
         @implicit_attributes[table] = attrib_hash[table]
       end
     }
-
-#    new_implicit_attributes = attrib_hash
-#    new_implicit_attributes.update(existing_implicit_attributes)
-
-#    set_implicit_attributes(new_implicit_attributes)
   end # }}}
 
 protected
@@ -757,12 +721,9 @@ protected
   # Demands a value to be set for create and update procedures. 
   def self.expects(attrib_name, klass=nil)
   # {{{
-
     if klass.nil? then table = get_table_name 
     else table = klass.table end
-
     add_explicit_attribute(table, attrib_name.to_s)
-
   end # }}}
 
   def self.hide_attribute(attrib_name)
@@ -783,7 +744,6 @@ private
   # 
   def self.add_explicit_attribute(table_name, attrib_name)
   # {{{
-    
     table_explicit_attributes = get_explicit_attributes[table_name]
     if(!table_explicit_attributes.nil?) 
     then table_explicit_attributes.push(attrib_name)
@@ -794,7 +754,6 @@ private
     get_explicit_attributes.update({table_name => table_explicit_attributes})
     
     set_explicit_attributes(new_explicit_attributes)
-
   end # }}}
 
 private 
@@ -811,7 +770,6 @@ private
     get_implicit_attributes.update({table_name => table_implicit_attributes})
     
     set_implicit_attributes(new_implicit_attributes)
-    
   end # }}}
   
   ##########################################################################
@@ -836,13 +794,13 @@ public
   # instance holding it. 
   # Note that this method is operating on a Table_Accessor instance, not
   # on class Table_Accessor itself. 
-  def initialize(instance_attrib_values, cache=nil) 
+  def initialize(instance_attrib_values, field_names, joined_models=[], cache=nil) 
   # {{{
-
     @loaded_from_cache = (cache == :cached)
     # set instance variables. 
     # class instance variables are made accessible 
     # in Table_Instance.setup_instance
+    @joined_models = joined_models
 
     if @loaded_from_cache then
       @attribute_values = instance_attrib_values
@@ -850,19 +808,20 @@ public
       @attribute_values = Hash.new
       values      = instance_attrib_values
       field_index = 0
-      self.class.get_all_table_names.each { |table| 
-        @attribute_values[table] = Hash.new
-        field_names = self.class.get_attributes[table]
-        for attr_index in 0...field_names.length do
-          @attribute_values[table][field_names[attr_index]] = values[field_index]
-          field_index += 1
-        end
+      models = [ self.class ] 
+      models += joined_models 
+      models.each { |model|
+        model.get_all_table_names.each { |table| 
+          @attribute_values[table] = Hash.new
+          field_names = model.get_attributes[table]
+          for attr_index in 0...field_names.length do
+            @attribute_values[table][field_names[attr_index]] = values[field_index]
+            field_index += 1
+          end
+        }
       }
     end
-    # @attribute_values.update(instance_attrib_values)
-
     setup_instance()
-  
   end # }}}
 
 public
@@ -888,12 +847,9 @@ public
   # use table :tablename if class != table only. 
   def self.table(_table, _schema=nil)
   # {{{
-  
     set_table_name(_table.to_s)
     schema(_schema.to_s) unless _schema.nil?
-    
     load_attribute_fields();
-  
   end # }}}
 
 private
@@ -919,7 +875,6 @@ protected
   #  don't extend primary_keys of parent!
   def self.primary_key(*prim_key) 
   # {{{
-
     keys = Array.new(1,get_table_name) + Array.new(1,prim_key.at(0))
     add_primary_keys(keys)
 
@@ -931,7 +886,6 @@ protected
     else 
       add_implicit_attribute(get_table_name, prim_key.at(0).to_s)
     end
-
   end # }}}
 
   # Called in Cuba.import_imp_model. Defines prepared statements like 
@@ -980,7 +934,6 @@ protected
   #   thus allowing key tuples and free naming of table fields. 
   def self.has_a(*args)
   # {{{
-    
     if (args.length < 2) then 
       raise Lore::Exception::Invalid_Usage.new('has_a expects at least Type, :foreign_key_name'); 
     end
@@ -1004,7 +957,6 @@ protected
     add_has_a_klass(accessor, args[1..-1])
 
     define_entity_access_methods(accessor, args[1..-1])
-  
   end # }}}
 
   def self.maps(*accessors)
@@ -1067,7 +1019,6 @@ private
   # Meta-programs class instance methods for accessing types
   # associated via has_a. 
   def self.define_entity_access_methods(accessor, foreign_keys, type_name=nil)
-
     type_name = accessor.to_s.split('::').at(-1).downcase unless type_name
 
     log('defining method '+type_name+'_entity')
@@ -1094,7 +1045,6 @@ private
       self.__send__ 'set_'+type_name+'_entity', other
       self.commit
     }
-
   end
 
 private
@@ -1102,7 +1052,6 @@ private
   # Meta-programs class instance methods for accessing types
   # associated via has_n. 
   def self.define_entities_access_methods(accessor, values)
-
     type_name = accessor.to_s.split('::').at(-1).downcase unless type_name
     
     log('defining method add_'+type_name+'_entity')
@@ -1119,59 +1068,8 @@ private
       }
       accessor.all_with(foreign_key_values)
     }
-
   end
 
-protected
-  
-  ##########################################################################
-  # usage in derived classes: 
-  #   has_a_named :table_a, :a_foo, :foreign_key_1, :foreign_key_2, ...
-  #   has_a_named :table_a, :a_bar, :foreign_key_1, :foreign_key_2, ...
-  #
-  # This method allows one type to aggregate the same type twice, referencing 
-  # them under different names, such as (see example) get_a_foo(), get_a_bar(). 
-  def self.has_a_named(*args)
-  # {{{
-
-    if (args.length < 3) then 
-      raise Lore::Model_Exception.new(self, 'has_a_named expects at least :Type, :handle_name, :foreign_key_name'); 
-    end
-    
-    foreign_table_name   = args.at(0).get_table_name
-    # convert schema.table => table:
-    foreign_table     = args.at(0).get_table_name.split('.').at(1)
-    # convert Module::Other::Klass_Name => klass_name:
-    foreign_name     = args.at(0).to_s.split('::')[-1].downcase
-
-    foreign_keys = Array.new(1,foreign_table_name) + args[2...args.length]
-    add_foreign_keys(foreign_keys)
-    
-    new_has_a = Array.new(1,foreign_table_name)
-    new_has_a = get_has_a + new_has_a 
-    set_has_a(new_has_a)
-
-    # TODO: To be wrapped by Table_Instance, feeding this method with 
-    # primary keys required to get referenced has_a tuple. 
-    if args.at(2).nil? then type_name = foreign_name
-    else type_name = args.at(2).to_s
-    end
-    
-    log('defining method get_'+type_name)
-      
-    define_method('get_'+type_name) { 
-      # see self.has_a
-    }
-    
-    log('defining method set_'+type_name)
-    # TODO: To be wrapped by Table_Instance, feeding this method with 
-    # primary keys required to set referenced has_a tuple. 
-    define_method('set_'+type_name) {|*keys|
-      # see self.has_a
-    }
-    
-  end # }}}
-  
 protected
   
   def self.belongs_to(*args)
@@ -1337,7 +1235,6 @@ protected
   # is_a. 
   def self.aggregates(*args) 
   # {{{
-    
     parent = args.at(0)
     
     # before:   parent_pkeys   = Hash { Parent => [id, name] }
@@ -1372,71 +1269,58 @@ protected
     use_label(parent.get_labels)
 
     define_entity_access_methods(parent, args[1..-1])
-	
   end # }}}
   
 private
   
   def self.add_is_a(table_name, derive_tree)
   # {{{
-    
     new_is_a = Hash.new
     new_is_a[table_name] = derive_tree
     new_is_a.update(get_is_a)
 
     set_is_a(new_is_a)
-
   end # }}}
 
 private
   
   def self.add_is_a_klass(klass, foreign_key)
   # {{{
-    
     @is_a_klasses = Hash.new if @is_a_klasses.nil?
     @is_a_klasses[foreign_key] = klass
-
   end # }}}
   
 private
   
   def self.add_aggregate(table_name, derive_tree)
   # {{{
-    
     new_aggregates = Hash.new
     new_aggregates[table_name] = derive_tree
     new_aggregates.update(get_aggregates)
 
     set_aggregates(new_aggregates)
-
   end # }}}
 
 private
   
   def self.add_aggregate_klass(klass, attributes)
   # {{{
-    
     new_aggregate_klasses = get_aggregate_klasses
     attributes.each { |attribute|
       new_aggregate_klasses[get_table_name+'.' << attribute.to_s] = klass
     }
-
     set_aggregate_klasses(new_aggregate_klasses)
-
   end # }}}
 
 private
   
   def self.add_has_a_klass(klass, attributes)
   # {{{
-    
     new_has_a_klasses = get_has_a_klasses
     attributes.each { |attribute|
       new_has_a_klasses[get_table_name+'.' << attribute.to_s] = klass
     }
-
     set_has_a_klasses(new_has_a_klasses)
-
   end # }}}
   
 protected
@@ -1444,17 +1328,16 @@ protected
   # unless it has a non-empty value.
   def self.explicit(*args)
   # {{{
-
     new_explicit = get_explicit
     new_explicit[get_table_name] = args.map!{|elem| elem.to_s}
-
     add_explicit(new_explicit)
-
   end # }}}
   
 private
   
   ##########################################################################
+  # DELETE ME
+  # 
   # Usage: 
   # Cuba::Admin::Container_Local.select({'primary_key_1'=>'2', 
   #                                            'primary_key_2'=>'38', 
@@ -1462,7 +1345,6 @@ private
   #                                          })
   def self.select_row_by_key(*keys)
   # {{{
-
     # Aggregate klasses this klass is derived from and 
     # those it aggregates explicitly: 
     begin
@@ -1471,30 +1353,23 @@ private
       raise excep
       raise ::Exception.new('Unable to load instance from DB (Reason: ' << excep.message << ')')
     end
-    field_hash = result.get_row()
-
+    return result.get_row_with_field_names()
   end # }}}
   
 public
   
-  # Same as select, but with predefined primary key values as 
-  # hash. 
+  # DELETE ME
   def self.select_by_key(*keys)
   # {{{
-
     result = Lore::Table_Selector.select_on_keys(self, keys)
-    
     field_array = result.get_rows()
-
   end # }}}
 
 public
 
   def self.update(&block)
   # {{{
-    
     query_string = Lore::Table_Updater.block_update(self, &block)
-
   end # def }}}
   
 public
@@ -1503,22 +1378,17 @@ public
   # {{{
     GC.disable
     if(!clause.nil? && !clause.to_s.include?('*,')) then
-
       query_string = Lore::Table_Selector.select_query(clause.to_s, self, &block)
-      return Clause.new(query_string)
-
+      return Clause.new(query_string[:query])
     else
-
       what = clause.to_s
       result = Lore::Table_Selector.select_cached(what, self, &block)
-
     # result = Array.new
     # db_result.get_rows.each { |row|
     #   result.push(self.new(self, row))
     # }
       GC.enable
       return result
-
     end
 
   end # }}}
@@ -1558,6 +1428,7 @@ public
   #   EXPLAIN EXECUTE. "
   #
   def self.prepare(plan_name, *args, &block)
+  # {{{
     log('PREPARE: TRYING CLASS METHOD ' << plan_name.to_s)
     if !@@prepared_statements[plan_name] then
       Table_Selector.prepare(plan_name, self, args, &block)
@@ -1570,7 +1441,7 @@ public
       @@prepared_statements[plan_name] = true
       log('PREPARE: CREATED CLASS METHOD ' << plan_name.to_s)
     end
-  end
+  end # }}}
 
   def self.execute_prepared(plan_name, *args)
     plan_name = "#{table_name.gsub('.','_')}__#{plan_name.to_s}"
@@ -1635,9 +1506,6 @@ private
     
     key_hash = Hash.new
     
-    log('ATTRIBUTES TOTAL: ')
-    log(get_attributes.inspect)
-    
     attribute_name_array = Array.new
     attribute_table = ''
     get_attributes.each_pair { |table, fields|
@@ -1665,8 +1533,6 @@ private
       }
       
     }
-
-    log(key_hash.inspect)
     
   # sequence values only are known after insert operation, 
   # so we have to retreive the complete key_hash back from 
@@ -1674,7 +1540,6 @@ private
     key_hash = Lore::Table_Inserter.perform_insert(self, key_hash)
   # key_hash has been extended by sequence_values now, so we
   # return it: 
-    
     key_hash
     
   end # }}}
@@ -1707,7 +1572,6 @@ public
         attrib_values[attrib_name] = input_filters[attrib_key].call(attrib_value) 
       end
     }
-    log('FILTERED VALUES: ' << attrib_values.inspect)
     after_filters(attrib_values)
     
     # Predefine
@@ -1717,15 +1581,12 @@ public
       table_values = Hash.new
      
       attrib_name_array = Array.new
-      log('ALL ATTRIBS: ' << table.to_s + ' <-- ' << attribs.inspect)
       attrib_values.each_pair { |attrib_name, attrib_value|
         attrib_name = attrib_name.to_s
         attrib_name_array = attrib_name.split('.') 
         
         if attribs.include? attrib_name then
-			
           table_values[attrib_name] = attrib_value
-		  
         elsif attribs.include? attrib_name_array.at(2) and
             attrib_name_array.at(0)+'.'+attrib_name_array.at(1) == table then
           table_values[attrib_name_array.at(2)] = attrib_value
@@ -1735,17 +1596,13 @@ public
     }
     
     begin
-      
       before_validation(values)
       Lore::Validation::Parameter_Validator.invalid_params(self, 
                                                            values)
-      
     rescue Lore::Exception::Invalid_Klass_Parameters => ikp
-      
       # log'n'throw
       ikp.log
       raise ikp
-      
     end
 
     before_insert(attrib_values)
@@ -1755,6 +1612,8 @@ public
     #
     attrib_values = insert(attrib_values)
     
+    # This would be a double check, as self.load already filters 
+    # non-primary key attributes
     select_keys = Hash.new
     if @primary_keys then
       @primary_keys[table_name].each { |key|
@@ -1777,34 +1636,41 @@ public
   
   ##########################################################################
   # Return new Table_Accessor instance by loading an existing entry from 
-  # table. 
+  # table if present, or false if no entry has been found. 
+  # Accepts any combination of :primary_key => 'value'
+  # Also allows inherited primary keys. 
   def self.load(keys)
   # {{{
 
     before_load(keys)
 
-    select_keys = Hash.new
-
-    get_primary_keys[table_name].each { |attrib_name|
-      value = keys[attrib_name.intern]
-      value = keys[attrib_name.to_s] if value.nil?
-      value = keys[table_name+'.'+attrib_name.to_s] if value.nil?
-      select_keys[table_name+'.'+attrib_name.to_s] = value unless value.nil?
+    select_keys = {}
+    value = false
+    get_primary_keys.each_pair { |table, pkeys| 
+      pkeys.each { |attrib_name|
+        value = keys[table+'.'+attrib_name.to_s]  # The more explicit, the better. 
+        value = keys[attrib_name.intern] if value.nil? # Symbols are supposed to be more frequent than strings
+        value = keys[attrib_name.to_s] if value.nil?
+        select_keys[table+'.'+attrib_name.to_s] = value unless value.nil?
+      }
     }
 
-    return false if select_keys.empty?
-
-    log('Loading with prim keys: ' << select_keys.inspect)
-    instance_attribs_hash = select_row_by_key(select_keys)
-
-    return false if instance_attribs_hash.nil?
-
-    instance = new(instance_attribs_hash)
+    return false if select_keys.empty? 
     
-    #TODO: 
-    # after_load(instance)
+    cp = Clause.for(self)
+    c = Clause.new
+    select_keys.each_pair { |k,v|
+      c & (Clause.new(k.to_s.dup) == v.to_s)
+    }
+
+    instance = self.select { |inst|
+      inst.where(c)
+      inst.limit(1)
+    }.first
 
+    return false unless instance
     return instance
+
   end # }}}
 
 public
@@ -1886,41 +1752,10 @@ public
   # Inspect method
   def self.inspect
   # {{{
-
-#    return self.to_s + ' : Table_Accessor'
-
-    dump = 'Accessor: ' << self.to_s
-#   dump << "\n\t" <<  'own table name: '+get_table_name
-#   dump << "\n\t" <<  'attributes: '
-#   dump << "\n\t" <<  @attributes.inspect
-#   dump << "\n\t" <<  'explicit attributes: '
-#   dump << "\n\t" <<  @explicit_attributes.inspect
-#   dump << "\n\t" <<  'implicit attributes: '
-#   dump << "\n\t" <<  @implicit_attributes.inspect
-#   dump << "\n\t" <<  'constraints: '
-#   dump << "\n\t" <<  @constraints.inspect
-#   dump << "\n\t" <<  'attribute types: '
-#   dump << "\n\t" <<  @attribute_types.inspect
-#   dump << "\n\t" <<  'primary keys: '
-#   dump << "\n\t" <<  @primary_keys.inspect
-#   dump << "\n\t" <<  'sequences: '
-#   dump << "\n\t" <<  @sequences.inspect
-#   dump << "\n\t" <<  'foreign keys: '
-#   dump << "\n\t" <<  @foreign_keys.inspect
-#   dump << "\n\t" <<  'has_a: '
-#   dump << "\n\t" <<  @has_a.inspect
-#   dump << "\n\t" <<  'has_n: '
-#   dump << "\n\t" <<  @has_n.inspect
-#   dump << "\n\t" <<  'is_a: '
-#   dump << "\n\t" <<  @is_a.inspect
-#   dump << "\n\t" <<  'explicit: '
-#   dump << "\n\t" <<  @explicit.inspect
-#   dump << "\n"
-
+    'Lore::Table_Accessor: ' << self.to_s
   end # }}}
 
 end # class
 
-
 end # module