og 0.25.0 → 0.26.0

data/lib/og/evolution.rb

@@ -75,4 +75,4 @@ class Manager
   
 end
   
-end
+end

data/lib/og/manager.rb

@@ -129,6 +129,9 @@ class Manager
   end
 
   # Is this class manageable by Og?
+  #--
+  # FIXME: investigate this (polymorphic/unmanageable).
+  #++
 
   def manageable?(klass)
     klass.respond_to?(:properties) and (!klass.properties.empty?) # and klass.ann.self.polymorphic.nil?
@@ -217,6 +220,19 @@ class Manager
   end
   alias_method :unmanage_class, :unmanage_classes
 
+  # Allows functionality that requires a store is finalized
+  # to be implemented. A vastly superior method of constructing
+  # foreign key constraints is an example of functionality
+  # this provides. Currently only used by the PostgreSQL store.
+  # Another good use for this would be an alternate table
+  # and field creation routine, which could be much faster,
+  # something I intend to do to the PostgreSQL store if nobody
+  # has reasons for objecting.
+        
+  def post_setup
+    store.post_setup if store.respond_to?(:post_setup)
+  end
+  
 end
 
 end

data/lib/og/relation.rb

@@ -93,6 +93,10 @@ class Relation
   def enchant
   end
 
+  def to_s
+    @options[:target_name]
+  end
+
   # Access the hash values as methods.
 
   def method_missing(sym, *args)
@@ -320,4 +324,4 @@ end
 
 end
 
-# * George Moschovitis <gm@navel.gr>
+# * George Moschovitis <gm@navel.gr>

data/lib/og/relation/refers_to.rb

@@ -4,7 +4,13 @@ module Og
 
 class RefersTo < Relation
 
+  def self.foreign_key(rel)
+    "#{rel[:foreign_name] || rel[:target_singular_name]}_#{rel[:target_class].primary_key}"
+  end
+
   def enchant
+    raise "#{target_singular_name} in #{owner_class} refers to an undefined class" if target_class.nil?
+    
     self[:foreign_key] = "#{foreign_name || target_singular_name}_#{target_class.primary_key}"
 
     if self[:field]

data/lib/og/store.rb

@@ -17,6 +17,8 @@ class Store
   # Return the store for the given name.
 
   def self.for_name(name)
