og 0.16.0 → 0.17.0

data/test/og/tc_types.rb

@@ -0,0 +1,21 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+
+require 'test/unit'
+
+require 'og'
+
+class TestCaseOgTypes < Test::Unit::TestCase # :nodoc: all
+	include Og
+
+	class User
+		property :name, Og::VarChar(16), :unique => true
+
+		def initialize(name = nil)
+			@name = name
+		end
+	end
+	
+	def test_all
+		assert_equal [String, {:sql=>"VARCHAR(16)"}], Og::VarChar(16)
+	end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: og
 version: !ruby/object:Gem::Version 
-  version: 0.16.0
-date: 2005-04-18
+  version: 0.17.0
+date: 2005-05-16
 summary: Og (ObjectGraph)
 require_paths: 
   - lib
@@ -27,62 +27,66 @@ platform: ruby
 authors: 
   - George Moschovitis
 files: 
+  - README
   - CHANGELOG
-  - Rakefile
   - INSTALL
-  - README
+  - Rakefile
   - install.rb
   - benchmark/bench.rb
   - benchmark/sqlite-no-prepare.1.txt
   - benchmark/sqlite-no-prepare.2.txt
   - benchmark/sqlite-prepare.1.txt
   - benchmark/sqlite-prepare.2.txt
-  - examples/mock_example.rb
   - examples/run.rb
   - examples/mysql_to_psql.rb
   - examples/README
   - doc/tutorial.txt
   - doc/LICENSE
-  - doc/config.txt
   - doc/RELEASES
+  - doc/config.txt
   - doc/AUTHORS
   - lib/og
   - lib/og.rb
-  - lib/og/adapters
-  - lib/og/mixins
-  - lib/og/testing
-  - lib/og/typemacros.rb
-  - lib/og/enchant.rb
-  - lib/og/database.rb
-  - lib/og/meta.rb
-  - lib/og/validation.rb
+  - lib/og/collection.rb
+  - lib/og/entity.rb
+  - lib/og/relation.rb
+  - lib/og/relation
+  - lib/og/mixin
+  - lib/og/store
+  - lib/og/manager.rb
   - lib/og/errors.rb
-  - lib/og/adapters/filesys.rb
-  - lib/og/adapters/psql.rb
-  - lib/og/adapters/sqlite.rb
-  - lib/og/adapters/mysql.rb
-  - lib/og/adapters/oracle.rb
-  - lib/og/adapters/sqlserver.rb
-  - lib/og/adapters/base.rb
-  - lib/og/mixins/hierarchical.rb
-  - lib/og/mixins/tree.rb
-  - lib/og/mixins/orderable.rb
-  - lib/og/mixins/timestamped.rb
-  - lib/og/testing/mock.rb
+  - lib/og/store.rb
+  - lib/og/validation.rb
+  - lib/og/testing
+  - lib/og/types.rb
+  - lib/og/relation/belongs_to.rb
+  - lib/og/relation/has_many.rb
+  - lib/og/relation/has_one.rb
+  - lib/og/relation/refers_to.rb
+  - lib/og/relation/many_to_many.rb
+  - lib/og/relation/joins_many.rb
+  - lib/og/mixin/hierarchical.rb
+  - lib/og/mixin/orderable.rb
+  - lib/og/mixin/timestamped.rb
+  - lib/og/mixin/tree.rb
+  - lib/og/store/filesys.rb
+  - lib/og/store/psql.rb
+  - lib/og/store/sql.rb
+  - lib/og/store/mysql.rb
+  - lib/og/store/madeleine.rb
+  - lib/og/store/sqlserver.rb
+  - lib/og/store/sqlite.rb
+  - lib/og/store/memory.rb
   - test/og
