og 0.8.0 → 0.9.3

data/lib/og/backends/psql.rb

@@ -1,8 +1,6 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: psql.rb 194 2004-12-20 20:23:57Z gmosx $
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: psql.rb 248 2005-01-31 13:38:34Z gmosx $
 
 require 'postgres'
 
@@ -10,16 +8,14 @@ require 'og/backend'
 
 class Og
 
-# = PsqlBackend
-#
 # Implements a PostgreSQL powered backend.
 # This backend is compatible with Michael Neumann's postgres-pr
 # pure ruby driver.
-#
+
 class PsqlBackend < Og::Backend
 
 	# A mapping between Ruby and SQL types.
-	#
+	
 	TYPEMAP = {
 		Integer => 'integer',
 		Fixnum => 'integer',
@@ -34,7 +30,7 @@ class PsqlBackend < Og::Backend
 	}
 	
 	# Intitialize the connection to the RDBMS.
-	# 		
+	 		
 	def initialize(config)
 		begin
 			@conn = PGconn.connect(nil, nil, nil, nil, config[:database], 
@@ -55,7 +51,7 @@ class PsqlBackend < Og::Backend
 	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Escape an SQL string
-	#
+	
 	def self.escape(str)
 		return nil unless str
 		return PGconn.escape(str)
@@ -63,7 +59,7 @@ class PsqlBackend < Og::Backend
 
 	# Convert a ruby time to an sql timestamp.
 	# TODO: Optimize this
-	# 
+	 
 	def self.timestamp(time = Time.now)
 		return nil unless time
 		return time.strftime("%Y-%m-%d %H:%M:%S")
@@ -71,7 +67,7 @@ class PsqlBackend < Og::Backend
 	
 	# Output YYY-mm-dd
 	# TODO: Optimize this
-	#
+	
 	def self.date(date)
 		return nil unless date
 		return "#{date.year}-#{date.month}-#{date.mday}" 
@@ -79,14 +75,14 @@ class PsqlBackend < Og::Backend
 	
 	# Parse sql datetime
 	# TODO: Optimize this
-	#
+	
 	def self.parse_timestamp(str)
 		return Time.parse(str)		
 	end
 	
 	# Input YYYY-mm-dd
 	# TODO: Optimize this
-	#
+	
 	def self.parse_date(str)
 		return nil unless str
 		return Date.strptime(str)
@@ -98,7 +94,7 @@ class PsqlBackend < Og::Backend
 	# portable.
 	#
 	# FIXME: add extra handling for float.
-	#
+	
 	def self.write_prop(p)
 		if p.klass.ancestors.include?(Integer)
 			return "#\{@#{p.symbol} || 'NULL'\}"
@@ -111,7 +107,7 @@ class PsqlBackend < Og::Backend
 		elsif p.klass.ancestors.include?(Date)
 			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.date(@#{p.symbol})\}'" : 'NULL'\}|
 		elsif p.klass.ancestors.include?(TrueClass)
-			return "#\{@#{p.symbol} || 'NULL'\}"
+			return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
 		else 
 			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
 		end
@@ -119,7 +115,7 @@ class PsqlBackend < Og::Backend
 
 	# Return an evaluator for reading the property.
 	# No need to optimize this, used only to precalculate code.
-	#
+	
 	def self.read_prop(p, idx)
 		if p.klass.ancestors.include?(Integer)
 			return "res.getvalue(tuple, #{idx}).to_i()"
@@ -132,7 +128,7 @@ class PsqlBackend < Og::Backend
 		elsif p.klass.ancestors.include?(Date)
 			return "Og::PsqlBackend.parse_date(res.getvalue(tuple, #{idx}))"
 		elsif p.klass.ancestors.include?(TrueClass)
-			return "('true' == res.getvalue(tuple, #{idx}))"
+			return %|('t' == res.getvalue(tuple, #{idx}))|
 		else 
 			return "YAML::load(res.getvalue(tuple, #{idx}))"
 		end		
@@ -140,7 +136,7 @@ class PsqlBackend < Og::Backend
 
 	# Returns the code that actually inserts the object into the
 	# database. Returns the code as String.
-	#
+	
 	def self.insert_code(klass, sql, pre_cb, post_cb)
 		%{
 			#{pre_cb}
@@ -153,7 +149,7 @@ class PsqlBackend < Og::Backend
 
 	# generate the mapping of the database fields to the
 	# object properties.
-	#
+	
 	def self.calc_field_index(klass, og)
 		res = og.query "SELECT * FROM #{klass::DBTABLE} LIMIT 1"
 		meta = og.managed_classes[klass]
@@ -164,7 +160,7 @@ class PsqlBackend < Og::Backend
 	end
 	
 	# Generate the property for oid
-	#
+	
 	def self.eval_og_oid(klass)
 		klass.class_eval %{
 			prop_accessor :oid, Fixnum, :sql => "integer PRIMARY KEY"
@@ -176,28 +172,28 @@ class PsqlBackend < Og::Backend
 	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Create the database.
-	#
+	
 	def self.create_db(database, user = nil, password = nil)
 		Logger.info "Creating database '#{database}'."
 		`createdb #{database} -U #{user}`
 	end
 	
 	# Drop the database.
-	#
+	
 	def self.drop_db(database, user = nil, password = nil)
 		Logger.info "Dropping database '#{database}'."
 		`dropdb #{database} -U #{user}`
 	end
 	
-	# Execute an SQL query and return the result 
-	#
+	# Execute an SQL query and return the result.
+	
 	def query(sql)
 		Logger.debug sql if $DBG
 		return @conn.exec(sql)
 	end
 	
 	# Execute an SQL query, no result returned.
-	#
+	
 	def exec(sql)
 		Logger.debug sql if $DBG
 		res = @conn.exec(sql)
@@ -206,7 +202,7 @@ class PsqlBackend < Og::Backend
 
 	# Execute an SQL query and return the result. Wrapped in a rescue
 	# block.
-	#
+	
 	def safe_query(sql)
 		Logger.debug sql if $DBG
 		begin
@@ -220,7 +216,7 @@ class PsqlBackend < Og::Backend
 
 	# Execute an SQL query, no result returned. Wrapped in a rescue 
 	# block.
-	#
+	
 	def safe_exec(sql)
 		Logger.debug sql if $DBG
 		begin
@@ -233,7 +229,7 @@ class PsqlBackend < Og::Backend
 	end
 
 	# Check if it is a valid resultset.
-	#
+	
 	def valid?(res)
 		return !(res.nil? or 0 == res.num_tuples)
 	end
@@ -241,7 +237,7 @@ class PsqlBackend < Og::Backend
 	# Create the managed object table. The properties of the
 	# object are mapped to the table columns. Additional sql relations
 	# and constrains are created (indicices, sequences, etc).
-	#
+	
 	def create_table(klass)
 		fields = create_fields(klass, TYPEMAP)
 
@@ -282,6 +278,7 @@ class PsqlBackend < Og::Backend
 		# create the sequence for this table. Even if the table
 		# uses the oids_seq, attempt to create it. This makes
 		# the system more fault tolerant.
+
 		begin
 			exec "CREATE SEQUENCE #{klass::DBSEQ}"
 			Logger.info "Created sequence '#{klass::DBSEQ}'."	
@@ -336,15 +333,15 @@ class PsqlBackend < Og::Backend
 		
 	end
 	
-	# Drop the managed object table
-	#
+	# Drop the managed object table.
+	
 	def drop_table(klass)
 		super
 		exec "DROP SEQUENCE #{klass::DBSEQ}"		
 	end
 
 	# Deserialize one row of the resultset.
-	#
+	
 	def deserialize_one(res, klass)	
 		return nil unless valid?(res)
 		
@@ -359,9 +356,9 @@ class PsqlBackend < Og::Backend
 	end
 	
 	# Deserialize all rows of the resultset.
-	#
+	
 	def deserialize_all(res, klass)	
-		return nil unless valid?(res)
+		return [] unless valid?(res)
 
 		entities = []
 	
@@ -379,11 +376,11 @@ class PsqlBackend < Og::Backend
 	end
 
 	# Return a single integer value from the resultset.
-	#
+	
 	def get_int(res, idx = 0)	
 		return res.getvalue(0, idx).to_i
 	end
 
 end
 
-end # module
+end 

data/lib/og/connection.rb

@@ -1,17 +1,15 @@
-# code: 
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: connection.rb 167 2004-11-23 14:03:10Z gmosx $
+#-- 
+# George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: connection.rb 248 2005-01-31 13:38:34Z gmosx $
+#++
 
 class Og; 
 
-require "glue/property"
-require "glue/array"
-require "glue/time"
+require 'glue/property'
+require 'glue/array'
+require 'glue/time'
 
-# = Connection
-#
 # A Connection to the Database. This file defines the skeleton 
 # functionality. A backend specific implementation file (driver) 
 # implements all methods.
@@ -20,20 +18,23 @@ require "glue/time"
 #
 # - support caching.
 # - support prepared statements.
-#
+
 class Connection
 	# The frontend (Og) contains useful strucutres.
+	
 	attr_reader :og
 	
 	# The backend
+	
 	attr_reader :db
 
 	# If set to true, the select methods deserialize the 
 	# resultset to create entities.
+
 	attr_accessor :deserialize 
 		
 	# Initialize a connection to the database
-	#
+	
 	def initialize(og)
 		@og = og
 		@db = @og.config[:backend].new(@og.config)
@@ -189,9 +190,8 @@ class Connection
 		# TODO: implement this as stored procedure? naaah.
 		transaction do |tx|
 			tx.exec "DELETE FROM #{klass::DBTABLE} WHERE oid=#{oid}"
-			
-			if cascade and klass.respond_to?(:og_descendants)
-				klass.og_descendants.each do |dclass, linkback|
+			if cascade and klass.__meta.include?(:has)
+				klass.__meta[:has].each do |dclass, linkback|
 					tx.exec "DELETE FROM #{dclass::DBTABLE} WHERE #{linkback}=#{oid}"
 				end
 			end

data/lib/og/enchant.rb

@@ -1,20 +1,18 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
+# (c) 2004-2005 Navel, all rights reserved.
 # $Id: meta.rb 198 2004-12-22 11:26:59Z gmosx $
 
 class Og
 
 module Enchant
 
-	# Enchant a managed class. Add useful DB related methods to the 
-	# class and its instances. 
-	#
+	# Enchant a managed class. Add useful DB related methods 
+	# to the class and its instances. 
+	
 	def enchant(klass)
 		klass.module_eval <<-"end_eval", __FILE__, __LINE__
-			def self.create(*params)
-				obj = #{klass}.new(*params)
+			def self.create(*params, &block)
+				obj = #{klass}.new(*params, &block)
 				obj.save!
 			end
 				
@@ -26,6 +24,10 @@ module Enchant
 				Og.db.load(oid_or_name, #{klass})
 			end
 
+			def self.get(oid_or_name)
+				Og.db.load(oid_or_name, #{klass})
+			end
+			
 			def self.[](oid_or_name)
 				Og.db.load(oid_or_name, #{klass})
 			end
@@ -57,6 +59,11 @@ module Enchant
 			def self.delete(obj_or_oid)
 				Og.db.delete(obj_or_oid, #{klass})
 			end
+
+			def each(&block)
+				all.each(&block)
+			end
+			include Enumerable
 			
 			def save
 				Og.db << self
@@ -77,4 +84,4 @@ module Enchant
 
 end
 	
-end # namespace
+end

data/lib/og/meta.rb

@@ -1,8 +1,6 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: meta.rb 198 2004-12-22 11:26:59Z gmosx $
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: meta.rb 248 2005-01-31 13:38:34Z gmosx $
 
 require 'og/backend'
 require 'glue/inflector'
@@ -12,18 +10,42 @@ class Og
 # = MetaUtils
 #
 # Some useful meta-language utilities.
-#
+
 module MetaUtils # :nodoc: all
 
-	# Conver the klass to a string representation
+	# Convert the klass to a string representation
 	# The leading module if available is removed.
 	#--
 	# gmosx, FIXME: unify with the ogutils.encode method?
 	#++
+	
 	def self.expand(klass)
 		return klass.name.gsub(/^.*::/, '').gsub(/::/, '_').downcase
 	end
 
+	# Infer the target klass for a relation. When defining
+	# relations, tha target class is typically given. Some times
+	# in order to avoid forward declarations a symbol is given instead
+	# of a class. Other times on class is given at all, and 
+	# the inflection mechanism is used to infer the class name.
+
+	def self.resolve_class(name, klass)
+		klass ||= N::Inflector.camelize(name)
+		
+		return klass if klass.is_a?(Class)
+		
+		unless klass.is_a?(String) or klass.is_a?(Symbol)
+			raise 'Invalid class definition' 
+		end
+	
+		unless Object.const_get(klass.intern)
+			# Forward declaration.
+			Object.class_eval("class #{klass}; end")
+		end
+
+		return Object.const_get(klass)
+	end
+
 end
 
 # = MetaLanguage
@@ -33,11 +55,12 @@ end
 # from the excellent ActiveRecord library.
 #
 # Many more useful relations will be available soon.
-#
+
 module MetaLanguage
 
-	# Defines an SQL index.
-	#
+	# Defines an SQL index. Useful for defining indiced
+	# over multiple columns.
+	
 	def sql_index(index, options = {})
 		meta :sql_index, [index, options]
 	end
@@ -56,12 +79,14 @@ module MetaLanguage
 	# prop_accessor Fixnum, :parent_oid
 	# def parent; ... end
 	# def parent=(obj_or_oid); ... end
-	#
+	
 	def belongs_to(name, klass, options = {})
 		prop_eval = "prop_accessor Fixnum, :#{name}_oid"
 		prop_eval << ", :sql => '#{options[:sql]}'" if options[:sql]
 		prop_eval << ", :extra_sql => '#{options[:extra_sql]}'" if options[:extra_sql]
 
+		meta :belongs_to, klass
+		
 		module_eval %{
 			#{prop_eval}
 			
@@ -81,31 +106,31 @@ module MetaLanguage
 	# Example:
 	#
 	# class MyObject
-	#		has_one AnotherObject
+	#		has_one :child, TheClass
+	#		has_one :article
 	# end
 	#
 	# creates the code:
 	#
 	# ...
-	#
-	def has_one(name, klass, options = {})
+	
+	def has_one(name, klass = nil, options = {})
+
 		# linkback is the property of the child object that 'links back' 
 		# to this object. 
+
 		linkback = options[:linkback] || "#{MetaUtils.expand(self)}_oid"
 		
+		meta :has, [klass, linkback]
+		
 		module_eval %{
-			@@og_descendants ||= {}
-			@@og_descendants[#{klass}] = :#{linkback} 
-	
-			unless defined?(og_descendants)
-				def self.og_descendants
-					@@og_descendants
-				end
-			end
-			
 			def #{name}(extrasql = nil)
-				Og.db.select_one("SELECT * FROM #{Og::Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
+				Og.db.select_one("SELECT * FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
 			end
+
+			def delete_#{name}(extrasql = nil)
+				Og.db.exec("DELETE FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}") 
+			end			
 		}
 	end	
 	
@@ -121,36 +146,37 @@ module MetaLanguage
 	# creates the code:
 	#
 	# def children; ... end
-	#
+	
 	def has_many(name, klass, options = {})
 		name_s = N::Inflector.singularize(name.to_s)
 		
 		# linkback is the property of the child object that 'links back' 
 		# to this object. 
+
 		linkback = options[:linkback] || "#{MetaUtils.expand(self)}_oid"
 		
+		# keep belongs to metadata, useful for 
+		# reflection/scaffolding.
+
+		meta :has, [klass, linkback]
+
 		module_eval %{
-			@@og_descendants ||= {}
-			@@og_descendants[#{klass}] = :#{linkback} 
-	
-			unless defined?(og_descendants)
-				def self.og_descendants
-					@@og_descendants
-				end
-			end
-			
 			def #{name}(extrasql = nil)
-				Og.db.select("SELECT * FROM #{Og::Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
+				Og.db.select("SELECT * FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}", #{klass})
 			end
 
 			def #{name}_count(extrasql = nil)
-				Og.db.count("SELECT COUNT(*) FROM #{Og::Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}")
+				Og.db.count("SELECT COUNT(*) FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}")
 			end			
 
 			def add_#{name_s}(obj, extra = nil)
 				obj.#{linkback} = @oid
 				obj.save!
 			end
+			
+			def delete_all_#{name}(extrasql = nil)
+				Og.db.exec("DELETE FROM #{Backend.table(klass)} WHERE #{linkback}=\#\@oid \#\{extrasql\}") 
+			end			
 		}
 	end
 	
@@ -173,10 +199,10 @@ module MetaLanguage
 	#
 	# category.articles
 	# ...
-	#
 	#--
 	# FIXME: make more compatible with other enchant methods.
 	#++
+	
 	def many_to_many(name, klass, options = {})
 		list_o = name.to_s
 		prop_o = N::Inflector.singularize(list_o)
@@ -185,36 +211,38 @@ module MetaLanguage
 	
 		# exit if the class is allready indirectly 'enchanted' from the
 		# other class of the many_to_many relation.
+
 		return if self.respond_to?(prop_m)
 	
 		# Add some metadata to the class to allow for automatic join table
 		# calculation.
+
 		meta :sql_join, [klass, options]
 
-		# gmosx, FIXME: should I update descendants here ?
+		meta :many_to_many, klass
+		klass.meta :many_to_many, self 
 
 		# enchant this class
 		
 		module_eval %{
 			def #{list_o}(extrasql = nil)
-				Og.db.select("SELECT d.* FROM #{Og::Backend.table(klass)} AS d, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
+				Og.db.select("SELECT d.* FROM #{Backend.table(klass)} AS d, #{Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
 			end
 
 			def #{list_o}_count(extrasql = nil)
-				Og.db.select("SELECT COUNT(*) FROM #{Og::Backend.table(klass)} AS d, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
+				Og.db.select("SELECT COUNT(*) FROM #{Backend.table(klass)} AS d, #{Backend.join_table(self, klass)} AS j WHERE j.key1=\#\@oid AND j.key2=d.oid \#\{extrasql\}", #{klass})
 			end						
 			
 			def add_#{prop_o}(obj, extra = nil)
-				Og.db.exec("INSERT INTO #{Og::Backend.join_table(self, klass)} (key1, key2) VALUES (\#\@oid, \#\{obj.oid\})") 
+				Og.db.exec("INSERT INTO #{Backend.join_table(self, klass)} (key1, key2) VALUES (\#\@oid, \#\{obj.oid\})") 
 			end
 			
-			def del_#{prop_o}(obj_or_oid, extra = nil)
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key2=\#\{obj_or_oid.to_i\}") 
+			def delete_#{prop_o}(obj_or_oid, extra = nil)
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key2=\#\{obj_or_oid.to_i\}") 
 			end
-			alias_method :delete_#{prop_o}, :del_#{prop_o}
 
 			def clear_#{list_o}
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key1=\#\@oid") 
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key1=\#\@oid") 
 			end			
 		}
 		
@@ -222,40 +250,85 @@ module MetaLanguage
 		
 		klass.module_eval %{
 			def #{list_m}(extrasql = nil)
-				Og.db.select("SELECT s.* FROM #{Og::Backend.table(self)} AS s, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
+				Og.db.select("SELECT s.* FROM #{Backend.table(self)} AS s, #{Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
 			end
 
 			def #{list_m}_count(extrasql = nil)
-				Og.db.select("SELECT COUNT(*) FROM #{Og::Backend.table(self)} AS s, #{Og::Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
+				Og.db.select("SELECT COUNT(*) FROM #{Backend.table(self)} AS s, #{Backend.join_table(self, klass)} AS j WHERE j.key2=\#\@oid AND j.key1=s.oid \#\{extrasql\}", #{self})
 			end
 			
 			def add_#{prop_m}(obj, extra = nil)
-				Og.db.exec("INSERT INTO #{Og::Backend.join_table(self, klass)} (key1, key2) VALUES (\#\{obj.oid\}, \#\@oid)") 
+				Og.db.exec("INSERT INTO #{Backend.join_table(self, klass)} (key1, key2) VALUES (\#\{obj.oid\}, \#\@oid)") 
 			end
 			
-			def del_#{prop_m}(obj_or_oid, extra = nil)
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key1=\#\{obj_or_oid.to_i\}") 
+			def delete_#{prop_m}(obj_or_oid, extra = nil)
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key1=\#\{obj_or_oid.to_i\}") 
 			end
-			alias_method :delete_#{prop_m}, :del_#{prop_m}						
 
 			def clear_#{list_m}
-				Og.db.exec("DELETE FROM #{Og::Backend.join_table(self, klass)} WHERE key2=\#\@oid") 
+				Og.db.exec("DELETE FROM #{Backend.join_table(self, klass)} WHERE key2=\#\@oid") 
 			end			
 		}
 	end
 	alias :has_and_belongs_to_many :many_to_many 
 
+	# Implements a 'refers_to' relation.
+	# This is a one-way version of the 'has_one'/'belongs_to' 
+	# relations. The target object cannot link back to the source
+	# object.
+	# This is in fact EXACTLY the same as belongs_to with a 
+	# different name (!!!!)
+	#
+	# Automatically enchants the calling class with helper methods.
+	# 
+	# 
+	# Example:
+	#
+	# class MyObject
+	#		refers_to article, Article
+	# end
+	#
+	# creates the code:
+	#
+	# prop_accessor Fixnum, :article_oid
+	# def article; ... end
+	# def article=(obj_or_oid); ... end
+
+	def refers_to(name, klass, options = {})
+		prop_eval = "prop_accessor Fixnum, :#{name}_oid"
+		prop_eval << ", :sql => '#{options[:sql]}'" if options[:sql]
+		prop_eval << ", :extra_sql => '#{options[:extra_sql]}'" if options[:extra_sql]
+
+		meta :refers_to, klass
+		klass.meta :has, [self, "#{name}_oid"]
+		
+		module_eval %{
+			#{prop_eval}
+			
+			def #{name}
+				Og.db.load_by_oid(@#{name}_oid, #{klass})
+			end
+			
+			def #{name}=(obj_or_oid)
+				@#{name}_oid = obj_or_oid.to_i
+			end
+		}
+	end
+
 end
 
-end # namespace
+end
 
 # Include the meta-language extensions into Module. If the flag is
 # false the developer is responsible for including the MetaLanguage
 # module where needed.
-#
+# 
+# By default this is FALSE, to avoid polution of the Module object.
+# However if you include a prop_accessor or a managed Mixin in your
+# object MetaLanguage gets automatically extended in the class.
+
 if Og.include_meta_language
 	class Module # :nodoc: all
 		include Og::MetaLanguage
 	end
 end
-