lafcadio 0.4.3 → 0.5.2

data/lib/lafcadio/query.rb

@@ -39,8 +39,8 @@
 #   # => "select * from invoices where client = 99"
 # 
 # == Inclusion: +in+
-#   first_three_invs = object_store.getInvoices { |inv| inv.pkId.in( 1, 2, 3 ) }
-#   # => "select * from invoices where pkId in ( 1, 2, 3 )"
+#   first_three_invs = object_store.getInvoices { |inv| inv.pk_id.in( 1, 2, 3 ) }
+#   # => "select * from invoices where pk_id in ( 1, 2, 3 )"
 #
 # == Text comparison: +like+
 #   fname_starts_with_a = object_store.getUsers { |user|
@@ -84,54 +84,427 @@
 #   invoices = object_store.getInvoices { |inv| inv.rate.equals( 50 ).not }
 #   # => "select * from invoices where rate != 50"
 
-require 'lafcadio/includer'
-Includer.include( 'query' )
+require 'delegate'
 
 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 )
+			}
+			inferrer.execute
+		end
+		
 		def self.Or( *conditions )
 			conditions << CompoundCondition::OR
 			CompoundCondition.new( *conditions)
 		end
 
+		ASC		= 1
+		DESC 	= 2
+
+		attr_reader :object_type, :condition
+		attr_accessor :order_by, :order_by_order, :limit
+
+		def initialize(object_type, pk_idOrCondition = nil)
+			@object_type = object_type
+			( @condition, @order_by, @limit ) = [ nil, nil, nil ]
+			if pk_idOrCondition
+				if pk_idOrCondition.class <= Condition
+					@condition = pk_idOrCondition
+				else
+					@condition = Query::Equals.new( object_type.sql_primary_key_name,
+					                                pk_idOrCondition, object_type )
+				end
+			end
+			@order_by_order = ASC
+		end
+		
+		def and( &action ); compound( CompoundCondition::AND, action ); end
+		
+		def compound( comp_type, action )
+			rquery = Query.infer( @object_type ) { |dobj| action.call( dobj ) }
+			comp_cond = Query::CompoundCondition.new( @condition, rquery.condition,
+			                                          comp_type )
+			comp_cond.query
+		end
+		
+		def eql?( other ); other.class <= Query && other.to_sql == to_sql; end
+
+		def fields; '*'; end
+
+		def hash; to_sql.hash; end
+		
+		def limit_clause
+			"limit #{ @limit.begin }, #{ @limit.end - @limit.begin + 1 }" if @limit
+		end
+
+		def or( &action ); compound( CompoundCondition::OR, action ); end
+		
+		def order_clause
+			if @order_by
+				clause = "order by #{ @order_by } "
+				clause += @order_by_order == ASC ? 'asc' : 'desc'
+				clause
+			end
+		end
+
+		def sql_primary_key_field(object_type)
+			"#{ object_type.table_name }.#{ object_type.sql_primary_key_name }"
+		end
+
+		def tables
+			concrete_classes = object_type.self_and_concrete_superclasses.reverse
+			table_names = concrete_classes.collect { |domain_class|
+				domain_class.table_name
+			}
+			table_names.join( ', ' )
+		end
+
+		def to_sql
+			clauses = [ "select #{ fields }", "from #{ tables }" ]
+			clauses << where_clause if where_clause
+			clauses << order_clause if order_clause
+			clauses << limit_clause if limit_clause
+			clauses.join ' '
+		end
+
+		def where_clause
+			concrete_classes = object_type.self_and_concrete_superclasses.reverse
+			where_clauses = []
+			concrete_classes.each_with_index { |domain_class, i|
+				if i < concrete_classes.size - 1
+					join_clause = sql_primary_key_field( domain_class ) + ' = ' +
+					              sql_primary_key_field( concrete_classes[i+1] )
+					where_clauses << join_clause
+				else
+					where_clauses << @condition.to_sql if @condition
+				end
+			}
+			where_clauses.size > 0 ? 'where ' + where_clauses.join( ' and ' ) : nil
+		end
+
+		class Condition #:nodoc:
+			def Condition.search_term_type
+				Object
+			end
+
+			attr_reader :object_type
+
+			def initialize(fieldName, searchTerm, object_type)
+				@fieldName = fieldName
+				@searchTerm = searchTerm
+				unless @searchTerm.class <= self.class.search_term_type
+					raise "Incorrect searchTerm type #{ searchTerm.class }"
+				end
+				@object_type = object_type
+				if @object_type
+					unless @object_type <= DomainObject
+						raise "Incorrect object type #{ @object_type.to_s }"
+					end
+				end
+			end
+			
+			def db_field_name; get_field.db_table_and_field_name; end
+			
+			def get_field
+				anObjectType = @object_type
+				field = nil
+				while (anObjectType < DomainObject || anObjectType < DomainObject) &&
+							!field
+					field = anObjectType.get_class_field( @fieldName ) ||
+					        anObjectType.get_class_field_by_db_name( @fieldName )
+					anObjectType = anObjectType.superclass
+				end
+				if field
+					field
+				else
+					errStr = "Couldn't find field \"#{ @fieldName }\" in " +
+									 "#{ @object_type } domain class"
+					raise( MissingError, errStr, caller )
+				end
+			end
+			
+			def query; Query.new( @object_type, self ); end
+			
+			def not
+				Query::Not.new( self )
+			end
+
+			def primary_key_field?
+				[ @object_type.sql_primary_key_name, 'pk_id' ].include?( @fieldName )
+			end
+			
+			def to_condition; self; end
+		end
+
+		class Compare < Condition #:nodoc:
+			LESS_THAN							= 1
+			LESS_THAN_OR_EQUAL		= 2
+			GREATER_THAN_OR_EQUAL = 3
+			GREATER_THAN					= 4
+
+			@@comparators = {
+				LESS_THAN => '<',
+				LESS_THAN_OR_EQUAL => '<=',
+				GREATER_THAN_OR_EQUAL => '>=',
+				GREATER_THAN => '>'
+			}
+
+			@@mockComparators = {
+				LESS_THAN => Proc.new { |d1, d2| d1 < d2 },
+				LESS_THAN_OR_EQUAL => Proc.new { |d1, d2| d1 <= d2 },
+				GREATER_THAN_OR_EQUAL => Proc.new { |d1, d2| d1 >= d2 },
+				GREATER_THAN => Proc.new { |d1, d2| d1 > d2 }
+			}
+
+			def initialize(fieldName, searchTerm, object_type, compareType)
+				super fieldName, searchTerm, object_type
+				@compareType = compareType
+			end
+
+			def to_sql
+				if ( get_field.kind_of?( LinkField ) &&
+				     !@searchTerm.respond_to?( :pk_id ) )
+					search_val = @searchTerm.to_s
+				else
+					search_val = get_field.value_for_sql( @searchTerm ).to_s
+				end
+				"#{ db_field_name } #{ @@comparators[@compareType] } " + search_val
+			end
+
+			def object_meets(anObj)
+				value = anObj.send @fieldName
+				value = value.pk_id if value.class <= DomainObject
+				if value
+					@@mockComparators[@compareType].call(value, @searchTerm)
+				else
+					false
+				end
+			end
+		end
+
+		class CompoundCondition < Condition #:nodoc:
+			AND = 1
+			OR  = 2
+		
+			def initialize(*conditions)
+				if( [ AND, OR ].index(conditions.last) )
+					@compoundType = conditions.last
+					conditions.pop
+				else
+					@compoundType = AND
+				end
+				@conditions = conditions
+				@object_type = conditions[0].object_type
+			end
+
+			def object_meets(anObj)
+				if @compoundType == AND
+					@conditions.inject( true ) { |result, cond|
+						result && cond.object_meets( anObj )
+					}
+				else
+					@conditions.inject( false ) { |result, cond|
+						result || cond.object_meets( anObj )
+					}
+				end
+			end
+
+			def to_sql
+				booleanString = @compoundType == AND ? 'and' : 'or'
+				subSqlStrings = @conditions.collect { |cond| cond.to_sql }
+				"(#{ subSqlStrings.join(" #{ booleanString } ") })"
+			end
+		end
+
 		class DomainObjectImpostor #:nodoc:
