og 0.20.0 → 0.21.0

data/lib/og/store/sqlite.rb

@@ -1,8 +1,8 @@
 begin
-	require 'sqlite3'
+  require 'sqlite3'
 rescue Object => ex
-	Logger.error 'Ruby-Sqlite3 bindings are not installed!'
-	Logger.error ex
+  Logger.error 'Ruby-Sqlite3 bindings are not installed!'
+  Logger.error ex
 end
 
 require 'fileutils'
@@ -13,19 +13,21 @@ require 'og/store/sql'
 # more compatible with Og.
 
 class SQLite3::ResultSet
-	alias_method :blank?, :eof?
-	
-	def each_row
-		each do |row|
-			yield(row, 0)
-		end
-	end
-	
-	def first_value
-		val = self.next[0]
-		close
-		return val
-	end	
+  alias_method :blank?, :eof?
+  
+  def each_row
+    each do |row|
+      yield(row, 0)
+    end
+  end
+  
+  def first_value
+    val = self.next[0]
+    close
+    return val
+  end  
+  
+  alias_method :fields, :columns
 end
 
 module Og
@@ -36,171 +38,171 @@ module Og
 
 class SqliteStore < SqlStore
 
-	# Override if needed.
-	
-	def self.db_filename(options)
-		"#{options[:name]}.db"
-	end
-	
-	def self.destroy(options)
-		begin
-			FileUtils.rm(db_filename(options))	
-			super
-		rescue Object
-			Logger.info "Cannot drop '#{options[:name]}'!"
-		end
-	end
-
-	def initialize(options)
-		super
-		@conn = SQLite3::Database.new(self.class.db_filename(options))
-	end
-
-	def close
-		@conn.close
-		super
-	end
-	
-	def enchant(klass, manager)
-		klass.property :oid, Fixnum, :sql => 'integer PRIMARY KEY'
-		super
-	end
-
-	def query(sql)
-		Logger.debug sql if $DBG
-		return @conn.query(sql)
-	rescue => ex
-		handle_sql_exception(ex, sql)
-	end
-
-	def exec(sql)
-		Logger.debug sql if $DBG
-		@conn.query(sql).close
-	rescue => ex
-		handle_sql_exception(ex, sql)
-	end
-
-	def start
-		@conn.transaction if @transaction_nesting < 1
-		@transaction_nesting += 1
-	end
-	
-	def commit
-		@transaction_nesting -= 1
-		@conn.commit if @transaction_nesting < 1
-	end
-	
-	def rollback
-		@transaction_nesting -= 1
-		@conn.rollback if @transaction_nesting < 1
-	end
+  # Override if needed.
+  
+  def self.db_filename(options)
+    "#{options[:name]}.db"
+  end
+  
+  def self.destroy(options)
+    begin
+      FileUtils.rm(db_filename(options))  
+      super
+    rescue Object
+      Logger.info "Cannot drop '#{options[:name]}'!"
+    end
+  end
+
+  def initialize(options)
+    super
+    @conn = SQLite3::Database.new(self.class.db_filename(options))
+  end
+
+  def close
+    @conn.close
+    super
+  end
+  
+  def enchant(klass, manager)
+    klass.property :oid, Fixnum, :sql => 'integer PRIMARY KEY'
+    super
+  end
+
+  def query(sql)
+    Logger.debug sql if $DBG
+    return @conn.query(sql)
+  rescue => ex
+    handle_sql_exception(ex, sql)
+  end
+
+  def exec(sql)
+    Logger.debug sql if $DBG
+    @conn.query(sql).close
+  rescue => ex
+    handle_sql_exception(ex, sql)
+  end
+
+  def start
+    @conn.transaction if @transaction_nesting < 1
+    @transaction_nesting += 1
+  end
+  
+  def commit
+    @transaction_nesting -= 1
+    @conn.commit if @transaction_nesting < 1
+  end
+  
+  def rollback
+    @transaction_nesting -= 1
+    @conn.rollback if @transaction_nesting < 1
+  end
 
   def last_insert_rowid
-		conn.query("SELECT last_insert_rowid()").first_value.to_i
-	end
+    conn.query("SELECT last_insert_rowid()").first_value.to_i
+  end
 
