og 0.24.0 → 0.25.0

data/lib/og/store/psql.rb

@@ -5,6 +5,63 @@ rescue Object => ex
   Logger.error ex
 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)"
+    ret = r.result.flatten
+    r.clear
+    ret
+  end
+
+  # Returns true if a table exists within the database, false 
+  # 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)}'"
+    ret = r.result.size != 0
+    r.clear
+    ret
+  end
+
+  # Returns the PostgreSQL OID of a table within the database or 
+  # 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)}'"
+    ret = r.result.flatten.first
+    r.clear
+    ret
+  end
+
+  # Returns an array of arrays containing the list of fields within a
+  # table. Each element contains two elements, the first is the field
+  # name and the second is the field type. Returns nil if the table
+  # does not exist.
+  
+  def table_field_list(table)
+    return nil unless pg_oid = table_oid(table)
+    r = self.exec "SELECT a.attname, pg_catalog.format_type(a.atttypid, a.atttypmod) FROM pg_catalog.pg_attribute a WHERE a.attrelid = '#{pg_oid}' AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum"
+    ret = r.result
+    r.clear
+    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.
+  
+  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
+    r.clear
+    ret
+  end
+
+end
+
 require 'og/store/sql'
 
 # Customize the standard postgres resultset to make
@@ -71,6 +128,8 @@ end
 # A Store that persists objects into a PostgreSQL database.
 # To read documentation about the methods, consult the documentation
 # for SqlStore and Store.
+#
+# This is the reference Og store.
 # 
 # === Design
 #
@@ -92,6 +151,28 @@ class PsqlStore < SqlStore
     super
   end
 
+  # Purges all tables from the database.
+  
+  def self.destroy_tables(options)
+
+    conn = PGconn.connect(
+      options[:address],
+      options[:port], nil, nil,
+      options[:name],
+      options[:user].to_s,
+      options[:password].to_s
+    )
+
+    conn.list_tables.each do |table|
+      sql = "DROP TABLE #{table} CASCADE"
+      conn.exec sql
+      Logger.debug "Dropped database table #{table}"
+    end
+
+    conn.close
+  end
+
+
   def initialize(options)
     super
   
@@ -134,7 +215,7 @@ class PsqlStore < SqlStore
       klass.const_set 'OGSEQ', "#{table(klass)}_oid_seq"
     end
 
-    if klass.ann.this.primary_key.symbol == :oid
+    if klass.ann.self.primary_key.symbol == :oid
       unless klass.properties.include? :oid
         klass.property :oid, Fixnum, :sql => 'serial PRIMARY KEY'
       end
@@ -165,7 +246,7 @@ class PsqlStore < SqlStore
   end
 
   # Start a new transaction.
-  
+
   def start  
     # neumann: works with earlier PSQL databases too.
     exec('BEGIN TRANSACTION') if @transaction_nesting < 1
@@ -174,79 +255,166 @@ class PsqlStore < SqlStore
 
 private
 
-  def create_table(klass)
-    fields = fields_for_class(klass)
+  # 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).
 
-    sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
-    
-    # Create table constraints.
-    
-    if constraints = klass.ann.this[:sql_constraint]
-      sql << ", #{constraints.join(', ')}"
+  def create_join_table_foreign_key_constraints(klass,info)
+
+    table_list = @conn.list_tables
+
+    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)
     end
-    
-    sql << ") WITHOUT OIDS;"
-    
-    # Create indices.
-    
-    if indices = klass.ann.this[:index]
-      for data in indices
-        idx, options = *data
-        idx = idx.to_s
-        pre_sql, post_sql = options[:pre], options[:post]
-        idxname = idx.gsub(/ /, "").gsub(/,/, "_").gsub(/\(.*\)/, "")
-        sql << " CREATE #{pre_sql} INDEX #{klass::OGTABLE}_#{idxname}_idx #{post_sql} ON #{klass::OGTABLE} (#{idx});"  
+    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}, "
       end
+      Logger.debug msg[0..-3] + ". (Should be retried later)."
+      return false
     end
 
