og 0.18.1 → 0.19.0

data/lib/og/mixin/optimistic_locking.rb

@@ -0,0 +1,59 @@
+require 'facet/macro'
+
+module Og
+
+# This error is thrown when you the object you are trynig
+# to update is allready updated by another thread.
+
+class StaleObjectError < StandardError
+end
+
+# Include this module into entity classes to provide optimistic
+# locking suport. For more information on optimistic locking
+# please consult:
+#
+# http://c2.com/cgi/wiki?OptimisticLocking
+# http://en.wikipedia.org/wiki/Optimistic_concurrency_control
+
+module Locking
+	property :lock_version, Fixnum, :default => 0
+	pre "@lock_version = 0", :on => :og_insert
+
+	def self.append_features(base) #:nodoc:
+		PropertyUtils.copy_features(self, base)
+
+		super
+
+		base.module_eval do
+			def self.enchant
+				self.send :alias_method, :update_without_lock, :update
+				self.send :alias_method, :update, :update_with_lock
+				self.send :alias_method, :save_without_lock, :save
+				self.send :alias_method, :save, :save_with_lock
+			end
+		end
+	end
+	
+	def update_with_lock
+		lock = @lock_version
+		@lock_version += 1
+
+		unless update_without_lock(:condition => "lock_version=#{lock}") == 1	
+			raise(StaleObjectError, 'Attempted to update a stale object')
+		end
+	end
+
+	def save_with_lock
+		lock = @lock_version
+		@lock_version += 1
+
+		unless save_without_lock(:condition => "lock_version=#{lock}") == 1	
+			raise(StaleObjectError, 'Attempted to update a stale object')
+		end
+	end
+	
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/og/relation.rb

@@ -11,6 +11,8 @@ class Relation
 
 	attr_accessor :options
 	
+	attr_accessor :is_polymorphic
+	
 	# A generalized initialize method for all relations.
 	# Contains common setup code.
 	
@@ -24,6 +26,27 @@ class Relation
 
 		@options[:target_class] = args.pop
 
+		if target_class == Object
+			# If the target class is just an Object mark that class
+			# as a polymorphic parent class.
+			# This class acts as template
+			# to generate customized versions of this class.
+
+			owner_class.meta(:polymorphic, owner_class)
+		elsif target_class.respond_to?(:metadata) and target_class.metadata.polymorphic
+			# If the target class is polymorphic, create a specialized
+			# version of the class enclosed in the owner namespace.
+			
+			target_dm = target_class.to_s.demodulize
+			owner_class.module_eval %{
+				class #{owner_class}::#{target_dm} < #{target_class}
+				end
+			}
+			eval %{
+				@options[:target_class] = #{owner_class}::#{target_dm}
+			}
+		end
+		
 		target_name = if collection
 			:target_plural_name
 		else 
@@ -53,9 +76,21 @@ class Relation
 		@options[key] = val
 	end
 
+	# Is the relation polymorphic?
+	
+	def polymorphic?
+		target_class == Object	
+	end
+
+	#--
+	# gmosx, TODO: remove, this is not really needed.
+	#++
+	
 	def resolve_options
 		@options[:owner_pk], @options[:owner_pkclass] = owner_class.primary_key
-		@options[:target_pk], @options[:target_pkclass] = target_class.primary_key
+		if target_class.respond_to?(:primary_key)
+			@options[:target_pk], @options[:target_pkclass] = target_class.primary_key
+		end
 	end
 
 	# To avoid forward declarations, references to undefined 
@@ -81,6 +116,14 @@ class Relation
 			@options[:target_class] = klass
 		end				
 	end
+
+	# Resolve a polymorphic target class.
+	# Overrided in subclasses.
+		
+	def resolve_polymorphic
+	end
+	
+	# This method is implemented in subclasses.
 	
 	def enchant 
 	end
@@ -93,12 +136,18 @@ class Relation
 
 	class << self
 
+		def resolve(klass, action)
+			if klass.__meta[:relations]
+				for relation in klass.__meta[:relations]
+					relation.send(action)
+				end
+			end		
+		end
+		
 		def enchant(klass)
 			if klass.__meta[:relations]
 				for relation in klass.__meta[:relations]
