og 0.29.0 → 0.30.0

data/lib/og/store/mysql.rb

@@ -214,31 +214,33 @@ private
     if @conn.list_tables.include?(klass::OGTABLE)
       actual_fields = conn.list_fields(klass::OGTABLE).fetch_fields.map {|f| f.name }
 
-      #Make new ones always - don't destroy by default because it might contain data you want back.
+      # Make new ones always - don't destroy by default because 
+      # it might contain data you want back.
+ 
       need_fields = fields.each do |needed_field|
-  field_name = needed_field[0..(needed_field.index(' ')-1)]
-  next if actual_fields.include?(field_name)
-
-  if @options[:evolve_schema] == true
-    Logger.debug "Adding field '#{needed_field}' to '#{klass::OGTABLE}'"
-    sql = "ALTER TABLE #{klass::OGTABLE} ADD COLUMN #{needed_field}"
-    @conn.query(sql)
-  else
-    Logger.info "WARNING: Table '#{klass::OGTABLE}' is missing field '#{needed_field}' and :evolve_schema is not set to true!"
-  end
+        field_name = needed_field[0..(needed_field.index(' ')-1)]
+        next if actual_fields.include?(field_name)
+
+        if @options[:evolve_schema] == true
+          Logger.debug "Adding field '#{needed_field}' to '#{klass::OGTABLE}'" if $DBG
+          sql = "ALTER TABLE #{klass::OGTABLE} ADD COLUMN #{needed_field}"
+          @conn.query(sql)
+        else
+          Logger.info "WARNING: Table '#{klass::OGTABLE}' is missing field '#{needed_field}' and :evolve_schema is not set to true!"
+        end
       end
 
       #Drop old ones
       needed_fields = fields.map {|f| f =~ /^([^ ]+)/; $1}
       actual_fields.each do |obsolete_field|
-  next if needed_fields.include?(obsolete_field)
-  if @options[:evolve_schema] == true and @options[:evolve_schema_cautious] == false
-    sql = "ALTER TABLE #{klass::OGTABLE} DROP COLUMN #{obsolete_field}"
-    Logger.debug "Removing obsolete field '#{obsolete_field}' from '#{klass::OGTABLE}'"
-    @conn.query(sql)
-       else
-    Logger.info "WARNING: You have an obsolete field '#{obsolete_field}' on table '#{klass::OGTABLE}' and :evolve_schema is not set or is in cautious mode!"
-  end
+      next if needed_fields.include?(obsolete_field)
+      if @options[:evolve_schema] == true and @options[:evolve_schema_cautious] == false
+        sql = "ALTER TABLE #{klass::OGTABLE} DROP COLUMN #{obsolete_field}"
+        Logger.debug "Removing obsolete field '#{obsolete_field}' from '#{klass::OGTABLE}'" if $DBG
+        @conn.query(sql)
+      else
+        Logger.info "WARNING: You have an obsolete field '#{obsolete_field}' on table '#{klass::OGTABLE}' and :evolve_schema is not set or is in cautious mode!"
+      end
       end
       return
     end
@@ -292,7 +294,7 @@ private
           create_join_table_sql(info).each do |sql|
           @conn.query sql
         end
-          Logger.debug "Created jointable '#{info[:table]}'."          
+          Logger.debug "Created jointable '#{info[:table]}'." if $DBG
         rescue => ex
           if ex.respond_to?(:errno) and ex.errno == 1050 # table already exists.
             Logger.debug 'Join table already exists' if $DBG
@@ -303,14 +305,21 @@ private
       end
     end
   end
-
+ 
   def create_field_map(klass)
     conn.query_with_result = true
     res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
     map = {}
 
+    # Check if the field should be ignored.
+    ignore = klass.ann[:self][:ignore_field] || klass.ann[:self][:ignore_fields] || klass.ann[:self][:ignore_columns]   
+
     res.num_fields.times do |i|
-      map[res.fetch_field.name.intern] = i
+      field_name = res.fetch_field.name.to_sym
+      
+      unless (ignore and ignore.include?(field_name))
+        map[field_name] = i
+      end
     end
 
     return map
