nitro 0.9.3 → 0.9.5

data/lib/nitro/version.rb

@@ -10,6 +10,6 @@ module Nitro
 
 	# The version of the server.
 
-	Version = '0.9.3'
+	Version = '0.9.5'
 
 end

data/lib/og/backend.rb

@@ -1,73 +1,69 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
+# (c) 2004-2005 Navel, all rights reserved.
 # $Id: backend.rb 202 2005-01-17 10:44:13Z gmosx $
 
-require "yaml"
+require 'yaml'
 
-require "og/connection"
+require 'og/connection'
 
 class Og
 
-# = Backend
-#
 # Abstract backend. A backend communicates with the RDBMS.
 # This is the base class for the various backend implementations.
-#
+
 class Backend
 	
 	# The actual connection to the database
 	attr_accessor :conn
 
 	# Intitialize the connection to the RDBMS.
-	# 	
+	 	
 	def initialize(config)
 		raise "Not implemented"
 	end
 
 	# Close the connection to the RDBMS.
-	# 	
+	 	
 	def close()
 		@conn.close()
 	end	
 
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-	# Utilities
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+	# :section: Utilities
 	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Encode the name of the klass as an sql safe string.
 	# The Module separators are replaced with _ and NOT stripped 
 	# out so that we can convert back to the original notation if 
 	# needed. The leading module if available is removed.
-	#
+	
 	def self.encode(klass)
 		"#{klass.name.gsub(/^.*::/, "")}".gsub(/::/, "_").downcase
 	end
 
 	# The name of the SQL table where objects of this class 
 	# are stored.
-	#
+	
 	def self.table(klass)
 		"_#{Og.table_prefix}#{encode(klass)}"
 	end
 
 	# The name of the join table for the two given classes.
-	#
+	
 	def self.join_table(klass1, klass2)
 		"_#{Og.table_prefix}j_#{encode(klass1)}_#{encode(klass2)}"
 	end
 	
 	# Returns the props that will be included in the insert query.
 	# For some backends the oid should be stripped.
-	#
+	
 	def self.props_for_insert(klass)
 		klass.__props
 	end
 	
 	# Precompile the insert code for the given class.
 	# The generated code sets the oid when inserting!
-	#
+	
 	def self.eval_og_insert(klass)
 		props = props_for_insert(klass)
 		
@@ -104,7 +100,7 @@ class Backend
 
 	# Precompile the update code for the given class.
 	# Ignore the oid when updating!
-	#
+	
 	def self.eval_og_update(klass)
 		props = klass.__props.reject { |p| :oid == p.symbol }
 		
@@ -146,7 +142,7 @@ class Backend
 	# Precompile the code to read objects of the given class 
 	# from the backend. In order to allow for changing 
 	# field/attribute orders we have to use a field mapping hash.
-	#
+	
 	def self.eval_og_deserialize(klass, og)
 		calc_field_index(klass, og)
 		
@@ -169,67 +165,67 @@ class Backend
 	end				
 	
 	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-	# Connection methods. 
+	# :section: Connection methods. 
 	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Create the database.
-	#
+	
 	def self.create_db(database, user = nil, password = nil)
 		Logger.info "Creating database '#{database}'."
 	end
 	
 	# Drop the database.
-	#
+	
 	def self.drop_db(database, user = nil, password = nil)
 		Logger.info "Dropping database '#{database}'."
 	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
 
 	# Execute an SQL query and return the result. Wrapped in a 
 	# rescue block. 
-	#
+	
 	def safe_query(sql)
 		raise "Not implemented"
 	end
 	
 	# Execute an SQL query, no result returned. Wrapped in a 
 	# rescue block.
-	#
+	
 	def safe_exec(sql)
 		raise "Not implemented"
 	end
 	
 	# Check if it is a valid resultset.
-	#
+	
 	def valid?(res)
 		raise "Not implemented"
 	end
 
 	# Start a new transaction.
-	#
+	
 	def start
 		exec "START TRANSACTION"
 	end
 	
 	# Commit a transaction.