-  - test/tc_og.rb
-  - test/og/adapters
-  - test/og/mixins
-  - test/og/tc_many_to_many.rb
-  - test/og/tc_validation.rb
-  - test/og/tc_lifecycle.rb
-  - test/og/tc_automanage.rb
-  - test/og/tc_meta.rb
-  - test/og/adapters/tc_filesys.rb
-  - test/og/adapters/tc_sqlite.rb
-  - test/og/adapters/tc_sqlserver.rb
-  - test/og/mixins/tc_hierarchical.rb
-  - test/og/mixins/tc_orderable.rb
+  - test/og/store
+  - test/og/mixin
+  - test/og/tc_types.rb
+  - test/og/tc_relation.rb
+  - test/og/tc_store.rb
+  - test/og/store/tc_filesys.rb
+  - test/og/mixin/tc_hierarchical.rb
+  - test/og/mixin/tc_orderable.rb
+  - test/og/mixin/tc_timestamped.rb
 test_files: []
 rdoc_options: 
   - "--main"
@@ -108,5 +112,15 @@ dependencies:
         - 
           - "="
           - !ruby/object:Gem::Version 
-            version: 0.16.0
+            version: 0.17.0
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: facets
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.7.1
       version: 

data/examples/mock_example.rb

@@ -1,50 +0,0 @@
-# = Og Mocking Example 
-#
-# A simple example to demonstrate how to mock Og.
-# Very useful in test units.
-#
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: mock_example.rb 1 2005-04-11 11:04:30Z gmosx $
-
-require 'rubygems'
-require 'flexmock'
-require 'og'
-require 'og/mock'
-
-class Article
-	prop_accessor :body, String
-
-	def initialize(body = nil)
-		@body = body
-	end
-end
-
-class SimpleTest < Test::Unit::TestCase
-
-	def setup
-		@og = Og::MockDatabase.new
-	end
-
-	def teardown
-		@og = nil
-	end
-
-	def test_me
-		mocks = [
-			Article.new('body1'),
-			Article.new('body2'),
-			Article.new('body3')
-		]
-		@og.mock_handle(:load_all) { |klass, extrasql| mocks }
-
-		# differnt ways to call the mocked method...
-		puts 'Here are the articles:', Article.all
-		puts 'Here are the articles:', Article.load_all
-		puts 'Here are the articles:', @og.load_all(Article)
-
-		# 3 times called
-		assert_equal(3, @og.mock_count(:load_all))
-	end
-
-end

data/lib/og/adapters/base.rb

