og 0.23.0 → 0.24.0

data/lib/og/store/mysql.rb

@@ -2,7 +2,7 @@ begin
   require 'mysql'
 rescue Object => ex
   Logger.error 'Ruby-Mysql bindings are not installed!'
-  Logger.error 'Trying to uses the pure-Ruby binding included in Og'
+  Logger.error 'Trying to use the pure-Ruby binding included in Og'
   begin
     # Attempt to use the included pure ruby version.
     require 'vendor/mysql'
@@ -87,8 +87,19 @@ module MysqlUtils
 end
 
 # A Store that persists objects into a MySQL database.
-# To read documentation about the methods, consult the documentation
-# for SqlStore and Store.
+# To read documentation about the methods, consult 
+# the documentation for SqlStore and Store.
+#
+# Here is some useful code to initialize your MySQL 
+# RDBMS for development. You probably want to be
+# more careful with provileges on your production
+# environment.
+#
+# mysql> GRANT ALL PRIVELEGES 
+# ON keystone.*
+# TO <$sys_dbuser name>@localhost
+# IDENTIFIED BY '(password)'
+# WITH GRANT OPTION;
 
 class MysqlStore < SqlStore
   extend MysqlUtils
@@ -109,6 +120,16 @@ class MysqlStore < SqlStore
     super
   end
 
+  # Initialize the MySQL store.
+  #
+  # === Options
+  #
+  # * :address, the addres where the server is listening.
+  # * :socket, is useful when the pure ruby driver is used.
+  #    this is the location of mysql.sock. For Ubuntu/Debian 
+  #    this is '/var/run/mysqld/mysqld.sock'. You can find
+  #    the location for your system in my.cnf
+  
   def initialize(options)
     super
 
@@ -118,9 +139,11 @@ class MysqlStore < SqlStore
       options[:address] || 'localhost', 
       options[:user],
       options[:password], 
-      options[:name]
+      options[:name],
+      options[:port],
+      options[:socket]
     )
-    
+
     # You should set recconect to true to avoid MySQL has
     # gone away errors.
     
@@ -143,9 +166,9 @@ class MysqlStore < SqlStore
     super
   end
 
-  def enchant(klass, manager)
-    if klass.metadata.primary_key.flatten.first == :oid
-      unless klass.properties.find { |p| p.symbol == :oid }
+  def enchant(klass, manager)  
+    if klass.ann.this.primary_key.symbol == :oid
+      unless klass.properties.include? :oid
         klass.property :oid, Fixnum, :sql => 'integer AUTO_INCREMENT PRIMARY KEY'
       end
     end
@@ -195,14 +218,23 @@ class MysqlStore < SqlStore
 private
 
   def create_table(klass)
+    # rp: fixes problems when user doesn't have 
+    # write access to db.
+    # THINK, should a method more like this be 
+    # used instead of catching database exceptions 
+    # for 'table exists'?
+    
+    return if @conn.list_tables.include?(klass::OGTABLE)
+    
+  
     fields = fields_for_class(klass)
 
     sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
     
-    # Create table constrains.
+    # Create table constraints.
     
-    if klass.metadata and constrains = klass.metadata.sql_constrain
-      sql << ", #{constrains.join(', ')}"
+    if constraints = klass.ann.this[:sql_constraint]
+      sql << ", #{constraints.join(', ')}"
     end
   
     if table_type = @options[:table_type]
@@ -213,7 +245,7 @@ private
     
     # Create indices.
     
-    if klass.__meta and indices = klass.__meta[:index]
+    if indices = klass.ann.this[:index]
       for data in indices
         idx, options = *data
         idx = idx.to_s
@@ -240,7 +272,7 @@ private
     # Create join tables if needed. Join tables are used in
     # 'many_to_many' relations.
     
-     if klass.__meta and join_tables = klass.__meta[:join_tables] 
+     if join_tables = klass.ann.this[:join_tables] 
       for info in join_tables
         begin
           create_join_table_sql(info).each do |sql|
@@ -248,8 +280,8 @@ private
           end
           Logger.debug "Created jointable '#{info[:table]}'."          
         rescue => ex