-	#
+	
 	def commit
 		exec "COMMIT"
 	end
 	
 	# Rollback transaction.
-	#
+	
 	def rollback
 		exec "ROLLBACK"
 	end	
@@ -239,7 +235,7 @@ class Backend
 	# If the property has an :sql metadata this overrides the 
 	# default mapping. If the property has an :extra_sql metadata 
 	# the extra sql is appended after the default mapping.
-	#
+	
 	def create_fields(klass, typemap)
 		fields = []
 		
@@ -267,35 +263,35 @@ class 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)
 		return if query("SELECT * FROM #{klass::DBTABLE} LIMIT 1")
 	end
 	
 	# Drop the managed object table
-	#
+	
 	def drop_table(klass)
 		exec "DROP TABLE #{klass::DBTABLE}"
 	end
 
 	# Deserialize one row of the resultset.
-	#
+	
 	def deserialize_one(res, klass)	
-		raise "Not implemented"
+		raise 'Not implemented'
 	end
 	
 	# Deserialize all rows of the resultset.
-	#
+	
 	def deserialize_all(res, klass)	
-		raise "Not implemented"
+		raise 'Not implemented'
 	end
 	
 	# Return a single integer value from the resultset.
-	#
+	
 	def get_int(res, idx = 0)
-		raise "Not implemented"
+		raise 'Not implemented'
 	end
 
 end
 
-end # namespace 
+end 

data/lib/og/backends/psql.rb

@@ -12,7 +12,7 @@ class Og
 # This backend is compatible with Michael Neumann's postgres-pr
 # pure ruby driver.
 
-class PsqlBackend < Og::Backend
+class PsqlBackend < Backend
 
 	# A mapping between Ruby and SQL types.
 	
@@ -101,15 +101,15 @@ class PsqlBackend < Og::Backend
 		elsif p.klass.ancestors.include?(Float)
 			return "#\{@#{p.symbol} || 'NULL'\}"		
 		elsif p.klass.ancestors.include?(String)
-			return "'#\{Og::PsqlBackend.escape(@#{p.symbol})\}'"
+			return "'#\{PsqlBackend.escape(@#{p.symbol})\}'"
 		elsif p.klass.ancestors.include?(Time)
-			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+			return %|#\{@#{p.symbol} ? "'#\{PsqlBackend.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
 		elsif p.klass.ancestors.include?(Date)