-					relation.resolve_target
-					relation.resolve_options
-					relation.enchant
+					relation.enchant unless relation.target_class == Object
 				end
 			end
 		end

data/lib/og/relation/has_many.rb

@@ -19,6 +19,22 @@ end
 # article.comments.size
 
 class HasMany < Relation
+=begin
+	def initialize(args, options = {})
+		super
+
+		# TODO: clean this up.
+		
+		unless target_class.relations.find { |r| r.is_a?(BelongsTo) and	r.target_class == owner_class }
+			target_class.belongs_to(owner_class)			
+		end
+	end
+=end
+	def resolve_polymorphic
+		unless target_class.relations.find { |r| r.is_a?(BelongsTo) and	r.target_class == owner_class }
+			target_class.belongs_to(owner_class)			
+		end
+	end
 
 	def enchant
 		self[:owner_singular_name] = owner_class.to_s.demodulize.underscore.downcase 

data/lib/og/store.rb

@@ -112,9 +112,9 @@ class Store
 	# Save an object to store. Insert if this is a new object or
 	# update if this is already inserted in the database.
 		 
-	def save(obj)
+	def save(obj, options = nil)
 		if obj.saved?
-			obj.og_update(self)
+			obj.og_update(self, options)
 		else
 			obj.og_insert(self)
 		end
@@ -129,8 +129,8 @@ class Store
 
 	# Update an object in the store.
 
-	def update(obj, properties = nil)
-		obj.og_update(self)
+	def update(obj, options = nil)
+		obj.og_update(self, options)
 	end
 
 	# Update selected properties of an object or class of

data/lib/og/store/mysql.rb

@@ -115,7 +115,7 @@ class MysqlStore < SqlStore
 	end
 	
 	def query(sql)
-#		Logger.debug sql if $DBG
+		Logger.debug sql if $DBG
 		@conn.query_with_result = true 
 		return @conn.query(sql)
 	rescue => ex
@@ -123,7 +123,7 @@ class MysqlStore < SqlStore
 	end
 
 	def exec(sql)
-#		Logger.debug sql if $DBG
+		Logger.debug sql if $DBG
 		@conn.query_with_result = false
 		@conn.query(sql)
 	rescue => ex
@@ -149,6 +149,11 @@ class MysqlStore < SqlStore
 		# FIXME: InnoDB supports transactions.
 	end
 
+	def sql_update(sql)
+		exec(sql)
+		@conn.affected_rows
+	end
+
 private
 
 	def create_table(klass)
@@ -161,8 +166,12 @@ private
 		if klass.__meta and constrains = klass.__meta[:sql_constrain]
 			sql << ", #{constrains.join(', ')}"
 		end
-		
-		sql << ");"
+	
+		if table_type = @options[:table_type]
+			sql << ") TYPE = #{table_type};"	
+		else
+			sql << ");"
+		end
 		
 		# Create indices.
 		
@@ -262,9 +271,14 @@ private
 	end
 
 	def eval_og_insert(klass)
