nitro 0.7.0 → 0.8.0

data/lib/og/backend.rb

@@ -8,33 +8,54 @@ require "yaml"
 
 require "og/connection"
 
-module Og
+class Og
 
-# = OgUtils
+# = Backend
 #
-# A collection of useful utilities.
+# Abstract backend. A backend communicates with the RDBMS.
+# This is the base class for the various backend implementations.
 #
-module Utils
+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
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# 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.
+	# 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.
+	# The name of the SQL table where objects of this class 
+	# are stored.
 	#
 	def self.table(klass)
-		"_#{$og_table_prefix}#{encode(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_#{Og::Utils.encode(klass1)}_#{Og::Utils.encode(klass2)}"
+		"_#{Og.table_prefix}j_#{encode(klass1)}_#{encode(klass2)}"
 	end
 	
 	# Returns the props that will be included in the insert query.
@@ -123,8 +144,8 @@ module Utils
 	end
 
 	# 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.
+	# 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)
@@ -136,7 +157,7 @@ module Utils
 			if idx = og.managed_classes[klass].field_index[p.name]
 				# more fault tolerant if a new field is added and it 
 				# doesnt exist in the database.
-				code << "@#{p.name} = #{Og::Utils.read_prop(p, idx)}"
+				code << "@#{p.name} = #{read_prop(p, idx)}"
 			end
 		end
 		
@@ -147,40 +168,20 @@ module Utils
 		}
 	end				
 	
-end
-
-# = 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	
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Connection methods. 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Create the database.
 	#
 	def self.create_db(database, user = nil, password = nil)
-		$log.info "Creating database '#{database}'."
+		Logger.info "Creating database '#{database}'."
 	end
 	
 	# Drop the database.
 	#
 	def self.drop_db(database, user = nil, password = nil)
-		$log.info "Dropping database '#{database}'."
+		Logger.info "Dropping database '#{database}'."
 	end
 	
 	# Execute an SQL query and return the result. 
@@ -195,15 +196,15 @@ class Backend
 		raise "Not implemented"
 	end
 
-	# Execute an SQL query and return the result. Wrapped in a rescue
-	# block. 
+	# 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.
+	# Execute an SQL query, no result returned. Wrapped in a 
+	# rescue block.
 	#
 	def safe_exec(sql)
 		raise "Not implemented"
@@ -235,9 +236,9 @@ class Backend
 
 	# Create the fields that correpsond to the klass properties.
 	# The generated fields array is used in create_table.
-	# 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.
+	# 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 = []
@@ -297,4 +298,4 @@ class Backend
 
 end
 
-end # module
+end # namespace 

data/lib/og/backends/mysql.rb

@@ -9,13 +9,48 @@ require "mysql"
 
 require "og/backend"
 
-module Og
+class Og
 
-# = Utils
+# = MysqlBackend
 #
-# A collection of useful utilities.
+# Implements a MySQL powered backend.
 #
-module Utils
+class MysqlBackend < 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 = Mysql.connect(config[:address], config[:user], 
+					config[:password], config[:database])
+		rescue => ex
+			if ex.errno == 1049 # database does not exist.
+				Logger.info "Database '#{config[:database]}' not found!"
+				MysqlBackend.create_db(config[:database], config[:user], config[:password])
+				retry
+			end
+			raise
+		end
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Utilities
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Escape an SQL string
 	#
@@ -68,15 +103,15 @@ module Utils
 		elsif p.klass.ancestors.include?(Float)
 			return "#\{@#{p.symbol} || 'NULL'\}"		
 		elsif p.klass.ancestors.include?(String)
-			return "'#\{Og::Utils.escape(@#{p.symbol})\}'"
+			return "'#\{Og::MysqlBackend.escape(@#{p.symbol})\}'"
 		elsif p.klass.ancestors.include?(Time)
-			return %|#\{@#{p.symbol} ? "'#\{Og::Utils.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+			return %|#\{@#{p.symbol} ? "'#\{Og::MysqlBackend.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
 		elsif p.klass.ancestors.include?(Date)
-			return %|#\{@#{p.symbol} ? "'#\{Og::Utils.date(@#{p.symbol})\}'" : 'NULL'\}|
+			return %|#\{@#{p.symbol} ? "'#\{Og::MysqlBackend.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)\}'" : "''"\}|
+			return %|#\{@#{p.symbol} ? "'#\{Og::MysqlBackend.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
 		end
 	end		
 
@@ -91,9 +126,9 @@ module Utils
 		elsif p.klass.ancestors.include?(String)
 			return "res[#{idx}]"
 		elsif p.klass.ancestors.include?(Time)
-			return "Og::Utils.parse_timestamp(res[#{idx}])"
+			return "Og::MysqlBackend.parse_timestamp(res[#{idx}])"
 		elsif p.klass.ancestors.include?(Date)