@@ -352,11 +361,11 @@ private
 
     klass.class_eval %{
       def og_insert(store)
-        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
         store.conn.query_with_result = false
         store.conn.query "#{sql}"
         @#{klass.pk_symbol} = store.conn.insert_id
-        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end

data/lib/og/store/psql.rb

@@ -224,7 +224,7 @@ class PsqlStore < SqlStore
     conn.list_tables.each do |table|
       begin
         conn.exec "DROP TABLE #{table} CASCADE"
-        Logger.debug "Dropped database table #{table}"
+        Logger.debug "Dropped database table #{table}" if $DBG
       rescue RuntimeError => ex
         catch :ok do # Racing
           throw :ok if ex.message =~ /tuple concurrently updated/
@@ -350,7 +350,7 @@ class PsqlStore < SqlStore
   
   def constraint_info(rel)
     if rel.join_table
-      info = join_table_info(rel.owner_class,rel.target_class)
+      info = join_table_info(rel)
       constraints = [ { :fk => info[:first_key], :referenced_table => info[:first_table], :table => rel.join_table, :pk => ( rel.owner_class.primary_key.field || rel.owner_class.primary_key.symbol ), :update => 'CASCADE', :delete => 'CASCADE'},
         { :fk => info[:second_key], :referenced_table => info[:second_table], :table => rel.join_table, :pk => ( rel.target_class.primary_key.field || rel.target_class.primary_key.symbol ), :update => 'CASCADE', :delete => 'CASCADE' } ]
     elsif rel.class == Og::HasMany
@@ -459,7 +459,7 @@ class PsqlStore < SqlStore
           # Exists in database and matches the object structure but has the
           # wrong definition (unlikely to happen very often).
           
-          Logger.debug "PostgreSQL database contains a constraint on table '#{table}' named '#{name}' which is incorrectly defined and will be redefined (OLD: '#{all_existing[table][name]}', NEW: '#{definition}')"
+          Logger.debug "PostgreSQL database contains a constraint on table '#{table}' named '#{name}' which is incorrectly defined and will be redefined (OLD: '#{all_existing[table][name]}', NEW: '#{definition}')" if $DBG
           drop_constraints << "ALTER TABLE #{table} DROP CONSTRAINT #{name}"
           create_constraints << "ALTER TABLE #{table} ADD CONSTRAINT #{name} #{definition}"
         end
@@ -480,7 +480,7 @@ class PsqlStore < SqlStore
             
             # Exists in database but doesn't match object model at all
             raise Exception if table.to_s.downcase == "table"
-            Logger.debug "PostgreSQL database contains a constraint on table '#{table}' named '#{name}' which does not match the object model and will be deleted"
+            Logger.debug "PostgreSQL database contains a constraint on table '#{table}' named '#{name}' which does not match the object model and will be deleted" if $DBG
             drop_constraints << "ALTER TABLE #{table} DROP CONSTRAINT #{name}"
           end
         end
@@ -500,7 +500,7 @@ class PsqlStore < SqlStore
   def create_constraints(param = nil)
     subsection_only = !!param
     sql_hash = param ? param : needed_constraints_sql
-    Logger.debug "PostgreSQL processing foreign key constraints" unless subsection_only 
+    Logger.debug "PostgreSQL processing foreign key constraints" unless subsection_only if $DBG
     started = Time.now
     deleted = 0
     nulled_relations = 0
@@ -583,7 +583,7 @@ class PsqlStore < SqlStore
     end
     text = text[0..-3].gsub(/,([^,]+)$/,' and \1')
     text << " in #{taken} seconds."
-    Logger.debug text
+    Logger.debug text if $DBG
   end
   
   # Called by Og.manager (in turn called by Og.setup) when Og.setup
@@ -634,7 +634,7 @@ private
           end          
         end
     else
-      Logger.debug "Table #{klass::OGTABLE} already exists"
+      Logger.debug "Table #{klass::OGTABLE} already exists" if $DBG
       #rp: basic field interrogation
       # TODO: Add type checking.
 
@@ -646,7 +646,7 @@ private
         next if actual_fields.include?(field_name)
 
         if @options[:evolve_schema] == true
-          Logger.debug "Adding field '#{needed_field}' to '#{klass::OGTABLE}'"
+          Logger.debug "Adding field '#{needed_field}' to '#{klass::OGTABLE}'" if $DBG
           sql = "ALTER TABLE #{klass::OGTABLE} ADD COLUMN #{needed_field}"
           begin
             @conn.exec(sql)
@@ -668,7 +668,7 @@ private
             @conn.exec(sql)
           rescue RuntimeError => ex
             raise unless ex.message =~ /does not exist/
-            Logger.debug "Removed obsolete field '#{obsolete_field}' from '#{klass::OGTABLE}'"
+            Logger.debug "Removed obsolete field '#{obsolete_field}' from '#{klass::OGTABLE}'" if $DBG
           end
        else
           Logger.info "WARNING: You have an obsolete field '#{obsolete_field}' on table '#{klass::OGTABLE}' and :evolve_schema is not set or is in cautious mode!"
@@ -685,7 +685,8 @@ private
 #      for info in join_tables
 #        unless @conn.table_exists? info[:table]
 #      join_tables = Array.new
-      join_tables = klass.relations.reject{|rel| !rel.join_table}.map{|rel| join_table_info(rel.owner_class, rel.target_class)}
+#      join_tables = klass.relations.reject{|rel| !rel.join_table}.map{|rel| join_table_info(rel)}
+    if join_tables = klass.ann.self[:join_tables]
       for info in join_tables
         unless @conn.table_exists? info[:table]
           create_join_table_sql(info).each do |sql|
@@ -697,11 +698,12 @@ private
               # Racing
             end
           end
-          Logger.debug "Created jointable '#{info[:table]}'."
+          Logger.debug "Created jointable '#{info[:table]}'." if $DBG
         else
-          Logger.debug "Join table '#{info[:table]}' already exists."
+          Logger.debug "Join table '#{info[:table]}' already exists." if $DBG
         end
       end
+    end
 
     # If we are being called by Og.setup, we can use a much cleaner method
     # for constructing foreign key constraints.
@@ -713,7 +715,7 @@ private
     # darcs repo (but NOT into any released version of Nitro)
 
     unless @options[:leave_constraints] == true or @stripped_constraints
-      Logger.debug "Stripping PostgreSQL foreign key constraints"
+      Logger.debug "Stripping PostgreSQL foreign key constraints" if $DBG
       all_foreign_keys.map{|k| k[1].map{|v| [k[0],v[0]] }[0]}.each do |table,constraint|
           prefix = constraint_prefix
           next unless constraint[0-prefix.size..-1] == constraint_prefix
@@ -734,7 +736,7 @@ private
     # related rows.
     exec "DROP TABLE #{klass.table} CASCADE"
   end
-
+  
   def create_field_map(klass)
     begin
       res = @conn.exec "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
@@ -746,9 +748,17 @@ private
     end
     map = {}
 
+    # Check if the field should be ignored.
+    ignore = klass.ann[:self][:ignore_field] || klass.ann[:self][:ignore_fields] || klass.ann[:self][:ignore_columns]   
+
     for field in res.fields
-      map[field.intern] = res.fieldnum(field)
+      field_name = field.to_sym
+      
+      unless (ignore and ignore.include?(field_name))
+        map[field_name] = res.fieldnum(field)
+      end
     end
+    
     return map
   ensure
     res.clear if res
@@ -791,18 +801,18 @@ private
 
     klass.class_eval %{ 
       def og_insert(store)
-        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
         res = store.conn.exec "SELECT nextval('#{klass::OGSEQ}')"
         @#{klass.pk_symbol} = res.getvalue(0, 0).to_i
         res.clear
         store.conn.exec("#{sql}").clear
-        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end
 
   def eval_og_allocate(klass)  
-    if klass.ann.self[:subclasses]
+    if klass.schema_inheritance?
       klass.module_eval %{
         def self.og_allocate(res, row = 0)
           Object.constant(res.getvalue(row, 0)).allocate

data/lib/og/store/sql.rb

@@ -2,6 +2,8 @@ require 'yaml'
 require 'time'
 
 require 'facet/kernel/constant'
+require 'facet/string/capitalized'
+require 'facet/ormsupport'
 
 module Og
 
@@ -175,7 +177,7 @@ module SqlUtils
 
   def join_table_key(klass)
     klass = klass.schema_inheritance_root_class if klass.schema_inheritance_child?
-    "#{klass.to_s.split('::').last.downcase}_oid"
+    "#{klass.to_s.demodulize.underscore.downcase}_oid"
   end
 
   def join_table_keys(class1, class2)
@@ -192,8 +194,11 @@ module SqlUtils
     return join_table_keys(first, second)
   end
 
-  def join_table_info(owner_class, target_class, postfix = nil)
+  def join_table_info(relation, postfix = nil)
+
     # some fixes for schema inheritance.
+
+    owner_class, target_class = relation.owner_class, relation.target_class
     
     raise "Undefined owner_class in #{target_class}" unless owner_class
     raise "Undefined target_class in #{owner_class}" unless target_class
@@ -210,10 +215,17 @@ module SqlUtils
       first_key, second_key = owner_key, target_key
     end
 
+    table = (relation.table ?
+      relation.table :
+      join_table(owner_class, target_class, postfix)
+    )
+    
     return {
-      :table => join_table(owner_class, target_class, postfix),
+      :table => table,
       :owner_key => owner_key,
+      :owner_table => table(owner_class),
       :target_key => target_key,
+      :target_table => table(target_class),
       :first_table => table(first),
       :first_key => first_key,
       :first_index => join_table_index(first_key),
@@ -288,11 +300,11 @@ class SqlStore < Store
   #++
 
   def enable_logging
-    require 'glue/aspects'
+    require 'facets/more/aspects'
     klass = self.class
-    klass.send :include, Glue::Aspects
+    klass.send :include, ::Aspects
     klass.pre "Logger.info sql", :on => [:exec, :query]
-    Glue::Aspects.wrap(klass, [:exec, :query])
+    ::Aspects.wrap(klass, [:exec, :query])
   end
 
   # Returns a list of tables that exist within the database but are 
@@ -492,6 +504,13 @@ class SqlStore < Store
   # calculate 'SUM(age)', :group => :name
 
   def aggregate(term = 'COUNT(*)', options = {})
+    klass = options[:class]
+    field = options[:field]
+
+    if field_properties = klass.properties[field]
+      return_type = field_properties[:klass]
+    end
+
     if options.is_a?(String)
       sql = options
     else
@@ -517,7 +536,7 @@ class SqlStore < Store
       values = []
       res = query(sql)
       res.each_row do |row, idx|
-        values << row[0].to_f 
+        values << type_cast(return_type, row[0])
       end
       return values
     else
@@ -525,11 +544,24 @@ class SqlStore < Store
       # gmosx, TODO: don't convert to float by default, perhaps
       # should consult an option.
       #++ 
-      return query(sql).first_value.to_f
+      return type_cast(return_type, query(sql).first_value)
     end
   end
   alias_method :calculate, :aggregate
 
+  def type_cast(klass, val)
+    typemap = {
+      Time => :parse_timestamp,
+      Date => :parse_date,
+    }
+
+    if method = typemap[klass]
+      send(method, val)
+    else
+      val.to_f
+    end
+  end
+
   # Perform a count query.
   
   def count(options = {})
@@ -640,7 +672,22 @@ private
     end
   end
   
-  # Create the fields that correpsond to the klass properties.
+  #utility function - return either the properties for the class
+  #or, in the case of schema inheritance, all of the properties
+  #of the class hierarchy, starting from the schema inheritance
+  #root class
+   
+  def get_properties_for_class(klass)
+    properties = klass.properties.dup
+    if(klass.schema_inheritance?)
+      for desc in klass.schema_inheritance_root_class.descendents
+        properties.update(desc.properties)
+      end  
+    end
+    properties
+  end
+    
+  # Create the fields that correspond to the klass properties.
   # The generated fields array is used in create_table.
   # If the property has an :sql annotation this overrides the 
   # default mapping. If the property has an :extra_sql annotation
@@ -648,17 +695,14 @@ private
   
   def fields_for_class(klass)
     fields = []
-    properties = klass.properties.dup
+    properties = get_properties_for_class(klass)
 
-    if klass.ancestors.include? SchemaInheritanceBase 
+    if klass.schema_inheritance?
       # This class as a superclass in a single table inheritance
       # chain. So inject a special class ogtype field that 
       # holds the class name.
+
       fields << "ogtype VARCHAR(30)"
-  
-      for desc in klass.schema_inheritance_root_class.descendents
-        properties.update(desc.properties)
-      end
     end
     
     for p in properties.values
@@ -739,6 +783,22 @@ private
 
   # :section: Lifecycle method compilers.
   
+  
+  # Get the fields from the database table. Also handles the
+  # change of ordering of the fields in the table.
+  #
+  # To ignore a database field use the ignore_fields annotation
+  # ie,
+  #
+  # class Article
+  #   ann self, :ignore_fields => [ :tsearch_idx, :ext_field ]
+  # end
+  #
+  # other aliases for ignore_fiels: ignore_field, ignore_column.
+  
+  def create_field_map(klass)
+  end
+    
   # Compile the og_insert method for the class.
 
   def eval_og_insert(klass)
@@ -755,9 +815,9 @@ private
 
     klass.module_eval %{ 
       def og_insert(store)
-        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
         store.exec "#{sql}"
-        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end
@@ -778,11 +838,11 @@ private
 
     klass.module_eval %{
       def og_update(store, options = nil)
-        #{Glue::Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
         sql = "#{sql}"
         sql << " AND \#{options[:condition]}" if options and options[:condition]
         changed = store.sql_update(sql)
-        #{Glue::Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
         return changed
       end
     }    
@@ -810,9 +870,9 @@ private
 
     klass.module_eval %{
        def og_read(res, row = 0, offset = 0)
-        #{Glue::Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
         #{code}
-        #{Glue::Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end
@@ -824,7 +884,7 @@ private
   def eval_og_delete(klass)
     klass.module_eval %{
        def og_delete(store, pk, cascade = true)
-        #{Glue::Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
         pk ||= @#{klass.pk_symbol}
         transaction do |tx|
           tx.exec "DELETE FROM #{klass.table} WHERE #{klass.pk_symbol}=\#{pk}"
@@ -834,7 +894,7 @@ private
             end
           end
         end
-        #{Glue::Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{::Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end
@@ -846,11 +906,11 @@ private
     klass.module_eval %{
       def og_create_schema(store)
         if Og.create_schema
-          #{Glue::Aspects.gen_advice_code(:og_create_schema, klass.advices, :pre) if klass.respond_to?(:advices)}
+          #{::Aspects.gen_advice_code(:og_create_schema, klass.advices, :pre) if klass.respond_to?(:advices)}
 #          unless self.class.superclass.ancestors.include? SchemaInheritanceBase
             store.send(:create_table, #{klass})
 #          end
-          #{Glue::Aspects.gen_advice_code(:og_create_schema, klass.advices, :post) if klass.respond_to?(:advices)}
+          #{::Aspects.gen_advice_code(:og_create_schema, klass.advices, :post) if klass.respond_to?(:advices)}
         end
       end
     }
@@ -974,12 +1034,7 @@ private
       # statement style escaping. 
              
       if condition.is_a?(Array)
-        args = condition.dup
-        str = args.shift
-        # ? handles a single type.
-        # ?* handles an array.
-        args.each { |arg| str.sub!(/\?\*/, quotea(arg)); str.sub!(/\?/, quote(arg)) }
-        condition = str
+        condition = prepare_statement(condition)
       end
 
       sql << " WHERE #{condition}"
@@ -997,7 +1052,18 @@ private
 
     return sql
   end
-
+  
+  #takes an array, the first parameter of which is a prepared statement
+  #style string; this handles parameter escaping.
+  def prepare_statement(condition)
+    args = condition.dup
+    str = args.shift
+    # ? handles a single type.
+    # ?* handles an array.
+    args.each { |arg| str.sub!(/\?\*/, quotea(arg)); str.sub!(/\?/, quote(arg)) }
+    condition = str
+  end
+  
   # Subclasses can override this if they need some other order.
   # This is needed because different backends require different
   # order of the keywords.
@@ -1113,7 +1179,7 @@ private
 
   def update_condition(options, cond, joiner = 'AND')
     if options[:condition]
-      options[:condition] +=  " #{joiner} #{cond}"
+      [options[:condition]].flatten[0] <<  " #{joiner} #{cond}"
     else
       options[:condition] = cond
     end