+    Logger.info "Og uses the #{name.to_s.capitalize} store."
+    
     # gmosx: to keep RDoc happy.
     eval %{
       require 'og/store/#{name}'
@@ -94,6 +96,8 @@ class Store
   # update if this is already inserted in the database.
 
   def save(obj, options = nil)
+    return false unless obj.valid?
+
     if obj.saved?
       obj.og_update(self, options)
     else
@@ -101,6 +105,15 @@ class Store
     end
   end
   alias_method :<<, :save
+  alias_method :validate_and_save, :save
+
+  def force_save!(obj, options)
+    if obj.saved?
+      obj.og_update(self, options)
+    else
+      obj.og_insert(self)
+    end
+  end
 
   # Insert an object in the store.
 

data/lib/og/store/kirby.rb

@@ -1,7 +1,7 @@
 begin
-  require 'og/vendor/kirbybase'
+  require 'kirbybase'
 rescue Object => ex
-  Logger.error 'KirbyBase is not installed!'
+  Logger.error "KirbyBase is not installed. Please run 'gem install KirbyBase'"
   Logger.error ex
 end
 
@@ -58,9 +58,9 @@ class KirbyStore < SqlStore
   end
 
   def enchant(klass, manager)
-    klass.send :attr_accessor, :recno
-    klass.send :alias_method, :oid, :recno
-    klass.send :alias_method, :oid=, :recno=
+    klass.send :attr_accessor, :oid
+    klass.send :alias_method, :recno, :oid
+    klass.send :alias_method, :recno=, :oid= 
 
     symbols = klass.properties.keys
 
@@ -128,6 +128,7 @@ class KirbyStore < SqlStore
     end
 
     if order = options[:order]
+      order = order.to_s
       desc = (order =~ /DESC/)
       order = order.gsub(/DESC/, '').gsub(/ASC/, '')
       eval "objects.sort { |x, y| x.#{order} <=> y.#{order} }"

data/lib/og/store/mysql.rb

@@ -133,7 +133,7 @@ class MysqlStore < SqlStore
   def initialize(options)
     super
 
-    @typemap.update(TrueClass => 'tinyint')
+    @typemap.update(TrueClass => 'tinyint', Time => 'datetime')
 
     @conn = Mysql.connect(
       options[:address] || 'localhost', 
@@ -224,10 +224,39 @@ private
     # used instead of catching database exceptions 
     # for 'table exists'?
 
-    return if @conn.list_tables.include?(klass::OGTABLE)
+    fields = fields_for_class(klass)
 
+    if @conn.list_tables.include?(klass::OGTABLE)
+      actual_fields = conn.list_fields(klass::OGTABLE).fetch_fields.map {|f| f.name }
 
-    fields = fields_for_class(klass)
+      #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
+      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
+      end
+      return
+    end
 
     sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
 
@@ -276,8 +305,8 @@ private
       for info in join_tables
         begin
           create_join_table_sql(info).each do |sql|
-            @conn.query sql
-          end
+          @conn.query sql
+        end
           Logger.debug "Created jointable '#{info[:table]}'."          
         rescue => ex
           if ex.respond_to?(:errno) and ex.errno == 1050 # table already exists.

data/lib/og/store/psql.rb

@@ -8,8 +8,13 @@ end
 class PGconn
   # Lists all the tables within the database.
   
-  def list_tables 
-    r = self.exec "SELECT c.relname FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind='r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid)"
+  def list_tables
+    begin
+      r = self.exec "SELECT c.relname FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind='r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid)"
+    rescue Exception
+      # Racing
+      return []
+    end
     ret = r.result.flatten
     r.clear
     ret
@@ -19,7 +24,11 @@ class PGconn
   # otherwise.
   
   def table_exists?(table) #rp: this should be abstracted to the sql abstractor
-    r = self.exec "SELECT c.relname FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind='r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid) AND c.relname='#{self.class.escape(table.to_s)}'"
+    begin
+      r = self.exec "SELECT c.relname FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind='r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid) AND c.relname='#{self.class.escape(table.to_s)}'"
+    rescue Exception
+      return false # Racing...
+    end
     ret = r.result.size != 0
     r.clear
     ret
@@ -29,7 +38,11 @@ class PGconn
   # nil if it doesn't exist. Mostly for internal usage.
   
   def table_oid(table)
-    r = self.exec "SELECT c.oid FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind='r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid) AND c.relname='#{self.class.escape(table.to_s)}'"
+    begin
+      r = self.exec "SELECT c.oid FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind='r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid) AND c.relname='#{self.class.escape(table.to_s)}'"
+    rescue Exception
+      return nil # Racing...
+    end
     ret = r.result.flatten.first
     r.clear
     ret
@@ -48,14 +61,53 @@ class PGconn
     ret
   end
 
-  # Returns an array of arrays containing the PostgreSQL foreign keys
-  # within a table. The first element is the constraint name and the
-  # second element is the constraint definition.
+  # Returns a hash containing the foreign key constrains within a table.
+  # The keys are constraint names and the values are the constraint
+  # definitions.
   
   def table_foreign_keys(table)
     return nil unless pg_oid = table_oid(table)
     r = self.exec "SELECT conname, pg_catalog.pg_get_constraintdef(oid, true) as condef FROM pg_catalog.pg_constraint r WHERE r.conrelid = '#{pg_oid}' AND r.contype = 'f'"
-    ret = r.result
+    res = r.result
+    ret = Hash.new
+    res.each do |double|
+      ret[double.first] = double.last
+    end
+    r.clear
+    ret
+  end
+  
+  # Returns a hash keyed by table (as a string) with each value also
+  # being a hash keyed by the constraint name (as a string) and the
+  # value being a string that contains the constraint definition.
+   
+  def all_foreign_keys
+    loop_counter = 0
+    loop_max = 5
+    begin
+      r = self.exec "SELECT c.relname,r.conname, pg_catalog.pg_get_constraintdef(r.oid, true) as condef FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace JOIN pg_catalog.pg_constraint r ON r.conrelid = c.oid WHERE c.relkind='r' AND r.contype ='f' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid);"
+    rescue RuntimeError => ex
+      raise unless ex.message =~ /cache lookup failed for relation (\d+)/ # Racing
+#      damaged_relation = $1
+#      Logger.error "Got damage to #{damaged_relation}"
+      loop_counter += 1
+      if loop_counter > loop_max
+        Logger.error "PostgreSQL had more than #{loop_max} cache errors, your database is almost certainly corrupt as pg_class does not match the PostgreSQL cache. Either use pg_dump to save the data, re-create the database, let og rebuild the schema and use pg_restore to restore the data, or repair it by hand"
+        exit
+      end
+      Logger.error "There is a problem with PostgreSQL's internal cache, retrying... (#{loop_counter} of #{loop_max})"
+      # you have a horrible setup anyhow, and it allows your
+      # horrible setup to work (deleting tables so fast
+      # in parallel PostgreSQL's internal lookups fail)
+      sleep 2
+      retry
+    end
+    res = r.result
+    ret = Hash.new
+    res.each do |tripple|
+      ret[tripple.first] ||= Hash.new
+      ret[tripple[0]][tripple[1]] = tripple[2]
+    end
     r.clear
     ret
   end
@@ -98,7 +150,7 @@ module PsqlUtils
   
   def escape(str)
     return nil unless str
-    return PGconn.escape(str)
+    return PGconn.escape(str.to_s)
   end
 
   # TODO, mneumann:
@@ -164,9 +216,17 @@ class PsqlStore < SqlStore
     )
 
     conn.list_tables.each do |table|
-      sql = "DROP TABLE #{table} CASCADE"
-      conn.exec sql
-      Logger.debug "Dropped database table #{table}"
+      begin
+        conn.exec "DROP TABLE #{table} CASCADE"
+        Logger.debug "Dropped database table #{table}"
+      rescue RuntimeError => ex
+        catch :ok do # Racing
+          throw :ok if ex.message =~ /tuple concurrently updated/
+          throw :ok if ex.message =~ /does not exist/          
+          throw :ok if ex.message =~ /cache lookup failed/          
+          raise
+        end
+      end
     end
 
     conn.close
@@ -185,7 +245,6 @@ class PsqlStore < SqlStore
       options[:user].to_s, 
       options[:password].to_s
     )