@@ -1,706 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: base.rb 17 2005-04-14 16:03:40Z gmosx $
-
-require 'yaml'
-require 'singleton'
-
-require 'glue/property'
-require 'glue/array'
-require 'glue/time'
-require 'glue/attribute'
-
-require 'og'
-require 'og/errors'
-
-module Og
-
-# An adapter communicates with the backend datastore. 
-# The adapters for all supported datastores extend this 
-# class. Typically, an RDBMS is used to implement a
-# datastore. 
-#
-# This is the base adapter implementation. Adapters for
-# well known RDBMS systems and other stores inherit 
-# from this class.
-
-class Adapter 
-	include Singleton
-
-	# A mapping between Ruby and backend Datastore types.
-
-	attr_accessor :typemap
-
-	# A map for casting Ruby types to SQL safe textual
-	# representations.
-
-	attr_accessor :typecast
-	
-	# Lookup the adapter instance from the adapter name.
-
-	def self.for_name(name)
-		# gmosx: RDoc complains about this, so lets use an
-		# eval, AAAAAAAARGH!
-		#	require "og/adapters/#{name}"
-		eval %{	
-			require 'og/adapters/#{name}'
-			return  #{name.capitalize}Adapter.instance 
-		}
-	end
-
-	def initialize
-		# The default mappings, should be valid for most
-		# RDBMS.
-
-		@typemap = {
-			Integer => 'integer',
-			Fixnum => 'integer',
-			Float => 'float',
-			String => 'text',
-			Time => 'timestamp',
-			Date => 'date',
-			TrueClass => 'boolean',
-			Object => 'text',
-			Array => 'text',
-			Hash => 'text'
-		}
-
-		# The :s: is a marker that will be replaced with the
-		# actual value to be casted. The default parameter of
-		# the Hash handles all other types (Object, Array, etc)
-
-		@typecast = Hash.new("'#\{#{self.class}.escape(:s:.to_yaml)\}'").update(
-			Integer => "\#\{:s:\}",
-			Float => "\#\{:s:\}",
-			String => "'#\{#{self.class}.escape(:s:)\}'",
-			Time => "'#\{#{self.class}.timestamp(:s:)\}'",
-			Date => "'#\{#{self.class}.date(:s:)\}'",
-			TrueClass => "#\{:s: ? \"'t'\" : 'NULL' \}"
-		)
-	end
-
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-	# :section: 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 nil unless 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
-
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-	# :section: Database methods 
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-	# Create the database.
-	
-	def create_db(database, user = nil, password = nil)
-		Logger.info "Creating database '#{database}'."
-		Og.create_schema = true
-	end
-	
-	# Drop the database.
-	
-	def drop_db(database, user = nil, password = nil)
-		Logger.info "Dropping database '#{database}'."
-	end
-
-	# Create a new connection to the backend.
-
-	def new_connection(db)
-		return Connection.new(db)
-	end
-
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-	# :section: O->R mapping methods and 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. A prefix is needed to avoid colision with
-	# reserved prefices (for example User maps to user which
-	# is reserved in postgresql). The prefix should start
-	# with an alphanumeric character to be compatible with
-	# all RDBMS (most notable Oracle).
-	#
-	# You may want to override this method to map an existing
-	# database schema using Og.
-	
-	def self.table(klass)
-		"og_#{Og.table_prefix}#{encode(klass)}"
-	end
-
-	# The name of the join table for the two given classes.
-	# A prefix is needed to avoid colision with reserved 
-	# prefices (for example User maps to user which
-	# is reserved in postgresql). The prefix should start
-	# with an alphanumeric character to be compatible with
-	# all RDBMS (most notable Oracle).
-	#
-	# You may want to override this method to map an existing
-	# database schema using Og.
-	
-	def self.join_table(klass1, klass2, field)
-		"og_#{Og.table_prefix}j_#{encode(klass1)}_#{encode(klass2)}_#{field}"
-	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 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 %|#\{@#{p.symbol} ? "'#\{#{self.class}.escape(@#{p.symbol})\}'" : 'NULL'\}|
-		elsif p.klass.ancestors.include?(Time)
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.timestamp(@#{p.symbol})\}'" : 'NULL'\}|
-		elsif p.klass.ancestors.include?(Date)
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.date(@#{p.symbol})\}'" : 'NULL'\}|
-		elsif p.klass.ancestors.include?(TrueClass)
-			return "#\{@#{p.symbol} ? \"'t'\" : 'NULL' \}"
-		else 
-			# gmosx: keep the '' for nil symbols.
-			return %|#\{@#{p.symbol} ? "'#\{#{self.class}.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 read_prop(p, idx)
-		if p.klass.ancestors.include?(Integer)
-			return "res[#{idx}].to_i"
-		elsif p.klass.ancestors.include?(Float)
-			return "res[#{idx}].to_f"
-		elsif p.klass.ancestors.include?(String)
-			return "res[#{idx}]"
-		elsif p.klass.ancestors.include?(Time)
-			return "#{self.class}.parse_timestamp(res[#{idx}])"
-		elsif p.klass.ancestors.include?(Date)
-			return "#{self.class}.parse_date(res[#{idx}])"
-		elsif p.klass.ancestors.include?(TrueClass)
-			return "('0' != res[#{idx}])"
-		else 
-			return "YAML::load(res[#{idx}])"
-		end				
-	end
-
-	# 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.
-	
-	def create_fields(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]}"
-				
-				if p.meta
-					# set default value (gmosx: not that useful in the
-					# current implementation).
-					if default = p.meta[:default]
-						field << " DEFAULT #{default.inspect} NOT NULL"
-					end
-				
-					# set unique
-					field << " UNIQUE" if p.meta[:unique]
-
-					# attach extra sql
-					if extra_sql = p.meta[:extra_sql]
-						field << " #{extra_sql}"
-					end
-				end
-			end
-			
-			fields << field 
-		end
-
-		return fields
-	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
-
-	# Returns the props that will be included in the insert query.
-	# For some backends the oid should be stripped.
-	
-	def props_for_insert(klass)
-		klass.__props
-	end
-
-	# Returns the code that actually inserts the object into the
-	# database. Returns the code as String.
-	
-	def insert_code(klass, sql, pre_cb, post_cb)
-		raise 'Not implemented!'
-	end
-	
-	# Generate the mapping of the database fields to the
-	# object properties.
-	
-	def calc_field_index(klass, og)
-		# Implement if needed.
-	end
-
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-	# :section: Precompile lifecycle methods.
-	# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-	# Precompile some code that gets executed all the time.
-	# Deletion code is not precompiled, because it is not used
-	# as frequently.
-
-	def eval_lifecycle_methods(klass, db)
-		eval_og_insert(klass, db)
-		eval_og_update(klass, db)
-		eval_og_read(klass, db)
-	end
-		
-	# Generate the property for oid.
-
-	def eval_og_oid(klass)
-		klass.class_eval %{
-			prop_accessor :oid, Fixnum, :sql => "integer PRIMARY KEY"
-		}
-	end
-
-	# Precompile the insert code for the given class.
-	# The generated code sets the oid when inserting!
-	
-	def eval_og_insert(klass, db)
-		klass.class_eval %{
-			def og_insert(conn)
-				#{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
-				#{insert_code(klass, db)}
-				#{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
-			end
-		}
-	end
-
-	# Precompile the update code for the given class.
-	# Ignore the oid when updating!
-	
-	def eval_og_update(klass, db)
-		props = klass.__props.reject { |p| :oid == p.symbol }
-		
-		updates = props.collect { |p|
-			"#{p.name}=#{write_prop(p)}"
-		}
-
-		sql = "UPDATE #{klass::DBTABLE} SET #{updates.join(', ')} WHERE oid=#\{@oid\}"
-
-		klass.class_eval %{
-			def og_update(conn)
-				#{Aspects.gen_advice_code(:og_update, klass.advices, :pre) if klass.respond_to?(:advices)}
-				conn.exec "#{sql}"
-				#{Aspects.gen_advice_code(:og_update, klass.advices, :post) if klass.respond_to?(:advices)}
-			end
-		}
-	end
-
-	# Precompile the code to read (deserialize) 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 eval_og_read(klass, db)
-		calc_field_index(klass, db)
-		
-		props = klass.__props 
-		code = []
-
-		props.each do |p|
-			if idx = db.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} = #{read_prop(p, idx)}"
-			end
-		end
-
-		klass.class_eval %{
-	 		def og_read(res, tuple = 0)
-				#{Aspects.gen_advice_code(:og_read, klass.advices, :pre) if klass.respond_to?(:advices)}
-				#{code.join('; ')}
-				#{Aspects.gen_advice_code(:og_read, klass.advices, :post) if klass.respond_to?(:advices)}
-			end
-		}
-	end				
-
-end
-
-# A Connection to the Database. This file defines the skeleton 
-# functionality. A store specific implementation file (adapter) 
-# implements all methods.
-#--
-# - support caching (memoize).
-# - use 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
-
-	# Get a row from the resultset.
-
-	def get_row(res)
-		return res
-	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
-	alias_method :update_propery, :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, obj_or_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
-	
-	protected
-
-	# Handles an adapter exception.
-
-	def handle_db_exception(ex, sql = nil)
-		Logger.error "DB error #{ex}, [#{sql}]"
-		Logger.error ex.backtrace.join("\n")
-		raise SqlException.new(ex, sql) if Og.raise_db_exceptions
-
-		# FIXME: should return :error or something.
-
-		return nil 
-	end
-
-end
-
-end