lafcadio 0.9.2 → 0.9.3

data/lib/lafcadio/objectStore.rb

@@ -3,6 +3,7 @@ require 'lafcadio/depend'
 require 'lafcadio/domain'
 require 'lafcadio/query'
 require 'lafcadio/util'
+require 'monitor'
 
 module Lafcadio
 	class DomainObjectInitError < RuntimeError #:nodoc:
@@ -42,11 +43,16 @@ module Lafcadio
 
 		def db_object #:nodoc:
 			if @db_object.nil? || needs_refresh?
-				@db_object = ObjectStore.get_object_store.get( @domain_class, @pk_id )
-				@d_obj_retrieve_time = Time.now
+				dbo = ObjectStore.get_object_store.get( @domain_class, @pk_id )
+				self.db_object = dbo
 			end
 			@db_object
 		end
+		
+		def db_object=( dbo )
+			@db_object = dbo
+			@d_obj_retrieve_time = Time.now
+		end
 
 		def hash #:nodoc:
 			db_object.hash
@@ -141,10 +147,8 @@ module Lafcadio
 	# DomainObject#pre_commit_trigger and DomainObject#post_commit_trigger for
 	# more.
 	class ObjectStore < ContextualService::Service
-		# Returns true if the current stored instance is a MockObjectStore.
-		def self.mock?; get_object_store.mock?; end
-		
 		@@db_bridge = nil
+		@@db_type = 'Mysql'
 		
 		# Returns the DbBridge; this is useful in case you need to use raw SQL for
 		# a specific query.
@@ -154,13 +158,20 @@ module Lafcadio
 			DbConnection.db_name= dbName
 		end
 		
+		def self.db_type; @@db_type; end
+		
+		def self.db_type=( dbt ); @@db_type = dbt; end
+		
+		# Returns true if the current stored instance is a MockObjectStore.
+		def self.mock?; get_object_store.mock?; end
+		
 		def initialize #:nodoc:
 			@cache = ObjectStore::Cache.new self.class.db_bridge
 		end
 
 		# Returns all domain objects for the given domain class.
-		def all(domain_class)
-			@cache.get_by_query( Query.new( domain_class ) )
+		def all( domain_class, opts = {} )
+			@cache.get_by_query( Query.new( domain_class, opts ) )
 		end
 
 		# Returns the DbBridge; this is useful in case you need to use raw SQL for
@@ -169,7 +180,8 @@ module Lafcadio
 		
 		# 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 (