-			attr_reader :domainClass
+			attr_reader :domain_class
 		
-			def initialize( domainClass )
-				@domainClass = domainClass
+			def initialize( domain_class )
+				@domain_class = domain_class
 			end
 			
 			def method_missing( methId, *args )
 				fieldName = methId.id2name
-				if fieldName == 'pkId'
-					ObjectFieldImpostor.new( self, fieldName )
-				else
-					begin
-						classField = @domainClass.getField( fieldName )
-						ObjectFieldImpostor.new( self, classField )
-					rescue MissingError
-						super( methId, *args )
-					end
+				begin
+					classField = @domain_class.get_field( fieldName )
+					ObjectFieldImpostor.new( self, classField )
+				rescue MissingError
+					super( methId, *args )
 				end
 			end
 		end
 		
+		class Equals < Condition #:nodoc:
+			def r_val_string
+				field = get_field
+				if @searchTerm.class <= ObjectField
+					@searchTerm.db_table_and_field_name
+				else
+					field.value_for_sql(@searchTerm).to_s
+				end
+			end
+
+			def object_meets(anObj)
+				if @searchTerm.class <= ObjectField
+					compare_value = anObj.send( @searchTerm.name )
+				else
+					compare_value = @searchTerm
+				end
+				compare_value == anObj.send( @fieldName )
+			end
+
+			def to_sql
+				sql = "#{ db_field_name } "
+				unless @searchTerm.nil?
+					sql += "= " + r_val_string
+				else
+					sql += "is null"
+				end
+				sql
+			end
+		end
+
+		class In < Condition #:nodoc:
+			def self.search_term_type
+				Array
+			end
+
+			def object_meets(anObj)
+				value = anObj.send @fieldName
+				@searchTerm.index(value) != nil
+			end
+
+			def to_sql
+				"#{ db_field_name } in (#{ @searchTerm.join(', ') })"
+			end
+		end
+
 		class Inferrer #:nodoc:
