og 0.15.0 → 0.16.0

data/lib/og/{adapter.rb → adapters/base.rb}

@@ -1,28 +1,28 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: adapter.rb 323 2005-03-24 09:43:52Z gmosx $
+# $Id: base.rb 17 2005-04-14 16:03:40Z gmosx $
 
 require 'yaml'
 require 'singleton'
 
-require 'og/connection'
+require 'glue/property'
+require 'glue/array'
+require 'glue/time'
+require 'glue/attribute'
 
-module Og
-
-# Encapsulates a lower lever adapter SQL excpetion.
+require 'og'
+require 'og/errors'
 
-class SqlException < Exception
-	attr_accessor :adapter_exception, :sql
+module Og
 
-	def initialize(adapter_exception, sql = nil)
-		@adapter_exception, @sql = adapter_exception, sql
-	end
-end
-	
 # An adapter communicates with the backend datastore. 
 # The adapters for all supported datastores extend this 
 # class. Typically, an RDBMS is used to implement a
-# datastore.
+# datastore. 
+#
+# This is the base adapter implementation. Adapters for
+# well known RDBMS systems and other stores inherit 
+# from this class.
 
 class Adapter 
 	include Singleton
@@ -39,8 +39,13 @@ class Adapter
 	# Lookup the adapter instance from the adapter name.
 
 	def self.for_name(name)