-			return "Og::Utils.parse_date(res[#{idx}])"
+			return "Og::MysqlBackend.parse_date(res[#{idx}])"
 		elsif p.klass.ancestors.include?(TrueClass)
 			return "('true' == res[#{idx}])"
 		else 
@@ -140,70 +175,36 @@ module Utils
 			prop_accessor :oid, Fixnum, :sql => "integer AUTO_INCREMENT PRIMARY KEY"
 		}
 	end
-end
 
-# = MysqlBackend
-#
-# Implements a MySQL powered backend.
-#
-class MysqlBackend < 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 = Mysql.connect(config[:address], config[:user], 
-					config[:password], config[:database])
-		rescue => ex
-			if ex.errno == 1049 # database does not exist.
-				$log.info "Database '#{config[:database]}' not found!"
-				MysqlBackend.create_db(config[:database], config[:user], config[:password])
-				retry
-			end
-			raise
-		end
-	end
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Connection methods. 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Create the database.
 	#
 	def self.create_db(database, user = nil, password = nil)
-		$log.info "Creating database '#{database}'."
+		Logger.info "Creating database '#{database}'."
 		`mysqladmin -f --user=#{user} --password=#{password} create #{database}`
 	end
 	
 	# Drop the database.
 	#
 	def self.drop_db(database, user = nil, password = nil)
-		$log.info "Dropping database '#{database}'."
+		Logger.info "Dropping database '#{database}'."
 		`mysqladmin -f --user=#{user} --password=#{password} drop #{database}`
 	end
 
 	# Execute an SQL query and return the result 
 	#
 	def query(sql)
-		$log.debug sql if $DBG
+		Logger.debug sql if $DBG
 		return @conn.query(sql)
 	end
 	
 	# Execute an SQL query, no result returned.
 	#
 	def exec(sql)
-		$log.debug sql if $DBG
+		Logger.debug sql if $DBG
 		@conn.query(sql)
 	end
 
@@ -211,12 +212,12 @@ class MysqlBackend < Og::Backend
 	# block.
 	#
 	def safe_query(sql)
-		$log.debug sql if $DBG
+		Logger.debug sql if $DBG
 		begin
 			return @conn.query(sql)
 		rescue => ex
-			$log.error "DB error #{ex}, [#{sql}]"
-			$log.error ex.backtrace
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.error ex.backtrace
 			return nil
 		end
 	end
@@ -225,12 +226,12 @@ class MysqlBackend < Og::Backend
 	# block.
 	#
 	def safe_exec(sql)
-		$log.debug sql if $DBG
+		Logger.debug sql if $DBG
 		begin
 			@conn.query(sql)
 		rescue => ex
-			$log.error "DB error #{ex}, [#{sql}]"
-			$log.error ex.backtrace
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.error ex.backtrace
 		end
 	end
 	
@@ -277,10 +278,10 @@ class MysqlBackend < Og::Backend
 		
 		begin
 			exec(sql)
-			$log.info "Created table '#{klass::DBTABLE}'."
+			Logger.info "Created table '#{klass::DBTABLE}'."
 		rescue => ex
 			if ex.errno == 1050 # table already exists.
-				$log.debug "Table already exists" if $DBG
+				Logger.debug "Table already exists" if $DBG
 			else
 				raise
 			end
@@ -308,16 +309,16 @@ class MysqlBackend < Og::Backend
 				
 				# gmosx: dont use DBTABLE here, perhaps the join class
 				# is not managed yet.
-				join_table = "#{Og::Utils.join_table(klass, join_class)}"
-				join_src = "#{Og::Utils.encode(klass)}_oid"
-				join_dst = "#{Og::Utils.encode(join_class)}_oid"
+				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
 					if ex.errno == 1050 # table already exists.
-						$log.debug "Join table already exists" if $DBG
+						Logger.debug "Join table already exists" if $DBG
 					else
 						raise
 					end

data/lib/og/backends/psql.rb

@@ -4,17 +4,55 @@
 # (c) 2004 Navel, all rights reserved.
 # $Id: psql.rb 194 2004-12-20 20:23:57Z gmosx $
 
-require "postgres"
+require 'postgres'
 
-require "og/backend"
+require 'og/backend'
 
-module Og
+class Og
 
-# = Utils
+# = PsqlBackend
 #
-# A collection of useful utilities.
+# Implements a PostgreSQL powered backend.
+# This backend is compatible with Michael Neumann's postgres-pr
+# pure ruby driver.
 #
-module Utils
+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
+				Logger.info "Database '#{config[:database]}' not found!"
+				PsqlBackend.create_db(config[:database], config[:user])
+				retry
+			end
+			raise
+		end
+	end
+
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Utilities
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Escape an SQL string
 	#
@@ -67,15 +105,15 @@ module Utils
 		elsif p.klass.ancestors.include?(Float)
 			return "#\{@#{p.symbol} || 'NULL'\}"		
 		elsif p.klass.ancestors.include?(String)
