lafcadio 0.9.0 → 0.9.1

data/lib/lafcadio/objectField.rb~

@@ -12,10 +12,10 @@ module Lafcadio
 
 		def self.instantiate_from_xml( domain_class, fieldElt ) #:nodoc:
 			parameters = instantiation_parameters( fieldElt )
-			instantiate_with_parameters( domain_class, parameters )
+			create_with_args( domain_class, parameters )
 		end
 
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
+		def self.create_with_args( domain_class, parameters ) #:nodoc:
 			instance = self.new( domain_class, parameters['name'] )
 			if ( db_field_name = parameters['db_field_name'] )
 				instance.db_field_name = db_field_name
@@ -277,7 +277,7 @@ module Lafcadio
 			( $' || linked_type.name ).camel_case_to_underscore
 		end
 
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
+		def self.create_with_args( domain_class, parameters ) #:nodoc:
 			linked_type = parameters['linked_type']
 			instance = self.new(
 				domain_class, linked_type,
@@ -293,7 +293,7 @@ module Lafcadio
 		def self.instantiation_parameters( fieldElt ) #:nodoc:
 			parameters = super( fieldElt )
 			linked_typeStr = fieldElt.attributes['linked_type']
-			linked_type = DomainObject.get_domain_class_from_string( linked_typeStr )
+			linked_type = Class.by_name linked_typeStr
 			parameters['linked_type'] = linked_type
 			parameters['delete_cascade'] = fieldElt.attributes['delete_cascade'] == 'y'
 			parameters
@@ -395,7 +395,7 @@ module Lafcadio
 	# enums as the +enums+ argument.
 	#
 	class EnumField < StringField
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
+		def self.create_with_args( domain_class, parameters ) #:nodoc:
 			self.new( domain_class, parameters['name'], parameters['enums'] )
 		end
 
@@ -457,7 +457,7 @@ module Lafcadio
 
 	# FloatField represents a decimal value.
 	class FloatField < ObjectField
-		def self.instantiate_with_parameters( domain_class, parameters ) #:nodoc:
+		def self.create_with_args( domain_class, parameters ) #:nodoc:
 			self.new( domain_class, parameters['name'] )
 		end
 
@@ -504,7 +504,7 @@ module Lafcadio
 	end
 
 	class SubsetDomainObjectField < DomainObjectField #:nodoc:
-		def self.instantiate_with_parameters( domain_class, parameters )
+		def self.create_with_args( domain_class, parameters )
 			self.new( domain_class, parameters['linked_type'],
 			          parameters['subset_field'], parameters['name'] )
 		end

data/lib/lafcadio/objectStore.rb

@@ -5,238 +5,18 @@ require 'lafcadio/query'
 require 'lafcadio/util'
 
 module Lafcadio
-	class Committer #:nodoc:
-		INSERT 	= 1
-		UPDATE 	= 2
-		DELETE  = 3
-
-		attr_reader :commit_type, :db_object
-
-		def initialize(db_object, dbBridge, cache)
-			@db_object = db_object
-			@dbBridge = dbBridge
-			@cache = cache
-			@objectStore = ObjectStore.get_object_store
-			@commit_type = nil
-		end
-		
-		def execute
-			@db_object.verify if LafcadioConfig.new()['checkFields'] == 'onCommit'
-			set_commit_type
-			@db_object.last_commit = get_last_commit
-			@db_object.pre_commit_trigger
-			update_dependent_domain_objects if @db_object.delete
-			@dbBridge.commit @db_object
-			unless @db_object.pk_id
-				@db_object.pk_id = @dbBridge.last_pk_id_inserted
-			end
-			@cache.update_after_commit self
-			@db_object.post_commit_trigger
-		end
-
-		def get_last_commit
-			if @db_object.delete
-				DomainObject::COMMIT_DELETE
-			elsif @db_object.pk_id
-				DomainObject::COMMIT_EDIT
-			else
-				DomainObject::COMMIT_ADD
-			end
-		end
-		
-		def set_commit_type
-			if @db_object.delete
-				@commit_type = DELETE
-			elsif @db_object.pk_id
-				@commit_type = UPDATE
-			else
-				@commit_type = INSERT
-			end
-		end
-
-		def update_dependent_domain_objects
-			dependent_classes = @db_object.domain_class.dependent_classes
-			dependent_classes.keys.each { |aClass|
-				field = dependent_classes[aClass]
-				collection = @objectStore.get_filtered( aClass.name, @db_object,
-																							 field.name )
-				collection.each { |dependentObject|
-					if field.delete_cascade
-						dependentObject.delete = true
-					else
-						dependentObject.send( field.name + '=', nil )
-					end
-					@objectStore.commit(dependentObject)
-				}
-			}
-		end
-	end
-
-	class CouldntMatchDomainClassError < RuntimeError #:nodoc:
-	end
-
-	class DbBridge #:nodoc:
-		@@last_pk_id_inserted = nil
-		
-		def self._load(aString)
-			aString =~ /db_conn:/
-			db_conn_str = $'
-			begin
-				db_conn = Marshal.load db_conn_str
-			rescue TypeError
-				db_conn = nil
-			end
-			DbConnection.set_db_connection db_conn
-			new
-		end
-		
-		def initialize
-			@db_conn = DbConnection.get_db_connection
-			ObjectSpace.define_finalizer( self, proc { |id|
-				DbConnection.get_db_connection.disconnect
-			} )
-		end
-
-		def _dump(aDepth)
-			dbDump = @dbh.respond_to?( '_dump' ) ? @dbh._dump : @dbh.class.to_s
-			"dbh:#{dbDump}"
-		end
-		
-		def commit(db_object)
-			sqlMaker = DomainObjectSqlMaker.new(db_object)
-			sqlMaker.sql_statements.each { |sql, binds| execute_commit( sql, binds ) }
-			if sqlMaker.sql_statements[0].first =~ /insert/
-				sql = 'select last_insert_id()'
-				result = execute_select( sql )
-				@@last_pk_id_inserted = result[0]['last_insert_id()'].to_i
-			end
-		end
-		
-		def execute_commit( sql, binds ); @db_conn.do( sql, *binds ); end
-		
-		def execute_select(sql)
-			maybe_log sql
-			begin
-				@db_conn.select_all( sql )
-			rescue DBI::DatabaseError => e
-				raise $!.to_s + ": #{ e.errstr }"
-			end	
-		end
-		
-		def get_collection_by_query(query)
-			domain_class = query.domain_class
-			execute_select( query.to_sql ).collect { |row_hash|
-				domain_class.new( SqlValueConverter.new( domain_class, row_hash ) )
-			}
-		end
-		
-		def group_query( query )
-			execute_select( query.to_sql ).map { |row| query.result_row( row ) }
-		end
-
-		def last_pk_id_inserted; @@last_pk_id_inserted; end
-		
-		def maybe_log(sql)
-			config = LafcadioConfig.new
-			if config['logSql'] == 'y'
-				sqllog = Log4r::Logger['sql'] || Log4r::Logger.new( 'sql' )
-				filename = File.join( config['logdir'], config['sqlLogFile'] || 'sql' )
-				outputter = Log4r::FileOutputter.new( 'outputter',
-																							{ :filename => filename } )
-				sqllog.outputters = outputter
-				sqllog.info sql
-			end
-		end
-		
-		def transaction( action )
-			tr = Transaction.new @db_conn
-			tr.commit
-			begin
-				action.call tr
-				tr.commit
-			rescue RollbackError
-				# rollback handled by Transaction
-			rescue
-				err_to_raise = $!
-				tr.rollback false
-				raise err_to_raise
-			end
-		end
-		
-		class Transaction
-			def initialize( db_conn ); @db_conn = db_conn; end
-			
-			def commit; @db_conn.commit; end
-				
-			def rollback( raise_error = true )
-				@db_conn.rollback
-				raise RollbackError if raise_error
-			end
-		end
-		
-		class RollbackError < StandardError; end
-	end
-
-	class DbConnection < ContextualService::Service
-		@@connectionClass = DBI
-		@@db_name = nil
-		@@dbh = nil
-
-		def self.flush
-			DbConnection.set_db_connection( nil )
-			@@dbh = nil
-		end
-
-		def self.set_connection_class( aClass ); @@connectionClass = aClass; end
-
-		def self.set_db_name( db_name ); @@db_name = db_name; end
-
-		def self.set_dbh( dbh ); @@dbh = dbh; end
-		
-		def initialize
-			@@dbh = load_new_dbh if @@dbh.nil?
-			@dbh = @@dbh
-		end
-	
-		def disconnect; @dbh.disconnect if @dbh; end
-		
-		def load_new_dbh
-			config = LafcadioConfig.new
-			dbName = @@db_name || config['dbname']
-			dbAndHost = nil
-			if dbName && config['dbhost']
-				dbAndHost = "dbi:Mysql:#{ dbName }:#{ config['dbhost'] }"
-			else
-				dbAndHost = "dbi:#{config['dbconn']}"
-			end
-			@@dbh = @@connectionClass.connect( dbAndHost, config['dbuser'],
-																				 config['dbpassword'] )
-			@@dbh['AutoCommit'] = false
-			@@dbh
-		end
-		
-		def method_missing( symbol, *args )
-			@dbh.send( symbol, *args )
-		end
-	end
-
 	class DomainObjectInitError < RuntimeError #:nodoc:
-		attr_reader :messages
-
-		def initialize(messages)
-			@messages = messages
-		end
 	end
 
 	class DomainObjectNotFoundError < RuntimeError #:nodoc:
 	end
 
 	# The DomainObjectProxy is used when retrieving domain objects that are 
-	# linked to other domain objects with DomainObjectFields. In terms of +domain_class+
-	# and 
-	# +pk_id+, a DomainObjectProxy instance looks to the outside world like the 
-	# domain object it's supposed to represent. It only retrieves its domain 
-	# object from the database when member data is requested.
+	# linked to other domain objects with DomainObjectFields. In terms of
+	# +domain_class+ and +pk_id+, a DomainObjectProxy instance looks to the
+	# outside world like the domain object it's supposed to represent. It only
+	# retrieves its domain object from the database when member data is
+	# requested.
 	#
 	# In normal usage you will probably never manipulate a DomainObjectProxy
 	# directly, but you may discover it by accident by calling
@@ -247,122 +27,43 @@ module Lafcadio
 
 		attr_accessor :domain_class, :pk_id
 
-		def initialize(domain_classOrDbObject, pk_id = nil)
-			if pk_id
-				@domain_class = domain_classOrDbObject
-				@pk_id = pk_id
-			elsif domain_classOrDbObject.class < DomainObject
-				@db_object = domain_classOrDbObject
+		def initialize( *args ) #:nodoc:
+			if args.size == 2
+				@domain_class = args.first
+				@pk_id = args.last
+			elsif args.first.is_a?( DomainObject )
 				@d_obj_retrieve_time = Time.now
-				@domain_class = @db_object.class
-				@pk_id = @db_object.pk_id
+				@domain_class = args.first.class
+				@pk_id = args.first.pk_id
 			else
 				raise ArgumentError
 			end
-			@db_object = nil
 		end
 
-		def get_db_object
-			object_store = ObjectStore.get_object_store
+		def db_object #:nodoc:
 			if @db_object.nil? || needs_refresh?
-				@db_object = object_store.get( @domain_class, @pk_id )
+				@db_object = ObjectStore.get_object_store.get( @domain_class, @pk_id )
 				@d_obj_retrieve_time = Time.now
 			end
 			@db_object
 		end
 
-		def hash
-			get_db_object.hash
+		def hash #:nodoc:
+			db_object.hash
 		end
 
-		def method_missing(methodId, *args)
-			get_db_object.send(methodId.id2name, *args)
+		def method_missing( methodId, *args ) #:nodoc:
+			db_object.send( methodId, *args )
 		end
 
-		def needs_refresh?
+		def needs_refresh? #:nodoc:
 			object_store = ObjectStore.get_object_store
 			last_commit_time = object_store.last_commit_time( @domain_class, @pk_id )
-			!last_commit_time.nil? && last_commit_time > @d_obj_retrieve_time
+			last_commit_time && last_commit_time > @d_obj_retrieve_time
 		end
 		
-		def to_s
-			get_db_object.to_s
-		end
-	end
-
-	class DomainObjectSqlMaker #:nodoc:
-		attr_reader :bind_values
-
-		def initialize(obj); @obj = obj; end
-
-		def delete_sql( domain_class )
-			"delete from #{ domain_class.table_name} " +
-					"where #{ domain_class.sql_primary_key_name }=#{ @obj.pk_id }"
-		end
-
-		def get_name_value_pairs( domain_class )
-			nameValues = []
-			domain_class.class_fields.each { |field|
-				unless field.instance_of?( PrimaryKeyField )
-					value = @obj.send(field.name)
-					unless field.db_will_automatically_write
-						nameValues << field.name_for_sql
-						nameValues <<(field.value_for_sql(value))
-					end
-					if field.bind_write?
-						@bind_values << value
-					end
-				end
-			}
-			QueueHash.new( *nameValues )
-		end
-
-		def insert_sql( domain_class )
-			fields = domain_class.class_fields
-			nameValuePairs = get_name_value_pairs( domain_class )
-			if domain_class.is_based_on?
-				nameValuePairs[domain_class.sql_primary_key_name] = 'LAST_INSERT_ID()'
-			end
-			fieldNameStr = nameValuePairs.keys.join ", "
-			fieldValueStr = nameValuePairs.values.join ", "
-			"insert into #{ domain_class.table_name}(#{fieldNameStr}) " +
-					"values(#{fieldValueStr})"
-		end
-
-		def sql_statements
-			statements = []
-			if @obj.error_messages.size > 0
-				raise DomainObjectInitError, @obj.error_messages, caller
-			end
-			@obj.class.self_and_concrete_superclasses.each { |domain_class|
-				statements << statement_bind_value_pair( domain_class )
- 			}
-			statements.reverse
-		end
-
-		def statement_bind_value_pair( domain_class )
-			@bind_values = []
-			if @obj.pk_id == nil
-				statement = insert_sql( domain_class )
-			else
-				if @obj.delete
-					statement = delete_sql( domain_class )
-				else
-					statement = update_sql( domain_class)
-				end
-			end
-			[statement, @bind_values]
-		end
-
-		def update_sql( domain_class )
-			nameValueStrings = []
-			nameValuePairs = get_name_value_pairs( domain_class )
-			nameValuePairs.each { |key, value|
-				nameValueStrings << "#{key}=#{ value }"
-			}
-			allNameValues = nameValueStrings.join ', '
-			"update #{ domain_class.table_name} set #{allNameValues} " +
-					"where #{ domain_class.sql_primary_key_name}=#{@obj.pk_id}"
+		def to_s #:nodoc:
+			db_object.to_s
 		end
 	end
 
@@ -379,29 +80,31 @@ module Lafcadio
 	# [dbhost]     The database host.
 	#
 	# = Instantiating ObjectStore
-	# The ObjectStore is a ContextualService, meaning you can't get an instance by
-	# calling ObjectStore.new. Instead, you should call
-	# ObjectStore.get_object_store. (Using a ContextualService makes it easier to
-	# make out the ObjectStore for unit tests: See ContextualService for more.)
+	# You can't get an instance of ObjectStore by calling ObjectStore.new.
+	# Instead, you should call ObjectStore.get_object_store.
 	#
 	# = Dynamic method calls
 	# ObjectStore uses reflection to provide a lot of convenience methods for
 	# querying domain objects in a number of ways.
-	# [ObjectStore#get< domain class > (pk_id)]
+	# [ObjectStore#< domain class >( pk_id )]
 	#   Retrieves one domain object by pk_id. For example,
-	#     ObjectStore#getUser( 100 )
-	#   will return User 100.
-	# [ObjectStore#get< domain class >s (searchTerm, fieldName = nil)]
+	#     ObjectStore#user( 100 )
+	#   will return User 100. Note that you can also just user DomainObject.[]:
+	#     User[100]
+	# [ObjectStore#< plural of domain class >( searchTerm, fieldName = nil )]
 	#   Returns a collection of all instances of that domain class matching that
 	#   search term. For example,
-	#     ObjectStore#getProducts( aProductCategory )
+	#     ObjectStore#products( a_product_category )
 	#   queries MySQL for all products that belong to that product category. You
 	#   can omit +fieldName+ if +searchTerm+ is a non-nil domain object, and the
 	#   field connecting the first domain class to the second is named after the
 	#   domain class. (For example, the above line assumes that Product has a
-	#   field named "productCategory".) Otherwise, it's best to include
+	#   field named "product_category".) Otherwise, it's best to include
 	#   +fieldName+:
-	#     ObjectStore#getUsers( "Jones", "lastName" )
+	#     ObjectStore#users( "Jones", "lastName" )
+	#   Note that these can also be accessed through DomainObject.get:
+	#     Product.get( a_product_category )
+	#     User.get( "Jones", "lastName" )
 	#
 	# = Querying
 	# ObjectStore can also be used to generate complex, ad-hoc queries which
@@ -409,14 +112,19 @@ module Lafcadio
 	# Furthermore, these queries can be run against in-memory data stores, which
 	# is particularly useful for tests.
 	#   date = Date.new( 2003, 1, 1 )
-	#   ObjectStore#getInvoices { |invoice|
-	#     Query.And( invoice.date.gte( date ), invoice.rate.equals( 10 ),
-	#                invoice.hours.equals( 10 ) )
+	#   ObjectStore#invoices { |invoice|
+	#     invoice.date.gte( date ) & invoice.rate.equals( 10 ) &
+	#                invoice.hours.equals( 10 )
 	#   }
 	# is the same as
 	#   select * from invoices
 	#   where (date >= '2003-01-01' and rate = 10 and hours = 10)
-	# See lafcadio/query.rb for more.
+	# Note that you can also use DomainObject.get:
+	#   Invoice.get { |invoice|
+	#     invoice.date.gte( date ) & invoice.rate.equals( 10 ) &
+	#                invoice.hours.equals( 10 )
+	#   }
+	# See lafcadio/query.rb for more on the query inference syntax.
 	#
 	# = SQL Logging
 	# Lafcadio uses log4r to log all of its SQL statements. The simplest way to
@@ -430,60 +138,43 @@ module Lafcadio
 	# = Triggers
 	# Domain classes can be set to fire triggers either before or after commits.
 	# Since these triggers are executed in Ruby, they're easy to test. See
-	# DomainObject#pre_commit_trigger and DomainObject#post_commit_trigger for more.
+	# DomainObject#pre_commit_trigger and DomainObject#post_commit_trigger for
+	# more.
 	class ObjectStore < ContextualService::Service
-		def self.set_db_name(dbName) #:nodoc:
-			DbConnection.set_db_name dbName
-		end
+		# Returns true if the current stored instance is a MockObjectStore.
+		def self.mock?; get_object_store.mock?; end
 		
-		def initialize( dbBridge = nil ) #:nodoc:
-			@dbBridge = dbBridge == nil ? DbBridge.new : dbBridge
-			@cache = ObjectStore::Cache.new( @dbBridge )
-		end
-
-		# Commits a domain object to the database. You can also simply call
-		#   myDomainObject.commit
-		def commit(db_object)
-			@cache.commit( db_object )
-			db_object
-		end
+		@@db_bridge = nil
 		
-		# Flushes one domain object from its cache.
-		def flush(db_object)
-			@cache.flush db_object
+		# Returns the DbBridge; this is useful in case you need to use raw SQL for
+		# a specific query.
+		def self.db_bridge; @@db_bridge ||= DbBridge.new; end
+			
+		def self.db_name= (dbName)
+			DbConnection.db_name= dbName
 		end
-
-		# Returns the domain object corresponding to the domain class and pk_id.
-		def get( domain_class, pk_id )
-			query = Query.new domain_class, pk_id
-			@cache.get_by_query( query )[0] ||
-			    ( raise( DomainObjectNotFoundError,
-					         "Can't find #{domain_class} #{pk_id}", caller ) )
+		
+		def initialize #:nodoc:
+			@cache = ObjectStore::Cache.new self.class.db_bridge
 		end
 
 		# Returns all domain objects for the given domain class.
-		def get_all(domain_class); @cache.get_by_query( Query.new( domain_class ) ); end
-
-		# Returns the DbBridge; this is useful in case you need to use raw SQL for a
-		# specific query.
-		def get_db_bridge; @dbBridge; end
-		
-		def get_field_name( domain_object )
-			domain_object.domain_class.basename.camel_case_to_underscore
+		def all(domain_class)
+			@cache.get_by_query( Query.new( domain_class ) )
 		end
 
-		def get_filtered(domain_class_name, searchTerm, fieldName = nil) #:nodoc:
-			domain_class = DomainObject.get_domain_class_from_string(
-				domain_class_name
+		# Returns the DbBridge; this is useful in case you need to use raw SQL for
+		# a specific query.
+		def db_bridge; @cache.db_bridge; end
+		
+		# Returns the domain object corresponding to the domain class and pk_id.
+		def get( domain_class, pk_id )
+			@cache.get_by_query( Query.new( domain_class, pk_id ) ).first or (
+				raise(
+					DomainObjectNotFoundError, "Can't find #{domain_class} #{pk_id}",
+					caller
+				)
 			)
-			unless fieldName
-				fieldName = domain_class.get_link_field( searchTerm.domain_class ).name
-			end
-			get_subset( Query::Equals.new( fieldName, searchTerm, domain_class ) )
-		end
-
-		def get_map_match( domain_class, mapped ) #:nodoc:
-			Query::Equals.new( get_field_name( mapped ), mapped, domain_class )
 		end
 
 		def get_map_object( domain_class, map1, map2 ) #:nodoc:
@@ -491,48 +182,53 @@ module Lafcadio
 				raise ArgumentError,
 						"ObjectStore#get_map_object needs two non-nil keys", caller
 			end
-			mapMatch1 = get_map_match domain_class, map1
-			mapMatch2 = get_map_match domain_class, map2
-			condition = Query::CompoundCondition.new mapMatch1, mapMatch2
-			get_subset(condition)[0]
+			query = Query.infer( domain_class ) { |dobj|
+				dobj.send(
+					map1.domain_class.basename.camel_case_to_underscore
+				).equals( map1 ) &
+				dobj.send(
+					map2.domain_class.basename.camel_case_to_underscore
+				).equals( map2 )
+			}
+			query( query ).first
 		end
 
-		def get_mapped(searchTerm, resultTypeName) #:nodoc:
-			resultType = DomainObject.get_domain_class_from_string resultTypeName
-			firstTypeName = searchTerm.class.basename
-			secondTypeName = resultType.basename
-			mapTypeName = firstTypeName + secondTypeName
-			get_filtered( mapTypeName, searchTerm ).collect { |mapObj|
-				mapObj.send( resultType.name.decapitalize )
-			}
+		def group_query( query ) #:nodoc:
+			@cache.group_query( query )
 		end
-		
+
 		# Retrieves the maximum value across all instances of one domain class.
-		#   ObjectStore#get_max( Client )
+		#   ObjectStore#max( Client )
 		# returns the highest +pk_id+ in the +clients+ table.
-		#   ObjectStore#get_max( Invoice, "rate" )
+		#   ObjectStore#max( Invoice, "rate" )
 		# will return the highest rate for all invoices.
-		def get_max( domain_class, field_name = 'pk_id' )
+		def max( domain_class, field_name = 'pk_id' )
 			qry = Query::Max.new( domain_class, field_name )
-			@dbBridge.group_query( qry ).only[:max]
+			@cache.group_query( qry ).only[:max]
 		end
 
-		# Retrieves a collection of domain objects by +pk_id+.
-		#   ObjectStore#get_objects( Clients, [ 1, 2, 3 ] )
-		def get_objects( domain_class, pk_ids )
-			if pk_ids.is_a?( Array ) && pk_ids.all? { |elt| elt.is_a?( Integer ) }
-				get_subset Query::In.new( 'pk_id', pk_ids, domain_class )
+		def method_missing(methodId, *args) #:nodoc:
+			if [ :commit, :flush, :last_commit_time ].include?( methodId )
+				@cache.send( methodId, *args )
 			else
-				raise(
-					ArgumentError, 
-					"ObjectStore#get_objects( domain_class, pk_ids ): pk_ids needs to " +
-							"be an array of integers",
-					caller
-				)
+				proc = block_given? ? ( proc { |obj| yield( obj ) } ) : nil
+				dispatch = MethodDispatch.new( methodId, proc, *args )
+				if dispatch.symbol
+					dispatch.dispatch self
+				else
+					super
+				end
 			end
 		end
-
-		def get_subset(conditionOrQuery) #:nodoc:
+		
+		def mock? #:nodoc:
+			false
+		end
+		
+		# Passes a query and selects with it.
+		#   qry = Query.infer( User ) { |user| user.fname.equals( 'Francis' ) }
+		#   francises = ObjectStore.get_object_store.query( qry )
+		def query(conditionOrQuery)
 			if conditionOrQuery.class <= Query::Condition
 				condition = conditionOrQuery
 				query = Query.new condition.domain_class, condition
@@ -542,259 +238,537 @@ module Lafcadio
 			@cache.get_by_query( query )
 		end
 		
-		def last_commit_time( domain_class, pk_id ) #:nodoc:
-			@cache.last_commit_time( domain_class, pk_id )
-		end
-
-		def method_missing(methodId, *args) #:nodoc:
-			proc = block_given? ? ( proc { |obj| yield( obj ) } ) : nil
-			dispatch = MethodDispatch.new( methodId, proc, *args )
-			self.send( dispatch.symbol, *dispatch.args )
-		end
-		
-		def mock? #:nodoc:
-			false
-		end
-		
-		def query( query ); @dbBridge.group_query( query ); end
-
-		def respond_to?( symbol, include_private = false )
-			begin
-				dispatch = MethodDispatch.new( symbol )
-			rescue NoMethodError
+		def respond_to?( symbol, include_private = false ) #:nodoc:
+			if MethodDispatch.new( symbol ).symbol
+				true
+			else
 				super
 			end
 		end
 		
-		def transaction( &action ); @dbBridge.transaction( action ); end
+		# As long as the underlying database table sorts transactions, you can use
+		# this to run transactional logic. These transactions will auto commit at 
+		# the end of the block, and can be rolled back.
+		#   ObjectStore.get_object_store.transaction do |tr|
+		#     Client.new( 'name' => 'Big Co.' ).commit
+		#     tr.rollback
+		#   end   # the client will not be saved to the DB
+		def transaction( &action ); @cache.transaction( action ); end
 		
 		class Cache #:nodoc:
-			def initialize( dbBridge )
-				@dbBridge = dbBridge
-				@objects = {}
-				@collections_by_query = {}
-				@commit_times = {}
+			attr_reader :db_bridge
+			
+			def initialize( db_bridge = DbBridge.new )
+				@db_bridge = db_bridge
+				@domain_class_caches = {}
 			end
 
 			def commit( db_object )
-				committer = Committer.new db_object, @dbBridge, self
-				committer.execute
+				db_object.verify if LafcadioConfig.new()['checkFields'] == 'onCommit'
+				db_object.last_commit_type = get_last_commit db_object
+				db_object.pre_commit_trigger
+				update_dependent_domain_objects( db_object ) if db_object.delete
+				@db_bridge.commit db_object
+				db_object.pk_id = @db_bridge.last_pk_id_inserted unless db_object.pk_id
+				update_after_commit db_object
+				db_object.post_commit_trigger
+				db_object.reset_original_values_hash
+				db_object
 			end
-
-			# Flushes a domain object.
-			def flush(db_object)
-				hash_by_domain_class( db_object.domain_class ).delete db_object.pk_id
-				flush_collection_cache( db_object.domain_class )
+			
+			def cache( domain_class )
+				unless @domain_class_caches[domain_class]
+					@domain_class_caches[domain_class] = DomainClassCache.new(
+						domain_class, @db_bridge
+					)
+				end
+				@domain_class_caches[domain_class]
 			end
 			
-			def flush_collection_cache( domain_class )
-				@collections_by_query.keys.each { |query|
-					if query.domain_class == domain_class
-						@collections_by_query.delete( query )
-					end
-				}
+			def get_last_commit( db_object )
+				if db_object.delete
+					DomainObject::COMMIT_DELETE
+				elsif db_object.pk_id
+					DomainObject::COMMIT_EDIT
+				else
+					DomainObject::COMMIT_ADD
+				end
 			end
 
-			# Returns a cached domain object, or nil if none is found.
-			def get( domain_class, pk_id )
-				hash_by_domain_class( domain_class )[pk_id].clone
+			def method_missing( meth, *args )
+				simple_dispatch = [
+					:get_by_query, :queries, :save, :set_commit_time,
+					:update_after_commit
+				]
+				if simple_dispatch.include?( meth )
+					cache( args.first.domain_class ).send( meth, *args )
+				elsif [ :[], :last_commit_time ].include?( meth )
+					cache( args.first ).send( meth, *args[1..-1] )
+				elsif [ :group_query, :transaction ].include?( meth )
+					@db_bridge.send( meth, *args )
+				end
 			end
 
-			# Returns an array of all domain objects of a given type.
-			def get_all( domain_class )
-				hash_by_domain_class( domain_class ).values.collect { |d_obj|
-					d_obj.clone
+			def update_dependent_domain_class( db_object, aClass, field )
+				object_store = ObjectStore.get_object_store
+				collection = aClass.get( db_object, field.name )
+				collection.each { |dependentObject|
+					if field.delete_cascade
+						dependentObject.delete = true
+					else
+						dependentObject.send( field.name + '=', nil )
+					end
+					object_store.commit dependentObject
 				}
 			end
 
-			def get_by_query( query )
-				unless @collections_by_query[query]
+			def update_dependent_domain_objects( db_object )
+				dependent_classes = db_object.domain_class.dependent_classes
+				dependent_classes.keys.each { |aClass|
+					update_dependent_domain_class(
+						db_object, aClass, dependent_classes[aClass]
+					)
+				}
+			end
+			
+			class DomainClassCache < Hash #:nodoc:
+				attr_reader :commit_times, :domain_class, :queries
+				
+				def initialize( domain_class, db_bridge )
+					super()
+					@domain_class, @db_bridge = domain_class, db_bridge
+					@commit_times = {}
+					@queries = {}
+				end
+
+				def []( pk_id )
+					dobj = super
+					dobj ? dobj.clone : nil
+				end
+				
+				def collect_from_superset( query )
+					if ( pk_ids = find_superset_pk_ids( query ) )
+						db_objects = ( pk_ids.collect { |pk_id|
+							self[ pk_id ]
+						} ).select { |dobj| query.dobj_satisfies?( dobj ) }
+						db_objects = query.order_and_limit_collection db_objects
+						queries[query] = db_objects.collect { |dobj| dobj.pk_id }
+						true
+					else
+						false
+					end
+				end
+				
+				def find_superset_pk_ids( query )
 					superset_query, pk_ids =
-						@collections_by_query.find { |other_query, pk_ids|
+						queries.find { |other_query, pk_ids|
 							query.implies?( other_query )
 						}
-					if pk_ids
-						@collections_by_query[query] = ( pk_ids.collect { |pk_id|
-							get( query.domain_class, pk_id )
-						} ).select { |dobj| query.object_meets( dobj ) }.collect { |dobj|
-							dobj.pk_id
-						}
-					elsif @collections_by_query.values
-						newObjects = @dbBridge.get_collection_by_query(query)
-						newObjects.each { |dbObj| save dbObj }
-						@collections_by_query[query] = newObjects.collect { |dobj|
-							dobj.pk_id
-						}
+					pk_ids
+				end
+				
+				# Flushes a domain object.
+				def flush( db_object )
+					delete db_object.pk_id
+					flush_queries
+				end
+				
+				def flush_queries
+					queries.keys.each do |query|
+						queries.delete( query ) if query.domain_class == domain_class
 					end
 				end
-				collection = []
-				@collections_by_query[query].each { |pk_id|
-					dobj = get( query.domain_class, pk_id )
-					collection << dobj if dobj
-				}
-				collection
+
+				def get_by_query( query )
+					unless queries[query]
+						collected = collect_from_superset query
+						if !collected and queries.values
+							query_db query
+						end
+					end
+					collection = []
+					queries[query].each { |pk_id|
+						dobj = self[ pk_id ]
+						collection << dobj if dobj
+					}
+					collection
+				end
+
+				def last_commit_time( pk_id ); commit_times[pk_id]; end
+				
+				def query_db( query )
+					newObjects = @db_bridge.select_dobjs query
+					newObjects.each { |dbObj| save dbObj }
+					queries[query] = newObjects.collect { |dobj| dobj.pk_id }
+				end
+							
+				# Saves a domain object.
+				def save(db_object)
+					self[db_object.pk_id] = db_object
+					flush_queries
+				end
+			
+				def set_commit_time( d_obj ); commit_times[d_obj.pk_id] = Time.now; end
+
+				def update_after_commit( db_object ) #:nodoc:
+					if [ DomainObject::COMMIT_EDIT, DomainObject::COMMIT_ADD ].include?(
+						db_object.last_commit_type
+					)
+						save db_object
+					elsif db_object.last_commit_type == DomainObject::COMMIT_DELETE
+						flush db_object
+					end
+					set_commit_time db_object
+				end
 			end
+		end
 
-			def hash_by_domain_class( domain_class )
-				unless @objects[domain_class]
-					@objects[domain_class] = {}
+		class CommitSqlStatementsAndBinds < Array #:nodoc:
+			attr_reader :bind_values
+	
+			def initialize( obj )
+				@obj = obj
+				reversed = []
+				@obj.class.self_and_concrete_superclasses.each { |domain_class|
+					reversed << statement_bind_value_pair( domain_class )
+				}
+				reversed.reverse.each do |statement, binds|
+					self << [ statement, binds ]
 				end
-				@objects[domain_class]
 			end
+	
+			def delete_sql( domain_class )
+				"delete from #{ domain_class.table_name} " +
+						"where #{ domain_class.sql_primary_key_name }=#{ @obj.pk_id }"
+			end
+	
+			def get_name_value_pairs( domain_class )
+				nameValues = []
+				domain_class.class_fields.each { |field|
+					unless field.instance_of?( PrimaryKeyField )
+						value = @obj.send(field.name)
+						unless field.db_will_automatically_write?
+							nameValues << field.db_field_name
+							nameValues << field.value_for_sql( value )
+						end
+						if field.bind_write?
+							@bind_values << value
+						end
+					end
+				}
+				QueueHash.new( *nameValues )
+			end
+	
+			def insert_sql( domain_class )
+				fields = domain_class.class_fields
+				nameValuePairs = get_name_value_pairs( domain_class )
+				if domain_class.is_child_domain_class?
+					nameValuePairs[domain_class.sql_primary_key_name] = 'LAST_INSERT_ID()'
+				end
+				fieldNameStr = nameValuePairs.keys.join ", "
+				fieldValueStr = nameValuePairs.values.join ", "
+				"insert into #{ domain_class.table_name}(#{fieldNameStr}) " +
+						"values(#{fieldValueStr})"
+			end
+	
+			def statement_bind_value_pair( domain_class )
+				@bind_values = []
+				if @obj.pk_id == nil
+					statement = insert_sql( domain_class )
+				else
+					if @obj.delete
+						statement = delete_sql( domain_class )
+					else
+						statement = update_sql( domain_class)
+					end
+				end
+				[statement, @bind_values]
+			end
+	
+			def update_sql( domain_class )
+				nameValueStrings = []
+				nameValuePairs = get_name_value_pairs( domain_class )
+				nameValuePairs.each { |key, value|
+					nameValueStrings << "#{key}=#{ value }"
+				}
+				allNameValues = nameValueStrings.join ', '
+				"update #{ domain_class.table_name} set #{allNameValues} " +
+						"where #{ domain_class.sql_primary_key_name}=#{@obj.pk_id}"
+			end
+		end
 
-			def last_commit_time( domain_class, pk_id )
-				by_domain_class = @commit_times[domain_class]
-				by_domain_class ? by_domain_class[pk_id] : nil
+		class DbBridge #:nodoc:
+			@@last_pk_id_inserted = nil
+			
+			def self._load(aString)
+				aString =~ /db_conn:/
+				db_conn_str = $'
+				begin
+					db_conn = Marshal.load db_conn_str
+				rescue TypeError
+					db_conn = nil
+				end
+				DbConnection.set_db_connection db_conn
+				new
+			end
+			
+			def initialize
+				@db_conn = DbConnection.get_db_connection
+				ObjectSpace.define_finalizer( self, proc { |id|
+					DbConnection.get_db_connection.disconnect
+				} )
+			end
+	
+			def _dump(aDepth)
+				dbDump = @dbh.respond_to?( '_dump' ) ? @dbh._dump : @dbh.class.to_s
+				"dbh:#{dbDump}"
 			end
 			
-			def set_commit_time( d_obj )
-				by_domain_class = @commit_times[d_obj.domain_class]
-				if by_domain_class.nil?
-					by_domain_class = {}
-					@commit_times[d_obj.domain_class] = by_domain_class
+			def commit(db_object)
+				statements_and_binds = ObjectStore::CommitSqlStatementsAndBinds.new(
+					db_object
+				)
+				statements_and_binds.each do |sql, binds|
+					@db_conn.do( sql, *binds )
+				end
+				if statements_and_binds[0].first =~ /insert/
+					sql = 'select last_insert_id()'
+					result = select_all( sql )
+					@@last_pk_id_inserted = result[0]['last_insert_id()'].to_i
 				end
-				by_domain_class[d_obj.pk_id] = Time.now
 			end
-
-			# Saves a domain object.
-			def save(db_object)
-				hash = hash_by_domain_class( db_object.domain_class )
-				hash[db_object.pk_id] = db_object
-				flush_collection_cache( db_object.domain_class )
+			
+			def group_query( query )
+				select_all( query.to_sql ).map { |row| query.result_row( row ) }
 			end
+	
+			def last_pk_id_inserted; @@last_pk_id_inserted; end
 			
-			def update_after_commit( committer ) #:nodoc:
-				if committer.commit_type == Committer::UPDATE ||
-					committer.commit_type == Committer::INSERT
-					save( committer.db_object )
-				elsif committer.commit_type == Committer::DELETE
-					flush( committer.db_object )
+			def maybe_log(sql)
+				config = LafcadioConfig.new
+				if config['logSql'] == 'y'
+					sqllog = Log4r::Logger['sql'] || Log4r::Logger.new( 'sql' )
+					filename = File.join(
+						config['logdir'], config['sqlLogFile'] || 'sql'
+					)
+					outputter = Log4r::FileOutputter.new(
+						'outputter', { :filename => filename }
+					)
+					sqllog.outputters = outputter
+					sqllog.info sql
 				end
-				set_commit_time( committer.db_object )
+			end
+			
+			def select_all(sql)
+				maybe_log sql
+				begin
+					@db_conn.select_all( sql )
+				rescue DBI::DatabaseError => e
+					raise $!.to_s + ": #{ e.errstr }"
+				end	
+			end
+			
+			def select_dobjs(query)
+				domain_class = query.domain_class
+				select_all( query.to_sql ).collect { |row_hash|
+					domain_class.new( SqlToRubyValues.new( domain_class, row_hash ) )
+				}
+			end
+			
+			def transaction( action )
+				tr = Transaction.new @db_conn
+				tr.commit
+				begin
+					action.call tr
+					tr.commit
+				rescue RollbackError
+					# rollback handled by Transaction
+				rescue
+					err_to_raise = $!
+					tr.rollback false
+					raise err_to_raise
+				end
+			end
+			
+			class Transaction #:nodoc:
+				def initialize( db_conn ); @db_conn = db_conn; end
+				
+				def commit; @db_conn.commit; end
+					
+				def rollback( raise_error = true )
+					@db_conn.rollback
+					raise RollbackError if raise_error
+				end
+			end
+			
+			class RollbackError < StandardError #:nodoc:
 			end
 		end
 
+		class DbConnection < ContextualService::Service #:nodoc:
+			@@conn_class = DBI
+			@@db_name = nil
+	
+			def self.connection_class=( aClass ); @@conn_class = aClass; end
+	
+			def self.db_name=( db_name ); @@db_name = db_name; end
+	
+			def initialize; @dbh = load_new_dbh; end
+		
+			def disconnect; @dbh.disconnect; end
+			
+			def load_new_dbh
+				config = LafcadioConfig.new
+				dbName = @@db_name || config['dbname']
+				dbAndHost = nil
+				if dbName && config['dbhost']
+					dbAndHost = "dbi:Mysql:#{ dbName }:#{ config['dbhost'] }"
+				else
+					dbAndHost = "dbi:#{config['dbconn']}"
+				end
+				dbh = @@conn_class.connect(
+					dbAndHost, config['dbuser'], config['dbpassword']
+				)
+				dbh['AutoCommit'] = false
+				dbh
+			end
+			
+			def method_missing( symbol, *args )
+				@dbh.send( symbol, *args )
+			end
+		end
+	
 		class MethodDispatch #:nodoc:
 			attr_reader :symbol, :args
 		
 			def initialize( orig_method, *other_args )
 				@orig_method = orig_method
 				@orig_args = other_args
-				if @orig_args.size > 0
-					@maybe_proc = @orig_args.shift
-				end
+				@maybe_proc = @orig_args.shift if @orig_args.size > 0
 				@methodName = orig_method.id2name
-				if @methodName =~ /^get(.*)$/
-					dispatch_get_method
-				else
-					raise_no_method_error
-				end
+				dispatch_method
+			end
+			
+			def camel_case_method_name
+				@orig_method.id2name.underscore_to_camel_case
+			end
+			
+			def dispatch( object_store )
+				target = ( @target or object_store )
+				target.send( @symbol, *@args )
+			end
+			
+			def dispatch_all
+				@symbol = :all
+				@args = [ @domain_class ]
+			end
+			
+			def dispatch_domain_class_get( searchTerm, fieldName )
+				@symbol = :get
+				@args = [ searchTerm, fieldName ]
+				@target = @domain_class
 			end
 			
-			def dispatch_get_plural
+			def dispatch_get_map_object( domain_class )
+				@symbol = :get_map_object
+				@args = [ domain_class, @orig_args[0], @orig_args[1] ]
+			end
+
+			def dispatch_plural
 				if @orig_args.size == 0 && @maybe_proc.nil?
-					@symbol = :get_all
-					@args = [ @domain_class ]
+					dispatch_all
 				else
-					searchTerm = @orig_args[0]
-					fieldName = @orig_args[1]
+					searchTerm, fieldName = @orig_args[0..1]
 					if searchTerm.nil? && @maybe_proc.nil? && fieldName.nil?
-						msg = "ObjectStore\##{ @orig_method } needs a field name as its " +
-						      "second argument if its first argument is nil"
-						raise( ArgumentError, msg, caller )
+						raise_plural_needs_field_arg_if_first_arg_nil
+					elsif !@maybe_proc.nil? && searchTerm.nil?
+						dispatch_plural_by_query_block
+					elsif @maybe_proc.nil? && ( !( searchTerm.nil? && fieldName.nil? ) )
+						dispatch_domain_class_get( searchTerm, fieldName )
+					else
+						raise_plural_cant_have_both_query_block_and_search_term
 					end
-					dispatch_get_plural_by_query_block_or_search_term( searchTerm,
-					                                                   fieldName )
 				end
 			end
 			
-			def dispatch_get_plural_by_query_block
+			def dispatch_plural_by_query_block
 				inferrer = Query::Inferrer.new( @domain_class ) { |obj|
 					@maybe_proc.call( obj )
 				}
-				@symbol = :get_subset
+				@symbol = :query
 				@args = [ inferrer.execute ]
 			end
 
-			def dispatch_get_plural_by_query_block_or_search_term( searchTerm,
-					                                                   fieldName )
-				if !@maybe_proc.nil? && searchTerm.nil?
-					dispatch_get_plural_by_query_block
-				elsif @maybe_proc.nil? && ( !( searchTerm.nil? && fieldName.nil? ) )
-					@symbol = :get_filtered
-					@args = [ @domain_class.name, searchTerm, fieldName ]
-				else
-					raise( ArgumentError,
-					 	     "Shouldn't send both a query block and a search term",
-					       caller )
-				end
-			end
-			
-			def dispatch_get_method
-				begin
-					dispatch_get_singular
-				rescue CouldntMatchDomainClassError
-					domain_class_name = camel_case_method_name_after_get.singular
+			def dispatch_method
+				unless ( dispatch_singular )
+					domain_class_name = camel_case_method_name.singular
 					begin
-						@domain_class =
-								DomainObject.get_domain_class_from_string( domain_class_name )
-						dispatch_get_plural
-					rescue CouldntMatchDomainClassError
-						raise_no_method_error
+						@domain_class = Module.by_name domain_class_name
+						dispatch_plural
+					rescue NameError
+						# skip it
 					end
 				end
 			end
 			
-			def dispatch_get_singular
-				domain_class = DomainObject.get_domain_class_from_string(
-					camel_case_method_name_after_get
-				)
-				if @orig_args[0].class <= Integer
-					@symbol = :get
-					@args = [ domain_class, @orig_args[0] ]
-				elsif @orig_args[0].class <= DomainObject
-					@symbol = :get_map_object
-					@args = [ domain_class, @orig_args[0], @orig_args[1] ]
+			def dispatch_singular
+				begin
+					d_class_name = @orig_method.id2name.underscore_to_camel_case
+					domain_class = Module.by_name d_class_name
+					if @orig_args[0].class <= Integer
+						@symbol = :get
+						@args = [ domain_class, @orig_args[0] ]
+					elsif @orig_args[0].class <= DomainObject
+						dispatch_get_map_object domain_class
+					elsif @orig_args.empty?
+						@symbol = :get
+					end
+					true
+				rescue NameError
+					false
 				end
 			end
 			
-			def camel_case_method_name_after_get
-				@orig_method.id2name =~ /^get(.*)$/
-				$1.underscore_to_camel_case
+			def raise_plural_needs_field_arg_if_first_arg_nil
+				msg = "ObjectStore\##{ @orig_method } needs a field name as its " +
+				      "second argument if its first argument is nil"
+				raise( ArgumentError, msg, caller )
 			end
 			
-			def raise_no_method_error
-				raise( NoMethodError, "undefined method '#{ @methodName }'", caller )
+			def raise_plural_cant_have_both_query_block_and_search_term
+				raise(
+					ArgumentError, "Shouldn't send both a query block and a search term",
+					caller
+				)
 			end
 		end
-	end
-
-	class SqlValueConverter #:nodoc:
-		attr_reader :domain_class, :row_hash
-
-		def initialize( domain_class, row_hash )
-			@domain_class = domain_class
-			@row_hash = row_hash
-		end
 
-		def []( key )
-			begin
-				field = @domain_class.get_field( key )
-				val = field.value_from_sql( @row_hash[ field.db_field_name ] )
-				if field.instance_of?( PrimaryKeyField ) && val.nil?
-					raise FieldMatchError, error_msg, caller
+		class SqlToRubyValues #:nodoc:
+			attr_reader :domain_class, :row_hash
+	
+			def initialize( domain_class, row_hash )
+				@domain_class = domain_class
+				@row_hash = row_hash
+			end
+	
+			def []( key )
+				if ( field = @domain_class.field key )
+					val = field.value_from_sql( @row_hash[ field.db_field_name ] )
+					if field.instance_of?( PrimaryKeyField ) && val.nil?
+						raise FieldMatchError, error_msg, caller
+					else
+						val
+					end
 				else
-					val
+					nil
 				end
-			rescue MissingError
-				nil
 			end
-		end
-
-		def error_msg
-			"The field \"" + @domain_class.sql_primary_key_name +
-					"\" can\'t be found in the table \"" + 
-					@domain_class.table_name + "\"."
+	
+			def error_msg
+				"The field \"" + @domain_class.sql_primary_key_name +
+						"\" can\'t be found in the table \"" + 
+						@domain_class.table_name + "\"."
+			end
 		end
 	end
 end