lafcadio 0.4.3

data/lib/lafcadio/objectStore/DbBridge.rb~

@@ -0,0 +1,140 @@
+require 'rubygems'
+
+require 'dbi'
+require_gem 'log4r'
+require 'lafcadio/util/LafcadioConfig'
+
+module Lafcadio
+	class DbBridge #:nodoc:
+		@@dbh = nil
+		@@lastPkIdInserted = nil
+		@@dbName = nil
+		@@connectionClass = DBI
+		
+		def DbBridge.setDbName(dbName)
+			@@dbName = dbName
+		end
+		
+		def DbBridge._load(aString)
+			aString =~ /dbh:/
+			dbString = $'
+			begin
+				dbh = Marshal.load(dbString)
+			rescue TypeError
+				dbh = nil
+			end
+			new dbh
+		end
+		
+		def DbBridge.flushConnection
+			@@dbh = nil
+		end
+		
+		def DbBridge.setConnectionClass( aClass )
+			@@connectionClass = aClass
+		end
+		
+		def DbBridge.disconnect
+			@@dbh.disconnect if @@dbh
+		end
+		
+		def initialize(dbh = nil)
+			if dbh == nil
+				if @@dbh == nil
+					config = LafcadioConfig.new
+					dbName = @@dbName || 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'] )
+				end
+			else
+				@@dbh = dbh
+			end
+			@dbh = @@dbh
+			ObjectSpace.define_finalizer( self, proc { |id| DbBridge.disconnect } )
+		end
+		
+		def maybeLog(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 commit(dbObject)
+			require 'lafcadio/objectStore/DomainObjectSqlMaker'
+			sqlMaker = DomainObjectSqlMaker.new(dbObject)
+			sqlMaker.sqlStatements.each { |sql, binds| executeCommit( sql, binds ) }
+			if sqlMaker.sqlStatements[0].first =~ /insert/
+				sql = 'select last_insert_id()'
+				result = executeSelect( sql )
+				@@lastPkIdInserted = result[0]['last_insert_id()'].to_i
+			end
+		end
+		
+		def executeCommit( sql, binds )
+			@dbh.do( sql, *binds )
+		end
+		
+		def getCollectionByQuery(query)
+			require 'lafcadio/objectStore/SqlValueConverter'
+			objectType = query.objectType
+			coll = []
+			objects = []
+			result = executeSelect query.toSql
+			result.each { |row_hash|
+				converter = SqlValueConverter.new(objectType, row_hash)
+				obj = objectType.new converter
+				objects << obj
+			}
+			coll = coll.concat objects
+			coll
+		end
+		
+		def executeSelect(sql)
+			maybeLog sql
+			begin
+				@dbh.select_all( sql )
+			rescue DBI::DatabaseError => e
+				raise $!.to_s + ": #{ e.errstr }"
+			end	
+		end
+		
+		def _dump(aDepth)
+			if @db.respond_to? '_dump'
+				dbDump = @db._dump
+			else
+				dbDump = @db.class.to_s
+			end
+			"dbh:#{dbDump}"
+		end
+		
+		def lastPkIdInserted
+			@@lastPkIdInserted
+		end
+		
+		def group_query( query )
+			row = executeSelect( query.toSql )[0]
+			result = []
+			row.each { |val|
+				if query.field_name != 'pkId'
+					a_field = query.objectType.getField( query.field_name )
+					result << a_field.valueFromSQL( val )
+				else
+					result << val.to_i
+				end
+			}
+			result
+		end
+	end
+end

data/lib/lafcadio/objectStore/DomainComparable.rb

@@ -0,0 +1,25 @@
+module Lafcadio
+	module DomainComparable
+		include Comparable
+
+		# A DomainObject or DomainObjectProxy is compared by +objectType+ and by
+		# +pkId+. 
+		def <=>(anOther)
+			if anOther.respond_to?( 'objectType' )
+				if self.objectType == anOther.objectType
+					self.pkId <=> anOther.pkId
+				else
+					self.objectType.name <=> anOther.objectType.name
+				end
+			else
+				nil
+			end
+		end
+		
+		def eql?(otherObj)
+			self == otherObj
+		end
+
+		def hash; "#{ self.class.name } #{ pkId }".hash; end
+	end
+end

data/lib/lafcadio/objectStore/DomainObjectInitError.rb

@@ -0,0 +1,9 @@
+module Lafcadio
+	class DomainObjectInitError < RuntimeError #:nodoc:
+		attr_reader :messages
+
+		def initialize(messages)
+			@messages = messages
+		end
+	end
+end

data/lib/lafcadio/objectStore/DomainObjectNotFoundError.rb

@@ -0,0 +1,4 @@
+module Lafcadio
+	class DomainObjectNotFoundError < RuntimeError #:nodoc:
+	end
+end

data/lib/lafcadio/objectStore/DomainObjectProxy.rb

@@ -0,0 +1,62 @@
+require 'lafcadio/objectStore/DomainComparable'
+
+module Lafcadio
+	# The DomainObjectProxy is used when retrieving domain objects that are 
+	# linked to other domain objects with LinkFields. In terms of +objectType+ and 
+	# +pkId+, 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
+	# DomainObjectProxy#class (or DomainObject#class) instead of
+	# DomainObjectProxy#objectType (or DomainObjectProxy#objectType).
+	class DomainObjectProxy
+		include DomainComparable
+
+		attr_accessor :objectType, :pkId
+
+		def initialize(objectTypeOrDbObject, pkId = nil)
+			if pkId
+				@objectType = objectTypeOrDbObject
+				@pkId = pkId
+			elsif objectTypeOrDbObject.class < DomainObject
+				@dbObject = objectTypeOrDbObject
+				@d_obj_retrieve_time = Time.now
+				@objectType = @dbObject.class
+				@pkId = @dbObject.pkId
+			else
+				raise ArgumentError
+			end
+			@dbObject = nil
+		end
+
+		def getDbObject
+			object_store = ObjectStore.getObjectStore
+			if @dbObject.nil? || needs_refresh?
+				@dbObject = object_store.get(@objectType, @pkId)
+								@d_obj_retrieve_time = Time.now
+
+			end
+			@dbObject
+		end
+
+		def method_missing(methodId, *args)
+			getDbObject.send(methodId.id2name, *args)
+		end
+
+		def needs_refresh?
+			object_store = ObjectStore.getObjectStore
+			last_commit_time = object_store.last_commit_time( @objectType, @pkId )
+			!last_commit_time.nil? && last_commit_time > @d_obj_retrieve_time
+		end
+		
+		def to_s
+			getDbObject.to_s
+		end
+
+		def hash
+			getDbObject.hash
+		end
+	end
+end

data/lib/lafcadio/objectStore/DomainObjectSqlMaker.rb

@@ -0,0 +1,74 @@
+require 'lafcadio/objectStore/DomainObjectInitError'
+
+module Lafcadio
+	class DomainObjectSqlMaker #:nodoc:
+		attr_reader :bindValues
+
+		def initialize(obj); @obj = obj; end
+
+		def insertSQL(objectType)
+			fields = objectType.classFields
+			nameValuePairs = getNameValuePairs(objectType)
+			if objectType.isBasedOn?
+				nameValuePairs[objectType.sqlPrimaryKeyName] = 'LAST_INSERT_ID()'
+			end
+			fieldNameStr = nameValuePairs.keys.join ", "
+			fieldValueStr = nameValuePairs.values.join ", "
+			"insert into #{ objectType.tableName}(#{fieldNameStr}) " +
+					"values(#{fieldValueStr})"
+		end
+
+		def getNameValuePairs(objectType)
+			require 'lafcadio/util/QueueHash'
+			nameValues = []
+			objectType.classFields.each { |field|
+				value = @obj.send(field.name)
+				unless field.dbWillAutomaticallyWrite
+					nameValues << field.nameForSQL
+					nameValues <<(field.valueForSQL(value))
+				end
+				if field.bind_write?
+					@bindValues << value
+				end
+			}
+			QueueHash.new( *nameValues )
+		end
+
+		def updateSQL(objectType)
+			nameValueStrings = []
+			nameValuePairs = getNameValuePairs(objectType)
+			nameValuePairs.each { |key, value|
+				nameValueStrings << "#{key}=#{ value }"
+			}
+			allNameValues = nameValueStrings.join ', '
+			"update #{ objectType.tableName} set #{allNameValues} " +
+					"where #{ objectType.sqlPrimaryKeyName}=#{@obj.pkId}"
+		end
+
+		def deleteSql(objectType)
+			"delete from #{ objectType.tableName} " +
+					"where #{ objectType.sqlPrimaryKeyName }=#{ @obj.pkId }"
+		end
+
+		def sqlStatements
+			statements = []
+			if @obj.errorMessages.size > 0
+				raise DomainObjectInitError, @obj.errorMessages, caller
+			end
+			@obj.class.selfAndConcreteSuperclasses.each { |objectType|
+				@bindValues = []
+				if @obj.pkId == nil
+					statement = insertSQL(objectType)
+				else
+					if @obj.delete
+						statement = deleteSql(objectType)
+					else
+						statement = updateSQL(objectType)
+					end
+				end
+				statements << [statement, @bindValues]
+ 			}
+			statements.reverse
+		end
+	end
+end

data/lib/lafcadio/objectStore/ObjectStore.rb

@@ -0,0 +1,207 @@
+require 'lafcadio'
+
+module Lafcadio
+	# The ObjectStore represents the database in a Lafcadio application.
+	#
+	# = Configuring the ObjectStore
+	# The ObjectStore depends on a few values being set correctly in the
+	# LafcadioConfig file:
+	# [dbuser]     The database username.
+	# [dbpassword] The database password.
+	# [dbname]     The database name.
+	# [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.getObjectStore. (Using a ContextualService makes it easier to
+	# make out the ObjectStore for unit tests: See ContextualService for more.)
+	#
+	# = 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 > (pkId)]
+	#   Retrieves one domain object by pkId. For example,
+	#     ObjectStore#getUser( 100 )
+	#   will return User 100.
+	# [ObjectStore#get< domain class >s (searchTerm, fieldName = nil)]
+	#   Returns a collection of all instances of that domain class matching that
+	#   search term. For example,
+	#     ObjectStore#getProducts( aProductCategory )
+	#   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
+	#   +fieldName+:
+	#     ObjectStore#getUsers( "Jones", "lastName" )
+	#
+	# = Querying
+	# ObjectStore can also be used to generate complex, ad-hoc queries which
+	# emulate much of the functionality you'd get from writing the SQL yourself.
+	# 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 ) )
+	#   }
+	# is the same as
+	#   select * from invoices
+	#   where (date >= '2003-01-01' and rate = 10 and hours = 10)
+	# See lafcadio/query.rb for more.
+	#
+	# = SQL Logging
+	# Lafcadio uses log4r to log all of its SQL statements. The simplest way to
+	# turn on logging is to set the following values in the LafcadioConfig file:
+	# [logSql]     Should be set to "y" to turn on logging.
+	# [logdir]     The directory where log files should be written. Required if
+	#              +logSql+ is "y"
+	# [sqlLogFile] The name of the file (not including its directory) where SQL
+	#              should be logged. Default is "sql".
+	#
+	# = 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#preCommitTrigger and DomainObject#postCommitTrigger for more.
+	class ObjectStore < ContextualService
+		def ObjectStore.setDbName(dbName) #:nodoc:
+			DbBridge.setDbName dbName
+		end
+		
+		def initialize(context, dbBridge = nil) #:nodoc:
+			super context
+			@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(dbObject)
+			require 'lafcadio/objectStore/Committer'
+			committer = Committer.new dbObject, @dbBridge
+			committer.execute
+			updateCacheAfterCommit( committer )
+		end
+		
+		# Flushes one domain object from its cache.
+		def flush(dbObject)
+			@cache.flush dbObject
+		end
+
+		# Returns the domain object corresponding to the domain class and pkId.
+		def get(objectType, pkId)
+			query = Query.new objectType, pkId
+			@cache.getByQuery( query )[0] ||
+			    ( raise( DomainObjectNotFoundError,
+					         "Can't find #{objectType} #{pkId}", caller ) )
+		end
+
+		# Returns all domain objects for the given domain class.
+		def getAll(objectType)
+			query = Query.new( objectType )
+			@cache.getByQuery( query )
+		end
+
+		# Returns the DbBridge; this is useful in case you need to use raw SQL for a
+		# specific query.
+		def getDbBridge; @dbBridge; end
+
+		def getFiltered(objectTypeName, searchTerm, fieldName = nil) #:nodoc:
+			require 'lafcadio/query/Link'
+			objectType = DomainObject.getObjectTypeFromString objectTypeName
+			unless fieldName
+				fieldName = searchTerm.objectType.bareName
+				fieldName = fieldName.decapitalize
+			end
+			if searchTerm.class <= DomainObject
+				condition = Query::Link.new(fieldName, searchTerm, objectType)
+			else
+				condition = Query::Equals.new(fieldName, searchTerm, objectType)
+			end
+			getSubset( condition )
+		end
+
+		def getMapMatch(objectType, mapped) #:nodoc:
+			fieldName = mapped.objectType.bareName.decapitalize
+			Query::Equals.new(fieldName, mapped, objectType)
+		end
+
+		def getMapObject(objectType, map1, map2) #:nodoc:
+			require 'lafcadio/query/CompoundCondition'
+			unless map1 && map2
+				raise ArgumentError,
+						"ObjectStore#getMapObject needs two non-nil keys", caller
+			end
+			mapMatch1 = getMapMatch objectType, map1
+			mapMatch2 = getMapMatch objectType, map2
+			condition = Query::CompoundCondition.new mapMatch1, mapMatch2
+			getSubset(condition)[0]
+		end
+
+		def getMapped(searchTerm, resultTypeName) #:nodoc:
+			resultType = DomainObject.getObjectTypeFromString resultTypeName
+			coll = []
+			firstTypeName = searchTerm.class.bareName
+			secondTypeName = resultType.bareName
+			mapTypeName = firstTypeName + secondTypeName
+			getFiltered(mapTypeName, searchTerm).each { |mapObj|
+				coll << mapObj.send( resultType.name.decapitalize )
+			}
+			coll
+		end
+		
+		# Retrieves the maximum value across all instances of one domain class.
+		#   ObjectStore#getMax( Client )
+		# returns the highest +pkId+ in the +clients+ table.
+		#   ObjectStore#getMax( Invoice, "rate" )
+		# will return the highest rate for all invoices.
+		def getMax( domain_class, field_name = nil )
+			query = Query::Max.new( domain_class, field_name )
+			@dbBridge.group_query( query ).only
+		end
+
+		# Retrieves a collection of domain objects by +pkId+.
+		#   ObjectStore#getObjects( Clients, [ 1, 2, 3 ] )
+		def getObjects(objectType, pkIds)
+			require 'lafcadio/query/In'
+			condition = Query::In.new('pkId', pkIds, objectType)
+			getSubset condition
+		end
+
+		def getSubset(conditionOrQuery) #:nodoc:
+			if conditionOrQuery.class <= Query::Condition
+				condition = conditionOrQuery
+				query = Query.new condition.objectType, condition
+			else
+				query = conditionOrQuery
+			end
+			@cache.getByQuery( query )
+		end
+		
+		def last_commit_time( domain_class, pkId ) #:nodoc:
+			@cache.last_commit_time( domain_class, pkId )
+		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
+		
+		# Caches one domain object.
+		def set(dbObject)
+			@cache.save dbObject
+		end
+		
+		def updateCacheAfterCommit( committer ) #:nodoc:
+			if committer.commitType == Committer::UPDATE ||
+				committer.commitType == Committer::INSERT
+				set( committer.dbObject )
+			elsif committer.commitType == Committer::DELETE
+				@cache.flush( committer.dbObject )
+			end
+			@cache.set_commit_time( committer.dbObject )
+		end
+	end
+end