org.nakedobjects.persistence.sql
Class SqlObjectStore

java.lang.Object
  org.nakedobjects.object.AbstractNakedObjectStore
      org.nakedobjects.persistence.sql.SqlObjectStore

All Implemented Interfaces:

DebugInfo, NakedObjectStore

public class SqlObjectStore

extends AbstractNakedObjectStore

Constructor Summary

SqlObjectStore()

Method Summary

void	abortTransaction()
void	addCollectionMapper(java.lang.String childClass, java.lang.String fieldName, SqlCollectionMapper mapper)
void	addElement(NakedCollection collection, NakedObject element)
void	addMapper(SqlObjectMapper mapper)
java.util.Enumeration	classes() Returns a list of all the classes (as NakedClasses) that this object store can handle.
boolean	containsElement(NakedCollection collection, NakedObject element)
void	destroyObject(NakedObject object) Removes the specified object from the object store.
void	endTransaction()
DatabaseConnection	getConnection() return the database connection strategy, which is used to get a java.sql.Connection.
java.util.Vector	getNextElements(NakedCollection collection, NakedObject fromObject, int count) Retrieve the next set (the number specified by count) of objects for the specified collection starting from, but not including, the specified object.
java.util.Vector	getNextInstances(NakedObject pattern, NakedObject fromInstance, int count) Gets the next page of instances.
NakedObject	getObject(java.lang.Object oid) Retrieves the object identified by the specified OID from the object store.
java.util.Vector	getPreviousElements(NakedCollection collection, NakedObject toObject, int count) Retrieve the previous set (the number specified by count) of objects for the specified collection starting from the specified object.
java.util.Vector	getPreviousInstances(NakedObject pattern, NakedObject toInstance, int count) Gets the previous page of instances.
protected NakedObject	getUnresolvedObject(org.nakedobjects.persistence.sql.SqlOid oid)
boolean	hasInstances(NakedClass type) Checks whether there are any instances of the specified type.
void	init()
boolean	isFirstElement(NakedCollection collection, NakedObject element)
boolean	isFirstInstance(NakedObject pattern, NakedObject instance) Checks whether the specified instance is the first one instance in the set of all instances.
boolean	isLastElement(NakedCollection collection, NakedObject element)
boolean	isLastInstance(NakedObject pattern, NakedObject instance) Checks whether the specified instance is the last instance in the set of all instances.
void	makePersistent(NakedObject object) Makes a naked object persistent.
java.lang.String	name()
int	numberOfElements(NakedCollection collection)
int	numberOfInstances(NakedObject pattern)
void	removeElement(NakedCollection collection, NakedObject element)
void	resolve(NakedObject object) Re-initialises the fields of an object.
void	save(NakedObject object) Persists the specified object's state.
long	serialNumber(java.lang.String id) Generates a unique serial number for the specified squence set.
void	shutdown()
void	startTransaction()

Methods inherited from class org.nakedobjects.object.AbstractNakedObjectStore

areObjectsDistributed, areObjectsProxied, broadcastAddUpdate, broadcastObjectUpdate, broadcastRemoveUpdate, createInstance, getCachedObject, getDebugData, getDebugTitle, getLog, isLoaded, loaded, log, log, persistenceType, restart, setLog, setUpdateNotifier, unloaded

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SqlObjectStore

public SqlObjectStore()
               throws ObjectStoreException

Method Detail

getConnection

public DatabaseConnection getConnection()

return the database connection strategy, which is used to get a java.sql.Connection.

isFirstElement

public boolean isFirstElement(NakedCollection collection,
                              NakedObject element)
                       throws ObjectStoreException

Throws:

ObjectStoreException

isFirstInstance

public boolean isFirstInstance(NakedObject pattern,
                               NakedObject instance)
                        throws ObjectStoreException

Description copied from interface: NakedObjectStore

Checks whether the specified instance is the first one instance in the set of all instances. The object store should find the instances as specified in the getNextInstances method. It should then check the first instance to see if it is the same as the one specified in instance and return true if it is, or false if it isn't.

Throws:

ObjectStoreException

isLastElement