-	def sql_update(sql)
-		exec(sql)
-		@conn.changes
-	end
+  def sql_update(sql)
+    exec(sql)
+    @conn.changes
+  end
 
 private
 
-	def create_table(klass)
-		fields = fields_for_class(klass)
-
-		sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
-		
-		# Create table constrains.
-		
-		if klass.__meta and constrains = klass.__meta[:sql_constrain]
-			sql << ", #{constrains.join(', ')}"
-		end
-		
-		sql << ");"
-		
-		# Create indices.
-		
-		if klass.__meta and indices = klass.__meta[: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
-
-		begin
-			@conn.query(sql).close
-			Logger.info "Created table '#{klass::OGTABLE}'."
-		rescue Object => ex
-			# gmosx: any idea how to better test this?
-			if ex.to_s =~ /table .* already exists/i
-				Logger.debug 'Table already exists' if $DBG
-				return
-			else
-				raise
-			end
-		end
-		
-		# Create join tables if needed. Join tables are used in
-		# 'many_to_many' relations.
-		
- 		if klass.__meta and join_tables = klass.__meta[:join_tables] 
-			for join_table in join_tables
-				begin
-					@conn.query("CREATE TABLE #{join_table} (key1 integer NOT NULL, key2 integer NOT NULL)").close
-					@conn.query("CREATE INDEX #{join_table}_key1_idx ON #{join_table} (key1)").close
-					@conn.query("CREATE INDEX #{join_table}_key2_idx ON #{join_table} (key2)").close
-				rescue Object => ex
-					# gmosx: any idea how to better test this?
-					if ex.to_s =~ /table .* already exists/i
-						Logger.debug 'Join table already exists' if $DBG
-					else
-						raise
-					end
-				end
-			end
-		end
-	end
-
-	def create_field_map(klass)
-		res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
-		map = {}
-		
-		fields = res.columns
-
-		fields.size.times do |i|
-			map[fields[i].intern] = i
-		end
-	
-		return map
-	ensure
-		res.close if res
-	end
-
-	def eval_og_insert(klass)
-		pk = klass.primary_key.first
-		props = klass.properties
-		values = props.collect { |p| write_prop(p) }.join(',') 
-
-		if klass.metadata.superclass or klass.metadata.subclasses
-			props << Property.new(:ogtype, String)
-			values << ", '#{klass}'"
-		end
-		
-		sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"
-
-		klass.class_eval %{ 
-			def og_insert(store)
-				#{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-				store.query("#{sql}").close
-				@#{pk} = store.last_insert_rowid				
-				#{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
-			end
-		}
-	end
+  def create_table(klass)
+    fields = fields_for_class(klass)
+
+    sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
+    
+    # Create table constrains.
+    
+    if klass.__meta and constrains = klass.__meta[:sql_constrain]
+      sql << ", #{constrains.join(', ')}"
+    end
+    
+    sql << ");"
+    
+    # Create indices.
+    
+    if klass.__meta and indices = klass.__meta[: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
+
+    begin
+      @conn.query(sql).close
+      Logger.info "Created table '#{klass::OGTABLE}'."
+    rescue Object => ex
+      # gmosx: any idea how to better test this?
+      if ex.to_s =~ /table .* already exists/i
+        Logger.debug 'Table already exists' if $DBG
+        return
+      else
+        raise
+      end
+    end
+    
+    # Create join tables if needed. Join tables are used in
+    # 'many_to_many' relations.
+    
+     if klass.__meta and join_tables = klass.__meta[:join_tables] 
+      for info in join_tables
+        begin
+          create_join_table_sql(info).each do |sql|
+            @conn.query(sql).close
+          end
+        rescue Object => ex
+          # gmosx: any idea how to better test this?
+          if ex.to_s =~ /table .* already exists/i
+            Logger.debug 'Join table already exists' if $DBG
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  def create_field_map(klass)
+    res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
+    map = {}
+    
+    fields = res.columns
+
+    res.fields.size.times do |i|
+      map[fields[i].intern] = i
+    end
+  
+    return map
+  ensure
+    res.close if res
+  end
+
+  def eval_og_insert(klass)
+    pk = klass.primary_key.first
+    props = klass.properties
+    values = props.collect { |p| write_prop(p) }.join(',') 
+
+    if klass.metadata.superclass or klass.metadata.subclasses
+      props << Property.new(:ogtype, String)
+      values << ", '#{klass}'"
+    end
+    
+    sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"
+
+    klass.class_eval %{ 
+      def og_insert(store)
+        #{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        store.query("#{sql}").close
+        @#{pk} = store.last_insert_rowid        
+        #{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+      end
+    }
+  end
 
 end
 

data/lib/og/store/sqlserver.rb

@@ -3,10 +3,10 @@
 # DO NOT USE YET!
 
 begin
-	require 'dbi'
+  require 'dbi'
 rescue Object => ex
-	Logger.error 'Ruby-DBI bindings not present or ADO support not available.'
-	Logger.error ex
+  Logger.error 'Ruby-DBI bindings not present or ADO support not available.'
+  Logger.error ex
 end
 
 require 'og/store/sql'
@@ -15,55 +15,55 @@ require 'og/store/sql'
 # more compatible with Og.
 =begin
 class Sqlserver::Result
-	def blank?
-		0 == num_rows
-	end
+  def blank?
+    0 == num_rows
+  end
 
-	alias_method :next, :fetch_row	
+  alias_method :next, :fetch_row  
 
-	def each_row
-		each do |row|
-			yield(row, 0)
-		end
-	end
-	
-	def first_value
-		val = fetch_row[0]
-		free
-		return val
-	end
-	
-	alias_method :close, :free
+  def each_row
+    each do |row|
+      yield(row, 0)
+    end
+  end
+  
+  def first_value
+    val = fetch_row[0]
+    free
+    return val
+  end
+  
+  alias_method :close, :free
 end
 =end
 
 module Og
 
 module SqlserverUtils
-	include SqlUtils
-	
-	def escape(str)
-		return nil unless str
-		return Sqlserver.quote(str)
-	end
-	
-	def quote(val)
-		case val
-			when Fixnum, Integer, Float
-				val ? val.to_s : 'NULL'
-			when String
-				val ? "'#{escape(val)}'" : 'NULL'
-			when Time
-				val ? "'#{timestamp(val)}'" : 'NULL'
-			when Date
-				val ? "'#{date(val)}'" : 'NULL'
-			when TrueClass
-				val ? "'1'" : 'NULL'
-			else 
-				# gmosx: keep the '' for nil symbols.
-				val ? escape(val.to_yaml) : ''
-		end 
-	end	
+  include SqlUtils
+  
+  def escape(str)
+    return nil unless str
+    return Sqlserver.quote(str)
+  end
+  
+  def quote(val)
+    case val
+      when Fixnum, Integer, Float
+        val ? val.to_s : 'NULL'
+      when String
+        val ? "'#{escape(val)}'" : 'NULL'
+      when Time
+        val ? "'#{timestamp(val)}'" : 'NULL'
+      when Date
+        val ? "'#{date(val)}'" : 'NULL'
+      when TrueClass
+        val ? "'1'" : 'NULL'
+      else 
+        # gmosx: keep the '' for nil symbols.
+        val ? escape(val.to_yaml) : ''
+    end 
+  end  
 end
 
 # A Store that persists objects into a Sqlserver database.
@@ -71,195 +71,185 @@ end
 # for SqlStore and Store.
 
 class SqlserverStore < SqlStore
-	extend SqlserverUtils
-	include SqlserverUtils
+  extend SqlserverUtils
+  include SqlserverUtils
 
-	def self.create(options)
-		raise 'Not implemented'
-	end
+  def self.create(options)
+    raise 'Not implemented'
+  end
 
-	def self.destroy(options)
-		raise 'Not implemented'
-	end
+  def self.destroy(options)
+    raise 'Not implemented'
+  end
 
-	def initialize(options)
-		super
+  def initialize(options)
+    super
 
-		begin
-			@conn = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=#{options[:address]};Initial Catalog=#{options[:name]};User Id=#{options[:user]};Password=#{options[:password]};")
-		rescue => ex
-			# gmosx, FIXME: drak, fix this!
-			if ex.to_s =~ /database .* does not exist/i
-				Logger.info "Database '#{options[:name]}' not found!"
-				self.class.create(options)
-				retry
-			end
-			raise
-		end
-	end
+    begin
+      @conn = DBI.connect("DBI:ADO:Provider=SQLOLEDB;Data Source=#{options[:address]};Initial Catalog=#{options[:name]};User Id=#{options[:user]};Password=#{options[:password]};")
+    rescue => ex
+      # gmosx, FIXME: drak, fix this!
+      if ex.to_s =~ /database .* does not exist/i
+        Logger.info "Database '#{options[:name]}' not found!"
+        self.class.create(options)
+        retry
+      end
+      raise
+    end
+  end
 
-	def close
-		@conn.disconnect
-		super
-	end
+  def close
+    @conn.disconnect
+    super
+  end
 
-	def enchant(klass, manager)
-		klass.property :oid, Fixnum, :sql => 'integer AUTO_INCREMENT PRIMARY KEY'
-		super
-	end
-	
-	def query(sql)
-#		Logger.debug sql if $DBG
-		return @conn.select_all(sql)
-	rescue => ex
-		handle_sql_exception(ex, sql)
-	end
+  def enchant(klass, manager)
+    klass.property :oid, Fixnum, :sql => 'integer AUTO_INCREMENT PRIMARY KEY'
+    super
+  end
+  
+  def query(sql)
+#    Logger.debug sql if $DBG
+    return @conn.select_all(sql)
+  rescue => ex
+    handle_sql_exception(ex, sql)
+  end
 
-	def exec(sql)
-#		Logger.debug sql if $DBG
-		@conn.execute(sql).finish 
-	rescue => ex
-		handle_sql_exception(ex, sql)
-	end
+  def exec(sql)
+#    Logger.debug sql if $DBG
+    @conn.execute(sql).finish 
+  rescue => ex
+    handle_sql_exception(ex, sql)
+  end
 
 private
 
-	def create_table(klass)
-		fields = fields_for_class(klass)
+  def create_table(klass)
+    fields = fields_for_class(klass)
 
-		sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
-		
-		# Create table constrains.
-		
-		if klass.__meta and constrains = klass.__meta[:sql_constrain]
-			sql << ", #{constrains.join(', ')}"
-		end
-		
-		sql << ");"
-		
-		# Create indices.
-		
-		if klass.__meta and indices = klass.__meta[: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.query_with_result = false
+    sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
+    
+    # Create table constrains.
+    
+    if klass.__meta and constrains = klass.__meta[:sql_constrain]
+      sql << ", #{constrains.join(', ')}"
+    end
+    
+    sql << ");"
+    
+    # Create indices.
+    
+    if klass.__meta and indices = klass.__meta[: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.query_with_result = false
 
-		begin
-			conn.query(sql)
-			Logger.info "Created table '#{klass::OGTABLE}'."
-		rescue => ex
-			# gmosx: any idea how to better test this?
-			if ex.errno == 1050 # table already exists.
-				Logger.debug 'Table already exists' if $DBG
-				return
-			else
-				raise
-			end
-		end
-=begin
-		# Create join tables if needed. Join tables are used in
-		# 'many_to_many' relations.
-		
-		if klass.__meta and joins = klass.__meta[:sql_join] 
-			for data in joins
-				# the class to join to and some options.
-				join_name, join_class, options = *data
-				
-				join_table = "#{self.class.join_table(klass, join_class, join_name)}"
-				join_src = "#{self.class.encode(klass)}_oid"
-				join_dst = "#{self.class.encode(join_class)}_oid"
+    begin
+      conn.query(sql)
+      Logger.info "Created table '#{klass::OGTABLE}'."
+    rescue => ex
+      # gmosx: any idea how to better test this?
+      if ex.errno == 1050 # table already exists.
+        Logger.debug 'Table already exists' if $DBG
+        return
+      else
+        raise
+      end
+    end
 
-				begin
-					conn.exec("CREATE TABLE #{join_table} ( key1 integer NOT NULL, key2 integer NOT NULL )").clear
-					conn.exec("CREATE INDEX #{join_table}_key1_idx ON #{join_table} (key1)").clear
-					conn.exec("CREATE INDEX #{join_table}_key2_idx ON #{join_table} (key2)").clear
-				rescue => ex
-					# gmosx: any idea how to better test this?
-					if ex.errno == 1050 # table already exists.
-						Logger.debug 'Join table already exists'
-					else
-						raise
-					end
-				end
-			end
-		end
-=end
-	end
+    # Create join tables if needed. Join tables are used in
+    # 'many_to_many' relations.
+    
+    if klass.__meta and join_tables = klass.__meta[:join_tables] 
+      for join_table in join_tables
+        begin
+          conn.query(create_join_table_sql(join_table))
+        rescue => ex
+          # gmosx: any idea how to better test this?
+          if ex.errno == 1050 # table already exists.
+            Logger.debug 'Join table already exists'
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
 
-	def create_field_map(klass)
-		conn.query_with_result = true
-		res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
-		map = {}
+  def create_field_map(klass)
+    conn.query_with_result = true
+    res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
+    map = {}
 
-		res.num_fields.times do |i|
-			map[res.fetch_field.name.intern] = i
-		end
+    res.num_fields.times do |i|
+      map[res.fetch_field.name.intern] = i
+    end
 
-		return map
-	ensure
-		res.close if res
-	end
+    return map
+  ensure
+    res.close if res
+  end
 
-	def write_prop(p)
-		if p.klass.ancestors.include?(Integer)
-			return "#\{@#{p.symbol} || 'NULL'\}"
-		elsif p.klass.ancestors.include?(Float)
-			return "#\{@#{p.symbol} || 'NULL'\}"		
-		elsif p.klass.ancestors.include?(String)
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
-		elsif p.klass.ancestors.include?(Time)
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
-		elsif p.klass.ancestors.include?(Date)
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
-		elsif p.klass.ancestors.include?(TrueClass)
-			return "#\{@#{p.symbol} ? \"'1'\" : 'NULL' \}"
-		else 
-			# gmosx: keep the '' for nil symbols.
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
-		end
-	end		
-	
-	def read_prop(p, col)
-		if p.klass.ancestors.include?(Integer)
-			return "res[#{col} + offset].to_i"
-		elsif p.klass.ancestors.include?(Float)
-			return "res[#{col} + offset].to_f"
-		elsif p.klass.ancestors.include?(String)
-			return "res[#{col} + offset]"
-		elsif p.klass.ancestors.include?(Time)
-			return "#{self.class}.parse_timestamp(res[#{col} + offset])"
-		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])"
-		else 
-			return "YAML.load(res[#{col} + offset])"
-		end				
-	end
+  def write_prop(p)
+    if p.klass.ancestors.include?(Integer)
+      return "#\{@#{p.symbol} || 'NULL'\}"
+    elsif p.klass.ancestors.include?(Float)
+      return "#\{@#{p.symbol} || 'NULL'\}"    
+    elsif p.klass.ancestors.include?(String)
+      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
+    elsif p.klass.ancestors.include?(Time)
+      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+    elsif p.klass.ancestors.include?(Date)
+      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
+    elsif p.klass.ancestors.include?(TrueClass)
+      return "#\{@#{p.symbol} ? \"'1'\" : 'NULL' \}"
+    else 
+      # gmosx: keep the '' for nil symbols.
+      return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
+    end
+  end    
+  
+  def read_prop(p, col)
+    if p.klass.ancestors.include?(Integer)
+      return "res[#{col} + offset].to_i"
+    elsif p.klass.ancestors.include?(Float)
+      return "res[#{col} + offset].to_f"
+    elsif p.klass.ancestors.include?(String)
+      return "res[#{col} + offset]"
+    elsif p.klass.ancestors.include?(Time)
+      return "#{self.class}.parse_timestamp(res[#{col} + offset])"
+    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])"
+    else 
+      return "YAML.load(res[#{col} + offset])"
+    end        
+  end
 
-	def eval_og_insert(klass)
-		props = klass.properties
-		values = props.collect { |p| write_prop(p) }.join(',') 
-		
-		sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"
+  def eval_og_insert(klass)
+    props = klass.properties
+    values = props.collect { |p| write_prop(p) }.join(',') 
+    
+    sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"
 
-		klass.class_eval %{
-			def og_insert(store)
-				#{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
-				#{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
-			end
-		}
-	end
+    klass.class_eval %{
+      def og_insert(store)
+        #{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
+        #{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+      end
+    }
+  end
 
 end