-    
     schema_order = options[:schema_order]
     encoding = options[:encoding]
     min_messages = options[:min_messages]
@@ -252,68 +311,283 @@ class PsqlStore < SqlStore
     exec('BEGIN TRANSACTION') if @transaction_nesting < 1
     @transaction_nesting += 1
   end
+  
+  # Returns the Og::Manager that owns this store.
+  
+  def manager
+    manager = nil
+    ok = false
+    ObjectSpace.each_object(Og::Manager) do |manager|
+      if manager.store.__id__ == self.__id__
+        ok = true
+        break
+      end
+    end
+    raise RuntimeError, "#{self.class} could not find it's manager" unless ok
+    manager
+  end
+   
+  # Returns an array containing the constraints needed for this relation.
+  # The array contains hashes with the format:
+  #
+  # :table => The name of the table to which the constraint should be
+  # applied.
+  # :referenced_table => The name of the table which the foreign key
+  # refers to.
+  # :fk => The name of the field to turn into a foreign key.
+  # :pk => The primary key of the referenced table.
+  # :update => The action that should be taken if the primary key
+  # of a referenced row is changed.
+  # :delete => The action that should be taken if a referenced
+  # row is deleted.
+  # :name => The name of the constraint to apply.
+  
+  def constraint_info(rel)
+    if rel.join_table
+      info = join_table_info(rel.owner_class,rel.target_class)
+      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
+      constraints = [ { :fk => rel.foreign_key, :table => rel.target_class::OGTABLE, :referenced_table => rel.owner_class::OGTABLE, :pk => ( rel.owner_class.primary_key.field || rel.owner_class.primary_key.symbol ), :update => 'SET NULL', :delete => 'SET NULL' } ]
+    else
+      constraints = [ { :fk => rel.foreign_key, :table => rel.owner_class::OGTABLE, :referenced_table => rel.target_class::OGTABLE, :pk => ( rel.target_class.primary_key.field || rel.target_class.primary_key.symbol ), :update => 'SET NULL', :delete => 'SET NULL' } ]
+    end
+   
+    constraints.each do |constraint|
+      constraint[:name] = constraint_name(constraint)
+    end
+    
+    # This checks for not-yet-enchanted entities, is there a better way?
+    constraints.reject{|info| [info[:table], info[:referenced_table]].include?(:OGTABLE) }
+  end
 