+			qry = Query.new( domain_class, :pk_id => pk_id )
+			@cache.get_by_query( qry ).first or (
 				raise(
 					DomainObjectNotFoundError, "Can't find #{domain_class} #{pk_id}",
 					caller
@@ -231,7 +243,7 @@ module Lafcadio
 		def query(conditionOrQuery)
 			if conditionOrQuery.class <= Query::Condition
 				condition = conditionOrQuery
-				query = Query.new condition.domain_class, condition
+				query = Query.new( condition.domain_class, :condition => condition )
 			else
 				query = conditionOrQuery
 			end
@@ -256,9 +268,12 @@ module Lafcadio
 		def transaction( &action ); @cache.transaction( action ); end
 		
 		class Cache #:nodoc:
+			include MonitorMixin
+		
 			attr_reader :db_bridge
 			
 			def initialize( db_bridge = DbBridge.new )
+				super()
 				@db_bridge = db_bridge
 				@domain_class_caches = {}
 			end
@@ -268,8 +283,12 @@ module Lafcadio
 				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
+				synchronize do
+					@db_bridge.commit db_object
+					unless db_object.pk_id
+						db_object.pk_id = @db_bridge.last_pk_id_inserted
+					end
+				end
 				update_after_commit db_object
 				db_object.post_commit_trigger
 				db_object.reset_original_values_hash
@@ -285,20 +304,36 @@ module Lafcadio
 				@domain_class_caches[domain_class]
 			end
 			
+			def get_by_query( query )
+				main_cache = cache query.domain_class
+				unless main_cache.queries[query]
+					if query.one_pk_id?
+						collected = false
+					else
+						collected = main_cache.collect_from_superset query
+					end
+					if !collected and main_cache.queries.values
+						newObjects = @db_bridge.select_dobjs query
+						newObjects.each { |dbObj| main_cache.save dbObj }
+						main_cache.queries[query] = newObjects.collect { |dobj| dobj.pk_id }
+					end
+				end
+				main_cache.queries[query].map { |pk_id| main_cache[pk_id] }.compact
+			end
+
 			def get_last_commit( db_object )
 				if db_object.delete
-					DomainObject::COMMIT_DELETE
+					:delete
 				elsif db_object.pk_id
-					DomainObject::COMMIT_EDIT
+					:update
 				else
-					DomainObject::COMMIT_ADD
+					:insert
 				end
 			end
 
 			def method_missing( meth, *args )
 				simple_dispatch = [
-					:get_by_query, :queries, :save, :set_commit_time,
-					:update_after_commit
+					:queries, :save, :set_commit_time, :update_after_commit
 				]
 				if simple_dispatch.include?( meth )
 					cache( args.first.domain_class ).send( meth, *args )
@@ -379,29 +414,8 @@ module Lafcadio
 					end
 				end
 
-				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
@@ -411,11 +425,11 @@ module Lafcadio
 				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?(
+					if [ :update, :insert ].include?(
 						db_object.last_commit_type
 					)
 						save db_object
-					elsif db_object.last_commit_type == DomainObject::COMMIT_DELETE
+					elsif db_object.last_commit_type == :delete
 						flush db_object
 					end
 					set_commit_time db_object
@@ -430,7 +444,9 @@ module Lafcadio
 				@obj = obj
 				reversed = []
 				@obj.class.self_and_concrete_superclasses.each { |domain_class|
-					reversed << statement_bind_value_pair( domain_class )
+					statement_bind_value_pairs( domain_class ).reverse.each do |pair|
+						reversed << pair
+					end
 				}
 				reversed.reverse.each do |statement, binds|
 					self << [ statement, binds ]
@@ -463,7 +479,8 @@ module Lafcadio
 				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()'
+					pair = DbBridge.last_inserted_pk_id_pair domain_class.superclass
+					nameValuePairs[domain_class.sql_primary_key_name] = pair.first
 				end
 				fieldNameStr = nameValuePairs.keys.join ", "
 				fieldValueStr = nameValuePairs.values.join ", "
@@ -471,18 +488,24 @@ module Lafcadio
 						"values(#{fieldValueStr})"
 			end
 	
-			def statement_bind_value_pair( domain_class )
+			def statement_bind_value_pairs( domain_class )
 				@bind_values = []
 				if @obj.pk_id == nil
 					statement = insert_sql( domain_class )
+					pairs = [ [statement, @bind_values] ]
+					if domain_class.is_child_domain_class? and ObjectStore.db_type == 'Pg'
+						setval_sql = "select setval( '#{ domain_class.postgres_pk_id_seq }', currval('#{ domain_class.superclass.postgres_pk_id_seq }') )"
+						pairs << [ setval_sql, @bind_values ]
+					end
+					pairs
 				else
 					if @obj.delete
 						statement = delete_sql( domain_class )
 					else
 						statement = update_sql( domain_class)
 					end
+					[ [statement, @bind_values] ]
 				end
-				[statement, @bind_values]
 			end
 	
 			def update_sql( domain_class )
@@ -512,8 +535,18 @@ module Lafcadio
 				new
 			end
 			
+			def self.last_inserted_pk_id_pair( domain_class )
+				case ObjectStore.db_type
+				when 'Mysql'
+					[ 'last_insert_id()', 'last_insert_id()' ]
+				when 'Pg'
+					[ "currval('#{ domain_class.postgres_pk_id_seq }')", 'currval' ]
+				end
+			end
+
 			def initialize
 				@db_conn = DbConnection.get_db_connection
+				@transaction = nil
 				ObjectSpace.define_finalizer( self, proc { |id|
 					DbConnection.get_db_connection.disconnect
 				} )
@@ -532,9 +565,24 @@ module Lafcadio
 					@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
+					@@last_pk_id_inserted = get_last_pk_id_inserted(
+						db_object.domain_class
+					)
+				end
+				@db_conn.do( 'commit' ) unless @transaction
+			end
+			
+			def get_last_pk_id_inserted( domain_class )
+				pair = self.class.last_inserted_pk_id_pair( domain_class )
+				sql = 'select ' + pair.first
+				begin
+					select_all( sql ).first[pair.last].to_i
+				rescue RuntimeError
+					error_msg =
+							"The field \"" + domain_class.sql_primary_key_name +
+							"\" can\'t be found in the table \"" + 
+							domain_class.table_name + "\"."
+					raise FieldMatchError, error_msg, caller
 				end
 			end
 			
@@ -570,24 +618,39 @@ module Lafcadio
 			
 			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 ) )
+				select_all( query.to_sql( ObjectStore.db_type ) ).collect { |row_hash|
+					dobj = domain_class.new(
+						SqlToRubyValues.new( domain_class, row_hash )
+					)
+					if query.include
+						query.include.each do |include_sym|
+							field = domain_class.field include_sym
+							included_dclass = field.linked_type
+							if dobj.send( field.name )
+								dobj.send( field.name ).db_object = included_dclass.new(
+									SqlToRubyValues.new( included_dclass, row_hash )
+								)
+							end
+						end
+					end
+					dobj
 				}
 			end
 			
 			def transaction( action )
-				tr = Transaction.new @db_conn
-				tr.commit
+				@transaction = Transaction.new @db_conn
+				@transaction.commit
 				begin
-					action.call tr
-					tr.commit
+					action.call @transaction
+					@transaction.commit
 				rescue RollbackError
 					# rollback handled by Transaction
 				rescue
 					err_to_raise = $!
-					tr.rollback false
+					@transaction.rollback false
 					raise err_to_raise
 				end
+				@transaction = nil
 			end
 			
 			class Transaction #:nodoc:
@@ -617,17 +680,21 @@ module Lafcadio
 		
 			def disconnect; @dbh.disconnect; end
 			
-			def load_new_dbh
+			def driver_url
 				config = LafcadioConfig.new
 				dbName = @@db_name || config['dbname']
-				dbAndHost = nil
+				driver_name = config['dbtype'] || 'Mysql'
 				if dbName && config['dbhost']
-					dbAndHost = "dbi:Mysql:#{ dbName }:#{ config['dbhost'] }"
+					"dbi:#{ driver_name }:#{ dbName }:#{ config['dbhost'] }"
 				else
-					dbAndHost = "dbi:#{config['dbconn']}"
+					"dbi:#{config['dbconn']}"
 				end
+			end
+			
+			def load_new_dbh
+				config = LafcadioConfig.new
 				dbh = @@conn_class.connect(
-					dbAndHost, config['dbuser'], config['dbpassword']
+					driver_url, config['dbuser'], config['dbpassword']
 				)
 				dbh['AutoCommit'] = false
 				dbh

data/lib/lafcadio/objectStore.rb~

@@ -3,6 +3,7 @@ require 'lafcadio/depend'
 require 'lafcadio/domain'
 require 'lafcadio/query'
 require 'lafcadio/util'
+require 'monitor'
 
 module Lafcadio
 	class DomainObjectInitError < RuntimeError #:nodoc:
@@ -12,11 +13,11 @@ module Lafcadio
 	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
@@ -27,7 +28,7 @@ module Lafcadio
 
 		attr_accessor :domain_class, :pk_id
 
-		def initialize( *args )
+		def initialize( *args ) #:nodoc:
 			if args.size == 2
 				@domain_class = args.first
 				@pk_id = args.last
@@ -40,29 +41,34 @@ module Lafcadio
 			end
 		end
 
-		def db_object
+		def db_object #:nodoc:
 			if @db_object.nil? || needs_refresh?
-				@db_object = ObjectStore.get_object_store.get( @domain_class, @pk_id )
-				@d_obj_retrieve_time = Time.now
+				dbo = ObjectStore.get_object_store.get( @domain_class, @pk_id )
+				self.db_object = dbo
 			end
 			@db_object
 		end
+		
+		def db_object=( dbo )
+			@db_object = dbo
+			@d_obj_retrieve_time = Time.now
+		end
 
-		def hash
+		def hash #:nodoc:
 			db_object.hash
 		end
 
-		def method_missing( methodId, *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 && last_commit_time > @d_obj_retrieve_time
 		end
 		
-		def to_s
+		def to_s #:nodoc:
 			db_object.to_s
 		end
 	end
@@ -80,29 +86,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
@@ -110,14 +118,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
@@ -131,25 +144,44 @@ 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.mock?; get_object_store.mock?; end
-		
 		@@db_bridge = nil
-			
+		@@db_type = 'Mysql'
+		
+		# 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) #:nodoc:
+		def self.db_name= (dbName)
 			DbConnection.db_name= dbName
 		end
 		
+		def self.db_type; @@db_type; end
+		
+		def self.db_type=( dbt ); @@db_type = dbt; end
+		
+		# Returns true if the current stored instance is a MockObjectStore.
+		def self.mock?; get_object_store.mock?; end
+		
 		def initialize #:nodoc:
 			@cache = ObjectStore::Cache.new self.class.db_bridge
 		end
 
+		# Returns all domain objects for the given domain class.
+		def all( domain_class, opts = {} )
+			@cache.get_by_query( Query.new( domain_class, opts ) )
+		end
+
+		# 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 (
+			qry = Query.new( domain_class, :pk_id => pk_id )
+			@cache.get_by_query( qry ).first or (
 				raise(
 					DomainObjectNotFoundError, "Can't find #{domain_class} #{pk_id}",
 					caller
@@ -157,23 +189,6 @@ module Lafcadio
 			)
 		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; @cache.db_bridge; end
-		
-		def get_filtered(domain_class_name, searchTerm, fieldName = nil) #:nodoc:
-			domain_class = Class.by_name domain_class_name
-			unless fieldName
-				fieldName = domain_class.link_field( searchTerm.domain_class ).name
-			end
-			get_subset( Query::Equals.new( fieldName, searchTerm, domain_class ) )
-		end
-
 		def get_map_object( domain_class, map1, map2 ) #:nodoc:
 			unless map1 && map2
 				raise ArgumentError,
@@ -187,44 +202,23 @@ module Lafcadio
 					map2.domain_class.basename.camel_case_to_underscore
 				).equals( map2 )
 			}
-			get_subset( query ).first
+			query( query ).first
+		end
+
+		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 )
 			@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 )