-			return "'#\{Og::Utils.escape(@#{p.symbol})\}'"
+			return "'#\{Og::PsqlBackend.escape(@#{p.symbol})\}'"
 		elsif p.klass.ancestors.include?(Time)
-			return %|#\{@#{p.symbol} ? "'#\{Og::Utils.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
+			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
 		elsif p.klass.ancestors.include?(Date)
-			return %|#\{@#{p.symbol} ? "'#\{Og::Utils.date(@#{p.symbol})\}'" : 'NULL'\}|
+			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.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)\}'" : "''"\}|
+			return %|#\{@#{p.symbol} ? "'#\{Og::PsqlBackend.escape(@#{p.symbol}.to_yaml)\}'" : "''"\}|
 		end
 	end		
 
@@ -90,9 +128,9 @@ module Utils
 		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}))"
+			return "Og::PsqlBackend.parse_timestamp(res.getvalue(tuple, #{idx}))"
 		elsif p.klass.ancestors.include?(Date)
-			return "Og::Utils.parse_date(res.getvalue(tuple, #{idx}))"
+			return "Og::PsqlBackend.parse_date(res.getvalue(tuple, #{idx}))"
 		elsif p.klass.ancestors.include?(TrueClass)
 			return "('true' == res.getvalue(tuple, #{idx}))"
 		else 
@@ -132,73 +170,36 @@ module Utils
 			prop_accessor :oid, Fixnum, :sql => "integer PRIMARY KEY"
 		}
 	end
-end
 
-# = 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",
-		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
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+	# Connection methods. 
+	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	# Create the database.
 	#
 	def self.create_db(database, user = nil, password = nil)
-		$log.info "Creating database '#{database}'."
+		Logger.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}'."
+		Logger.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
+		Logger.debug sql if $DBG
 		return @conn.exec(sql)
 	end
 	
 	# Execute an SQL query, no result returned.
 	#
 	def exec(sql)
-		$log.debug sql if $DBG
+		Logger.debug sql if $DBG
 		res = @conn.exec(sql)
 		res.clear()
 	end
@@ -207,12 +208,12 @@ class PsqlBackend < Og::Backend
 	# block.
 	#
 	def safe_query(sql)
-		$log.debug sql if $DBG
+		Logger.debug sql if $DBG
 		begin
 			return @conn.exec(sql)
 		rescue => ex
-			$log.error "DB error #{ex}, [#{sql}]"
-			$log.error ex.backtrace
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.error ex.backtrace
 			return nil
 		end
 	end
@@ -221,13 +222,13 @@ class PsqlBackend < Og::Backend
 	# block.
 	#
 	def safe_exec(sql)
-		$log.debug sql if $DBG
+		Logger.debug sql if $DBG
 		begin
 			res = @conn.exec(sql) 
 			res.clear()
 		rescue => ex
-			$log.error "DB error #{ex}, [#{sql}]"
-			$log.error ex.backtrace
+			Logger.error "DB error #{ex}, [#{sql}]"
+			Logger.error ex.backtrace
 		end
 	end
 
@@ -268,11 +269,11 @@ class PsqlBackend < Og::Backend
 
 		begin
 			exec(sql)
-			$log.info "Created table '#{klass::DBTABLE}'."
+			Logger.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
+				Logger.debug "Table already exists" if $DBG
 			else
 				raise
 			end
@@ -283,11 +284,11 @@ class PsqlBackend < Og::Backend
 		# the system more fault tolerant.
 		begin
 			exec "CREATE SEQUENCE #{klass::DBSEQ}"
-			$log.info "Created 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
-				$log.debug "Sequence already exists" if $DBG
+				Logger.debug "Sequence already exists" if $DBG
 			else
 				raise
 			end
@@ -303,9 +304,9 @@ class PsqlBackend < Og::Backend
 				
 				# gmosx: dont use DBTABLE here, perhaps the join class
 				# is not managed yet.
-				join_table = "#{Og::Utils.join_table(klass, join_class)}"
-				join_src = "#{Og::Utils.encode(klass)}_oid"
-				join_dst = "#{Og::Utils.encode(join_class)}_oid"
+				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)"
@@ -313,7 +314,7 @@ class PsqlBackend < Og::Backend
 				rescue => ex
 					# gmosx: any idea how to better test this?
 					if ex.to_s =~ /relation .* already exists/i
-						$log.debug "Join table already exists" if $DBG
+						Logger.debug "Join table already exists" if $DBG
 					else
 						raise
 					end
@@ -323,11 +324,11 @@ class PsqlBackend < Og::Backend
 		
 		begin
 			exec(sql)
-			$log.info "Created join table '#{join_table}'."
+			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
-				$log.debug "Join table already exists" if $DBG
+				Logger.debug "Join table already exists" if $DBG
 			else
 				raise
 			end