og 0.7.0 → 0.8.0

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

data/lib/og/connection.rb

@@ -4,7 +4,7 @@
 # (c) 2004 Navel, all rights reserved.
 # $Id: connection.rb 167 2004-11-23 14:03:10Z gmosx $
 
-module Og; 
+class Og; 
 
 require "glue/property"
 require "glue/array"
@@ -38,14 +38,14 @@ class Connection
 		@og = og
 		@db = @og.config[:backend].new(@og.config)
 		@deserialize = true
-		$log.debug "Created DB connection."
+		Logger.debug "Created DB connection." if $DBG 
 	end
 	
 	# Close the connection to the database
 	#
 	def close()
 		@db.close()
-		$log.debug "Closed DB connection."
+		Logger.debug "Closed DB connection." if $DBG
 	end
 
 	# Save an object to the database. Insert if this is a new object or
@@ -252,14 +252,13 @@ class Connection
 			yield(@db) 
 			@db.commit()
 		rescue => ex
-			$log.error "DB Error: ERROR IN TRANSACTION"
-			$log.error #{ex}
-			$log.error #{ex.backtrace}
+			Logger.error "DB Error: ERROR IN TRANSACTION"
+			Logger.error #{ex}
+			Logger.error #{ex.backtrace}
 			@db.rollback()
 		end
 	end
 		
 end
 
-end # module
-
+end 

data/lib/og/enchant.rb

@@ -0,0 +1,80 @@
+# code: 
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: meta.rb 198 2004-12-22 11:26:59Z gmosx $
+
+class Og
+
+module Enchant
+
+	# Enchant a managed class. Add useful DB related methods to the 
+	# class and its instances. 
+	#
+	def enchant(klass)
+		klass.module_eval <<-"end_eval", __FILE__, __LINE__
+			def self.create(*params)
+				obj = #{klass}.new(*params)
+				obj.save!
+			end
+				
+			def self.save(obj)
+				Og.db << obj
+			end
+			
+			def self.load(oid_or_name)
+				Og.db.load(oid_or_name, #{klass})
+			end
+
+			def self.[](oid_or_name)
+				Og.db.load(oid_or_name, #{klass})
+			end
+			
+			def self.load_all(extra_sql = nil)
+				Og.db.load_all(#{klass}, extra_sql)
+			end
+			
+			def self.all(extra_sql = nil)
+				Og.db.load_all(#{klass}, extra_sql)
+			end
+
+			def self.count(sql = "SELECT COUNT(*) FROM #{klass::DBTABLE}")
+				Og.db.count(sql, #{klass})
+			end
+
+			def self.select(sql)
+				Og.db.select(sql, #{klass})
+			end
+
+			def self.select_one(sql)
+				Og.db.select_one(sql, #{klass})
+			end
+
+			def self.one(sql)
+				Og.db.select_one(sql, #{klass})
+			end
+			
+			def self.delete(obj_or_oid)
+				Og.db.delete(obj_or_oid, #{klass})
+			end
+			
+			def save
+				Og.db << self
+				return self
+			end
+			alias_method :save!, :save
+			
+			def update_properties(updatesql)
+				Og.db.pupdate(updatesql, self.oid, #{klass})
+			end
+			alias_method :pupdate!, :update_properties
+			
+			def delete!
+				Og.db.delete(@oid, #{klass})
+			end
+		end_eval
+	end
+
+end
+	
+end # namespace