public boolean isLastElement(NakedCollection collection,
                             NakedObject element)
                      throws ObjectStoreException

Throws:

ObjectStoreException

isLastInstance

public boolean isLastInstance(NakedObject pattern,
                              NakedObject instance)
                       throws ObjectStoreException

Description copied from interface: NakedObjectStore

Checks whether the specified instance is the last instance in the set of all instances. The object store should find the instances as specified in the getPreviousInstances method. It should then check the last instance to see if it is the same as the one specified in instance and return true if it is, or false if it isn't.

Throws:

ObjectStoreException

getNextElements

public java.util.Vector getNextElements(NakedCollection collection,
                                        NakedObject fromObject,
                                        int count)
                                 throws ObjectStoreException

Description copied from interface: NakedObjectStore

Retrieve the next set (the number specified by count) of objects for the specified collection starting from, but not including, the specified object. If fromObject is null then start from the first element. If the number of returned is less than the requested number then this set is the last set.

Throws:

ObjectStoreException

getNextInstances

public java.util.Vector getNextInstances(NakedObject pattern,
                                         NakedObject fromInstance,
                                         int count)
                                  throws ObjectStoreException

Description copied from interface: NakedObjectStore

Gets the next page of instances. The object store should create a vector and add to it those instances held by the persistence mechanism that:- 1) are of the type that the pattern object is; 2) have the same content as the pattern object where the pattern object has values or references specified, i.e. empty value objects and null references are to be ignored; 3) matches the fromObject object, or those that are found after it, unless fromObject is null in which case this last condition does not apply. The number of instances added to the vector should be limited to the number specified in count.

Throws:

ObjectStoreException

getObject

public NakedObject getObject(java.lang.Object oid)
                      throws ObjectNotFoundException,
                             ObjectStoreException

Description copied from interface: NakedObjectStore

Retrieves the object identified by the specified OID from the object store. The cache should be checked first and, if the object is cached, the cached version should be returned. It is important that if this method is called again, while the originally returned object is in working memory, then this method must return that same Java object. Assuming that the object is not cached then the data for the object should be retreived from the persistence mechanism and the object recreated (as describe previously). The specified OID should then be assigned to the recreated object by calling its setOID. Before returning the object its resolved flag should also be set by calling its setResolved method as well. If the persistence mechanism does not known of an object with the specified OID then a ObjectNotFoundException should be thrown. Note that the OID could be for an internal collection, and is therefore related to the parent object (using a CompositeOid). The elements for an internal collection are commonly stored as part of the parent object, so to get element the parent object needs to be retrieved first, and the internal collection can be got from that. Returns the stored NakedObject object that has the specified OID.

Parameters:

oid - of the object to be retrieved

Returns:

the requested naked object

Throws:

ObjectNotFoundException - when no object corresponding to the oid can be found

ObjectStoreException

getPreviousElements

public java.util.Vector getPreviousElements(NakedCollection collection,
                                            NakedObject toObject,
                                            int count)
                                     throws ObjectStoreException

Description copied from interface: NakedObjectStore

Retrieve the previous set (the number specified by count) of objects for the specified collection starting from the specified object. If fromObject is null then start from the first element. If the number of elements before toObject is less than the number of elements requested then return the required number of elements from the start of the collection.

Throws:

ObjectStoreException

getPreviousInstances

public java.util.Vector getPreviousInstances(NakedObject pattern,
                                             NakedObject toInstance,
                                             int count)
                                      throws ObjectStoreException

Description copied from interface: NakedObjectStore

Gets the previous page of instances. This should be implemented as the getNextInstances method was, except the last instance in the vector should be the one specified in toObject. If, however, the toObject is null then the vector should contain the last count instances.

Throws:

ObjectStoreException

abortTransaction

public void abortTransaction()

addElement

public void addElement(NakedCollection collection,
                       NakedObject element)
                throws ObjectStoreException

Throws:

ObjectStoreException

addMapper

public void addMapper(SqlObjectMapper mapper)
               throws ObjectStoreException

Throws:

ObjectStoreException

addCollectionMapper