-			else
-				raise(
-					ArgumentError, 
-					"ObjectStore#get_objects( domain_class, pk_ids ): pk_ids needs to " +
-							"be an array of integers",
-					caller
-				)
-			end
-		end
-
-		def get_subset(conditionOrQuery) #:nodoc:
-			if conditionOrQuery.class <= Query::Condition
-				condition = conditionOrQuery
-				query = Query.new condition.domain_class, condition
-			else
-				query = conditionOrQuery
-			end
-			@cache.get_by_query( query )
-		end
-		
 		def method_missing(methodId, *args) #:nodoc:
 			if [ :commit, :flush, :last_commit_time ].include?( methodId )
 				@cache.send( methodId, *args )
@@ -232,7 +226,7 @@ module Lafcadio
 				proc = block_given? ? ( proc { |obj| yield( obj ) } ) : nil
 				dispatch = MethodDispatch.new( methodId, proc, *args )
 				if dispatch.symbol
-					self.send( dispatch.symbol, *dispatch.args )
+					dispatch.dispatch self
 				else
 					super
 				end
@@ -243,9 +237,20 @@ module Lafcadio
 			false
 		end
 		
-		def query( query ); @cache.group_query( query ); end
-
-		def respond_to?( symbol, include_private = false )
+		# 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 => condition )
+			else
+				query = conditionOrQuery
+			end
+			@cache.get_by_query( query )
+		end
+		
+		def respond_to?( symbol, include_private = false ) #:nodoc:
 			if MethodDispatch.new( symbol ).symbol
 				true
 			else
