og 0.5.0

data/lib/og/backends/psql.rb

@@ -0,0 +1,359 @@
+# code: 
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: psql.rb 159 2004-11-18 10:18:30Z gmosx $
+
+require "postgres"
+
+require "og/backend"
+
+module Og
+
+# = Utils
+#
+# A collection of useful utilities.
+#
+module Utils
+
+	# Escape an SQL string
+	#
+	def self.escape(str)
+		return nil unless str
+		return PGconn.escape(str)
+	end
+
+	# 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")
+	end
+	
+	# Output YYY-mm-dd
+	# TODO: Optimize this
+	#
+	def self.date(date)
+		return nil unless date
+		return "#{date.year}-#{date.month}-#{date.mday}" 
+	end
+	
+	# 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)
+	end
+
+	# Return an sql string evaluator for the property.
+	# No need to optimize this, used only to precalculate code.
+	# YAML is used to store general Ruby objects to be more 
+	# portable.
+	#
+	# FIXME: add extra handling for float.
+	#
+	def self.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 "'#\{Og::Utils.escape(@#{p.symbol})\}'"
+		elsif p.klass.ancestors.include?(Time)
+			return %|#\{@#{p.symbol} ? "'#\{Og::Utils.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(Date)
+			return %|#\{@#{p.symbol} ? "'#\{Og::Utils.date(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(TrueClass)
+			return "#\{@#{p.symbol} || 'NULL'\}"
+		else 
+			return %|#\{@#{p.symbol} ? "'#\{Og::Utils.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
+		end
+	end		
+
+	# 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()"
+		elsif p.klass.ancestors.include?(Float)
+			return "res.getvalue(tuple, #{idx}).to_f()"
+		elsif p.klass.ancestors.include?(String)
+			return "res.getvalue(tuple, #{idx})"
+		elsif p.klass.ancestors.include?(Time)
+			return "Og::Utils.parse_timestamp(res.getvalue(tuple, #{idx}))"
+		elsif p.klass.ancestors.include?(Date)
+			return "Og::Utils.parse_date(res.getvalue(tuple, #{idx}))"
+		elsif p.klass.ancestors.include?(TrueClass)
+			return "('true' == res.getvalue(tuple, #{idx}))"
+		else 
+			return "YAML::load(res.getvalue(tuple, #{idx}))"
+		end		
+	end
+
+	# 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}
+			res = conn.db.query("SELECT nextval('#{klass::DBSEQ}')")
+			@oid = res.getvalue(0, 0).to_i
+			conn.exec "#{sql}"
+			#{post_cb}
+		}
+	end
+
+	# 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]
+	
+		for field in res.fields
+			meta.field_index[field] = res.fieldnum(field)
+		end
+	end
+	
+	# Generate the property for oid
+	#
+	def self.eval_og_oid(klass)
+		klass.class_eval %{
+			prop_accessor :oid, Fixnum, :sql => "integer PRIMARY KEY"
+		}
+	end
+end
+
+# = PsqlBackend
+#
+# Implements a PostgreSQL powered backend.
+#
+class PsqlBackend < Og::Backend
+
+	# A mapping between Ruby and SQL types.
+	#
+	TYPEMAP = {
+		Integer => "integer",
+		Fixnum => "integer",
+		Float => "float",
+		String => "text",
+		Time => "timestamp",
+		Date => "date",
+		TrueClass => "boolean",
+		Object => "text",
+		Array => "text",
+		Hash => "text"
+	}
+	
+	# Intitialize the connection to the RDBMS.
+	# 		
+	def initialize(config)
+		begin
+			@conn = PGconn.connect(nil, nil, nil, nil, config[:database], 
+				config[:user], config[:password])
+		rescue => ex
+			# gmosx: any idea how to better test this?
+			if ex.to_s =~ /database .* does not exist/i
+				$log.info "Database '#{config[:database]}' not found!"
+				PsqlBackend.create_db(config[:database], config[:user])
+				retry
+			end
+			raise
+		end
+	end
+
+	# Create the database.
+	#
+	def self.create_db(database, user = nil, password = nil)
+		$log.info "Creating database '#{database}'."
+		`createdb #{database} -U #{user}`
+	end
+	
+	# Drop the database.
+	#
+	def self.drop_db(database, user = nil, password = nil)
+		$log.info "Dropping database '#{database}'."
+		`dropdb #{database} -U #{user}`
+	end
+	
+	# Execute an SQL query and return the result 
+	#
+	def query(sql)
+		$log.debug sql if $DBG
+		return @conn.exec(sql)
+	end
+	
+	# Execute an SQL query, no result returned.
+	#
+	def exec(sql)
+		$log.debug sql if $DBG
+		res = @conn.exec(sql)
+		res.clear()
+	end
+
+	# Execute an SQL query and return the result. Wrapped in a rescue
+	# block.
+	#
+	def safe_query(sql)
+		$log.debug sql if $DBG
+		begin
+			return @conn.exec(sql)
+		rescue => ex
+			$log.error "DB error #{ex}, [#{sql}]"
+			$log.error ex.backtrace
+			return nil
+		end
+	end
+
+	# Execute an SQL query, no result returned. Wrapped in a rescue 
+	# block.
+	#
+	def safe_exec(sql)
+		$log.debug sql if $DBG
+		begin
+			res = @conn.exec(sql) 
+			res.clear()
+		rescue => ex
+			$log.error "DB error #{ex}, [#{sql}]"
+			$log.error ex.backtrace
+		end
+	end
+
+	# Check if it is a valid resultset.
+	#
+	def valid?(res)
+		return !(res.nil? or 0 == res.num_tuples)
+	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)
+		fields = []
+		
+		klass.__props.each do |p|
+			klass.sql_index(p.symbol) if p.meta[:sql_index]
+				
+			field = "#{p.symbol}"
+			
+			if p.meta and p.meta[:sql]
+				field << " #{p.meta[:sql]}"
+			else
+				field << " #{TYPEMAP[p.klass]}"
+			end
+			
+			fields << field 
+		end
+
+		sql = "CREATE TABLE #{klass::DBTABLE} (#{fields.join(', ')}"
+		
+		# Create table constrains
+		
+		if klass.__meta and constrains = klass.__meta[:sql_constrain]
+			sql << ", #{constrains.join(', ')}"
+		end
+		
+		sql << ") WITHOUT OIDS;"
+		
+		# Create indices
+		
+		if klass.__meta
+			for data in klass.__meta[:sql_index]
+				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::DBTABLE}_#{idxname}_idx #{post_sql} ON #{klass::DBTABLE} (#{idx});"  
+			end
+		end
+
+		begin
+			exec(sql)
+			$log.info "Created table '#{klass::DBTABLE}'."
+		rescue => ex
+			# gmosx: any idea how to better test this?
+			if ex.to_s =~ /relation .* already exists/i
+				$log.debug "Table already exists" if $DBG
+			else
+				raise
+			end
+		end
+
+		# 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}"
+			$log.info "Created sequence '#{klass::DBSEQ}'."	
+		rescue => ex
+			# gmosx: any idea how to better test this?
+			if ex.to_s =~ /relation .* already exists/i
+				$log.debug "Sequence already exists" if $DBG
+			else
+				raise
+			end
+		end
+	end
+	
+	# 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)
+		
+		# gmosx: Managed objects should have no params constructor.
+		entity = klass.new()
+		entity.og_deserialize(res, 0)
+		
+#		get_join_fields(res, 0, entity, join_fields) if join_fields
+
+		res.clear()
+		return entity
+	end
+	
+	# Deserialize all rows of the resultset.
+	#
+	def deserialize_all(res, klass)	
+		return nil unless valid?(res)
+
+		entities = []
+	
+		for tuple in (0...res.num_tuples)
+			entity = klass.new()
+			entity.og_deserialize(res, tuple)
+			
+#			get_join_fields(res, tuple, entity, join_fields) if join_fields
+			
+			entities << entity
+		end
+		
+		res.clear()
+		return entities
+	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

