nitro 0.12.0 → 0.13.0

data/lib/og/connection.rb

@@ -1,304 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: connection.rb 270 2005-03-07 17:52:16Z gmosx $
-
-module Og; 
-
-require 'glue/property'
-require 'glue/array'
-require 'glue/time'
-
-# 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 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
-
-	# Read the first column of the resultset as an Integer.
-
-	def read_int(res, idx = 0)
-		raise 'Not implemented!'
-	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
-			# 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 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
-
-	# 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	
-
-	# 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, 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
-		
-end
-
-end 

data/lib/og/database.rb

@@ -1,282 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: database.rb 270 2005-03-07 17:52:16Z gmosx $
-
-require 'glue/logger'
-require 'glue/attribute'
-require 'glue/property'
-require 'glue/array'
-require 'glue/hash'
-require 'glue/time'
-require 'glue/pool'
-
-require 'og/enchant'
-require 'og/meta'
-require 'og/observer'
-
-module Og
-	
-# Encapsulates an Og Database.
-
-class Database
-	include Og::Enchant
-
-	# Managed class metadata
-	
-	class ManagedClassMeta
-		# The managed class.
-		attr_accessor :klass
-		
-		# A mapping of the database fields to the object properties.
-		attr_accessor :field_index
-		
-		def initialize(klass = nil)
-			@klass = klass
-			@field_index = {}
-		end
-	end
-
-	# hash of configuration options.
-
-	attr_accessor :config
-
-	# The adapter that comunicates with the backend
-	# datastore.
-
-	attr_accessor :adapter
-
-	# Pool of connections.
-	
-	attr_accessor :connection_pool
-
-	# Managed classes.
-	
-	attr_accessor :managed_classes
-
-	# Initialize the database interface.
-	
-	def initialize(config)
-		@config = config
-
-		# populate with default options if needed.
-		@config[:connection_count] ||= 1
-		
-		Logger.info "Connecting to database '#{@config[:database]}' using the '#{@config[:adapter]}' adapter."
-
-		@adapter =  Adapter.for_name(@config[:adapter])
-
-		@connection_pool = N::Pool.new
-		@managed_classes = N::SafeHash.new
-		
-		@config[:connection_count].times do
-			@connection_pool << @adapter.new_connection(self)
-		end
-	
-		# gmosx, FIXME: this automanage code is not elegant and slow
-		# should probably recode this, along with glue/property.rb
-		
-		if Og.auto_manage_classes
-			# automatically manage classes with properties and metadata.
-			# gmosx: Any idea how to optimize this?
-
-			classes_to_manage = []
-
-			ObjectSpace.each_object(Class) do |c|
-				if c.respond_to?(:__props) and c.__props
-					classes_to_manage << c
-				end
-			end
-			
-			Logger.debug "Og auto manages the following classes:"
-			Logger.debug "#{classes_to_manage.inspect}"
-			
-			manage_classes(*classes_to_manage)
-		end
-
-		# use the newly created database.
-		Og.use(self)
-	end
-		
-	# Shutdown the database interface.
-	
-	def shutdown
-		for con in @connection_pool
-			con.close()
-		end
-	end
-	alias_method :close, :shutdown
-
-	# Get a connection from the pool to access the database.
-	# Stores the connection in a thread-local variable.
-
-	def get_connection
-		thread = Thread.current
-		
-		unless conn = thread[:og_conn]
-			conn = @connection_pool.pop()
-			thread[:og_conn] = conn
-		end
-		
-		return conn
-	end
-	alias_method :connection, :get_connection
-	
-	# Restore an unused connection to the pool.
-	
-	def put_connection
-		thread = Thread.current
-		
-		if conn = thread[:og_conn]
-			thread[:og_conn] = nil
-			return @connection_pool.push(conn)
-		end
-	end	
-	
-	# Utility method, automatically restores a connection to the pool.
-	
-	def connect(&block)
-		result = nil
-		
-		begin
-			conn = get_connection
-			result = yield(conn)
-		ensure
-			put_connection
-		end
-
-		return result
-	end
-	alias_method :open, :connect
-	
-	# Register a standard Ruby class as managed.
-	
-	def manage(klass)
-		return if managed?(klass) or klass.ancestors.include?(Unmanageable)
-		
-		@managed_classes[klass] = ManagedClassMeta.new(klass)
-		
-		# Add standard og methods to the class.
-		convert(klass)
-		
-		# Add helper methods to the class.
-		enchant(klass) if Og.enchant_managed_classes 
-	end
-	
-	# Helper method to set multiple managed classes.
-	
-	def manage_classes(*klasses)
-		for klass in klasses
-			manage(klass)
-		end
-	end
-	
-	# Stop managing a Ruby class
-	
-	def unmanage(klass)
-		@managed_classes.delete(klass)
-	end
-	
-	# Is this class managed?
-	#	
-	def managed?(klass)
-		return @managed_classes.include?(klass)
-	end
-	
-	# Add standard og functionality to the class
-	
-	def convert(klass)
-		# gmosx: this check is needed to allow the developer to customize
-		# the sql generated for oid
-
-		@adapter.eval_og_oid(klass) unless klass.instance_methods.include?(:oid)
-		
-		klass.class_eval %{
-			DBTABLE = "#{Adapter.table(klass)}"
-			DBSEQ = "#{Adapter.table(klass)}_oid_seq" 
-	
-			cattr_accessor :og_db
-
-			def to_i
-				@oid
-			end			
-		}
-
-		# Set the adapter.
-
-		klass.og_db = self
-		
-		# Add observer support.
-		
-		klass.extend(Observable)
-
-		# Create the schema for this class if not available.
-		
-		@adapter.create_table(klass, self) if Og.create_schema				
-
-		# @adapter.eval_og_insert(klass, self)
-		# @adapter.eval_og_update(klass, self)
-		# @adapter.eval_og_read(klass, self)
-
-		@adapter.eval_lifecycle_methods(klass, self)
-	end
-	
-	# Automatically wrap connection methods.
-	
-	def self.wrap_method(method, args)
-		args = args.split(/,/)
-		class_eval %{
-			def #{method}(#{args.join(", ")})
-				thread = Thread.current
-				
-				unless conn = thread[:og_conn]
-					conn = @connection_pool.pop()
-					thread[:og_conn] = conn
-				end
-			
-				return conn.#{method}(#{args.collect {|a| a.split(/=/)[0]}.join(", ")})
-			end
-		}
-	end
-
-	wrap_method :db, ''
-	wrap_method :create_table, 'klass'
-	wrap_method :drop_table, 'klass'
-	wrap_method :save, 'obj';	alias_method :<<, :save; alias_method :put, :save
-	wrap_method :insert, 'obj'
-	wrap_method :update, 'obj'
-	wrap_method :update_properties, 'update_sql, obj_or_oid, klass = nil'
-	wrap_method :pupdate, 'update_sql, obj_or_oid, klass = nil'
-	wrap_method :load, 'oid, klass'; alias_method :get, :load	
-	wrap_method :load_by_oid, 'oid, klass'
-	wrap_method :load_by_name, 'name, klass'	
-	wrap_method :load_all, 'klass, extrasql = nil'
-	wrap_method :select, 'sql, klass'
-	wrap_method :select_one, 'sql, klass'
-	wrap_method :count, 'sql, klass = nil'
-	wrap_method :delete, 'obj_or_oid, klass = nil'	
-	wrap_method :prepare, 'sql'
-	wrap_method :query, 'sql'
-	wrap_method :exec, 'sql'
-
-	class << self
-
-		# Create a new database.
-
-		def create_db!(config)
-			adapter = Adapter.for_name(config[:adapter])
-			adapter.create_db(config[:database], config[:user], config[:password])
-		end
-		alias_method :create!, :create_db!
-
-		# Drop an existing database.
-
-		def drop_db!(config)
-			adapter = Adapter.for_name(config[:adapter])
-			adapter.drop_db(config[:database], config[:user], config[:password])
-		end
-		alias_method :drop!, :drop_db!
-		
-	end
-end
-
-end