-private
-
-  # Adds foreign key constraints to a join table, replicating all
-  # modifications to OIDs to the join tables and also purging
-  # any left over data from deleted records (at the time of
-  # implementation, self-join cases left this data here).
-
-  def create_join_table_foreign_key_constraints(klass,info)
 
-    table_list = @conn.list_tables
+  # Returns a hash keyed by table (as a string) with each value also
+  # being a hash keyed by the constraint name (as a string) and the
+  # value being a string that contains the constraint definition.
+  #
+  # This format matches the actual constrains returned by the
+  # all_foreign_keys method added to the PGConn class.
+
+  def all_needed_constraints
+    relations = manager.managed_classes.map{|klass| klass.relations}.flatten.uniq
+    need_constraints = Hash.new    
+    relations.each do |relation|
+      infos = constraint_info(relation)
+      infos.each do |info|
+        # Skip constraints we already know we need
+        next if need_constraints[info[:table]] and need_constraints[info[:table]].has_key? info[:name]
+        need_constraints[info[:table]] ||= Hash.new
+        need_constraints[info[:table]][info[:name]] = constraint_definition(info)
+      end
+    end
+    need_constraints    
+  end
 
-    needed_tables = [ info[:table], info[:first_table], info[:second_table] ]
-    missing_tables = Array.new
-    needed_tables.each do |table|
-      missing_tables << table unless table_list.include?(table)
+  # Returns an SQL fragment containing the correct definition for a foreign key constraint.
+  
+  def constraint_definition(info)
+    "FOREIGN KEY (#{info[:fk]}) REFERENCES #{info[:referenced_table]}(#{info[:pk]}) ON UPDATE #{info[:update]} ON DELETE #{info[:delete]}"
+  end
+  
+  # Works the same as all_needed_constraints but only acts on one class and
+  # returns the same hash as part of yet another hash with two keys, tables
+  # and constraints. This is done to prevent having to resolve the
+  # relations again later just to map tables.
+  
+  def needed_constraints(klass)
+    need_constraints = Hash.new
+    tables = Array.new
+    (klass.relations + klass.resolve_remote_relations).each do |rel|
+      constraint_info(rel).each do |info|
+        tables.concat [info[:table], info[:referenced_table]]
+        need_constraints[info[:table]] ||= Hash.new
+        need_constraints[info[:table]][info[:name]] = constraint_definition(info)
+      end
+    end  
+    { :tables => tables.uniq, :constraints => need_constraints }
+  end
+  
+  # Returns the appropriate constraint prefix for a foreign key constraint.
+  
+  def constraint_prefix
+    "#{Og.table_prefix}c"
+  end
+  
+  # Returns the appropriate name for a constraint element generated by
+  # the constraint_info method.  
+   
+  def constraint_name(hash)
+    "#{constraint_prefix}_#{hash[:table]}_#{hash[:fk]}"
+  end
+  
+  def needed_constraints_sql(klass = nil)
+    if klass
+      constraints = needed_constraints(klass)
+      all_needed = constraints[:constraints]
+      all_existing = Hash.new
+      constraints[:tables].each do |table|
+        all_existing[table] = @conn.table_foreign_keys(table)
+      end
+    else
+      all_existing = @conn.all_foreign_keys
+      all_needed = all_needed_constraints
     end