-		require "og/adapters/#{name}"
-		eval %{	return  #{name.capitalize}Adapter.instance }
+		# gmosx: RDoc complains about this, so lets use an
+		# eval, AAAAAAAARGH!
+		#	require "og/adapters/#{name}"
+		eval %{	
+			require 'og/adapters/#{name}'
+			return  #{name.capitalize}Adapter.instance 
+		}
 	end
 
 	def initialize
@@ -326,61 +331,11 @@ class Adapter
 	# The generated code sets the oid when inserting!
 	
 	def eval_og_insert(klass, db)
-
-		# Attach object callbacks.
-		
-		if klass.instance_methods.include?('og_pre_insert')
-			pre_cb = 'og_pre_insert(conn);'
-		else
-			pre_cb = ''
-		end
-
-		if klass.instance_methods.include?('og_post_insert')
-			post_cb = 'og_post_insert(conn);'
-		else
-			post_cb = ''
-		end
-
-		if klass.instance_methods.include?('og_pre_insert_update')
-			pre_cb << 'og_pre_insert_update(conn);'
-		end
-
-		if klass.instance_methods.include?('og_post_insert_update')
-			post_cb << 'og_post_insert_update(conn);'
-		end
-
-		# Attach observers.
-
-		if observers = klass.__meta[:og_observers]
-			observers.each_with_index do |o, idx|
-				if o.is_a?(Class)
-					obs = "#{o}.instance"
-					o = o.instance
-				else
-					obs = "self.class.__meta[:og_observers][#{idx}]" 
-				end
-
-				if o.respond_to?(:og_pre_insert)
-					pre_cb << "#{obs}.og_pre_insert(conn, self);"
-				end
-
-				if o.respond_to?(:og_post_insert)
-					post_cb << "#{obs}.og_post_insert(conn, self);"
-				end
-
-				if o.respond_to?(:og_pre_insert_update)
-					pre_cb << "#{obs}.og_pre_insert_update(conn, self);"
-				end
-				
-				if o.respond_to?(:og_post_insert_update)
-					post_cb << "#{obs}.og_post_insert_update(conn, self);"
-				end
-			end
-		end
-			
 		klass.class_eval %{
 			def og_insert(conn)
-				#{insert_code(klass, db, pre_cb, post_cb)}
+				#{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+				#{insert_code(klass, db)}
+				#{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
 			end
 		}
 	end
@@ -397,62 +352,11 @@ class Adapter
 
 		sql = "UPDATE #{klass::DBTABLE} SET #{updates.join(', ')} WHERE oid=#\{@oid\}"
 
-		# Attach object callbacks.
-
-		if klass.instance_methods.include?('og_pre_update')
-			pre_cb = 'og_pre_update(conn);'
-		else
-			pre_cb = ''
-		end
-
-		if klass.instance_methods.include?('og_post_update')
-			post_cb = 'og_post_update(conn);'
-		else
-			post_cb = ''
-		end
-
-		if klass.instance_methods.include?('og_pre_insert_update')
-			pre_cb << 'og_pre_insert_update(conn);'
-		end
-
-		if klass.instance_methods.include?('og_post_insert_update')
-			post_cb << 'og_post_insert_update(conn);'
-		end
-		
-		# Attach observers.
-
-		if observers = klass.__meta[:og_observers]
-			observers.each_with_index do |o, idx|
-				if o.is_a?(Class)
-					obs = "#{o}.instance"
-					o = o.instance
-				else
-					obs = "self.class.__meta[:og_observers][#{idx}]" 
-				end
-
-				if o.respond_to?(:og_pre_update)
-					pre_cb << "#{obs}.og_pre_update(conn, self);"
-				end
-
-				if o.respond_to?(:og_post_update)
-					post_cb << "#{obs}.og_post_update(conn, self);"
-				end
-
-				if o.respond_to?(:og_pre_insert_update)
-					pre_cb << "#{obs}.og_pre_insert_update(conn, self);"
-				end
-				
-				if o.respond_to?(:og_post_insert_update)
-					post_cb << "#{obs}.og_post_insert_update(conn, self);"
-				end
-			end
-		end
-
 		klass.class_eval %{
 			def og_update(conn)
-				#{pre_cb}
+				#{Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
 				conn.exec "#{sql}"
-				#{post_cb}
+				#{Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
 			end
 		}
 	end
@@ -474,50 +378,328 @@ class Adapter
 				code << "@#{p.name} = #{read_prop(p, idx)}"
 			end
 		end
-		
-		# Attach object callbacks.
 
-		if klass.instance_methods.include?('og_pre_read')
-			pre_cb = 'og_pre_read(conn);'
-		else
-			pre_cb = ''
+		klass.class_eval %{
+	 		def og_read(res, tuple = 0)
+				#{Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
+				#{code.join('; ')}
+				#{Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
+			end
+		}
+	end				
+
+end
+
+# A Connection to the Database. This file defines the skeleton 
+# functionality. A store specific implementation file (adapter) 
+# implements all methods.
+#--
+# - support caching (memoize).
+# - use prepared statements.
+#++
+
+class Connection
+
+	# The Og database object. 
+	
+	attr_reader :db
+
+	# The actual connection to the backend store.
+
+	attr_accessor :store
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Backend connection methods.
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Initialize a connection to the database.
+	
+	def initialize(db)
+		@db = db
+		Logger.debug "Created DB connection." if $DBG 
+	end
+	
+	# Close the connection to the database.
+	
+	def close
+		Logger.debug "Closed DB connection." if $DBG
+	end
+
+	# 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)
+		raise 'Not implemented!'
+	end
+	
+	# Drop the managed object table.
+	
+	def drop_table(klass)
+		exec "DROP TABLE #{klass::DBTABLE}"
+	end
+
+	# Prepare an sql statement.
+
+	def prepare(sql)
+		raise 'Not implemented!'		
+	end
+	
+	# Execute an SQL query and return the result.
+	
+	def query(sql)
+		raise 'Not implemented!'
+	end
+	
+	# Execute an SQL query, no result returned.
+	
+	def exec(sql)
+		raise 'Not implemented!'
+	end
+	alias_method :execute, :exec
+
+	# Start a new transaction.
+	
+	def start
+		exec 'START TRANSACTION'
+	end
+	
+	# Commit a transaction.
+	
+	def commit
+		exec 'COMMIT'
+	end
+	
+	# Rollback a transaction.
+	
+	def rollback
+		exec 'ROLLBACK'
+	end
+	
+	# Transaction helper. In the transaction block use
+	# the db pointer to the backend.
+	
+	def transaction(&block)
+		begin
+			start
+			yield(self) 
+			commit
+		rescue => ex
+			Logger.error "DB Error: ERROR IN TRANSACTION"
+			Logger.error "#{ex}"
+			Logger.error "#{ex.backtrace}"
+			rollback
 		end
+	end
+		
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Deserialization methods.
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Is the given resultset valid?
+
+	def valid_res?(res)
+		return !(res.nil?)
+	end
+	
+	# Read (deserialize) one row of the resultset.
+	
+	def read_one(res, klass)
+		raise 'Not implemented!'
+	end
+
+	# Read (deserialize) all rows of the resultset.
+
+	def read_all(res, klass)
+		raise 'Not implemented!'
+	end
 
-		if klass.instance_methods.include?('og_post_read')
-			post_cb = 'og_post_read(conn);'
+	# Read the first column of the resultset as an Integer.
+
+	def read_int(res, idx = 0)
+		raise 'Not implemented!'
+	end
+
+	# Get a row from the resultset.
+
+	def get_row(res)
+		return res
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Managed object methods.
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Save an object to the database. Insert if this is a new object or
+	# update if this is already stored in the database.
+		
+	def save(obj)
+		if obj.oid
+			# object allready inserted, update!
+			obj.og_update(self)
 		else
-			post_cb = ''
+			# not in the database, insert!
+			obj.og_insert(self)
 		end
+	end
+	alias_method :<<, :save
+	alias_method :put, :save
+	
+	# Force insertion of managed object.
+	
+	def insert(obj)
+		obj.og_insert(self)
+	end
 
-		# Attach observers.
+	# Force update of managed object.
+	
+	def update(obj)
+		obj.og_update(self)
+	end
 
-		if observers = klass.__meta[:og_observers]
-			observers.each_with_index do |o, idx|
-				if o.is_a?(Class)
-					obs = "#{o}.instance"
-					o = o.instance
-				else
-					obs = "self.class.__meta[:og_observers][#{idx}]" 
-				end
+	# Update only specific fields of the managed object.
+	# 
+	# Input:
+	# sql = the sql code to updated the properties.
+	#
+	# WARNING: the object in memory is not updated.
+	#--
+	# TODO: should update the object in memory.
+	#++
+	
+	def update_properties(update_sql, obj_or_oid, klass = nil)
+		oid = obj_or_oid.to_i
+		klass = obj_or_oid.class unless klass
+		
+		exec "UPDATE #{klass::DBTABLE} SET #{update_sql} WHERE oid=#{oid}"
+	end
+	alias_method :pupdate, :update_properties
+	alias_method :update_propery, :update_properties
 
-				if o.respond_to?(:og_pre_read)
-					pre_cb << "#{obs}.og_pre_read(conn, self);"
-				end
+	# Load an object from the database.
+	#
+	# Input:
+	# oid = the object oid, OR the object name.
+	
+	def load(oid, klass)
+		if oid.to_i > 0 # a valid Fixnum ?
+			load_by_oid(oid, klass)
+		else
+			load_by_name(oid, klass)
+		end
+	end
+	alias_method :get, :load
+	
+	# Load an object by oid.
+	
+	def load_by_oid(oid, klass)
+		res = query "SELECT * FROM #{klass::DBTABLE} WHERE oid=#{oid}"
+		read_one(res, klass)
+	end
+	alias_method :get_by_oid, :load_by_oid
+	
+	# Load an object by name.
+	
+	def load_by_name(name, klass)
+		res = query "SELECT * FROM #{klass::DBTABLE} WHERE name='#{name}'"
+		read_one(res, klass)
+	end
+	alias_method :get_by_name, :load_by_name
+	
+	# Load all objects of the given klass.
+	# Used to be called 'collect' in an earlier version.
+	
+	def load_all(klass, extrasql = nil)
+		res = query "SELECT * FROM #{klass::DBTABLE} #{extrasql}"
+		read_all(res, klass)
+	end
+	alias_method :get_all, :load_all
+	
+	# Perform a standard SQL query to the database. Deserializes the
+	# results.
+	
+	def select(sql, klass)
+		unless sql =~ /SELECT/i
+			sql = "SELECT * FROM #{klass::DBTABLE} WHERE #{sql}"
+		end
+		
+		res = query(sql)
+		read_all(res, klass)
+	end
+	
+	# Optimized for one result.
+	
+	def select_one(sql, klass)
+		unless sql =~ /SELECT/i
+			sql = "SELECT * FROM #{klass::DBTABLE} WHERE #{sql}"
+		end
+		
+		res = query(sql)
+		read_one(res, klass)
+	end	
 
-				if o.respond_to?(:og_post_read)
-					post_cb << "#{obs}.og_post_read(conn, self);"
+	# Perform a count query.
+		
+	def count(sql, klass = nil)
+		unless sql =~ /SELECT/i
+			sql = "SELECT COUNT(*) FROM #{klass::DBTABLE} WHERE #{sql}"
+		end
+		
+		res =	query(sql)
+		return read_int(res)
+	end
+	
+	# Delete an object from the database. Allways perform a deep delete.
+	#
+	# No need to optimize here with pregenerated code. Deletes are
+	# not used as much as reads or writes.
+	#
+	# Input:
+	#
+	# obj_or_oid = Object or oid to delete.
+	# klass = Class of object (can be nil if an object is passed)
+	#
+	#--
+	# TODO: pre evaluate for symmetry to the other methods
+	#++
+	
+	def delete(obj_or_oid, klass = nil, cascade = true)
+		oid = obj_or_oid.to_i
+		klass = obj_or_oid.class unless klass
+
+		# this is a class callback!
+		
+		if klass.respond_to?(:og_pre_delete)
+			klass.og_pre_delete(self, obj_or_oid)
+		end
+		
+		# TODO: implement this as stored procedure? naaah.
+		# TODO: also handle many_to_many relations.
+
+		transaction do |tx|
+			tx.exec "DELETE FROM #{klass::DBTABLE} WHERE oid=#{oid}"
+			if cascade and klass.__meta.include?(:descendants)
+				klass.__meta[:descendants].each do |dclass, linkback|
+					tx.exec "DELETE FROM #{dclass::DBTABLE} WHERE #{linkback}=#{oid}"
 				end
 			end
 		end
+	end
+	alias_method :delete!, :delete
+	
+	protected
 
-		klass.class_eval %{
-	 		def og_read(res, tuple = 0)
-				#{pre_cb}
-				#{code.join('; ')}
-				#{post_cb}
-			end
-		}
-	end				
+	# Handles an adapter exception.
+
+	def handle_db_exception(ex, sql = nil)
+		Logger.error "DB error #{ex}, [#{sql}]"
+		Logger.error ex.backtrace.join("\n")
+		raise SqlException.new(ex, sql) if Og.raise_db_exceptions
+
+		# FIXME: should return :error or something.
+
+		return nil 
+	end
 
 end