lafcadio 0.8.3 → 0.9.0

data/lib/lafcadio/objectStore.rb~

@@ -76,18 +76,18 @@ module Lafcadio
 	end
 
 	class DbBridge #:nodoc:
-		@@dbh = nil
 		@@last_pk_id_inserted = nil
 		
 		def self._load(aString)
-			aString =~ /dbh:/
-			dbString = $'
+			aString =~ /db_conn:/
+			db_conn_str = $'
 			begin
-				dbh = Marshal.load(dbString)
+				db_conn = Marshal.load db_conn_str
 			rescue TypeError
-				dbh = nil
+				db_conn = nil
 			end
-			new dbh
+			DbConnection.set_db_connection db_conn
+			new
 		end
 		
 		def initialize
@@ -131,10 +131,7 @@ module Lafcadio
 		end
 		
 		def group_query( query )
-			execute_select( query.to_sql )[0].collect { |val|
-				a_field = query.domain_class.get_field( query.field_name )
-				a_field.value_from_sql( val )
-			}
+			execute_select( query.to_sql ).map { |row| query.result_row( row ) }
 		end
 
 		def last_pk_id_inserted; @@last_pk_id_inserted; end
@@ -150,6 +147,34 @@ module Lafcadio
 				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
@@ -186,6 +211,8 @@ module Lafcadio
 			end
 			@@dbh = @@connectionClass.connect( dbAndHost, config['dbuser'],
 																				 config['dbpassword'] )
+			@@dbh['AutoCommit'] = false
+			@@dbh
 		end
 		
 		def method_missing( symbol, *args )
@@ -280,7 +307,7 @@ module Lafcadio
 					value = @obj.send(field.name)
 					unless field.db_will_automatically_write
 						nameValues << field.name_for_sql
-						nameValues << field.value_for_sql(value)
+						nameValues <<(field.value_for_sql(value))
 					end
 					if field.bind_write?
 						@bind_values << value
@@ -486,7 +513,8 @@ module Lafcadio
 		#   ObjectStore#get_max( Invoice, "rate" )
 		# will return the highest rate for all invoices.
 		def get_max( domain_class, field_name = 'pk_id' )
-			@dbBridge.group_query( Query::Max.new( domain_class, field_name ) ).only
+			qry = Query::Max.new( domain_class, field_name )
+			@dbBridge.group_query( qry ).only[:max]
 		end
 
 		# Retrieves a collection of domain objects by +pk_id+.
@@ -527,6 +555,8 @@ module Lafcadio
 		def mock? #:nodoc:
 			false
 		end
+		
+		def query( query ); @dbBridge.group_query( query ); end
 
 		def respond_to?( symbol, include_private = false )
 			begin
@@ -536,6 +566,8 @@ module Lafcadio
 			end
 		end
 		
+		def transaction( &action ); @dbBridge.transaction( action ); end
+		
 		class Cache #:nodoc:
 			def initialize( dbBridge )
 				@dbBridge = dbBridge
@@ -582,21 +614,11 @@ module Lafcadio
 							query.implies?( other_query )
 						}
 					if pk_ids