-			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.date(@#{p.symbol})\}'" : 'NULL'\}|
+			return %|#\{@#{p.symbol} ? "'#\{PsqlBackend.date(@#{p.symbol})\}'" : 'NULL'\}|
 		elsif p.klass.ancestors.include?(TrueClass)
 			return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
 		else 
-			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
+			return %|#\{@#{p.symbol} ? "'#\{PsqlBackend.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
 		end
 	end		
 
@@ -124,9 +124,9 @@ class PsqlBackend < Og::Backend
 		elsif p.klass.ancestors.include?(String)
 			return "res.getvalue(tuple, #{idx})"
 		elsif p.klass.ancestors.include?(Time)
-			return "Og::PsqlBackend.parse_timestamp(res.getvalue(tuple, #{idx}))"
+			return "PsqlBackend.parse_timestamp(res.getvalue(tuple, #{idx}))"
 		elsif p.klass.ancestors.include?(Date)
-			return "Og::PsqlBackend.parse_date(res.getvalue(tuple, #{idx}))"
+			return "PsqlBackend.parse_date(res.getvalue(tuple, #{idx}))"
 		elsif p.klass.ancestors.include?(TrueClass)
 			return %|('t' == res.getvalue(tuple, #{idx}))|
 		else 

data/lib/og/backends/sqlite.rb

@@ -0,0 +1,383 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id$
+
+require 'sqlite'
+
+require 'og/backend'
+
+class Og
+
+# Implements an SQLite powered backend.
+
+class SqliteBackend < 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 = SQLite::Database.new(config[:database])
+		rescue => ex
+			# gmosx: any idea how to better test this?
+			if ex.to_s =~ /database .* does not exist/i
+				Logger.info "Database '#{config[:database]}' not found!"
+				SqliteBackend.create_db(config[:database], config[:user])
+				retry
+			end
+			raise
+		end
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Utilities
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# Escape an SQL string
+	
+	def self.escape(str)
+		return nil unless str
+		return str.gsub( /'/, "''" )
+	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 "'#\{SqliteBackend.escape(@#{p.symbol})\}'"
+		elsif p.klass.ancestors.include?(Time)
+			return %|#\{@#{p.symbol} ? "'#\{SqliteBackend.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(Date)
+			return %|#\{@#{p.symbol} ? "'#\{SqliteBackend.date(@#{p.symbol})\}'" : 'NULL'\}|
+		elsif p.klass.ancestors.include?(TrueClass)
+			return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
+		else 
+			return %|#\{@#{p.symbol} ? "'#\{SqliteBackend.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 "PsqlBackend.parse_timestamp(res.getvalue(tuple, #{idx}))"
+		elsif p.klass.ancestors.include?(Date)
+			return "PsqlBackend.parse_date(res.getvalue(tuple, #{idx}))"
+		elsif p.klass.ancestors.include?(TrueClass)
+			return %|('t' == 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
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Connection methods. 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	# 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.
+	
+	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)
+		res.clear()
+	end
+
+	# Execute an SQL query and return the result. Wrapped in a rescue
+	# block.
+	
+	def safe_query(sql)
+		Logger.debug sql if $DBG
+		begin
+			return @conn.exec(sql)
+		rescue => ex
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.error ex.backtrace
+			return nil
+		end
+	end
+
+	# Execute an SQL query, no result returned. Wrapped in a rescue 
+	# block.
+	
+	def safe_exec(sql)
+		Logger.debug sql if $DBG
+		begin
+			res = @conn.exec(sql) 
+			res.clear()
+		rescue => ex
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.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 = create_fields(klass, TYPEMAP)
+
+		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 and indices = klass.__meta[:sql_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::DBTABLE}_#{idxname}_idx #{post_sql} ON #{klass::DBTABLE} (#{idx});"  
+			end
+		end
+
+		begin
+			exec(sql)
+			Logger.info "Created table '#{klass::DBTABLE}'."
+		rescue => ex
+			# gmosx: any idea how to better test this?
+			if ex.to_s =~ /relation .* already exists/i
+				Logger.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}"
+			Logger.info "Created sequence '#{klass::DBSEQ}'."	
+		rescue => ex
+			# gmosx: any idea how to better test this?
+			if ex.to_s =~ /relation .* already exists/i
+				Logger.debug "Sequence already exists" if $DBG
+			else
+				raise
+			end
+		end
+		
+		# 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_class, options = *data
+				
+				# gmosx: dont use DBTABLE here, perhaps the join class
+				# is not managed yet.
+				join_table = "#{self.class.join_table(klass, join_class)}"
+				join_src = "#{self.class.encode(klass)}_oid"
+				join_dst = "#{self.class.encode(join_class)}_oid"
+				begin
+					exec "CREATE TABLE #{join_table} ( key1 integer NOT NULL, key2 integer NOT NULL )"
+					exec "CREATE INDEX #{join_table}_key1_idx ON #{join_table} (key1)"
+					exec "CREATE INDEX #{join_table}_key2_idx ON #{join_table} (key2)"
+				rescue => ex
+					# gmosx: any idea how to better test this?
+					if ex.to_s =~ /relation .* already exists/i
+						Logger.debug "Join table already exists" if $DBG
+					else
+						raise
+					end
+				end
+			end
+		end
+		
+		begin
+			exec(sql)
+			Logger.info "Created join table '#{join_table}'."
+		rescue => ex
+			# gmosx: any idea how to better test this?
+			if ex.to_s =~ /relation .* already exists/i
+				Logger.debug "Join table 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 [] 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