-			def initialize( domainClass, &action )
-				@domainClass = domainClass; @action = action
+			def initialize( domain_class, &action )
+				@domain_class = domain_class; @action = action
 			end
 			
 			def execute
-				impostor = DomainObjectImpostor.new( @domainClass )
-				condition = @action.call( impostor )
-				query = Query.new( @domainClass, condition )
+				impostor = DomainObjectImpostor.new( @domain_class )
+				condition = @action.call( impostor ).to_condition
+				query = Query.new( @domain_class, condition )
+			end
+		end
+		
+		class Like < Condition #:nodoc:
+			PRE_AND_POST	= 1
+			PRE_ONLY			= 2
+			POST_ONLY			= 3
+
+			def initialize(
+					fieldName, searchTerm, object_type, matchType = PRE_AND_POST)
+				super fieldName, searchTerm, object_type
+				@matchType = matchType
+			end
+			
+			def get_regexp
+				if @matchType == PRE_AND_POST
+					Regexp.new(@searchTerm)
+				elsif @matchType == PRE_ONLY
+					Regexp.new(@searchTerm.to_s + "$")
+				elsif @matchType == POST_ONLY
+					Regexp.new("^" + @searchTerm)
+				end
+			end
+
+			def object_meets(anObj)
+				value = anObj.send @fieldName
+				if value.class <= DomainObject || value.class == DomainObjectProxy
+					value = value.pk_id.to_s
+				end
+				if value.class <= Array
+					(value.index(@searchTerm) != nil)
+				else
+					get_regexp.match(value) != nil
+				end
+			end
+
+			def to_sql
+				withWildcards = @searchTerm
+				if @matchType == PRE_AND_POST
+					withWildcards = "%" + withWildcards + "%"
+				elsif @matchType == PRE_ONLY
+					withWildcards = "%" + withWildcards
+				elsif @matchType == POST_ONLY
+					withWildcards += "%"
+				end
+				"#{ db_field_name } like '#{ withWildcards }'"
 			end
 		end