-    if missing_tables.size > 0
-      msg = "Join table #{info[:table]} needs PostgreSQL foreign key constraints but the following table"
-      msg << (missing_tables.size > 1 ? "s were " : " was ")
-      msg << "missing: "
-      missing_tables.each do |table|
-        msg << "#{table}, "
+         
+    drop_constraints = Array.new
+    create_constraints = Array.new
+      
+    all_needed.each_pair do |table,constraints|
+      constraints.each_pair do |name,definition|
+      
+        # If neither of these are matched, the constraint already exists
+        # and has the correct definition.
+        
+        if all_existing[table].nil? or all_existing[table][name].nil?
+        
+          # Does not exist in database
+          
+          create_constraints << "ALTER TABLE #{table} ADD CONSTRAINT #{name} #{definition}"
+        elsif all_existing[table][name] != definition
+        
+          # 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}')"
+          drop_constraints << "ALTER TABLE #{table} DROP CONSTRAINT #{name}"
+          create_constraints << "ALTER TABLE #{table} ADD CONSTRAINT #{name} #{definition}"
+        end
       end
-      Logger.debug msg[0..-3] + ". (Should be retried later)."
-      return false
     end
 
-    #This info should maybe be in join metadata?
-    target_class = nil
-    klass.relations.each do |rel|
-      if rel.join_table == info[:table]
-        target_class =  rel.target_class
-        break
+    # You can't do this when managing classes seperately without spidering
+    # each other class managed by this stores manager as other classes
+    # can want relations within the same tables too. I will add spidering
+    # support at some point but this isn't very important since these
+    # complicated and convoluted routines will now rarely happen thank
+    # to the setup hooking.
+
+    unless klass
+      all_existing.each_pair do |table,constraints|
+        constraints.each_key do |name|
+          if all_needed[table].nil? or all_needed[table][name].nil?
+            
+            # 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"
+            drop_constraints << "ALTER TABLE #{table} DROP CONSTRAINT #{name}"
+          end
+        end
       end
     end
-
-    if target_class
-      Logger.debug "Adding PostgreSQL foreign key constraints to #{info[:table]}"
-
-      # TODO: This should also interrograte the constraint definition
-      # incase people meddle with the database in an insane fashion
-      # (very, very low priority)
       
-      existing_constraints = @conn.table_foreign_keys(info[:table]).map {|fk| fk.first}
-
-      constraints = Array.new
-      constraints << { :table => info[:first_table], :join_table => info[:table], :primary_key => klass.primary_key.field || klass.primary_key.symbol, :foreign_key => info[:first_key] }
-      constraints << { :table => info[:second_table], :join_table => info[:table], :primary_key => target_class.primary_key.field || target_class.primary_key.symbol, :foreign_key => info[:second_key] }
+    {
+      :drop => drop_constraints,
+      :create => create_constraints
+    }
+      
+  end
+  
+  # Takes a hash with constraints to drop and create and performs
+  # the work.
+  
+  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 
+    started = Time.now
+    deleted = 0
+    nulled_relations = 0
+    deleted_relations = 0
+    created = 0
+  
+    sql_hash[:drop].each do |sql|
+      begin
+        @conn.exec(sql)
+      rescue RuntimeError => ex
+        raise unless ex.message =~ /does not exist/
+      end
+      deleted += 1
+    end
 