@@ -253,12 +258,22 @@ module Lafcadio
 			end
 		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:
+			include MonitorMixin
+		
 			attr_reader :db_bridge
 			
 			def initialize( db_bridge = DbBridge.new )
+				super()
 				@db_bridge = db_bridge
 				@domain_class_caches = {}
 			end
@@ -268,10 +283,15 @@ module Lafcadio
 				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
+				synchronize do
+					@db_bridge.commit db_object
+					unless db_object.pk_id
+						db_object.pk_id = @db_bridge.last_pk_id_inserted
+					end
+				end
 				update_after_commit db_object
 				db_object.post_commit_trigger
+				db_object.reset_original_values_hash
 				db_object
 			end
 			
@@ -284,20 +304,36 @@ module Lafcadio
 				@domain_class_caches[domain_class]
 			end
 			
+			def get_by_query( query )
+				main_cache = cache query.domain_class
+				unless main_cache.queries[query]
+					if query.one_pk_id?
+						collected = false
+					else
+						collected = main_cache.collect_from_superset query
+					end
+					if !collected and main_cache.queries.values
+						newObjects = @db_bridge.select_dobjs query
+						newObjects.each { |dbObj| main_cache.save dbObj }
+						main_cache.queries[query] = newObjects.collect { |dobj| dobj.pk_id }
+					end
+				end
+				main_cache.queries[query].map { |pk_id| main_cache[pk_id] }.compact
+			end
+
 			def get_last_commit( db_object )
 				if db_object.delete