+
+		class Link < Condition #:nodoc:
+			def initialize( fieldName, searchTerm, object_type )
+				if searchTerm.pk_id.nil?
+					raise ArgumentError,
+					      "Can't query using an uncommitted domain object as a search term",
+								caller
+				else
+					super( fieldName, searchTerm, object_type )
+				end
+			end
 		
+			def self.search_term_type
+				DomainObject
+			end
+
+			def object_meets(anObj)
+				value = anObj.send @fieldName
+				value ? value.pk_id == @searchTerm.pk_id : false
+			end
+
+			def to_sql
+				"#{ db_field_name } = #{ @searchTerm.pk_id }"
+			end
+		end
+
+		class Max < Query #:nodoc:
+			attr_reader :field_name
+		
+			def initialize( object_type, field_name = 'pk_id' )
+				super( object_type )
+				@field_name = field_name
+			end
+		
+			def collect( coll )
+				max = coll.inject( nil ) { |max, d_obj|
+					a_value = d_obj.send( @field_name )
+					( max.nil? || a_value > max ) ? a_value : max
+				}
+				[ max ]
+			end
+		
+			def fields
+				"max(#{ @object_type.get_field( @field_name ).db_field_name })"
+			end
+		end
+
+		class Not < Condition #:nodoc:
+			def initialize(unCondition)
+				@unCondition = unCondition
+			end
+
+			def object_meets(obj)
+				!@unCondition.object_meets(obj)
+			end
+			
+			def object_type; @unCondition.object_type; end
+
+			def to_sql
+				"!(#{ @unCondition.to_sql })"
+			end
+		end
+
 		class ObjectFieldImpostor #:nodoc:
-			def ObjectFieldImpostor.comparators
+			def self.comparators
 				{ 
 					'lt' => Compare::LESS_THAN, 'lte' => Compare::LESS_THAN_OR_EQUAL,
 					'gte' => Compare::GREATER_THAN_OR_EQUAL,
@@ -143,32 +516,32 @@ module Lafcadio
 		
 			def initialize( domainObjectImpostor, class_field_or_name )
 				@domainObjectImpostor = domainObjectImpostor
-				if class_field_or_name == 'pkId'
-					@db_field_name = 'pkId'
+				if class_field_or_name == 'pk_id'
+					@db_field_name = 'pk_id'
 				else
 					@class_field = class_field_or_name
-					@db_field_name = class_field_or_name.dbFieldName
+					@db_field_name = class_field_or_name.db_field_name
 				end
 			end
 			
 			def method_missing( methId, *args )
 				methodName = methId.id2name
 				if !ObjectFieldImpostor.comparators.keys.index( methodName ).nil?
-					registerCompareCondition( methodName, *args )
+					register_compare_condition( methodName, *args )
 				else
 					super( methId, *args )
 				end
 			end
 			
-			def registerCompareCondition( compareStr, searchTerm)
+			def register_compare_condition( compareStr, searchTerm)
 				compareVal = ObjectFieldImpostor.comparators[compareStr]
 				Compare.new( @db_field_name, searchTerm,
-										 @domainObjectImpostor.domainClass, compareVal )
+				             @domainObjectImpostor.domain_class, compareVal )
 			end
 			
 			def equals( searchTerm )
 				Equals.new( @db_field_name, field_or_field_name( searchTerm ),
-				            @domainObjectImpostor.domainClass )
+					          @domainObjectImpostor.domain_class )
 			end
 			
 			def field_or_field_name( search_term )
@@ -191,13 +564,24 @@ module Lafcadio
 					matchType = Query::Like::PRE_AND_POST
 				end
 				Query::Like.new( @db_field_name, searchTerm,
-												 @domainObjectImpostor.domainClass, matchType )
+												 @domainObjectImpostor.domain_class, matchType )
 			end
 			
 			def in( *searchTerms )
 				Query::In.new( @db_field_name, searchTerms,
-											 @domainObjectImpostor.domainClass )
+											 @domainObjectImpostor.domain_class )
 			end
+			
+			def to_condition
+				if @class_field.instance_of?( BooleanField )
+					Query::Equals.new( @db_field_name, true,
+					                   @domainObjectImpostor.domain_class )
+				else
+					raise
+				end
+			end
+			
+			def not; to_condition.not; end
 		end
 	end
 end