public void addCollectionMapper(java.lang.String childClass,
                                java.lang.String fieldName,
                                SqlCollectionMapper mapper)
                         throws ObjectStoreException

Throws:

ObjectStoreException

classes

public java.util.Enumeration classes()
                              throws ObjectStoreException

Description copied from interface: NakedObjectStore

Returns a list of all the classes (as NakedClasses) that this object store can handle.

Specified by:

classes in interface NakedObjectStore

Overrides:

classes in class AbstractNakedObjectStore

Throws:

ObjectStoreException

containsElement

public boolean containsElement(NakedCollection collection,
                               NakedObject element)
                        throws ObjectStoreException

Throws:

ObjectStoreException

destroyObject

public void destroyObject(NakedObject object)
                   throws ObjectStoreException

Description copied from interface: NakedObjectStore

Removes the specified object from the object store. The specified object's data should be removed from the persistence mechanism and, if it is cached (which it probably is), removed from the cache also.

Throws:

ObjectStoreException

endTransaction

public void endTransaction()

hasInstances

public boolean hasInstances(NakedClass type)
                     throws ObjectStoreException

Description copied from interface: NakedObjectStore

Checks whether there are any instances of the specified type. The object store should look for instances of the type represented by type and return true if there are, or false if there are not.

Throws:

ObjectStoreException

init

public void init()
          throws ObjectStoreException

Specified by:

init in interface NakedObjectStore

Overrides:

init in class AbstractNakedObjectStore

Throws:

ObjectStoreException

makePersistent

public void makePersistent(NakedObject object)
                    throws ObjectStoreException

Description copied from interface: NakedObjectStore

Makes a naked object persistent. The specified object should be stored away via this object store's persistence mechanism, and have an new and unique OID assigned to it (by calling the object's setOid method). The object, should also be added to the cache as the object is implicitly 'in use'.

If the object has any associations then each of these, where they aren't already persistent, should also be made persistent by recursively calling this method.

If the object to be persisted is a collection, then each element of that collection, that is not already persistent, should be made persistent by recursively calling this method.

Throws:

ObjectStoreException

name

public java.lang.String name()

numberOfElements

public int numberOfElements(NakedCollection collection)
                     throws ObjectStoreException

Throws:

ObjectStoreException

numberOfInstances

public int numberOfInstances(NakedObject pattern)
                      throws ObjectStoreException

Throws:

ObjectStoreException

removeElement

public void removeElement(NakedCollection collection,
                          NakedObject element)
                   throws ObjectStoreException

Throws:

ObjectStoreException

resolve

public void resolve(NakedObject object)
             throws ObjectStoreException

Description copied from interface: NakedObjectStore

Re-initialises the fields of an object. This method should return immediately if the object's resolved flag (determined by calling isResolved on the object) is already set. If the object is unresolved then the object's missing data should be retreieved from the persistence mechanism and be used to set up the value objects and associations. The object should be set up in the same manner as in getObject above.

Throws:

ObjectStoreException

save

public void save(NakedObject object)
          throws ObjectStoreException

Description copied from interface: NakedObjectStore

Persists the specified object's state. Essentially the data held by the persistence mechanism should be updated reflect the state of the specified objects. Once updated, the object store should issue a notification to all of the object's users via the UpdateNotifier object. This can be achieved simply, if extending the AbstractObjectStore by calling its broadcastObjectUpdate method.

Throws:

ObjectStoreException

serialNumber

public long serialNumber(java.lang.String id)

Description copied from interface: NakedObjectStore

Generates a unique serial number for the specified squence set. Each set of serial numbers are a simple numerical sequence. Calling this method with a unused sequence name creates a new set.

shutdown

public void shutdown()

Specified by:

shutdown in interface NakedObjectStore

Overrides:

shutdown in class AbstractNakedObjectStore

startTransaction

public void startTransaction()

getUnresolvedObject

protected NakedObject getUnresolvedObject(org.nakedobjects.persistence.sql.SqlOid oid)
                                   throws ObjectNotFoundException,
                                          ObjectStoreException

Throws:

ObjectNotFoundException

ObjectStoreException