data/lib/og/connection.rb

@@ -0,0 +1,265 @@
+# code: 
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: connection.rb 167 2004-11-23 14:03:10Z gmosx $
+
+module Og; 
+
+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.
+#
+# === Future 
+#
+# - 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)
+		@deserialize = true
+		$log.debug "Created DB connection."
+	end
+	
+	# Close the connection to the database
+	#
+	def close()
+		@db.close()
+		$log.debug "Closed DB connection."
+	end
+
+	# 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
+			# 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
+
+	# Force update of managed object.
+	#
+	def update(obj)
+		obj.og_update(self)
+	end
+
+	# Update only specific fields of the managed object.
+	# 
+	# Input:
+	# sql = the sql code to updated the properties.
+	#
+	# WARNING: the object in memoryis 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
+
+	# 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}"
+		@deserialize? @db.deserialize_one(res, klass) : res
+	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}'"
+		@deserialize? @db.deserialize_one(res, klass) : res
+	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}"
+		@deserialize? @db.deserialize_all(res, klass) : res
+	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 = @db.safe_query(sql)
+		@deserialize? @db.deserialize_all(res, klass) : res
+	end
+	
+	# Optimized for one result.
+	#
+	def select_one(sql, klass)
+		unless sql =~ /SELECT/i
+			sql = "SELECT * FROM #{klass::DBTABLE} WHERE #{sql}"
+		end
+		
+		res = @db.safe_query(sql)
+		@deserialize? @db.deserialize_one(res, klass) : res
+	end	
+
+	# Perform a count query.
+	#	
+	def count(sql, klass = nil)
+		unless sql =~ /SELECT/i
+			sql = "SELECT COUNT(*) FROM #{klass::DBTABLE} WHERE #{sql}"
+		end
+		
+		res =	@db.safe_query(sql)
+		
+		return @db.get_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)
+	#
+	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, oid)
+		end
+		
+		# 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|
+					tx.exec "DELETE FROM #{dclass::DBTABLE} WHERE #{linkback}=#{oid}"
+				end
+			end
+		end
+	end
+	alias_method :delete!, :delete
+		
+	# 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)
+		@db.create_table(klass)
+	end
+	
+	# Drop the managed object table.
+	#
+	def drop_table(klass)
+		@db.drop_table(klass)
+	end
+
+	# Execute an SQL query and return the result 
+	#
+	def query(sql)
+		@db.safe_query(sql)
+	end
+	
+	# Execute an SQL query, no result returned.
+	#
+	def exec(sql)
+		@db.safe_exec(sql)
+	end
+
+	# Start a new transaction.
+	#
+	def start
+		@db.start()
+	end
+	
+	# Commit a transaction.
+	#
+	def commit
+		@db.commit()
+	end
+	
+	# Rollback transaction.
+	#
+	def rollback
+		@db.rollback()
+	end
+	
+	# Transaction helper. In the transaction block use
+	# the db pointer to the backend.
+	#
+	def transaction(&block)
+		begin
+			@db.start()
+			yield(@db) 
+			@db.commit()
+		rescue => ex
+			$log.error "DB Error: ERROR IN TRANSACTION"
+			$log.error #{ex}
+			$log.error #{ex.backtrace}
+			@db.rollback()
+		end
+	end
+		
+end
+
+end # module
+