-    begin
-      @conn.exec(sql).clear
-      Logger.info "Created table '#{klass::OGTABLE}'."
-    rescue Object => ex
-      # gmosx: any idea how to better test this?
-      if ex.to_s =~ /relation .* already exists/i
-        Logger.debug 'Table already exists'
-        return
-      else
-        raise
+    #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
+      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] }
+
+      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
+        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})."
+      end
+    end
+  end
+
+  def create_table(klass)
+    fields = fields_for_class(klass)
+
+    unless @conn.table_exists? klass::OGTABLE
+
+      sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
+
+      # Create table constraints.
+
+      if constraints = klass.ann.self[:sql_constraint]
+        sql << ", #{constraints.join(', ')}"
+      end
+
+      sql << ") WITHOUT OIDS;"
+
+      # Create indices.
+
+      if indices = klass.ann.self[:index]
+        for data in indices
+          idx, options = *data
+          idx = idx.to_s
+          pre_sql, post_sql = options[:pre], options[:post]
+          idxname = idx.gsub(/ /, "").gsub(/,/, "_").gsub(/\(.*\)/, "")
+          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}'."
+    else
+      Logger.debug "Table #{klass::OGTABLE} already exists"
+      #rp: basic field interrogation
+      # TODO: Add type checking.
+
+      actual_fields = @conn.table_field_list(klass::OGTABLE).map {|pair| pair.first}
+
+      #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.exec(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.exec(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
     end
 
     # Create join tables if needed. Join tables are used in
     # 'many_to_many' relations.
-    
-     if join_tables = klass.ann.this[:join_tables] 
-      for info in join_tables
-        begin
-          create_join_table_sql(info).each do |sql|
-            @conn.exec(sql).clear
-          end
-          Logger.debug "Created jointable '#{info[:table]}'."
-        rescue Object => ex
-          # gmosx: any idea how to better test this?
-          if ex.to_s =~ /relation .* already exists/i
-            Logger.debug 'Join table already exists' if $DBG
+      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
+            end
+            Logger.debug "Created jointable '#{info[:table]}'."
           else
-            raise
+            Logger.debug "Join table '#{info[:table]}' already exists."
           end
+          create_join_table_foreign_key_constraints(player,info)
         end
       end
     end
+
   end
 
   def drop_table(klass)
-    super
-    exec "DROP SEQUENCE #{klass::OGSEQ}"    
+    # foreign key constraints will remove the need to do manual cleanup on
+    # postgresql join tables.
+    exec "DROP TABLE #{klass.table} CASCADE"
   end
 
   def create_field_map(klass)
     res = @conn.exec "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
     map = {}
-  
+
     for field in res.fields
       map[field.intern] = res.fieldnum(field)
     end
-  
+
     return map
   ensure
     res.clear if res
@@ -284,23 +452,23 @@ private
       props << Property.new(:symbol => :ogtype, :klass => String)
       values << ", '#{klass}'"
     end