-          if ex.respond_to?(:errno) and ex.errno == 1050 # table already exists.
-            Logger.debug 'Join table already exists' if $DBG
+          if ex.respond_to?(:errno) and ex.errno == 1050 # table already exists.
+            Logger.debug 'Join table already exists' if $DBG
           else
             raise
           end
@@ -274,20 +306,20 @@ private
 
   def write_prop(p)
     if p.klass.ancestors.include?(Integer)
-      return "#\{@#{p.symbol} || 'NULL'\}"
+      return "#\{@#{p} || 'NULL'\}"
     elsif p.klass.ancestors.include?(Float)
-      return "#\{@#{p.symbol} || 'NULL'\}"    
+      return "#\{@#{p} || 'NULL'\}"    
     elsif p.klass.ancestors.include?(String)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.escape(@#{p})\}'" : 'NULL'\}|
     elsif p.klass.ancestors.include?(Time)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.timestamp(@#{p})\}'" : 'NULL'\}|
     elsif p.klass.ancestors.include?(Date)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.date(@#{p})\}'" : 'NULL'\}|
     elsif p.klass.ancestors.include?(TrueClass)
-      return "#\{@#{p.symbol} ? \"'1'\" : 'NULL' \}"
+      return "#\{@#{p} ? \"'1'\" : 'NULL' \}"
     else 
       # gmosx: keep the '' for nil symbols.
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.escape(@#{p}.to_yaml)\}'" : "''"\}|
     end
   end    
   
@@ -303,18 +335,18 @@ private
     elsif p.klass.ancestors.include?(Date)
       return "#{self.class}.parse_date(res[#{col} + offset])"
     elsif p.klass.ancestors.include?(TrueClass)
-      return "('0' != res[#{col} + offset])"
+      return "('1' == res[#{col} + offset])"
     else 
       return "YAML.load(res[#{col} + offset])"
     end        
   end
 
   def eval_og_insert(klass)
-    props = klass.properties.dup
+    props = klass.properties.values
     values = props.collect { |p| write_prop(p) }.join(',') 
 
-    if klass.metadata.superclass or klass.metadata.subclasses
-      props << Property.new(:ogtype, String)
+    if klass.schema_inheritance?
+      props << Property.new(:symbol => :ogtype, :klass => String)
       values << ", '#{klass}'"
     end
     
@@ -323,7 +355,6 @@ private
     klass.class_eval %{
       def og_insert(store)
         #{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-        puts "#{sql}"
         store.conn.query_with_result = false
         store.conn.query "#{sql}"
         @#{klass.pk_symbol} = store.conn.insert_id

data/lib/og/store/psql.rb

@@ -59,6 +59,8 @@ module PsqlUtils
   end  
   
   def parse_blob(val)
+    return '' unless val
+    
     val.gsub(/\\(\\|'|[0-3][0-7][0-7])/) do |s|
       if s.size == 2 then s[1,1] else s[1,3].oct.chr end
     end
@@ -126,14 +128,14 @@ class PsqlStore < SqlStore
   end
 
   def enchant(klass, manager)
-    if sclass = klass.metadata.superclass
-      klass.const_set 'OGSEQ', "#{table(sclass.first)}_oid_seq"
+    if klass.schema_inheritance_child?
+      klass.const_set 'OGSEQ', "#{table(klass.schema_inheritance_root_class)}_oid_seq"      
     else
       klass.const_set 'OGSEQ', "#{table(klass)}_oid_seq"
     end
 
-    if klass.metadata.primary_key.flatten.first == :oid
-      unless klass.properties.find { |p| p.symbol == :oid }
+    if klass.ann.this.primary_key.symbol == :oid
+      unless klass.properties.include? :oid
         klass.property :oid, Fixnum, :sql => 'serial PRIMARY KEY'
       end
     end
@@ -177,17 +179,17 @@ private
 
     sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
     
-    # Create table constrains.
+    # Create table constraints.
     
-    if klass.__meta and constrains = klass.__meta[:sql_constrain]
-      sql << ", #{constrains.join(', ')}"
+    if constraints = klass.ann.this[:sql_constraint]
+      sql << ", #{constraints.join(', ')}"
     end
     
     sql << ") WITHOUT OIDS;"
     
     # Create indices.
     
-    if klass.__meta and indices = klass.__meta[:index]
+    if indices = klass.ann.this[:index]
       for data in indices
         idx, options = *data
         idx = idx.to_s
@@ -213,7 +215,7 @@ private
     # Create join tables if needed. Join tables are used in
     # 'many_to_many' relations.
     
-     if klass.__meta and join_tables = klass.__meta[:join_tables] 
+     if join_tables = klass.ann.this[:join_tables] 
       for info in join_tables
         begin
           create_join_table_sql(info).each do |sql|
@@ -275,11 +277,11 @@ private
   #++
 
   def eval_og_insert(klass)
-    props = klass.properties.dup
+    props = klass.properties.values.dup
     values = props.collect { |p| write_prop(p) }.join(',') 
 
-    if klass.metadata.superclass or klass.metadata.subclasses
-      props << Property.new(:ogtype, String)
+    if klass.schema_inheritance?
+      props << Property.new(:symbol => :ogtype, :klass => String)
       values << ", '#{klass}'"
     end
     
@@ -298,7 +300,7 @@ private
   end
 
   def eval_og_allocate(klass)  
-    if klass.metadata.subclasses
+    if klass.ann.this[:subclasses]
       klass.module_eval %{
         def self.og_allocate(res, row = 0)
           Object.constant(res.getvalue(row, 0)).allocate

data/lib/og/store/sql.rb

@@ -1,6 +1,7 @@
 require 'yaml'
+require 'time'
 
-require 'nano/object/constant'
+require 'nano/kernel/constant'
 
 module Og
 
@@ -105,53 +106,50 @@ module SqlUtils
 
   # Apply table name conventions to a class name.
   
-  def tableize(klass)
-    "#{klass.to_s.gsub(/::/, "_").downcase}"
-  end
+  def tableize(klass)
+    "#{klass.to_s.gsub(/::/, "_").downcase}"
+  end
 
   def table(klass)
-    if t = klass.metadata.sql_table
-      return t.first
+    klass.ann.this[:sql_table] || klass.ann.this[:table] || "#{Og.table_prefix}#{tableize(klass)}"
+  end
+
+  def join_object_ordering(obj1, obj2)
+    if obj1.class.to_s <= obj2.class.to_s
+      return obj1, obj2
     else
-      "#{Og.table_prefix}#{tableize(klass)}"
-    end 
+      return obj2, obj1, true
+    end
   end
 
-  def join_object_ordering(obj1, obj2)
-    if obj1.class.to_s <= obj2.class.to_s
-      return obj1, obj2
-    else
-      return obj2, obj1, true
-    end
-  end
-
-  def join_class_ordering(class1, class2)
+  def join_class_ordering(class1, class2)
     if class1.to_s <= class2.to_s
-      return class1, class2
+      return class1, class2
     else
-      return class2, class1, true
+      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.
-    "#{Og.table_prefix}j_#{tableize(class1)}_#{tableize(class2)}#{postfix}"
-  end
-
-  def join_table(class1, class2, postfix = nil)
-    first, second = join_class_ordering(class1, class2)
-    build_join_name(first, second, postfix)
-  end
-
-  def join_table_index(key)
-    "#{key}_idx"
-  end
-
-  def join_table_key(klass)
-    "#{klass.to_s.split('::').last.downcase}_oid"
-  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.
+    "#{Og.table_prefix}j_#{tableize(class1)}_#{tableize(class2)}#{postfix}"
+  end
+
+  def join_table(class1, class2, postfix = nil)
+    first, second = join_class_ordering(class1, class2)
+    build_join_name(first, second, postfix)
+  end
+
+  def join_table_index(key)
+    "#{key}_idx"
+  end
+
+  def join_table_key(klass)
+    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.
@@ -165,8 +163,14 @@ module SqlUtils
     first, second = join_class_ordering(class1, class2)
     return join_table_keys(first, second)
   end
-
-  def join_table_info(owner_class, target_class, postfix = nil)
+
+  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?
+    target_class = target_class.schema_inheritance_root_class if target_class.schema_inheritance_child?
+
     owner_key, target_key = join_table_keys(owner_class, target_class)
     first, second, changed = join_class_ordering(owner_class, target_class)
     
@@ -175,35 +179,35 @@ module SqlUtils
     else
       first_key, second_key = owner_key, target_key
     end
-    
-    return {
-      :table => join_table(owner_class, target_class, postfix),
-      :owner_key => owner_key,
-      :target_key => target_key,
-      :first_table => table(first),
-      :first_key => first_key,
-      :first_index => join_table_index(first_key),
-      :second_table => table(second),
-      :second_key => second_key,
-      :second_index => join_table_index(second_key)
-    }
-  end
-
+    
+    return {
+      :table => join_table(owner_class, target_class, postfix),
+      :owner_key => owner_key,
+      :target_key => target_key,
+      :first_table => table(first),
+      :first_key => first_key,
+      :first_index => join_table_index(first_key),
+      :second_table => table(second),
+      :second_key => second_key,
+      :second_index => join_table_index(second_key)
+    }
+  end
+
   # Subclasses can override this if they need a different 
   # syntax.
-  
-  def create_join_table_sql(join_table_info, suffix = 'NOT NULL', key_type = 'integer')
+  
+  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]
-    first_key = join_table_info[:first_key]
-    second_key = join_table_info[:second_key]
+    first_index = join_table_info[:first_index]
+    first_key = join_table_info[:first_key]
+    second_key = join_table_info[:second_key]
     second_index = join_table_info[:second_index]
 
     sql = []
 
     sql << %{      
-      CREATE TABLE #{join_table} (
-        #{first_key} integer NOT NULL,
+      CREATE TABLE #{join_table} (
+        #{first_key} integer NOT NULL,
         #{second_key} integer NOT NULL,
         PRIMARY KEY(#{first_key}, #{second_key})
       ) 
@@ -213,9 +217,9 @@ module SqlUtils
     # sql << "CREATE INDEX #{first_index} ON #{join_table} (#{first_key})"
     # sql << "CREATE INDEX #{second_index} ON #{join_table} (#{second_key})"
     
-    return sql
-  end
-
+    return sql
+  end
+
 end
 
 # An abstract SQL powered store.
@@ -267,8 +271,9 @@ class SqlStore < Store
 
     # setup the table where this class is mapped.
         
-    if sclass = klass.metadata.superclass
-      klass.const_set 'OGTABLE', table(sclass.first)
+    if klass.schema_inheritance_child?
+      # farms: allow deeper inheritance (TODO: use annotation :superclass)
+      klass.const_set 'OGTABLE', table(klass.schema_inheritance_root_class)
     else
       klass.const_set 'OGTABLE', table(klass)
     end
@@ -431,24 +436,28 @@ class SqlStore < Store
   # 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, second = join_object_ordering(obj1, obj2)
     first_key, second_key = ordered_join_table_keys(obj1.class, obj2.class)
     if options
       exec "INSERT INTO #{table} (#{first_key},#{second_key}, #{options.keys.join(',')}) VALUES (#{first.pk},#{second.pk}, #{options.values.map { |v| quote(v) }.join(',')})"
     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)
+    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.
@@ -496,6 +505,7 @@ private
   def drop_table(klass)
     exec "DROP TABLE #{klass.table}"
   end
+  alias_method :destroy, :drop_table
 
   # Evolve (recreate) the sql table where objects of this class 
   # are persisted.
@@ -509,57 +519,46 @@ private
   # Return the field for the given property.
 
   def field_for_property(property)
-    if f = property.meta[:field]
+    if f = property.field
       return f.to_s
     else
-      return property.symbol.to_s
+      return property.to_s
     end
   end
   
   # Create the fields that correpsond to the klass properties.
   # The generated fields array is used in create_table.
-  # If the property has an :sql metadata this overrides the 
-  # default mapping. If the property has an :extra_sql metadata 
+  # If the property has an :sql annotation this overrides the 
+  # default mapping. If the property has an :extra_sql annotation
   # the extra sql is appended after the default mapping.
   
   def fields_for_class(klass)
     fields = []
-    properties = klass.properties
+    properties = klass.properties.dup
 
-    if subclasses = klass.metadata.subclasses
+    if klass.ancestors.include? SchemaInheritanceBase 
       # 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 subclass in subclasses
-        properties.concat(subclass.properties)
+  
+      for desc in klass.descendents
+        properties.update(desc.properties)
       end
-      
-      properties.uniq!
     end
-  
-    properties.each do |p|
-      klass.index(p.symbol) if p.meta[:index]
+    
+    for p in properties.values
+      klass.index(p.symbol) if p.index
         
       field = field_for_property(p)
       
-      if p.meta and p.meta[:sql]
-        field << " #{p.meta[:sql]}"
+      if p.sql
+        field << " #{p.sql}"
       else
         field << " #{type_for_class(p.klass)}"
-        
-        if p.meta
-          field << " UNIQUE" if p.meta[:unique]  
-
-          if default = p.meta[:default]
-            field << " DEFAULT #{default.inspect} NOT NULL"
-          end
-        
-          if extra_sql = p.meta[:extra_sql]
-            field << " #{extra_sql}"
-          end
-        end
+        field << " UNIQUE" if p.unique  
+        field << " DEFAULT #{p.default.inspect} NOT NULL" if p.default
+        field << " #{p.extra_sql}" if p.extra_sql
       end
       
       fields << field
@@ -582,22 +581,22 @@ private
   
   def write_prop(p)
     if p.klass.ancestors.include?(Integer)
-      return "#\{@#{p.symbol} || 'NULL'\}"
+      return "#\{@#{p} || 'NULL'\}"
     elsif p.klass.ancestors.include?(Float)
-      return "#\{@#{p.symbol} || 'NULL'\}"    
+      return "#\{@#{p} || 'NULL'\}"    
     elsif p.klass.ancestors.include?(String)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.escape(@#{p})\}'" : 'NULL'\}|
     elsif p.klass.ancestors.include?(Time)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.timestamp(@#{p})\}'" : 'NULL'\}|
     elsif p.klass.ancestors.include?(Date)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.date(@#{p})\}'" : 'NULL'\}|
     elsif p.klass.ancestors.include?(TrueClass)
-      return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
+      return "#\{@#{p} ? \"'t'\" : 'NULL' \}"
     elsif p.klass.ancestors.include?(Og::Blob)
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(#{self.class}.blob(@#{p.symbol}))\}'" : 'NULL'\}|      
+      return %|#\{@#{p} ? "'#\{#{self.class}.escape(#{self.class}.blob(@#{p}))\}'" : 'NULL'\}|      
     else 
       # gmosx: keep the '' for nil symbols.
-      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
+      return %|#\{@#{p} ? "'#\{#{self.class}.escape(@#{p}.to_yaml)\}'" : "''"\}|
     end
   end    
 
@@ -630,11 +629,11 @@ private
 
   def eval_og_insert(klass)
     pk = klass.pk_symbol
-    props = klass.properties.dup
+    props = klass.properties.values.dup
     values = props.collect { |p| write_prop(p) }.join(',') 
 
-    if klass.metadata.superclass or klass.metadata.subclasses
-      props << Property.new(:ogtype, String)
+    if klass.ann.this[:superclass] or klass.ann.this[:subclasses]
+      props << Property.new(:symbol => :ogtype, :klass => String)
       values << ", '#{klass}'"
     end
     
@@ -653,7 +652,7 @@ private
 
   def eval_og_update(klass)
     pk = klass.pk_symbol
-    props = klass.properties.reject { |p| pk == p.symbol }
+    props = klass.properties.values.reject { |p| pk == p.symbol }
     
     updates = props.collect { |p|
       "#{field_for_property(p)}=#{write_prop(p)}"
@@ -680,14 +679,14 @@ private
   
   def eval_og_read(klass)
     code = []
-    props = klass.properties 
+    props = klass.properties.values
     field_map = create_field_map(klass)
 
-    props.each do |p|
-      f = field_for_property(p).intern
+    for p in props
+      f = field_for_property(p).to_sym
       
       if col = field_map[f]
-        code << "@#{p.symbol} = #{read_prop(p, col)}"
+        code << "@#{p} = #{read_prop(p, col)}"
       end
     end
     
@@ -713,8 +712,8 @@ private
         pk ||= @#{klass.pk_symbol}
         transaction do |tx|
           tx.exec "DELETE FROM #{klass.table} WHERE #{klass.pk_symbol}=\#{pk}"
-          if cascade and #{klass}.metadata[:descendants]
-            #{klass}.metadata[:descendants].each do |dclass, foreign_key|
+          if cascade and #{klass}.ann.this[:descendants]
+            #{klass}.ann.this.descendants.each do |dclass, foreign_key|
               tx.exec "DELETE FROM \#{dclass::OGTABLE} WHERE \#{foreign_key}=\#{pk}"
             end
           end
@@ -732,7 +731,9 @@ private
       def og_create_schema(store)
         if Og.create_schema
           #{Aspects.gen_advice_code(:og_create_schema, klass.advices, :pre) if klass.respond_to?(:advices)}
-          store.send(:create_table, #{klass})
+          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)}
         end
       end
@@ -743,7 +744,7 @@ private
   # STI parent classes it reads the class from the resultset.
 
   def eval_og_allocate(klass)  
-    if klass.metadata.subclasses
+    if klass.schema_inheritance? 
       klass.module_eval %{
         def self.og_allocate(res, row = 0)
           Object.constant(res[0]).allocate
@@ -784,14 +785,14 @@ private
         if rel = klass.relation(name)
           target_table = rel[:target_class]::OGTABLE
           tables << target_table
-#         join_conditions << "#{klass::OGTABLE}.#{rel[:foreign_key]}=#{target_table}.#{rel[:target_pk]}"
+          
           if rel.is_a?(JoinsMany)
             tables << rel[:join_table]
             owner_key, target_key = klass.ogmanager.store.join_table_keys(klass, rel[:target_class])
-            join_conditions << "#{rel[:join_table]}.#{owner_key}=#{klass::OGTABLE}.#{rel[:owner_pk]} AND \
-                                #{rel[:join_table]}.#{target_key}=#{rel[:target_class]::OGTABLE}.#{rel[:target_pk]}"
+            join_conditions << "#{rel.join_table}.#{owner_key}=#{klass::OGTABLE}.#{rel.owner_class.primary_key} AND \
+                                #{rel.join_table}.#{target_key}=#{rel.target_class::OGTABLE}.#{rel.target_class.primary_key}"
           else
-            join_conditions << "#{klass::OGTABLE}.#{rel[:foreign_key]}=#{target_table}.#{rel[:target_pk]}"
+            join_conditions << "#{klass::OGTABLE}.#{rel.foreign_key}=#{target_table}.#{rel.target_class.primary_key}"
           end
         else
           raise 'Unknown relation name'
@@ -826,7 +827,7 @@ private
       sql << " ORDER BY #{order}"
     end
 
-    resolve_limit_options(options, sql)
+    resolve_limit_options(options, sql)
 
     if extra = options[:extra]
       sql << " #{extra}"
@@ -834,20 +835,20 @@ private
     
     return sql
   end    
-
+
   # Subclasses can override this if they need some other order.
   # This is needed because different backends require different
   # order of the keywords.
-
-  def resolve_limit_options(options, sql)
-    if limit = options[:limit]
-      sql << " LIMIT #{limit}"
-
-      if offset = options[:offset]
-        sql << " OFFSET #{offset}"
-      end
-    end
-  end
+
+  def resolve_limit_options(options, sql)
+    if limit = options[:limit]
+      sql << " LIMIT #{limit}"
+
+      if offset = options[:offset]
+        sql << " OFFSET #{offset}"
+      end
+    end
+  end
 
   # :section: Deserialization methods.