-					DomainObject::COMMIT_DELETE
+					:delete
 				elsif db_object.pk_id
-					DomainObject::COMMIT_EDIT
+					:update
 				else
-					DomainObject::COMMIT_ADD
+					:insert
 				end
 			end
 
 			def method_missing( meth, *args )
 				simple_dispatch = [
-					:get_by_query, :queries, :save, :set_commit_time,
-					:update_after_commit
+					:queries, :save, :set_commit_time, :update_after_commit
 				]
 				if simple_dispatch.include?( meth )
 					cache( args.first.domain_class ).send( meth, *args )
@@ -310,9 +346,7 @@ module Lafcadio
 
 			def update_dependent_domain_class( db_object, aClass, field )
 				object_store = ObjectStore.get_object_store
-				collection = object_store.get_filtered(
-					aClass.name, db_object, field.name
-				)
+				collection = aClass.get( db_object, field.name )
 				collection.each { |dependentObject|
 					if field.delete_cascade
 						dependentObject.delete = true
@@ -332,7 +366,7 @@ module Lafcadio
 				}
 			end
 			
-			class DomainClassCache < Hash
+			class DomainClassCache < Hash #:nodoc:
 				attr_reader :commit_times, :domain_class, :queries
 				
 				def initialize( domain_class, db_bridge )
@@ -349,11 +383,11 @@ module Lafcadio
 				
 				def collect_from_superset( query )
 					if ( pk_ids = find_superset_pk_ids( query ) )