-      constraints.each do |constraint|
-        constraint_name = "ogc_#{constraint[:table]}_#{constraint[:foreign_key]}"
-        if existing_constraints.include?(constraint_name)
-          Logger.debug "PostgreSQL foreign key constraint linking #{constraint[:foreign_key]} on #{constraint[:join_table]} to #{constraint[:primary_key]} on #{constraint[:table]} already exists (#{constraint_name})."
-          next
+    sql_hash[:create].each do |sql|    
+      con_retry = true
+      begin
+        @conn.exec(sql)
+        created += 1
+      rescue PGError,RuntimeError => ex
+        next if ex.message =~ /already exists/ # Racing
+        unless ex.message =~ /.*violates foreign key constraint.*/
+          Logger.error "PostgreSQL connection returned an error for query #{sql}"
+          raise
+        end
+        if @options[:evolve_schema] == true and @options[:evolve_schema_cautious] == false
+          table, name, fk, referenced_table, pk =  sql.match(/^ALTER TABLE (\S+) ADD CONSTRAINT (\S+) FOREIGN KEY \((\S+)\) REFERENCES ([^ (]+)[ (]+([^)]+)/).captures
+          raise if [table,fk,pk,referenced_table].include? nil
+
+          cleaner_sql = "UPDATE #{table} SET #{fk} = NULL WHERE #{fk} NOT IN (SELECT #{pk} FROM #{referenced_table})"
+          begin
+            @conn.exec(cleaner_sql)
+            if cleaner_sql[0..5] == "UPDATE"
+              nulled_relations += 1
+            else
+              deleted_relations += 1
+            end
+              
+          rescue PGError,RuntimeError => ex
+            if ex.message =~ /.*violates not-null constraint.*/
+              cleaner_sql = "DELETE FROM #{table} WHERE #{fk} NOT IN (SELECT #{pk} FROM #{referenced_table})"
+              retry
+            end
+            Logger.error "PostgreSQL connection returned an error for query '#{cleaner_sql}' which was attempting to tidy up ready for the query '#{sql}'"
+            raise
+          end
+            
+          Logger.error "There were relationships in table #{table} that did not exist so they have been set to NULL (or deleted if this was not possible, i.e. for a join table)."
+          if con_retry
+            con_retry = false
+            retry
+          end
+        else
+          Logger.error "There are relationships in table #{table} that do not exist. Your database is corrupt. Please fix these or enable evolve_schema not in cautious mode and they will be fixed automatically."
+        end
+      end    
+    end
+    finished = Time.now
+    taken = Kernel.sprintf("%.2f", finished - started)
+    broken_relations = nulled_relations + deleted_relations
+    text = "PostgreSQL finished setting constraints. "
+    need_comma = false
+    if [0,0,0] == [deleted,created,broken_relations]
+      return if subsection_only # Make less chatty for short calls
+      text << "No action was taken, "
+    else
+      text << "#{created} constraints were added, " if created != 0
+      text << "#{deleted} constraints were deleted, " if deleted != 0
+      if broken_relations != 0
+        text.gsub!(/,([^,]+)$/,' and \1')
+        text << "#{broken_relations} relations were broken, causing "
+        if nullified_relations != 0
+          text << "#{nullified_relations} relations to have non-existant foreign keys set to null"
+          text << (deleted_relations == 0 ? ", " : " and ")
         end
-        sql = "ALTER TABLE #{constraint[:join_table]} ADD CONSTRAINT #{constraint_name} FOREIGN KEY (#{constraint[:foreign_key]}) REFERENCES #{constraint[:table]} (#{constraint[:primary_key]}) ON UPDATE CASCADE ON DELETE CASCADE"
-        @conn.exec(sql).clear
-        Logger.debug "Added PostgreSQL foreign key constraint linking #{constraint[:foreign_key]} on #{constraint[:join_table]} to #{constraint[:primary_key]} on #{constraint[:table]} (#{constraint_name})."
+        text << "#{nullified_relations} relations to have rows with non-existant foreign keys deleted, " if deleted_relations != 0
       end
     end
+    text = text[0..-3].gsub(/,([^,]+)$/,' and \1')
+    text << " in #{taken} seconds."
+    Logger.debug text
+  end
+  
+  # Called by Og.manager (in turn called by Og.setup) when Og.setup
+  # has finished, allowing better processing of foreign key
+  # constraints and possibly other enhancements.
+  
+  def post_setup
+    create_constraints
   end
+  
+private
 
   def create_table(klass)
     fields = fields_for_class(klass)
@@ -341,9 +615,17 @@ private
           sql << " CREATE #{pre_sql} INDEX #{klass::OGTABLE}_#{idxname}_idx #{post_sql} ON #{klass::OGTABLE} (#{idx});"  
         end
       end
-
-        @conn.exec(sql).clear
-        Logger.info "Created table '#{klass::OGTABLE}'."
+        begin
+          res = @conn.exec(sql)
+          res.clear
+          Logger.info "Created table '#{klass::OGTABLE}'."
+        rescue RuntimeError => ex
+          catch :ok do # Racing        
+            throw :ok if ex.message =~ /duplicate key violates unique constraint "pg_class_relname_nsp_index"/
+            throw :ok if ex.message =~ /already exists/
+            raise
+          end          
+        end
     else
       Logger.debug "Table #{klass::OGTABLE} already exists"
       #rp: basic field interrogation
@@ -359,7 +641,11 @@ private
         if @options[:evolve_schema] == true
           Logger.debug "Adding field '#{needed_field}' to '#{klass::OGTABLE}'"
           sql = "ALTER TABLE #{klass::OGTABLE} ADD COLUMN #{needed_field}"
-          @conn.exec(sql)
+          begin
+            @conn.exec(sql)
+          rescue RuntimeError => ex
+            raise unless ex.message =~ /already exists/
+          end
         else
           Logger.info "WARNING: Table '#{klass::OGTABLE}' is missing field '#{needed_field}' and :evolve_schema is not set to true!"
         end
@@ -371,8 +657,12 @@ private
         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.exec(sql)
+          begin
+            @conn.exec(sql)
+          rescue RuntimeError => ex
+            raise unless ex.message =~ /does not exist/
+            Logger.debug "Removed obsolete field '#{obsolete_field}' from '#{klass::OGTABLE}'"
+          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!"
         end
@@ -381,40 +671,77 @@ private
 
     # Create join tables if needed. Join tables are used in
     # 'many_to_many' relations.
-      players = klass.resolve_remote_relations.map{|rel| rel.owner_class if rel.collection}.compact.uniq
-      players << klass
-      players.each do |player|
-      if join_tables = player.ann.self[:join_tables] 
-        for info in join_tables
-          unless @conn.table_exists? info[:table]
-            create_join_table_sql(info).each do |sql|
-              @conn.exec(sql).clear
+    
+    # For some reason this is missing a self join case
+    # and therefore can't be used.
+#    if join_tables = klass.ann.self[:join_tables]
+#      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)}
+      for info in join_tables
+        unless @conn.table_exists? info[:table]
+          create_join_table_sql(info).each do |sql|
+            begin
+              res = @conn.exec(sql)
+              res.clear
+            rescue RuntimeError => ex
+              raise unless ex.message =~ /duplicate key violates unique constraint "pg_class_relname_nsp_index"/
+              # Racing
             end
-            Logger.debug "Created jointable '#{info[:table]}'."
-          else
-            Logger.debug "Join table '#{info[:table]}' already exists."
           end
-          create_join_table_foreign_key_constraints(player,info)
+          Logger.debug "Created jointable '#{info[:table]}'."
+        else
+          Logger.debug "Join table '#{info[:table]}' already exists."
         end
       end
+
+    # If we are being called by Og.setup, we can use a much cleaner method
+    # for constructing foreign key constraints.
+    return if @options[:called_by_og_setup]
+    
+    # Strip out old constraints... this shouldn't always be necessary but
+    # must be here for now while glycerin is still bleeding-edge to fix
+    # changes and a nasty error that made it into the glycerin developers
+    # 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"
+      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
+          begin
+            m.store.conn.exec "ALTER TABLE #{table} DROP CONSTRAINT #{constraint}"
+          rescue Exception
+          end
+      end
     end
+    
+    # Create sql constraints
+    create_constraints(needed_constraints_sql(klass))
 
   end
 
   def drop_table(klass)
     # foreign key constraints will remove the need to do manual cleanup on
-    # postgresql join tables.
+    # related rows.
     exec "DROP TABLE #{klass.table} CASCADE"
   end
 
   def create_field_map(klass)
-    res = @conn.exec "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
+    begin
+      res = @conn.exec "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
+    rescue RuntimeError => ex
+      raise unless ex.message =~ /does not exist/ or ex.message =~ /deleted while still in use/
+      # Racing
+      create_table(klass)
+      retry
+    end
     map = {}
 
     for field in res.fields
       map[field.intern] = res.fieldnum(field)
     end
-
     return map
   ensure
     res.clear if res
@@ -496,4 +823,4 @@ end
 # * George Moschovitis <gm@navel.gr>
 # * Michael Neumann <mneumann@ntecs.de>
 # * Ysabel <deb@ysabel.org>
-# * Rob Pitt <rob@motionpath.com>
+# * Rob Pitt <rob@motionpath.com>