-    
+
     sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| field_for_property(p)}.join(',')}) VALUES (#{values})"
 
     klass.class_eval %{ 
       def og_insert(store)
-        #{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{Glue::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
-        #{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end
 
   def eval_og_allocate(klass)  
-    if klass.ann.this[:subclasses]
+    if klass.ann.self[:subclasses]
       klass.module_eval %{
         def self.og_allocate(res, row = 0)
           Object.constant(res.getvalue(row, 0)).allocate
@@ -328,3 +496,4 @@ end
 # * George Moschovitis <gm@navel.gr>
 # * Michael Neumann <mneumann@ntecs.de>
 # * Ysabel <deb@ysabel.org>
+# * Rob Pitt <rob@motionpath.com>

data/lib/og/store/sql.rb

@@ -8,7 +8,7 @@ module Og
 module SqlUtils
 
   # Escape an SQL string
-  
+
   def escape(str)
     return nil unless str
     return str.gsub(/'/, "''")
@@ -16,19 +16,19 @@ module SqlUtils
 
   # Convert a ruby time to an sql timestamp.
   #--
-  # TODO: Optimize this
+  # TODO: Optimize this.
   #++
-   
+
   def timestamp(time = Time.now)
     return nil unless time
     return time.strftime("%Y-%m-%d %H:%M:%S")
   end
-  
+
   # Output YYY-mm-dd
   #--
   # TODO: Optimize this.
   #++
-  
+
   def date(date)
     return nil unless date
     return "#{date.year}-#{date.month}-#{date.mday}" 
@@ -37,40 +37,40 @@ module SqlUtils
   #--
   # TODO: implement me!
   #++
-  
+
   def blob(val)
     val
   end
 
   # Parse an integer.
-  
+
   def parse_int(int)
     int = int.to_i if int
     int
   end
-  
+
   # Parse a float.
-  
+
   def parse_float(fl)
     fl = fl.to_f if fl
     fl
   end
-  
+
   # Parse sql datetime
   #--
   # TODO: Optimize this.
   #++
-  
+
   def parse_timestamp(str)
     return nil unless str
     return Time.parse(str)    
   end
-  
+
   # Input YYYY-mm-dd
   #--
   # TODO: Optimize this.
   #++
-  
+
   def parse_date(str)
     return nil unless str
     return Date.strptime(str)
@@ -79,13 +79,13 @@ module SqlUtils
   #--
   # TODO: implement me!!
   #++
-  
+
   def parse_blob(val)
     val
   end
-  
+
   # Escape the various Ruby types.
-  
+
   def quote(val)
     case val
       when Fixnum, Integer, Float
@@ -98,20 +98,20 @@ module SqlUtils
         val ? "'#{date(val)}'" : 'NULL'
       when TrueClass
         val ? "'t'" : 'NULL'
-      else 
+      else
         # gmosx: keep the '' for nil symbols.
         val ? escape(val.to_yaml) : ''
-    end 
+    end
   end
 
   # Apply table name conventions to a class name.
-  
+
   def tableize(klass)
     "#{klass.to_s.gsub(/::/, "_").downcase}"
   end
 
   def table(klass)
-    klass.ann.this[:sql_table] || klass.ann.this[:table] || "#{Og.table_prefix}#{tableize(klass)}"
+    klass.ann.self[:sql_table] || klass.ann.self[:table] || "#{Og.table_prefix}#{tableize(klass)}"
   end
 
   def join_object_ordering(obj1, obj2)
@@ -129,7 +129,7 @@ module SqlUtils
       return class2, class1, true
     end
   end
-  
+
   def build_join_name(class1, class2, postfix = nil)
     # Don't reorder arguments, as this is used in places that
     # have already determined the order they want.
@@ -149,14 +149,14 @@ module SqlUtils
     klass = klass.schema_inheritance_root_class if klass.schema_inheritance_child?
     "#{klass.to_s.split('::').last.downcase}_oid"
   end
-  
+
   def join_table_keys(class1, class2)
     if class1 == class2
       # Fix for the self-join case.
       return join_table_key(class1), "#{join_table_key(class2)}2"
     else
       return join_table_key(class1), join_table_key(class2)
-    end    
+    end
   end
 
   def ordered_join_table_keys(class1, class2)
@@ -165,7 +165,7 @@ module SqlUtils
   end
 
   def join_table_info(owner_class, target_class, postfix = nil)
-   
+
     # some fixes for schema inheritance.
 
     owner_class = owner_class.schema_inheritance_root_class if owner_class.schema_inheritance_child?
@@ -173,13 +173,13 @@ module SqlUtils
 
     owner_key, target_key = join_table_keys(owner_class, target_class)
     first, second, changed = join_class_ordering(owner_class, target_class)
-    
+
     if changed
       first_key, second_key = target_key, owner_key
     else
       first_key, second_key = owner_key, target_key
     end
-    
+
     return {
       :table => join_table(owner_class, target_class, postfix),
       :owner_key => owner_key,
@@ -195,7 +195,7 @@ module SqlUtils
 
   # Subclasses can override this if they need a different 
   # syntax.
-  
+
   def create_join_table_sql(join_table_info, suffix = 'NOT NULL', key_type = 'integer')
     join_table = join_table_info[:table]
     first_index = join_table_info[:first_index]
@@ -210,13 +210,13 @@ module SqlUtils
         #{first_key} integer NOT NULL,
         #{second_key} integer NOT NULL,
         PRIMARY KEY(#{first_key}, #{second_key})
-      ) 
+      )
     }
-    
+
     # gmosx: not that useful?
     # sql << "CREATE INDEX #{first_index} ON #{join_table} (#{first_key})"
     # sql << "CREATE INDEX #{second_index} ON #{join_table} (#{second_key})"
-    
+
     return sql
   end
 
@@ -237,7 +237,7 @@ class SqlStore < Store
 
     # The default Ruby <-> SQL type mappings, should be valid 
     # for most RDBM systems.
-    
+
     @typemap = {
       Integer => 'integer',
       Fixnum => 'integer',
@@ -265,12 +265,36 @@ class SqlStore < Store
     Glue::Aspects.wrap(klass, [:exec, :query])
   end
 
-  # Enchants a class. 
+  # Returns a list of tables that exist within the database but are 
+  # not managed by the supplied manager.
+  
+  def unmanaged_tables(manager)
+    ret = Array.new
+    mt = managed_tables(manager)
+    @conn.list_tables.each do |table|
+      ret << table unless mt.include?(table)
+    end
+    ret
+  end
+
+  # Returns a list of tables within the database that are there to 
+  # support a class managed by the supplied manager.
+  
+  def managed_tables(manager)
+    ret = Array.new
+    manager.managed_classes.each do |klass|
+      ret << klass::OGTABLE
+      ret.concat(klass.relations.reject{|rel| not rel.options[:join_table]}.map{|rel| rel.options[:join_table]})
+    end
+    ret
+  end
+
+  # Enchants a class.
 
   def enchant(klass, manager)
 
     # setup the table where this class is mapped.
-        
+
     if klass.schema_inheritance_child?
       # farms: allow deeper inheritance (TODO: use annotation :superclass)
       klass.const_set 'OGTABLE', table(klass.schema_inheritance_root_class)
@@ -279,13 +303,13 @@ class SqlStore < Store
     end
 
     klass.module_eval 'def self.table; OGTABLE; end'
-  
+
     eval_og_allocate(klass)
-    
+
     super
 
     unless klass.polymorphic_parent?
-      # precompile class specific lifecycle methods.      
+      # precompile class specific lifecycle methods.
       eval_og_create_schema(klass)
       eval_og_insert(klass)
       eval_og_update(klass)
@@ -309,7 +333,9 @@ class SqlStore < Store
   # Loads an object from the store using the primary key.
 
   def load(pk, klass)
-    res = query "SELECT * FROM #{klass::OGTABLE} WHERE #{klass.pk_symbol}=#{pk}"
+    sql = "SELECT * FROM #{klass::OGTABLE} WHERE #{klass.pk_symbol}=#{pk}"
+    sql << " AND ogtype='#{klass}'" if klass.schema_inheritance_child?
+    res = query sql
     read_one(res, klass)
   end
   alias_method :exist?, :load
@@ -318,7 +344,9 @@ class SqlStore < Store
 
   def reload(obj, pk)
     raise 'Cannot reload unmanaged object' unless obj.saved?
-    res = query "SELECT * FROM #{obj.class.table} WHERE #{obj.class.pk_symbol}=#{pk}"
+    sql = "SELECT * FROM #{obj.class.table} WHERE #{obj.class.pk_symbol}=#{pk}"
+    sql << " AND ogtype='#{obj.class}'" if obj.class.schema_inheritance_child?
+    res = query sql
     obj.og_read(res.next, 0)
   ensure
     res.close if res
@@ -330,7 +358,7 @@ class SqlStore < Store
   #--
   # gmosx, THINK: condition is not really useful here :(
   #++
-  
+
   def update(obj, options = nil)
     if options and properties = options[:only]
       if properties.is_a?(Array)
@@ -352,7 +380,7 @@ class SqlStore < Store
 
   # Update selected properties of an object or class of
   # objects.
-  
+
   def update_properties(target, *properties)
     update(target, :only => properties)
   end
@@ -360,10 +388,10 @@ class SqlStore < Store
   alias_method :update_property, :update_properties
 
   # More generalized method, also allows for batch updates.
-  
+
   def update_by_sql(target, set, options = nil)
     set = set.gsub(/@/, '')
-    
+
     if target.is_a?(Class)
       sql = "UPDATE #{target.table} SET #{set} "
       sql << " WHERE #{options[:condition]}" if options and options[:condition]
@@ -381,7 +409,7 @@ class SqlStore < Store
   #
   # User.find(:condition  => 'age > 15', :order => 'score ASC', :offet => 10, :limit =>10)
   # Comment.find(:include => :entry)
-  
+
   def find(options)  
     klass = options[:class]
     sql = resolve_options(klass, options)
@@ -389,7 +417,7 @@ class SqlStore < Store
   end
 
   # Find one object.
-  
+
   def find_one(options)
     klass = options[:class]
 # gmosx, THINK: should not set this by default.
@@ -400,15 +428,15 @@ class SqlStore < Store
 
   # Perform a custom sql query and deserialize the 
   # results.
-  
+
   def select(sql, klass)
     sql = "SELECT * FROM #{klass.table} " + sql unless sql =~ /SELECT/
     read_all(query(sql), klass)
   end
   alias_method :find_by_sql, :select
-  
+
   # Specialized one result version of select.
-  
+
   def select_one(sql, klass)
     sql = "SELECT * FROM #{klass.table} " + sql unless sql =~ /SELECT/
     read_one(query(sql), klass)
@@ -416,7 +444,7 @@ class SqlStore < Store
   alias_method :find_by_sql_one, :select_one
 
   # Perform an aggregation over query results.
-    
+
   def aggregate(options)
     if options.is_a?(String)
       sql = options
@@ -425,16 +453,20 @@ class SqlStore < Store
       sql = "SELECT #{aggregate} FROM #{options[:class].table}"
       if condition = options[:condition]
         sql << " WHERE #{condition}"
+        sql << " AND " if options[:class].schema_inheritance_child?
+      else
+        sql << " WHERE " if options[:class].schema_inheritance_child?
       end
-    end    
-    
+      sql << "ogtype='#{options[:class]}'" if options[:class].schema_inheritance_child?
+    end
+
     query(sql).first_value.to_i
   end
   alias_method :count, :aggregate
-  
+
   # Relate two objects through an intermediate join table.
   # Typically used in joins_many and many_to_many relations.
-  
+
   def join(obj1, obj2, table, options = nil)
     first, second = join_object_ordering(obj1, obj2)
     first_key, second_key = ordered_join_table_keys(obj1.class, obj2.class)
@@ -443,48 +475,48 @@ class SqlStore < Store
     else
       exec "INSERT INTO #{table} (#{first_key},#{second_key}) VALUES (#{first.pk}, #{second.pk})"
     end
-  end 
+  end
 
   # Unrelate two objects be removing their relation from the
   # join table.
-    
+
   def unjoin(obj1, obj2, table)
     first, second = join_object_ordering(obj1, obj2)
     first_key, second_key = ordered_join_table_keys(obj1.class, obj2.class)
     exec "DELETE FROM #{table} WHERE #{first_key}=#{first.pk} AND #{second_key}=#{second.pk}"    
   end
-    
+
   def delete_all(klass)
     exec "DELETE FROM #{klass.table}"
   end
-    
+
   # :section: Transaction methods.
-  
+
   # Start a new transaction.
-  
+
   def start  
     exec('START TRANSACTION') if @transaction_nesting < 1
     @transaction_nesting += 1
   end
-  
+
   # Commit a transaction.
-  
+
   def commit
     @transaction_nesting -= 1
     exec('COMMIT') if @transaction_nesting < 1
   end
-  
+
   # Rollback a transaction.
-  
+
   def rollback
     @transaction_nesting -= 1
     exec('ROLLBACK') if @transaction_nesting < 1
   end
 
   # :section: Low level methods.
-  
+
   # Encapsulates a low level update method.
-  
+
   def sql_update(sql)
     exec(sql)
     # return affected rows.
@@ -503,6 +535,13 @@ private
   # persisted.
   
   def drop_table(klass)
+    # Remove leftover data from some join tabkes.
+    klass.relations.each do |rel|
+      if rel.class.to_s == "Og::JoinsMany" and rel.join_table
+        target_class =  rel.target_class
+        exec "DELETE FROM #{rel.join_table}"
+      end
+    end
     exec "DROP TABLE #{klass.table}"
   end
   alias_method :destroy, :drop_table
@@ -632,7 +671,7 @@ private
     props = klass.properties.values.dup
     values = props.collect { |p| write_prop(p) }.join(',') 
 
-    if klass.ann.this[:superclass] or klass.ann.this[:subclasses]
+    if klass.ann.self[:superclass] or klass.ann.self[:subclasses]
       props << Property.new(:symbol => :ogtype, :klass => String)
       values << ", '#{klass}'"
     end
@@ -641,9 +680,9 @@ private
 
     klass.module_eval %{ 
       def og_insert(store)
-        #{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
         store.exec "#{sql}"
-        #{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end
@@ -662,11 +701,11 @@ private
 
     klass.module_eval %{
       def og_update(store, options = nil)
-        #{Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{Glue::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)
-        #{Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
         return changed
       end
     }
@@ -684,57 +723,57 @@ private
 
     for p in props
       f = field_for_property(p).to_sym
-      
+
       if col = field_map[f]
         code << "@#{p} = #{read_prop(p, col)}"
       end
     end
-    
+
     code = code.join('; ')
 
     klass.module_eval %{
        def og_read(res, row = 0, offset = 0)
-        #{Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
         #{code}
-        #{Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
-  end        
+  end
 
   #--
   # FIXME: is pk needed as parameter?
   #++
-  
+
   def eval_og_delete(klass)
     klass.module_eval %{
        def og_delete(store, pk, cascade = true)
-        #{Aspects.gen_advice_code(:og_delete, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{Glue::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}"
-          if cascade and #{klass}.ann.this[:descendants]
-            #{klass}.ann.this.descendants.each do |dclass, foreign_key|
+          if cascade and #{klass}.ann.self[:descendants]
+            #{klass}.ann.self.descendants.each do |dclass, foreign_key|
               tx.exec "DELETE FROM \#{dclass::OGTABLE} WHERE \#{foreign_key}=\#{pk}"
             end
           end
         end
-        #{Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_delete, klass.advices, :post) if klass.respond_to?(:advices)}
       end
-    }    
+    }
   end
 
   # Creates the schema for this class. Can be intercepted with
   # aspects to add special behaviours.
-  
+
   def eval_og_create_schema(klass)
     klass.module_eval %{
       def og_create_schema(store)
         if Og.create_schema
-          #{Aspects.gen_advice_code(:og_create_schema, klass.advices, :pre) if klass.respond_to?(:advices)}
+          #{Glue::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
-          #{Aspects.gen_advice_code(:og_create_schema, klass.advices, :post) if klass.respond_to?(:advices)}
+          #{Glue::Aspects.gen_advice_code(:og_create_schema, klass.advices, :post) if klass.respond_to?(:advices)}
         end
       end
     }
@@ -758,7 +797,7 @@ private
       }
     end
   end
-  
+
   # :section: Misc methods.
 
   def handle_sql_exception(ex, sql = nil)
@@ -770,12 +809,26 @@ private
     return nil 
   end
 
+  # Resolve the finder options. Also takes scope into account.
+  #--
+  # FIXME: cleanup/refactor.
+  #++
+  
   def resolve_options(klass, options)
+    # Factor in scope.
+    
+    if scope = klass.get_scope
+      scope = scope.dup
+      scond = scope.delete(:condition)
+      scope.update(options)
+      options = scope
+    end
+  
     if sql = options[:sql]
       sql = "SELECT * FROM #{klass.table} " + sql unless sql =~ /SELECT/
       return sql
     end
-  
+
     tables = [klass::OGTABLE]
 
     if included = options[:include]
@@ -785,7 +838,7 @@ private
         if rel = klass.relation(name)
           target_table = rel[:target_class]::OGTABLE
           tables << target_table
-          
+
           if rel.is_a?(JoinsMany)
             tables << rel[:join_table]
             owner_key, target_key = klass.ogmanager.store.join_table_keys(klass, rel[:target_class])
@@ -813,16 +866,21 @@ private
       update_condition options, options[:join_condition]
     end
 
-    if ogtype = options[:type]
+    # Factor in scope in the conditions.
+    
+    update_condition(options, scond) if scond
+
+    # rp: type is not set in all instances such as Class.first so this fix goes here for now.
+    if ogtype = options[:type] || (klass.schema_inheritance_child? ? "#{klass}" : nil)
       update_condition options, "ogtype='#{ogtype}'"
     end
 
     sql = "SELECT #{fields} FROM #{tables.join(',')}"
-    
+
     if condition = options[:condition] || options[:where]
       sql << " WHERE #{condition}"
     end
-    
+
     if order = options[:order]
       sql << " ORDER BY #{order}"
     end
@@ -831,10 +889,10 @@ private
 
     if extra = options[:extra]
       sql << " #{extra}"
-    end    
-    
+    end
+
     return sql
-  end    
+  end
 
   # Subclasses can override this if they need some other order.
   # This is needed because different backends require different
@@ -853,15 +911,15 @@ private
   # :section: Deserialization methods.
 
   # Read a field (column) from a result set row.
-  
+
   def read_field
   end
-  
+
   # Dynamicaly deserializes a result set row into an object.
   # Used for specialized queries or join queries. Please
   # not that this deserialization method is slower than the
   # precompiled og_read method.
-  
+
   def read_row(obj, res, res_row, row)
     res.fields.each_with_index do |field, idx|
       obj.instance_variable_set "@#{field}", res_row[idx]
@@ -869,10 +927,10 @@ private
   end
 
   # Deserialize the join relations.
-  
+
   def read_join_relations(obj, res_row, row, join_relations)
     offset = obj.class.properties.size 
-    
+
     for rel in join_relations 
       rel_obj = rel[:target_class].og_allocate(res_row, row)
       rel_obj.og_read(res_row, row, offset) 
@@ -882,7 +940,7 @@ private
   end
 
   # Deserialize one object from the ResultSet.
-     
+
   def read_one(res, klass, options = nil)
     return nil if res.blank?
 
@@ -891,11 +949,12 @@ private
         klass.relation(n) 
       end
     end
-    
+
     res_row = res.next
-    
+    # causes STI classes to come back as the correct child class if accessed from the superclass
+    klass = Og::Entity::entity_from_string(res_row.result.flatten[res_row.fieldnum('ogtype')]) if klass.schema_inheritance?
     obj = klass.og_allocate(res_row, 0)
-    
+
     if options and options[:select]
       read_row(obj, res, res_row, 0)
     else
@@ -904,7 +963,7 @@ private
     end
 
     return obj
-    
+
   ensure
     res.close
   end
@@ -936,10 +995,10 @@ private
         objects << obj
       end
     end
-        
+
     return objects
-    
-  ensure 
+
+  ensure
     res.close
   end
 
@@ -962,3 +1021,4 @@ end
 # * Ghislain Mary
 # * Ysabel <deb@ysabel.org>
 # * Guillaume Pierronnet <guillaume.pierronnet@laposte.net>
+# * Rob Pitt <rob@motionpath.com>