-						queries[query] = ( pk_ids.collect { |pk_id|
+						db_objects = ( pk_ids.collect { |pk_id|
 							self[ pk_id ]
-						} ).select { |dobj| query.object_meets( dobj ) }.collect { |dobj|
-							dobj.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
@@ -380,29 +414,8 @@ module Lafcadio
 					end
 				end
 
-				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
@@ -412,11 +425,11 @@ module Lafcadio
 				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?(
+					if [ :update, :insert ].include?(
 						db_object.last_commit_type
 					)
 						save db_object
-					elsif db_object.last_commit_type == DomainObject::COMMIT_DELETE
+					elsif db_object.last_commit_type == :delete
 						flush db_object
 					end
 					set_commit_time db_object
@@ -431,7 +444,9 @@ module Lafcadio
 				@obj = obj
 				reversed = []
 				@obj.class.self_and_concrete_superclasses.each { |domain_class|
-					reversed << statement_bind_value_pair( domain_class )
+					statement_bind_value_pairs( domain_class ).reverse.each do |pair|
+						reversed << pair
+					end
 				}
 				reversed.reverse.each do |statement, binds|
 					self << [ statement, binds ]
@@ -464,7 +479,8 @@ module Lafcadio
 				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()'
+					pair = DbBridge.last_inserted_pk_id_pair domain_class.superclass
+					nameValuePairs[domain_class.sql_primary_key_name] = pair.first
 				end
 				fieldNameStr = nameValuePairs.keys.join ", "
 				fieldValueStr = nameValuePairs.values.join ", "
@@ -472,18 +488,24 @@ module Lafcadio
 						"values(#{fieldValueStr})"
 			end
 	
-			def statement_bind_value_pair( domain_class )
+			def statement_bind_value_pairs( domain_class )
 				@bind_values = []
 				if @obj.pk_id == nil
 					statement = insert_sql( domain_class )
+					pairs = [ [statement, @bind_values] ]
+					if domain_class.is_child_domain_class? and ObjectStore.db_type == 'Pg'
+						setval_sql = "select setval( '#{ domain_class.postgres_pk_id_seq }', currval('#{ domain_class.superclass.postgres_pk_id_seq }') )"
+						pairs << [ setval_sql, @bind_values ]
+					end
+					pairs
 				else
 					if @obj.delete
 						statement = delete_sql( domain_class )
 					else
 						statement = update_sql( domain_class)
 					end
+					[ [statement, @bind_values] ]
 				end
-				[statement, @bind_values]
 			end
 	
 			def update_sql( domain_class )
@@ -513,8 +535,18 @@ module Lafcadio
 				new
 			end
 			
+			def self.last_inserted_pk_id_pair( domain_class )
+				case ObjectStore.db_type
+				when 'Mysql'
+					[ 'last_insert_id()', 'last_insert_id()' ]
+				when 'Pg'
+					[ "currval('#{ domain_class.postgres_pk_id_seq }')", 'currval' ]
+				end
+			end
+
 			def initialize
 				@db_conn = DbConnection.get_db_connection
+				@transaction = nil
 				ObjectSpace.define_finalizer( self, proc { |id|
 					DbConnection.get_db_connection.disconnect
 				} )
@@ -533,10 +565,17 @@ module Lafcadio
 					@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
+					@@last_pk_id_inserted = get_last_pk_id_inserted(
+						db_object.domain_class
+					)
 				end
+				@db_conn.do( 'commit' ) unless @transaction
+			end
+			
+			def get_last_pk_id_inserted( domain_class )
+				pair = self.class.last_inserted_pk_id_pair( domain_class )
+				sql = 'select ' + pair.first
+				select_all( sql ).first[pair.last].to_i
 			end
 			
 			def group_query( query )
@@ -572,26 +611,41 @@ module Lafcadio
 			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 ) )
+					dobj = domain_class.new(
+						SqlToRubyValues.new( domain_class, row_hash )
+					)
+					if query.include
+						query.include.each do |include_sym|
+							field = domain_class.field include_sym
+							included_dclass = field.linked_type
+							if dobj.send( field.name )
+								dobj.send( field.name ).db_object = included_dclass.new(
+									SqlToRubyValues.new( included_dclass, row_hash )
+								)
+							end
+						end
+					end
+					dobj
 				}
 			end
 			
 			def transaction( action )
-				tr = Transaction.new @db_conn
-				tr.commit
+				@transaction = Transaction.new @db_conn
+				@transaction.commit
 				begin
-					action.call tr
-					tr.commit
+					action.call @transaction
+					@transaction.commit
 				rescue RollbackError
 					# rollback handled by Transaction
 				rescue
 					err_to_raise = $!
-					tr.rollback false
+					@transaction.rollback false
 					raise err_to_raise
 				end
+				@transaction = nil
 			end
 			
-			class Transaction
+			class Transaction #:nodoc:
 				def initialize( db_conn ); @db_conn = db_conn; end
 				
 				def commit; @db_conn.commit; end
@@ -602,10 +656,11 @@ module Lafcadio
 				end
 			end
 			
-			class RollbackError < StandardError; end
+			class RollbackError < StandardError #:nodoc:
+			end
 		end
 
-		class DbConnection < ContextualService::Service
+		class DbConnection < ContextualService::Service #:nodoc:
 			@@conn_class = DBI
 			@@db_name = nil
 	
@@ -617,17 +672,21 @@ module Lafcadio
 		
 			def disconnect; @dbh.disconnect; end
 			
-			def load_new_dbh
+			def driver_url
 				config = LafcadioConfig.new
 				dbName = @@db_name || config['dbname']
-				dbAndHost = nil
+				driver_name = config['dbtype'] || 'Mysql'
 				if dbName && config['dbhost']
-					dbAndHost = "dbi:Mysql:#{ dbName }:#{ config['dbhost'] }"
+					"dbi:#{ driver_name }:#{ dbName }:#{ config['dbhost'] }"
 				else
-					dbAndHost = "dbi:#{config['dbconn']}"
+					"dbi:#{config['dbconn']}"
 				end
+			end
+			
+			def load_new_dbh
+				config = LafcadioConfig.new
 				dbh = @@conn_class.connect(
-					dbAndHost, config['dbuser'], config['dbpassword']
+					driver_url, config['dbuser'], config['dbpassword']
 				)
 				dbh['AutoCommit'] = false
 				dbh
@@ -646,69 +705,75 @@ module Lafcadio
 				@orig_args = other_args
 				@maybe_proc = @orig_args.shift if @orig_args.size > 0
 				@methodName = orig_method.id2name
-				dispatch_get_method if @methodName =~ /^get(.*)$/
+				dispatch_method
+			end
+			
+			def camel_case_method_name
+				@orig_method.id2name.underscore_to_camel_case
 			end
 			
-			def camel_case_method_name_after_get
-				@orig_method.id2name =~ /^get(.*)$/
-				$1.underscore_to_camel_case
+			def dispatch( object_store )
+				target = ( @target or object_store )
+				target.send( @symbol, *@args )
 			end
 			
-			def dispatch_get_all
-				@symbol = :get_all
+			def dispatch_all
+				@symbol = :all
 				@args = [ @domain_class ]
 			end
 			
-			def dispatch_get_filtered( searchTerm, fieldName )
-				@symbol = :get_filtered
-				@args = [ @domain_class.name, searchTerm, fieldName ]
+			def dispatch_domain_class_get( searchTerm, fieldName )
+				@symbol = :get
+				@args = [ searchTerm, fieldName ]
+				@target = @domain_class
 			end
-
+			
 			def dispatch_get_map_object( domain_class )
 				@symbol = :get_map_object
 				@args = [ domain_class, @orig_args[0], @orig_args[1] ]
 			end
 
-			def dispatch_get_method
-				unless ( dispatch_get_singular )
-					domain_class_name = camel_case_method_name_after_get.singular
-					begin
-						@domain_class = Module.by_name domain_class_name
-						dispatch_get_plural
-					rescue NameError
-						# skip it
-					end
-				end
-			end
-			
-			def dispatch_get_plural
+			def dispatch_plural
 				if @orig_args.size == 0 && @maybe_proc.nil?
-					dispatch_get_all
+					dispatch_all
 				else
 					searchTerm, fieldName = @orig_args[0..1]
 					if searchTerm.nil? && @maybe_proc.nil? && fieldName.nil?
-						raise_get_plural_needs_field_arg_if_first_arg_nil
+						raise_plural_needs_field_arg_if_first_arg_nil
 					elsif !@maybe_proc.nil? && searchTerm.nil?
-						dispatch_get_plural_by_query_block
+						dispatch_plural_by_query_block
 					elsif @maybe_proc.nil? && ( !( searchTerm.nil? && fieldName.nil? ) )
-						dispatch_get_filtered( searchTerm, fieldName )
+						dispatch_domain_class_get( searchTerm, fieldName )
 					else
-						raise_get_plural_cant_have_both_query_block_and_search_term
+						raise_plural_cant_have_both_query_block_and_search_term
 					end
 				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_singular
+			def dispatch_method
+				unless ( dispatch_singular )
+					domain_class_name = camel_case_method_name.singular
+					begin
+						@domain_class = Module.by_name domain_class_name
+						dispatch_plural
+					rescue NameError
+						# skip it
+					end
+				end
+			end
+			
+			def dispatch_singular
 				begin
-					domain_class = Module.by_name camel_case_method_name_after_get
+					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] ]
@@ -723,13 +788,13 @@ module Lafcadio
 				end
 			end
 			
-			def raise_get_plural_needs_field_arg_if_first_arg_nil
+			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_get_plural_cant_have_both_query_block_and_search_term
+			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