-		props = klass.properties
+		props = klass.properties.dup
 		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 %{

data/lib/og/store/psql.rb

@@ -43,6 +43,27 @@ module PsqlUtils
 		return nil unless str
 		return PGconn.escape(str)
 	end
+
+	# TODO, mneumann:
+	#
+	# Blobs are actually a lot faster (and uses up less storage) for large data I
+	# think, as they need not to be encoded and decoded. I'd like to have both ;-)
+	# BYTEA is easier to handle than BLOBs, but if you implement BLOBs in a way
+	# that they are transparent to the user (as I did in Ruby/DBI), I'd prefer that
+	# way.
+	
+	def blob(val)
+		val.gsub(/[\000-\037\047\134\177-\377]/) do |b|
+			"\\#{ b[0].to_s(8).rjust(3, '0') }" 
+		end
+	end	
+	
+	def parse_blob(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
+	end   
+     
 end
 
 # A Store that persists objects into a PostgreSQL database.
@@ -122,6 +143,14 @@ class PsqlStore < SqlStore
 		handle_sql_exception(ex, sql)
 	end
 
+	def sql_update(sql)
+		Logger.debug sql if $DBG	
+		res = @conn.exec(sql)
+		changed = res.cmdtuples
+		res.clear
+		changed
+	end
+
 private
 
 	def create_table(klass)
@@ -214,6 +243,8 @@ private
 			return "#{self.class}.parse_date(res.getvalue(row, #{col} + offset))"
 		elsif p.klass.ancestors.include?(TrueClass)
 			return %|('t' == res.getvalue(row, #{col} + offset))|
+    elsif p.klass.ancestors.include?(Og::Blob)
+    	return "#{self.class}.parse_blob(res.getvalue(row, #{col} + offset))"
 		else 
 			return "YAML.load(res.getvalue(row, #{col} + offset))"
 		end		
@@ -226,6 +257,11 @@ private
 	def eval_og_insert(klass)
 		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})"
 
@@ -244,3 +280,6 @@ private
 end
 
 end
+
+# * George Moschovitis <gm@navel.gr>
+# * Michael Neumann <mneumann@ntecs.de>

data/lib/og/store/sql.rb

@@ -1,5 +1,7 @@
 require 'yaml'
 
+require 'facet/object/constant'
+
 module Og
 
 module SqlUtils
@@ -31,6 +33,14 @@ module SqlUtils
 		return "#{date.year}-#{date.month}-#{date.mday}" 
 	end
 
+	#--
+	# TODO: implement me!
+	#++
+	
+	def blob(val)
+		val
+	end
+
 	# Parse an integer.
 	
 	def parse_int(int)
@@ -65,6 +75,16 @@ module SqlUtils
 		return Date.strptime(str)
 	end
 
+	#--
+	# TODO: implement me!!
+	#++
+	
+	def parse_blob(val)
+		val
+	end
+	
+	# Escape the various Ruby types.
+	
 	def quote(val)
 		case val
 			when Fixnum, Integer, Float
@@ -141,17 +161,49 @@ class SqlStore < Store
 	# Enchants a class. 
 
 	def enchant(klass, manager)
-		klass.const_set 'OGTABLE', table(klass)
+
+		# setup the table where this class is mapped.
+				
+		if sclass = klass.metadata.superclass
+			klass.const_set 'OGTABLE', table(sclass.first)
+		else
+			klass.const_set 'OGTABLE', table(klass)
+		end
+
 		klass.module_eval 'def self.table; OGTABLE; end'
+	
+		# precompile a class specific allocate method. If this
+		# is an STI parent classes it reads the class from the
+		# resultset.
+		
+		if klass.metadata.subclasses
+			klass.module_eval %{
+				def self.og_allocate(res)
+					Object.constant(res[0]).allocate
+				end
+			}
+		else
+			klass.module_eval %{
+				def self.og_allocate(res)
+					self.allocate
+				end
+			}
+		end
 		
 		super
-	
-		create_table(klass) if Og.create_schema
 
-		eval_og_insert(klass)
-		eval_og_update(klass)
-		eval_og_read(klass)
-		eval_og_delete(klass)
+		unless klass.polymorphic_parent?
+			# create the table if needed.
+				
+			create_table(klass) if Og.create_schema
+
+			# precompile class specific lifecycle methods.
+			
+			eval_og_insert(klass)
+			eval_og_update(klass)
+			eval_og_read(klass)
+			eval_og_delete(klass)
+		end
 	end
 
 	# :section: Lifecycle methods.
@@ -162,6 +214,7 @@ class SqlStore < Store
 		res = query "SELECT * FROM #{klass::OGTABLE} WHERE #{klass.pk_symbol}=#{pk}"
 		read_one(res, klass)
 	end
+	alias_method :exist?, :load
 
 	# Reloads an object from the store.
 
@@ -177,8 +230,8 @@ class SqlStore < Store
 	# selected properties. Pass the required properties as symbols
 	# or strings.
 	
-	def update(obj, properties = nil)
-		if properties
+	def update(obj, options = nil)
+		if options and properties = options[:only]
 			if properties.is_a?(Array)
 				set = []
 				for p in properties
@@ -188,9 +241,11 @@ class SqlStore < Store
 			else
 				set = "#{properties}=#{quote(obj.send(properties))}"
 			end
-			exec "UPDATE #{obj.class.table} SET #{set} WHERE #{obj.class.pk_symbol}=#{obj.pk}"
+			sql = "UPDATE #{obj.class.table} SET #{set} WHERE #{obj.class.pk_symbol}=#{obj.pk}"
+			sql << " AND #{options[:condition]}" if options[:condition]
+			sql_update(sql)
 		else
-			obj.og_update(self)
+			obj.og_update(self, options)
 		end
 	end
 
@@ -202,14 +257,12 @@ class SqlStore < Store
 		
 		if target.is_a?(Class)
 			sql = "UPDATE #{target.table} SET #{set} "
-			if options
-				if condition = options[:condition] || options[:where]
-					sql << " WHERE #{condition}"
-				end
-			end
-			exec sql
+			sql << " WHERE #{options[:condition]}" if options and options[:condition]
+			sql_update(sql)
 		else
-			exec "UPDATE #{target.class.table} SET #{set} WHERE #{target.class.pk_symbol}=#{target.pk}"		
+			sql = "UPDATE #{target.class.table} SET #{set} WHERE #{target.class.pk_symbol}=#{target.pk}"
+			sql << " AND #{options[:condition]}" if options and options[:condition]
+			sql_update(sql)
 		end			
 	end
 	alias_method :pupdate, :update_properties
@@ -237,6 +290,21 @@ class SqlStore < Store
 		read_one(query(sql), klass, options[:include])
 	end
 
+	# 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
+	
+	# 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)
+	end
+	
 	def count(options)
 		if options.is_a?(String)
 			sql = options
@@ -295,6 +363,15 @@ class SqlStore < Store
 		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.
+	end
+
 private
 
 	def create_table(klass)
@@ -313,8 +390,22 @@ private
 	
 	def fields_for_class(klass)
 		fields = []
+		properties = klass.properties
+
+		if subclasses = klass.metadata.subclasses
+			# 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)
+			end
+			
+			properties.uniq!
+		end
 	
-		klass.properties.each do |p|
+		properties.each do |p|
 			klass.index(p.symbol) if p.meta[:index]
 				
 			field = p.symbol.to_s
@@ -368,6 +459,8 @@ private
 			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
 		elsif p.klass.ancestors.include?(TrueClass)
 			return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
+    elsif p.klass.ancestors.include?(Og::Blob)
+     return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(#{self.class}.blob(@#{p.symbol}))\}'" : 'NULL'\}|			
 		else 
 			# gmosx: keep the '' for nil symbols.
 			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
@@ -390,6 +483,8 @@ private
 			return "#{self.class}.parse_date(res[#{col} + offset])"
 		elsif p.klass.ancestors.include?(TrueClass)
 			return "('0' != res[#{col} + offset])"
+    elsif p.klass.ancestors.include?(Og::Blob)
+    	return "#{self.class}.parse_blob(res[#{col} + offset])"
 		else 
 			return "YAML::load(res[#{col} + offset])"
 		end				
@@ -397,12 +492,17 @@ private
 
 	# :section: Lifecycle method compilers.
 	
-	# Compile the og_update method for the class.
+	# Compile the og_insert method for the class.
 
 	def eval_og_insert(klass)
 		pk = klass.pk_symbol
 		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.table} (#{props.collect {|p| p.symbol.to_s}.join(',')}) VALUES (#{values})"
 
@@ -428,10 +528,13 @@ private
 		sql = "UPDATE #{klass::OGTABLE} SET #{updates.join(', ')} WHERE #{pk}=#\{@#{pk}\}"
 
 		klass.module_eval %{
-			def og_update(store)
+			def og_update(store, options = nil)
 				#{Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
-				store.exec "#{sql}"
+				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)}
+				return changed
 			end
 		}
 	end
@@ -474,8 +577,8 @@ private
 				pk ||= @#{klass.pk_symbol}
 				transaction do |tx|
 					tx.exec "DELETE FROM #{klass.table} WHERE #{klass.pk_symbol}=\#{pk}"
-					if cascade and #{klass}.__meta[:descendants]
-						#{klass}.__meta[:descendants].each do |dclass, foreign_key|
+					if cascade and #{klass}.metadata[:descendants]
+						#{klass}.metadata[:descendants].each do |dclass, foreign_key|
 							tx.exec "DELETE FROM \#{dclass::OGTABLE} WHERE \#{foreign_key}=\#{pk}"
 						end
 					end
@@ -497,6 +600,11 @@ private
 	end
 
 	def resolve_options(klass, options)
+		if sql = options[:sql]
+			sql = "SELECT * FROM #{klass.table} " + sql unless sql =~ /SELECT/
+			return sql
+		end
+	
 		tables = [klass::OGTABLE]
 
 		if included = options[:include]
@@ -514,22 +622,18 @@ private
 
 			fields = tables.collect { |t| "#{t}.*" }.join(',')
 
-			if options[:condition]
-				options[:condition] +=  " AND #{join_conditions.join(' AND ')}"
-			else
-				options[:condition] = join_conditions.join(' AND ')
-			end
+			update_condition options, join_conditions.join(' AND ')
 		else
 			fields = '*'
 		end
 
 		if join_table = options[:join_table]
 			tables << join_table
-			if options[:condition]
-				options[:condition] +=  " AND #{options[:join_condition]}"
-			else
-				options[:condition] = options[:join_condition]
-			end
+			update_condition options, options[:join_condition]
+		end
+
+		if ogtype = options[:type]
+			update_condition options, "ogtype='#{ogtype}'"
 		end
 
 		sql = "SELECT #{fields} FROM #{tables.join(',')}"
@@ -561,12 +665,12 @@ private
 
 	# Deserialize the join relations.
 	
-	def read_join_relations(obj, res, row, 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].allocate
-			rel_obj.og_read(res, row, offset) 
+			rel_obj = rel[:target_class].og_allocate(res_row)
+			rel_obj.og_read(res_row, row, offset) 
 			offset += rel_obj.class.properties.size 
 			obj.instance_variable_set("@#{rel[:name]}", rel_obj)
 		end
@@ -583,20 +687,21 @@ private
 			end
 		end
 		
-		row = res.next
+		res_row = res.next
 		
-		obj = klass.allocate
-		obj.og_read(row)
-		read_join_relations(obj, row, 0, join_relations) if join_relations
-
-		res.close
+		obj = klass.og_allocate(res_row)
+		obj.og_read(res_row)
+		read_join_relations(obj, res_row, 0, join_relations) if join_relations
 
 		return obj
+		
+	ensure
+		res.close
 	end
 
 	# Deserialize all objects from the ResultSet.
 
-	def read_all(res, klass, join_relations)
+	def read_all(res, klass, join_relations = nil)
 		return [] if res.blank?
 
 		if join_relations
@@ -608,15 +713,26 @@ private
 		objects = []
 
 		res.each_row do |res_row, row|		
-			obj = klass.allocate
+			obj = klass.og_allocate(res_row)
 			obj.og_read(res_row, row)
 			read_join_relations(obj, res_row, row, join_relations) if join_relations
 			objects << obj
 		end
 		
-		res.close
-		
 		return objects
+		
+	ensure 
+		res.close
+	end
+
+	# Helper method that updates the condition string.
+
+	def update_condition(options, cond, joiner = 'AND')
+		if options[:condition]
+			options[:condition] +=  " #{joiner} #{cond}"
+		else
+			options[:condition] = cond
+		end
 	end
 
 end
@@ -624,3 +740,5 @@ end
 end
 
 # * George Moschovitis <gm@navel.gr>
+# * Michael Neumann <mneumann@ntecs.de>
+# * Ghislain Mary