-						collection = ( pk_ids.collect { |pk_id|
+						@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
 						}
-						collection = collection[query.limit] if query.limit
-						if ( order_by = query.order_by )
-							collection = collection.sort_by { |pk_id|
-								get( query.domain_class, pk_id ).send( order_by )
-							}
-							collection.reverse! if query.order_by_order == Query::DESC
-						else
-							collection = collection.sort
-						end
-						@collections_by_query[query] = collection
 					elsif @collections_by_query.values
 						newObjects = @dbBridge.get_collection_by_query(query)
 						newObjects.each { |dbObj| save dbObj }
@@ -747,18 +769,23 @@ module Lafcadio
 		end
 	end
 
-	class SqlValueConverter #:nodoc:
+	class SqlValueConverter < Hash #:nodoc:
 		attr_reader :domain_class, :row_hash
 
 		def initialize( domain_class, row_hash )
+			super()
 			@domain_class = domain_class
-			@row_hash = row_hash
+			row_hash.each do |key, value| self[key] = value; end
 		end
 
 		def []( key )
+puts key.inspect
 			begin
 				field = @domain_class.get_field( key )
-				val = field.value_from_sql( @row_hash[ field.db_field_name ] )
+				sql_value = super field.db_field_name
+puts sql_value.inspect
+				val = field.value_from_sql sql_value
+puts val.inspect
 				if field.instance_of?( PrimaryKeyField ) && val.nil?
 					raise FieldMatchError, error_msg, caller
 				else
@@ -768,6 +795,10 @@ module Lafcadio
 				nil
 			end
 		end
+		
+		def each( &action )
+			super do |k, v| puts "#{ k } #{ v }"; action.call( k, self[k] ); end
+		end
 
 		def error_msg
 			"The field \"" + @domain_class.sql_primary_key_name +

data/lib/lafcadio/query.rb

@@ -90,10 +90,8 @@ module Lafcadio
 	class Query
 		def self.And( *conditions ); CompoundCondition.new( *conditions ); end
 		
-		def self.infer( domain_class, &action )
-			inferrer = Query::Inferrer.new( domain_class ) { |obj|
-				action.call( obj )
-			}
+		def self.infer( *args, &action )
+			inferrer = Query::Inferrer.new( *args ) { |obj| action.call( obj ) }
 			inferrer.execute
 		end
 		
@@ -108,15 +106,16 @@ module Lafcadio
 		attr_reader :domain_class, :condition
 		attr_accessor :order_by, :order_by_order, :limit
 
-		def initialize(domain_class, pk_idOrCondition = nil)
-			@domain_class = domain_class
+		def initialize(domain_class, pk_id_or_condition = nil, opts = {} )
+			@domain_class, @opts = domain_class, opts
 			( @condition, @order_by, @limit ) = [ nil, nil, nil ]
-			if pk_idOrCondition
-				if pk_idOrCondition.class <= Condition
-					@condition = pk_idOrCondition
+			if pk_id_or_condition
+				if pk_id_or_condition.class <= Condition
+					@condition = pk_id_or_condition
 				else
-					@condition = Query::Equals.new( 'pk_id', pk_idOrCondition,
-					                                domain_class )
+					@condition = Query::Equals.new(
+						'pk_id', pk_id_or_condition, domain_class
+					)
 				end
 			end
 			@order_by_order = ASC
@@ -124,20 +123,24 @@ module Lafcadio
 		
 		def and( &action ); compound( CompoundCondition::AND, action ); end
 		
+		def collect( coll )
+			if @opts[:group_functions] == [:count]
+				[ result_row( [coll.size] ) ]
+			else
+				raise
+			end
+		end
+			
 		def compound( comp_type, action )
 			rquery = Query.infer( @domain_class ) { |dobj| action.call( dobj ) }
 			comp_cond = Query::CompoundCondition.new( @condition, rquery.condition,
 			                                          comp_type )
-			q = comp_cond.query
-			[ :order_by, :order_by_order, :limit ].each do |attr|
-				q.send( attr.to_s + '=', self.send( attr ) )
-			end
-			q
+			comp_cond.query
 		end
 		
 		def eql?( other ); other.class <= Query && other.to_sql == to_sql; end
 
-		def fields; '*'; end
+		def fields; @opts[:group_functions] == [:count] ? 'count(*)' : '*'; end
 
 		def hash; to_sql.hash; end
 		
@@ -151,8 +154,14 @@ module Lafcadio
 		
 		def order_clause
 			if @order_by
-				order_by_field = @domain_class.get_field( @order_by )
-				clause = "order by #{ order_by_field.db_field_name } "
+				if @order_by.is_a? Array
+					field_str = @order_by.map { |f_name|
+						@domain_class.get_field( f_name.to_s ).db_field_name
+					}.join( ', ' )
+				else
+					field_str = @domain_class.get_field( @order_by ).db_field_name
+				end
+				clause = "order by #{ field_str } "
 				clause += @order_by_order == ASC ? 'asc' : 'desc'
 				clause
 			end
@@ -169,6 +178,14 @@ module Lafcadio
 				end
 			end
 		end
+		
+		def result_row( row )
+			if @opts[:group_functions] == [:count]
+				{ :count => row.first }
+			else
+				raise
+			end
+		end
 
 		def sql_primary_key_field(domain_class)
 			"#{ domain_class.table_name }.#{ domain_class.sql_primary_key_name }"
@@ -226,6 +243,10 @@ module Lafcadio
 				end
 			end
 			
+			def |( other_cond ); Query.Or( self, other_cond ); end
+			
+			def &( other_cond ); Query.And( self, other_cond ); end
+			
 			def implies?( other_condition )
 				self.eql?( other_condition ) or (
 					other_condition.respond_to?( :implied_by? ) and 
@@ -462,14 +483,22 @@ module Lafcadio
 		end
 
 		class Inferrer #:nodoc:
-			def initialize( domain_class, &action )
-				@domain_class = domain_class; @action = action
+			def initialize( *args, &action )
+				@domain_class = args.first; @action = action
+				unless args.size == 1
+					h = args.last
+					@order_by = h[:order_by]
+					@order_by_order = h[:order_by_order]
+				end
 			end
 			
 			def execute
 				impostor = DomainObjectImpostor.impostor( @domain_class )
 				condition = @action.call( impostor ).to_condition
 				query = Query.new( @domain_class, condition )
+				query.order_by = @order_by
+				query.order_by_order = @order_by_order
+				query
 			end
 		end
 		
@@ -532,12 +561,14 @@ module Lafcadio
 					a_value = d_obj.send( @field_name )
 					( max.nil? || a_value > max ) ? a_value : max
 				}
-				[ max ]
+				[ result_row( [max] ) ]
 			end
 		
 			def fields
 				"max(#{ @domain_class.get_field( @field_name ).db_field_name })"
 			end
+			
+			def result_row( row ); { :max => row.first }; end
 		end
 
 		class Not < Condition #:nodoc:
@@ -586,6 +617,10 @@ module Lafcadio
 				end
 			end
 			
+			def |( condition ); Query.Or( to_condition, condition ); end
+			
+			def &( condition ); Query.And( to_condition, condition ); end
+
 			def register_compare_condition( compareStr, searchTerm)
 				compareVal = ObjectFieldImpostor.comparators[compareStr]
 				Compare.new( @field_name, searchTerm,

data/lib/lafcadio/query.rb~

@@ -90,10 +90,8 @@ module Lafcadio
 	class Query
 		def self.And( *conditions ); CompoundCondition.new( *conditions ); end
 		
-		def self.infer( domain_class, &action )
-			inferrer = Query::Inferrer.new( domain_class ) { |obj|
-				action.call( obj )
-			}
+		def self.infer( *args, &action )
+			inferrer = Query::Inferrer.new( *args ) { |obj| action.call( obj ) }
 			inferrer.execute
 		end
 		
@@ -108,15 +106,16 @@ module Lafcadio
 		attr_reader :domain_class, :condition
 		attr_accessor :order_by, :order_by_order, :limit
 
-		def initialize(domain_class, pk_idOrCondition = nil)
-			@domain_class = domain_class
+		def initialize(domain_class, pk_id_or_condition = nil, opts = {} )
+			@domain_class, @opts = domain_class, opts
 			( @condition, @order_by, @limit ) = [ nil, nil, nil ]
-			if pk_idOrCondition
-				if pk_idOrCondition.class <= Condition
-					@condition = pk_idOrCondition
+			if pk_id_or_condition
+				if pk_id_or_condition.class <= Condition
+					@condition = pk_id_or_condition
 				else
-					@condition = Query::Equals.new( 'pk_id', pk_idOrCondition,
-					                                domain_class )
+					@condition = Query::Equals.new(
+						'pk_id', pk_id_or_condition, domain_class
+					)
 				end
 			end
 			@order_by_order = ASC
@@ -124,6 +123,14 @@ module Lafcadio
 		
 		def and( &action ); compound( CompoundCondition::AND, action ); end
 		
+		def collect( coll )
+			if @opts[:group_functions] == [:count]
+				[ result_row( [coll.size] ) ]
+			else
+				raise
+			end
+		end
+			
 		def compound( comp_type, action )
 			rquery = Query.infer( @domain_class ) { |dobj| action.call( dobj ) }
 			comp_cond = Query::CompoundCondition.new( @condition, rquery.condition,
@@ -133,7 +140,7 @@ module Lafcadio
 		
 		def eql?( other ); other.class <= Query && other.to_sql == to_sql; end
 
-		def fields; '*'; end
+		def fields; @opts[:group_functions] == [:count] ? 'count(*)' : '*'; end
 
 		def hash; to_sql.hash; end
 		
@@ -147,8 +154,14 @@ module Lafcadio
 		
 		def order_clause
 			if @order_by
-				order_by_field = @domain_class.get_field( @order_by )
-				clause = "order by #{ order_by_field.db_field_name } "
+				if @order_by.is_a? Array
+					field_str = @order_by.map { |f_name|
+						@domain_class.get_field( f_name.to_s ).db_field_name
+					}.join( ', ' )
+				else
+					field_str = @domain_class.get_field( @order_by ).db_field_name
+				end
+				clause = "order by #{ field_str } "
 				clause += @order_by_order == ASC ? 'asc' : 'desc'
 				clause
 			end
@@ -165,6 +178,14 @@ module Lafcadio
 				end
 			end
 		end
+		
+		def result_row( row )
+			if @opts[:group_functions] == [:count]
+				{ :count => row.first }
+			else
+				raise
+			end
+		end
 
 		def sql_primary_key_field(domain_class)
 			"#{ domain_class.table_name }.#{ domain_class.sql_primary_key_name }"
@@ -458,14 +479,22 @@ module Lafcadio
 		end
 
 		class Inferrer #:nodoc:
-			def initialize( domain_class, &action )
-				@domain_class = domain_class; @action = action
+			def initialize( *args, &action )
+				@domain_class = args.first; @action = action
+				unless args.size == 1
+					h = args.last
+					@order_by = h[:order_by]
+					@order_by_order = h[:order_by_order]
+				end
 			end
 			
 			def execute
 				impostor = DomainObjectImpostor.impostor( @domain_class )
 				condition = @action.call( impostor ).to_condition
 				query = Query.new( @domain_class, condition )
+				query.order_by = @order_by
+				query.order_by_order = @order_by_order
+				query
 			end
 		end
 		
@@ -528,12 +557,14 @@ module Lafcadio
 					a_value = d_obj.send( @field_name )
 					( max.nil? || a_value > max ) ? a_value : max
 				}
-				[ max ]
+				[ result_row( [max] ) ]
 			end
 		
 			def fields
 				"max(#{ @domain_class.get_field( @field_name ).db_field_name })"
 			end
+			
+			def result_row( row ); { :max => row.first }; end
 		end
 
 		class Not < Condition #:nodoc: