UnitOfWorkImpl

java.lang.Object
- oracle.toplink.essentials.internal.sessions.AbstractSession
- - oracle.toplink.essentials.internal.sessions.UnitOfWorkImpl

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, Session, UnitOfWork

Direct Known Subclasses:

RepeatableWriteUnitOfWork
```
public class UnitOfWorkImpl
extends AbstractSession
implements UnitOfWork
```
Implementation of oracle.toplink.essentials.sessions.UnitOfWork The public interface should be used by public API and testing, the implementation should be used internally.
See Also:
Purpose: To allow object level transactions. Description: The unit of work is a session that implements all of the normal protocol of a TopLink session. It can be spawned from any other session including another unit of work. Objects can be brought into the unit of work through reading them or through registering them. The unit of work will opperate on its own object space, that is the objects within the unit of work will be clones of the orignial objects. When the unit of work is commited, all changes to any objects registered within the unit of work will be commited to the database. A minimal commit/update will be performed and any foreign keys/circular reference/referencial integrity will be resolved. If the commit to the database is successful the changed objects will be merged back into the unit of work parent session. Responsibilities: Allow parallel transactions against a session's objects. Allow nested transactions. Not require the application to write objects that is changes, automatically determine what has changed. Perform a minimal commit/update of all changes that occured. Resolve foreign keys for newly created objects and maintain referencial integrity. Allow for the object transaction to use its own object space.
, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AfterExternalTransactionRolledBack`
`protected IdentityHashtable`	`allClones` This member variable contains a copy of all of the clones for this particular UOW
`static int`	`Birth`
`protected int`	`cloneDepth` Used during the cloning process to track the recursive depth in.
`protected IdentityHashtable`	`cloneMapping` Hashtable of all the clones.
`protected IdentityHashtable`	`cloneToOriginals` As well as used as lookup in merge algorithm for aggregates and others
`static int`	`CommitPending`
`static int`	`CommitTransactionPending`
`static int`	`Death`
`protected java.util.List`	`deferredModifyAllQueries` Contains deferred ModifyAllQuery's that have translation row for execution only.
`protected IdentityHashtable`	`deletedObjects`
`static int`	`DO_NOT_THROW_CONFORM_EXCEPTIONS` Used for Conforming Queries
`static int`	`Full`
`protected boolean`	`isSynchronized` With the new synchronized unit of work, need a lifecycle state variable to track birth, commited, pending_merge and death.
`protected MergeManager`	`lastUsedMergeManager` Used to store the list of locks that this UnitOfWork has acquired for this merge
`protected int`	`lifecycle`
`static java.lang.String`	`LOCK_QUERIES_PROPERTY`
`static int`	`MergePending`
`protected java.util.List`	`modifyAllQueries` lazy initialization done in storeModifyAllQuery.
`protected IdentityHashtable`	`newAggregates`
`protected IdentityHashtable`	`newObjectsCloneToOriginal`
`protected IdentityHashtable`	`newObjectsOriginalToClone`
`static int`	`None`
`protected IdentityHashtable`	`objectsDeletedDuringCommit`
`protected java.util.Map`	`objectsLockedForClone` This collection will be used to store those objects that are currently locked for the clone process.
`protected java.util.Hashtable`	`optimisticReadLockObjects` Kept reference of read lock objects
`protected AbstractSession`	`parent`
`static int`	`Partial`
`protected IdentityHashtable`	`pessimisticLockedObjects` use to track pessimistic locked objects
`protected java.util.Hashtable`	`readOnlyClasses` Read-only class can be used for reference data to avoid cloning when not required.
`protected IdentityHashtable`	`removedObjects`
`protected boolean`	`resumeOnTransactionCompletion` True if UnitOfWork should be resumed on completion of transaction.
`protected boolean`	`shouldCascadeCloneToJoinedRelationship` True if the value holder for the joined attribute should be triggered.
`protected boolean`	`shouldCheckWriteLock` PERF: Cache the write-lock check to avoid cost of checking in every register/clone.
`protected boolean`	`shouldNewObjectsBeCached` Allow for double merges of new objects by putting them into the cache.
`protected boolean`	`shouldPerformDeletesFirst` Flag indicating that deletes should be performed before other updates.
`protected int`	`shouldThrowConformExceptions` Flag indicating how to deal with exceptions on conforming queries.
`protected static boolean`	`SmartMerge` Used for merging dependent values without use of WL SessionAccessor
`static int`	`THROW_ALL_CONFORM_EXCEPTIONS`
`protected java.lang.Object`	`transaction` PERF: Stores the JTA transaction to optimize activeUnitOfWork lookup.
`protected UnitOfWorkChangeSet`	`unitOfWorkChangeSet` This method is used to store the current changeSet for this UnitOfWork.
`protected IdentityHashtable`	`unregisteredExistingObjects`
`protected IdentityHashtable`	`unregisteredNewObjects`
`protected int`	`validationLevel` The amount of validation can be configured.
`protected boolean`	`wasNonObjectLevelModifyQueryExecuted` True if either DataModifyQuery or ModifyAllQuery was executed.
`protected boolean`	`wasTransactionBegunPrematurely` Flag indicating that the transaction for this UOW was already begun.
`static int`	`WriteChangesFailed`

Fields inherited from class oracle.toplink.essentials.internal.sessions.AbstractSession
accessor, broker, commitManager, ejbqlPlaceHolderQueries, eventManager, exceptionHandler, externalTransactionController, identityMapAccessor, integrityChecker, isInProfile, lastDescriptorAccessed, logSessionString, name, numberOfActiveUnitsOfWork, platform, profiler, project, properties, queries, sessionLog, transactionMutex, wasJTSTransactionInternallyStarted

Constructor Summary

Constructors
Constructor and Description

UnitOfWorkImpl(AbstractSession parent)
INTERNAL: Create and return a new unit of work with the sesson as its parent.

Constructors
Constructor and Description
`UnitOfWorkImpl(AbstractSession parent)` INTERNAL: Create and return a new unit of work with the sesson as its parent.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`UnitOfWork`	`acquireUnitOfWork()` PUBLIC: Nested units of work are not supported in TopLink Essentials.
`void`	`addNewAggregate(java.lang.Object originalObject)` INTERNAL: Register a new aggregate object with the unit of work.
`void`	`addObjectDeletedDuringCommit(java.lang.Object object, ClassDescriptor descriptor)` INTERNAL: Add object deleted during root commit of unit of work.
`void`	`addPessimisticLockedClone(java.lang.Object clone)` INTERNAL:
`void`	`addReadOnlyClass(java.lang.Class theClass)` PUBLIC: Adds the given Java class to the receiver's set of read-only classes.
`void`	`addReadOnlyClasses(java.util.Vector classes)` PUBLIC: Adds the classes in the given Vector to the existing set of read-only classes.
`void`	`addRemovedObject(java.lang.Object orignal)` INTERNAL: Register that an object was removed in a nested unit of work.
`void`	`afterTransaction(boolean committed, boolean isExternalTransaction)` INTERNAL: Called after transaction is completed (committed or rolled back)
`void`	`assignSequenceNumber(java.lang.Object object)` ADVANCED: Assign sequence number to the object.
`void`	`assignSequenceNumbers()` ADVANCED: Assign sequence numbers to all new objects registered in this unit of work, or any new objects reference by any objects registered.
`protected void`	`basicPrintRegisteredObjects()` INTERNAL: Print the objects in the unit of work.
`void`	`beginEarlyTransaction()` PUBLIC: Tell the unit of work to begin a transaction now.
`void`	`beginTransaction()` INTERNAL: This is internal to the uow, transactions should not be used explictly in a uow.
`java.lang.Object`	`buildOriginal(java.lang.Object workingClone)` INTERNAL: Unregistered new objects have no original so we must create one for commit and resume and to put into the parent.
`UnitOfWorkChangeSet`	`calculateChanges(IdentityHashtable allObjects, UnitOfWorkChangeSet changeSet)` INTERNAL:
`protected boolean`	`canChangeReadOnlySet()` INTERNAL: Checks whether the receiver has been used.
`java.lang.Object`	`checkExistence(java.lang.Object object)` INTERNAL: Register the object and return the clone if it is existing otherwise return null if it is new.
`boolean`	`checkForUnregisteredExistingObject(java.lang.Object object)` INTERNAL:
`protected java.lang.Object`	`checkIfAlreadyRegistered(java.lang.Object object, ClassDescriptor descriptor)` INTERNAL: Return the value of the object if it already is registered, otherwise null.
`void`	`clear(boolean shouldClearCache)` INTERNAL: This method will clear all registered objects from this UnitOfWork.
`void`	`clearForClose(boolean shouldClearCache)` INTERNAL: Call this method if the uow will no longer used for comitting transactions: all the changes sets will be dereferenced, and (optionally) the cache cleared.
`protected java.lang.Object`	`cloneAndRegisterNewObject(java.lang.Object original)` ADVANCED: Register the new object with the unit of work.
`java.lang.Object`	`cloneAndRegisterObject(java.lang.Object original, CacheKey cacheKey, JoinedAttributeManager joinedAttributeManager)` INTERNAL: Clone and register the object.
`IdentityHashtable`	`collectAndPrepareObjectsForCommit()` INTERNAL: Prepare for commit.
`IdentityHashtable`	`collectAndPrepareObjectsForNestedMerge()` INTERNAL: Prepare for merge in nested uow.
`void`	`commit()` PUBLIC: Commit the unit of work to its parent.
`protected void`	`commitAfterWriteChanges()` INTERNAL: Commits a UnitOfWork where the commit process has already been initiated by all call to writeChanges().
`void`	`commitAndResume()` PUBLIC: Commit the unit of work to its parent.
`protected void`	`commitAndResumeAfterWriteChanges()` INTERNAL: Commits and resumes a UnitOfWork where the commit process has already been initiated by all call to writeChanges().
`void`	`commitAndResumeOnFailure()` PUBLIC: Commit the unit of work to its parent.
`void`	`commitAndResumeWithPreBuiltChangeSet(UnitOfWorkChangeSet uowChangeSet)` INTERNAL: This method is used by the MappingWorkbench for their read-only file feature this method must not be exposed to or used by customers until it has been revised and the feature revisited to support OptimisticLocking and Serialization
`protected boolean`	`commitInternallyStartedExternalTransaction()` PROTECTED: Used in commit and commit-like methods to commit internally started external transaction
`void`	`commitRootUnitOfWork()` INTERNAL: Commit the changes to any objects to the parent.
`void`	`commitRootUnitOfWorkWithPreBuiltChangeSet(UnitOfWorkChangeSet uowChangeSet)` INTERNAL: This method is used by the MappingWorkbench read-only files feature It will commit a pre-built unitofwork change set to the database
`protected void`	`commitToDatabase(boolean commitTransaction)` INTERNAL: CommitChanges To The Database from a calculated changeSet
`protected void`	`commitToDatabaseWithChangeSet(boolean commitTransaction)` INTERNAL: Commit the changes to any objects to the parent.
`protected void`	`commitToDatabaseWithPreBuiltChangeSet(UnitOfWorkChangeSet uowChangeSet, boolean commitTransaction)` INTERNAL: Commit pre-built changeSet to the database changest to the database.
`void`	`commitTransaction()` INTERNAL: This is internal to the uow, transactions should not be used explictly in a uow.
`protected void`	`commitTransactionAfterWriteChanges()` INTERNAL: After writeChanges() everything has been done except for committing the transaction.
`java.util.Vector`	`copyReadOnlyClasses()` INTERNAL: Copy the read only classes from the unit of work.
`java.lang.Object`	`deepMergeClone(java.lang.Object rmiClone)` PUBLIC: Merge the attributes of the clone into the unit of work copy.
`java.lang.Object`	`deepRevertObject(java.lang.Object clone)` PUBLIC: Revert the object's attributes from the parent.
`void`	`deepUnregisterObject(java.lang.Object clone)` ADVANCED: Unregister the object with the unit of work.
`void`	`deleteAllObjects(java.util.Vector domainObjects)` PUBLIC: Delete all of the objects and all of their privately owned parts in the database.
`protected void`	`discoverAllUnregisteredNewObjects()` INTERNAL: Search for any objects in the parent that have not been registered.
`void`	`discoverUnregisteredNewObjects(java.lang.Object clone, IdentityHashtable knownNewObjects, IdentityHashtable unregisteredExistingObjects, IdentityHashtable visitedObjects)` INTERNAL: Traverse the object to find references to objects not registered in this unit of work.
`void`	`dontPerformValidation()` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`java.lang.Object`	`executeCall(Call call, AbstractRecord translationRow, DatabaseQuery query)` INTERNAL: Override From session.
`void`	`forceUpdateToVersionField(java.lang.Object lockObject, boolean shouldModifyVersionField)` ADVANCED: Set optmistic read lock on the object.
`Accessor`	`getAccessor()` INTERNAL: The uow does not store a local accessor but shares its parents.
`Accessor`	`getAccessor(java.lang.Class domainClass)` INTERNAL: The uow does not store a local accessor but shares its parents.
`Accessor`	`getAccessor(java.lang.String sessionName)` INTERNAL: The uow does not store a local accessor but shares its parents.
`UnitOfWork`	`getActiveUnitOfWork()` PUBLIC: Return the active unit of work for the current active external (JTS) transaction.
`protected IdentityHashtable`	`getAllClones()` INTERNAL: This method is used to get a copy of the collection of all clones in the UnitOfWork
`java.util.Vector`	`getAllFromNewObjects(Expression selectionCriteria, java.lang.Class theClass, AbstractRecord translationRow, InMemoryQueryIndirectionPolicy valueHolderPolicy)` INTERNAL: Return any new objects matching the expression.
`java.lang.Object`	`getBackupClone(java.lang.Object clone)` INTERNAL: Return the backup clone for the working clone.
`java.lang.Object`	`getBackupCloneForCommit(java.lang.Object clone)` INTERNAL: Return the backup clone for the working clone.
`IdentityHashtable`	`getCloneMapping()` INTERNAL: Return the clone mapping.
`IdentityHashtable`	`getCloneToOriginals()` INTERNAL: Hashtable used to avoid garbage collection in weak caches.
`CommitManager`	`getCommitManager()` INTERNAL: The commit manager is used to resolve referncial integrity on commits of multiple objects.
`UnitOfWorkChangeSet`	`getCurrentChanges()` ADVANCED: This method Will Calculate the chages for the UnitOfWork.
`java.util.Vector`	`getDefaultReadOnlyClasses()` INTERNAL: Returns the set of read-only classes that gets assigned to each newly created UnitOfWork.
`IdentityHashtable`	`getDeletedObjects()` INTERNAL: The deleted objects stores any objects removed during the unit of work.
`ClassDescriptor`	`getDescriptorForAlias(java.lang.String alias)` PUBLIC: Return the descriptor for the alias.
`java.util.Map`	`getDescriptors()` PUBLIC: Return all registered descriptors.
`AbstractSession`	`getExecutionSession(DatabaseQuery query)` INTERNAL: Gets the session which this query will be executed on.
`int`	`getLifecycle()` INTERNAL: The life cycle tracks if the unit of work is active and is used for JTS.
`MergeManager`	`getMergeManager()` A reference to the last used merge manager.
`IdentityHashtable`	`getNewAggregates()` INTERNAL: The hashtable stores any new aggregates that have been cloned.
`IdentityHashtable`	`getNewObjectsCloneToOriginal()` INTERNAL: The new objects stores any objects newly created during the unit of work.
`IdentityHashtable`	`getNewObjectsOriginalToClone()` INTERNAL: The new objects stores any objects newly created during the unit of work.
`java.lang.Object`	`getObjectFromNewObjects(java.lang.Class theClass, java.util.Vector selectionKey)` INTERNAL: Return any new object matching the expression.
`java.lang.Object`	`getObjectFromNewObjects(Expression selectionCriteria, java.lang.Class theClass, AbstractRecord translationRow, InMemoryQueryIndirectionPolicy valueHolderPolicy)` INTERNAL: Return any new object matching the expression.
`IdentityHashtable`	`getObjectsDeletedDuringCommit()` INTERNAL: Returns all the objects which are deleted during root commit of unit of work.
`java.util.Hashtable`	`getOptimisticReadLockObjects()` INTERNAL: Return optimistic read lock objects
`java.lang.Object`	`getOriginalVersionOfNewObject(java.lang.Object workingClone)` INTERNAL: Return the original version of the new object (working clone).
`java.lang.Object`	`getOriginalVersionOfObject(java.lang.Object workingClone)` ADVANCED: Return the original version of the object(clone) from the parent's identity map.
`java.lang.Object`	`getOriginalVersionOfObjectOrNull(java.lang.Object workingClone)` ADVANCED: Return the original version of the object(clone) from the parent's identity map.
`AbstractSession`	`getParent()` PUBLIC: Return the parent.
`AbstractSession`	`getParentIdentityMapSession(DatabaseQuery query, boolean canReturnSelf, boolean terminalOnly)` INTERNAL: Gets the next link in the chain of sessions followed by a query's check early return, the chain of sessions with identity maps all the way up to the root session.
`IdentityHashtable`	`getPessimisticLockedObjects()` INTERNAL:
`Platform`	`getPlatform(java.lang.Class domainClass)` INTERNAL: Return the platform for a particular class.
`DatabaseQuery`	`getQuery(java.lang.String name)` PUBLIC: Return the query from the session pre-defined queries with the given name.
`DatabaseQuery`	`getQuery(java.lang.String name, java.util.Vector arguments)` PUBLIC: Return the query from the session pre-defined queries with the given name.
`java.util.Hashtable`	`getReadOnlyClasses()` INTERNAL: Returns the set of read-only classes for the receiver.
`protected IdentityHashtable`	`getRemovedObjects()` INTERNAL: The removed objects stores any newly registered objects removed during the nested unit of work.
`Sequencing`	`getSequencing()` INTERNAL: Return the Sequencing object used by the session.
`ServerPlatform`	`getServerPlatform()` INTERNAL: Marked internal as this is not customer API but helper methods for accessing the server platform from within TopLink's other sessions types (ie not DatabaseSession)
`java.lang.String`	`getSessionTypeString()` INTERNAL: Returns the type of session, its class.
`int`	`getShouldThrowConformExceptions()` INTERNAL: Return whether to throw exceptions on conforming queries
`int`	`getState()` INTERNAL: Find out what the lifecycle state of this UoW is in.
`java.lang.Object`	`getTransaction()` INTERNAL: PERF: Return the associated external transaction.
`UnitOfWorkChangeSet`	`getUnitOfWorkChangeSet()` ADVANCED: Returns the currentChangeSet from the UnitOfWork.
`IdentityHashtable`	`getUnregisteredExistingObjects()` INTERNAL: Used to lazy Initialize the unregistered existing Objects collection.
`protected IdentityHashtable`	`getUnregisteredNewObjects()` INTERNAL: This is used to store unregistred objects discovered in the parent so that the child unit of work knows not to register them on commit.
`int`	`getValidationLevel()` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`java.lang.Object`	`getWorkingCopyFromUnitOfWorkIdentityMap(java.lang.Object object, java.util.Vector primaryKey)` INTERNAL: Return the registered working copy from the unit of work identity map.
`boolean`	`hasChanges()` ADVANCED: The Unit of work is capable of preprocessing to determine if any on the clone have been changed.
`protected boolean`	`hasCloneMapping()`
`protected boolean`	`hasCloneToOriginals()`
`protected boolean`	`hasDeferredModifyAllQueries()`
`protected boolean`	`hasDeletedObjects()`
`protected boolean`	`hasModifications()` INTERNAL: Does this unit of work have any changes or anything that requires a write to the database and a transaction to be started.
`protected boolean`	`hasModifyAllQueries()`
`boolean`	`hasNewObjects()` INTERNAL: Return if there are any registered new objects.
`protected boolean`	`hasObjectsDeletedDuringCommit()`
`protected boolean`	`hasRemovedObjects()`
`void`	`initializeIdentityMapAccessor()` INTERNAL: Set up the IdentityMapManager.
`java.lang.Object`	`internalExecuteQuery(DatabaseQuery query, AbstractRecord databaseRow)` INTERNAL: Return the results from exeucting the database query.
`java.lang.Object`	`internalRegisterObject(java.lang.Object object, ClassDescriptor descriptor)` INTERNAL: Register the object with the unit of work.
`boolean`	`isActive()` PUBLIC: Return if the unit of work is active.
`boolean`	`isAfterWriteChangesButBeforeCommit()` INTERNAL: Has writeChanges() been attempted on this UnitOfWork? It may have either suceeded or failed but either way the UnitOfWork is in a highly restricted state.
`protected boolean`	`isAfterWriteChangesFailed()` INTERNAL: Once writeChanges has failed all a user can do really is rollback.
`boolean`	`isClassReadOnly(java.lang.Class theClass, ClassDescriptor descriptor)` PUBLIC: Checks to see if the specified class or descriptor is read-only or not in this UnitOfWork.
`boolean`	`isCloneNewObject(java.lang.Object clone)` INTERNAL: Check if the object is already registered.
`boolean`	`isCommitPending()` INTERNAL: Return if the unit of work is waiting to be committed or in the process of being committed.
`boolean`	`isDead()` INTERNAL: Return if the unit of work is dead.
`boolean`	`isInTransaction()` PUBLIC: Return whether the session currently has a database transaction in progress.
`boolean`	`isMergePending()` INTERNAL: Return if the unit of work is waiting to be merged or in the process of being merged.
`boolean`	`isNestedUnitOfWork()` PUBLIC: Return whether this session is a nested unit of work or not.
`boolean`	`isObjectDeleted(java.lang.Object object)` INTERNAL: Return if the object has been deleted in this unit of work.
`boolean`	`isObjectNew(java.lang.Object clone)` INTERNAL: This method is used to determine if the clone is a new Object in the UnitOfWork
`boolean`	`isObjectRegistered(java.lang.Object clone)` INTERNAL: Return whether the clone object is already registered.
`boolean`	`isOriginalNewObject(java.lang.Object original)` INTERNAL: Return whether the original object is new.
`boolean`	`isPessimisticLocked(java.lang.Object clone)` INTERNAL:
`static boolean`	`isSmartMerge()` INTERNAL: Return the status of smart merge
`protected void`	`issueModifyAllQueryList()` INTERNAL: Will notify all the deferred ModifyAllQuery's (excluding UpdateAllQuery's) and deferred UpdateAllQuery's to execute.
`void`	`issueSQLbeforeCompletion()` INTERNAL: For synchronized units of work, dump SQL to database.
`void`	`issueSQLbeforeCompletion(boolean commitTransaction)` INTERNAL: For synchronized units of work, dump SQL to database.
`boolean`	`isSynchronized()` INTERNAL: Return if this session is a synchronized unit of work.
`boolean`	`isUnitOfWork()` PUBLIC: Return if this session is a unit of work.
`protected void`	`mergeChangesIntoParent()` INTERNAL: Merge the changes to all objects to the parent.
`java.lang.Object`	`mergeClone(java.lang.Object rmiClone)` PUBLIC: Merge the attributes of the clone into the unit of work copy.
`java.lang.Object`	`mergeClone(java.lang.Object rmiClone, int cascadeDepth)` INTERNAL: Merge the attributes of the clone into the unit of work copy.
`void`	`mergeClonesAfterCompletion()` INTERNAL: for synchronized units of work, merge changes into parent
`java.lang.Object`	`mergeCloneWithReferences(java.lang.Object rmiClone)` PUBLIC: Merge the attributes of the clone into the unit of work copy.
`java.lang.Object`	`mergeCloneWithReferences(java.lang.Object rmiClone, int cascadePolicy)` PUBLIC: Merge the attributes of the clone into the unit of work copy.
`java.lang.Object`	`mergeCloneWithReferences(java.lang.Object rmiClone, int cascadePolicy, boolean forceCascade)` INTERNAL: Merge the attributes of the clone into the unit of work copy.
`java.lang.Object`	`newInstance(java.lang.Class theClass)` PUBLIC: Return a new instance of the class registered in this unit of work.
`void`	`performFullValidation()` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`void`	`performPartialValidation()` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`void`	`performRemove(java.lang.Object toBeDeleted, IdentityHashtable visitedObjects)` INTERNAL: This method will perform a delete operation on the provided objects pre-determing the objects that will be deleted by a commit of the UnitOfWork including privately owned objects.
`protected void`	`populateAndRegisterObject(java.lang.Object original, java.lang.Object workingClone, java.util.Vector primaryKey, ClassDescriptor descriptor, java.lang.Object writeLockValue, long readTime, JoinedAttributeManager joinedAttributeManager)` INTERNAL: This method is called from clone and register.
`protected void`	`postMergeChanges()` INTERNAL: Remove objects from parent's identity map.
`protected void`	`preMergeChanges()` INTERNAL: Remove objects deleted during commit from clone and new object cache so that these are not merged
`void`	`printRegisteredObjects()` PUBLIC: Print the objects in the unit of work.
`java.lang.Object`	`processDeleteObjectQuery(DeleteObjectQuery deleteQuery)` INTERNAL: This method is used to process delete queries that pass through the unitOfWork It is extracted out of the internalExecuteQuery method to reduce duplication
`java.util.Vector`	`registerAllObjects(java.util.Collection domainObjects)` PUBLIC: Register the objects with the unit of work.
`java.util.Vector`	`registerAllObjects(java.util.Vector domainObjects)` PUBLIC: Register the objects with the unit of work.
`java.lang.Object`	`registerExistingObject(java.lang.Object existingObject)` ADVANCED: Register the existing object with the unit of work.
`protected java.lang.Object`	`registerExistingObject(java.lang.Object objectToRegister, ClassDescriptor descriptor, JoinedAttributeManager joinedAttributeManager)` INTERNAL: Register the existing object with the unit of work.
`java.lang.Object`	`registerExistingObject(java.lang.Object existingObject, JoinedAttributeManager joinedAttributeManager)` INTERNAL: Register the existing object with the unit of work.
`java.lang.Object`	`registerNewObject(java.lang.Object newObject)` ADVANCED: Register the new object with the unit of work.
`protected java.lang.Object`	`registerNewObject(java.lang.Object implementation, ClassDescriptor descriptor)` INTERNAL: Updated to allow passing in of the object's descriptor Register the new object with the unit of work.
`protected void`	`registerNewObjectClone(java.lang.Object clone, java.lang.Object original)` INTERNAL: Register the working copy of a new object and its original.
`void`	`registerNewObjectForPersist(java.lang.Object newObject, IdentityHashtable visitedObjects)` INTERNAL: Register the new object with the unit of work.
`protected void`	`registerNewObjectInIdentityMap(java.lang.Object clone, java.lang.Object original)` INTERNAL: Add the new object to the cache if set to.
`protected void`	`registerNotRegisteredNewObjectForPersist(java.lang.Object newObject, ClassDescriptor descriptor)` INTERNAL: Called only by registerNewObjectForPersist method, and only if newObject is not already registered.
`java.lang.Object`	`registerObject(java.lang.Object object)` PUBLIC: Register the object with the unit of work.
`protected java.lang.Object`	`registerObject(java.lang.Object object, ClassDescriptor descriptor)` INTERNAL: Allows for calling method to provide the descriptor information for this object.
`void`	`registerWithTransactionIfRequired()` INTERNAL: Register this UnitOfWork against an external transaction controller
`void`	`release()` PUBLIC: Release the unit of work.
`void`	`removeAllReadOnlyClasses()` PUBLIC: Empties the set of read-only classes.
`void`	`removeForceUpdateToVersionField(java.lang.Object lockObject)` ADVANCED: Remove optimistic read lock from the object See forceUpdateToVersionField(Object)
`void`	`removeReadOnlyClass(java.lang.Class theClass)` PUBLIC: Removes a Class from the receiver's set of read-only classes.
`protected void`	`resetAllCloneCollection()` INTERNAL: Used in the resume to reset the all clones collection
`void`	`revertAndResume()` PUBLIC: Revert all changes made to any registered object.
`java.lang.Object`	`revertObject(java.lang.Object clone)` PUBLIC: Revert the object's attributes from the parent.
`java.lang.Object`	`revertObject(java.lang.Object clone, int cascadeDepth)` INTERNAL: Revert the object's attributes from the parent.
`void`	`rollbackTransaction()` INTERNAL: This is internal to the uow, transactions should not be used explictly in a uow.
`protected void`	`rollbackTransaction(boolean intendedToCommitTransaction)` INTERNAL: rollbackTransaction() with a twist for external transactions.
`IdentityHashtable`	`scanForConformingInstances(Expression selectionCriteria, java.lang.Class referenceClass, AbstractRecord arguments, ObjectLevelReadQuery query)` INTERNAL: Scans the UnitOfWork identity map for conforming instances.
`protected void`	`setAllClonesCollection(IdentityHashtable objects)` INTERNAL: Used to set the collections of all objects in the UnitOfWork.
`protected void`	`setCloneMapping(IdentityHashtable cloneMapping)` INTERNAL: Set the clone mapping.
`void`	`setDead()` INTERNAL: set UoW lifecycle state variable to DEATH
`protected void`	`setDeletedObjects(IdentityHashtable deletedObjects)` INTERNAL: The deleted objects stores any objects removed during the unit of work.
`protected void`	`setLifecycle(int lifecycle)` INTERNAL: The life cycle tracks if the unit of work is active and is used for JTS.
`void`	`setMergeManager(MergeManager mergeManager)` INTERNAL: A reference to the last used merge manager.
`protected void`	`setNewObjectsCloneToOriginal(IdentityHashtable newObjects)` INTERNAL: The new objects stores any objects newly created during the unit of work.
`protected void`	`setNewObjectsOriginalToClone(IdentityHashtable newObjects)` INTERNAL: The new objects stores any objects newly created during the unit of work.
`void`	`setObjectsDeletedDuringCommit(IdentityHashtable deletedObjects)` INTERNAL: Set the objects that have been deleted.
`void`	`setParent(AbstractSession parent)` INTERNAL: Set the parent.
`void`	`setPendingMerge()` INTERNAL: set UoW lifecycle state variable to PENDING_MERGE
`void`	`setReadOnlyClasses(java.util.Vector classes)` INTERNAL: Gives a new set of read-only classes to the receiver.
`protected void`	`setRemovedObjects(IdentityHashtable removedObjects)` INTERNAL: The removed objects stores any newly registered objects removed during the nested unit of work.
`void`	`setResumeUnitOfWorkOnTransactionCompletion(boolean resumeUnitOfWork)` INTERNAL: Set if this UnitofWork should be resumed after the end of the transaction Used when UnitOfWork is synchronized with external transaction control
`void`	`setShouldCascadeCloneToJoinedRelationship(boolean shouldCascadeCloneToJoinedRelationship)` INTERNAL: True if the value holder for the joined attribute should be triggered.
`void`	`setShouldNewObjectsBeCached(boolean shouldNewObjectsBeCached)` ADVANCED: By default new objects are not cached until the exist on the database.
`void`	`setShouldPerformDeletesFirst(boolean shouldPerformDeletesFirst)` ADVANCED: By default deletes are performed last in a unit of work.
`void`	`setShouldThrowConformExceptions(int shouldThrowExceptions)` ADVANCED: Conforming queries can be set to provide different levels of detail about the exceptions they encounter There are three levels: DO_NOT_THROW_CONFORM_EXCEPTIONS = 0; THROW_ALL_CONFORM_EXCEPTIONS = 1;
`static void`	`setSmartMerge(boolean option)` INTERNAL: Set smart merge flag.
`void`	`setSynchronized(boolean synched)` INTERNAL: Set isSynchronized flag to indicate that this session is a synchronized unit of work.
`void`	`setTransaction(java.lang.Object transaction)` INTERNAL: PERF: Set the associated external transaction.
`void`	`setUnitOfWorkChangeSet(UnitOfWorkChangeSet unitOfWorkChangeSet)` INTERNAL: Sets the current UnitOfWork change set to be the one passed in.
`protected void`	`setUnregisteredExistingObjects(IdentityHashtable newUnregisteredExistingObjects)` INTERNAL: Used to set the unregistered existing objects vector used when validation has been turned off.
`protected void`	`setUnregisteredNewObjects(IdentityHashtable newObjects)` INTERNAL:
`void`	`setValidationLevel(int validationLevel)` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`void`	`setWasNonObjectLevelModifyQueryExecuted(boolean wasNonObjectLevelModifyQueryExecuted)` INTERNAL: True if either DataModifyQuery or ModifyAllQuery was executed.
`void`	`setWasTransactionBegunPrematurely(boolean wasTransactionBegunPrematurely)` INTERNAL: Set a flag in the root UOW to indicate that a pess.
`java.lang.Object`	`shallowMergeClone(java.lang.Object rmiClone)` PUBLIC: Merge the attributes of the clone into the unit of work copy.
`java.lang.Object`	`shallowRevertObject(java.lang.Object clone)` PUBLIC: Revert the object's attributes from the parent.
`void`	`shallowUnregisterObject(java.lang.Object clone)` ADVANCED: Unregister the object with the unit of work.
`boolean`	`shouldCascadeCloneToJoinedRelationship()` INTERNAL: True if the value holder for the joined attribute should be triggered.
`boolean`	`shouldClearForCloseOnRelease()` INTERNAL: Indicates whether clearForClose methor should be called by release method.
`boolean`	`shouldNewObjectsBeCached()` ADVANCED: By default new objects are not cached until the exist on the database.
`boolean`	`shouldPerformDeletesFirst()` ADVANCED: By default all objects are inserted and updated in the database before any object is deleted.
`boolean`	`shouldPerformFullValidation()` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`boolean`	`shouldPerformNoValidation()` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`boolean`	`shouldPerformPartialValidation()` ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache.
`boolean`	`shouldReadFromDB()` INTERNAL: Indicates whether readObject should return the object read from the db in case there is no object in uow cache (as opposed to fetching the object from parent's cache).
`boolean`	`shouldResumeUnitOfWorkOnTransactionCompletion()` INTERNAL: Returns true if this UnitofWork should be resumed after the end of the transaction Used when UnitOfWork is synchronized with external transaction control
`void`	`storeDeferredModifyAllQuery(DatabaseQuery query, AbstractRecord translationRow)` INTERNAL: Store the deferred UpdateAllQuery's from the UoW in the list.
`void`	`storeModifyAllQuery(DatabaseQuery query)` INTERNAL: Store the ModifyAllQuery's from the UoW in the list.
`void`	`synchronizeAndResume()` INTERNAL Synchronize the clones and update their backup copies.
`protected void`	`undeleteObject(java.lang.Object object)` INTERNAL: THis method is used to transition an object from the deleted objects list to be simply be register.
`void`	`unregisterObject(java.lang.Object clone)` PUBLIC: Unregister the object with the unit of work.
`void`	`unregisterObject(java.lang.Object clone, int cascadeDepth)` INTERNAL: Unregister the object with the unit of work.
`void`	`updateChangeTrackersIfRequired(java.lang.Object objectToWrite, ObjectChangeSet changeSetToWrite, UnitOfWorkImpl uow, ClassDescriptor descriptor)` INTERNAL: This method is used internally to update the tracked objects if required
`void`	`validateObjectSpace()` ADVANCED: This can be used to help debugging an object-space corruption.
`boolean`	`wasNonObjectLevelModifyQueryExecuted()` INTERNAL: True if either DataModifyQuery or ModifyAllQuery was executed.
`boolean`	`wasTransactionBegunPrematurely()` INTERNAL: Indicates if a transaction was begun by a pessimistic locking or non-selecting query.
`void`	`writeChanges()` ADVANCED: Writes all changes now before commit().
`void`	`writesCompleted()` INTERNAL: This method notifies the accessor that a particular sets of writes has completed.

Methods inherited from class oracle.toplink.essentials.internal.sessions.AbstractSession
acquireNonSynchronizedUnitOfWork, addAlias, addEjbqlPlaceHolderQuery, addQuery, addQuery, basicBeginTransaction, basicCommitTransaction, basicRollbackTransaction, beginExternalTransaction, clearIntegrityChecker, clearLastDescriptorAccessed, clearProfile, clone, commitExternalTransaction, compareObjects, compareObjectsDontMatch, config, containsQuery, copyObject, copyObject, deleteAllObjects, deleteObject, doesObjectExist, dontLogMessages, endOperationProfile, executeNonSelectingCall, executeNonSelectingSQL, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeSelectingCall, executeSQL, fine, finer, finest, getActiveSession, getAliasDescriptors, getAllQueries, getBroker, getClassDescriptor, getClassDescriptor, getClassDescriptorForAlias, getDatasourceLogin, getDatasourcePlatform, getDescriptor, getDescriptor, getEjbqlPlaceHolderQueries, getEventManager, getExceptionHandler, getExceptionHandlerClass, getExternalTransactionController, getIdentityMapAccessor, getIdentityMapAccessorInstance, getIntegrityChecker, getLog, getLogin, getLogLevel, getLogLevel, getLogSessionString, getName, getNextQueryId, getNextSequenceNumberValue, getNumberOfActiveUnitsOfWork, getParentIdentityMapSession, getPlatform, getProfiler, getProject, getProperties, getProperty, getQueries, getRootSession, getSessionForClass, getSessionLog, getTransactionMutex, handleException, handleSevere, hasBroker, hasDescriptor, hasExceptionHandler, hasExternalTransactionController, hasProperties, incrementProfile, info, insertObject, isBroker, isClassReadOnly, isClientSession, isConnected, isDatabaseSession, isDistributedSession, isInBroker, isInProfile, isRemoteSession, isRemoteUnitOfWork, isServerSession, isSessionBroker, keyFromObject, keyFromObject, log, log, log, log, log, log, log, log, log, log, logMessage, logThrowable, prepareDatabaseQuery, processEJBQLQueries, processEJBQLQueries, readAllObjects, readAllObjects, readAllObjects, readAllObjects, readObject, readObject, readObject, readObject, readObject, refreshAndLockObject, refreshAndLockObject, refreshObject, releaseUnitOfWork, removeProperty, removeQuery, removeQuery, rollbackExternalTransaction, setAccessor, setBroker, setCommitManager, setDatasourceLogin, setEventManager, setExceptionHandler, setExternalTransactionController, setIntegrityChecker, setIsInProfile, setLog, setLogin, setLogin, setLogLevel, setName, setNumberOfActiveUnitsOfWork, setProfiler, setProject, setProperties, setProperty, setQueries, setSessionLog, setTransactionMutex, setWasJTSTransactionInternallyStarted, severe, shouldLog, shouldLogMessages, startOperationProfile, toString, unwrapObject, updateObject, updateProfile, validateQuery, verifyDelete, warning, wasJTSTransactionInternallyStarted, wrapObject, writeAllObjects, writeAllObjectsWithChangeSet, writeObject

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface oracle.toplink.essentials.sessions.UnitOfWork
deleteAllObjects, deleteObject, isClassReadOnly, refreshAndLockObject, refreshAndLockObject

Methods inherited from interface oracle.toplink.essentials.sessions.Session
addEjbqlPlaceHolderQuery, addQuery, clearIntegrityChecker, clearProfile, containsQuery, copyObject, copyObject, doesObjectExist, dontLogMessages, executeNonSelectingCall, executeNonSelectingSQL, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeQuery, executeSelectingCall, executeSQL, getActiveSession, getClassDescriptor, getClassDescriptor, getClassDescriptorForAlias, getDatasourceLogin, getDatasourcePlatform, getDescriptor, getDescriptor, getEjbqlPlaceHolderQueries, getEventManager, getExceptionHandler, getExternalTransactionController, getIdentityMapAccessor, getIntegrityChecker, getLog, getLogin, getLogLevel, getLogLevel, getName, getNextSequenceNumberValue, getPlatform, getProfiler, getProject, getProperties, getProperty, getQueries, getSessionLog, handleException, handleSevere, hasDescriptor, hasExceptionHandler, hasExternalTransactionController, isClientSession, isConnected, isDatabaseSession, isDistributedSession, isInProfile, isRemoteSession, isRemoteUnitOfWork, isServerSession, isSessionBroker, keyFromObject, log, log, logMessage, logThrowable, readAllObjects, readAllObjects, readAllObjects, readObject, readObject, readObject, readObject, refreshObject, removeProperty, removeQuery, setExceptionHandler, setExternalTransactionController, setIntegrityChecker, setLog, setLogLevel, setName, setProfiler, setProperty, setSessionLog, shouldLog, shouldLogMessages

- Field Detail
  - cloneToOriginals
```
protected transient IdentityHashtable cloneToOriginals
```
    As well as used as lookup in merge algorithm for aggregates and others
  - parent
```
protected transient AbstractSession parent
```
  - cloneMapping
```
protected IdentityHashtable cloneMapping
```
    Hashtable of all the clones. The key contains the clone of the object.
  - newObjectsCloneToOriginal
```
protected IdentityHashtable newObjectsCloneToOriginal
```
  - newObjectsOriginalToClone
```
protected IdentityHashtable newObjectsOriginalToClone
```
  - deletedObjects
```
protected IdentityHashtable deletedObjects
```
  - allClones
```
protected IdentityHashtable allClones
```
    This member variable contains a copy of all of the clones for this particular UOW
  - objectsDeletedDuringCommit
```
protected IdentityHashtable objectsDeletedDuringCommit
```
  - removedObjects
```
protected IdentityHashtable removedObjects
```
  - unregisteredNewObjects
```
protected IdentityHashtable unregisteredNewObjects
```
  - unregisteredExistingObjects
```
protected IdentityHashtable unregisteredExistingObjects
```
  - newAggregates
```
protected IdentityHashtable newAggregates
```
  - unitOfWorkChangeSet
```
protected UnitOfWorkChangeSet unitOfWorkChangeSet
```
    This method is used to store the current changeSet for this UnitOfWork.
  - pessimisticLockedObjects
```
protected IdentityHashtable pessimisticLockedObjects
```
    use to track pessimistic locked objects
  - lastUsedMergeManager
```
protected MergeManager lastUsedMergeManager
```
    Used to store the list of locks that this UnitOfWork has acquired for this merge
  - readOnlyClasses
```
protected java.util.Hashtable readOnlyClasses
```
    Read-only class can be used for reference data to avoid cloning when not required.
  - wasTransactionBegunPrematurely
```
protected boolean wasTransactionBegunPrematurely
```
    Flag indicating that the transaction for this UOW was already begun.
  - shouldNewObjectsBeCached
```
protected boolean shouldNewObjectsBeCached
```
    Allow for double merges of new objects by putting them into the cache.
  - shouldPerformDeletesFirst
```
protected boolean shouldPerformDeletesFirst
```
    Flag indicating that deletes should be performed before other updates.
  - shouldThrowConformExceptions
```
protected int shouldThrowConformExceptions
```
    Flag indicating how to deal with exceptions on conforming queries.
  - validationLevel
```
protected int validationLevel
```
    The amount of validation can be configured.
  - None
```
public static final int None
```
    See Also:
    
    Constant Field Values
  - Partial
```
public static final int Partial
```
    See Also:
    
    Constant Field Values
  - Full
```
public static final int Full
```
    See Also:
    
    Constant Field Values
  - isSynchronized
```
protected boolean isSynchronized
```
    With the new synchronized unit of work, need a lifecycle state variable to track birth, commited, pending_merge and death.
  - lifecycle
```
protected int lifecycle
```
  - Birth
```
public static final int Birth
```
    See Also:
    
    Constant Field Values
  - CommitPending
```
public static final int CommitPending
```
    See Also:
    
    Constant Field Values
  - CommitTransactionPending
```
public static final int CommitTransactionPending
```
    See Also:
    
    Constant Field Values
  - WriteChangesFailed
```
public static final int WriteChangesFailed
```
    See Also:
    
    Constant Field Values
  - MergePending
```
public static final int MergePending
```
    See Also:
    
    Constant Field Values
  - Death
```
public static final int Death
```
    See Also:
    
    Constant Field Values
  - AfterExternalTransactionRolledBack
```
public static final int AfterExternalTransactionRolledBack
```
    See Also:
    
    Constant Field Values
  - DO_NOT_THROW_CONFORM_EXCEPTIONS
```
public static final int DO_NOT_THROW_CONFORM_EXCEPTIONS
```
    Used for Conforming Queries
    
    See Also:
    
    Constant Field Values
  - THROW_ALL_CONFORM_EXCEPTIONS
```
public static final int THROW_ALL_CONFORM_EXCEPTIONS
```
    See Also:
    
    Constant Field Values
  - LOCK_QUERIES_PROPERTY
```
public static final java.lang.String LOCK_QUERIES_PROPERTY
```
    See Also:
    
    Constant Field Values
  - SmartMerge
```
protected static boolean SmartMerge
```
    Used for merging dependent values without use of WL SessionAccessor
  - optimisticReadLockObjects
```
protected java.util.Hashtable optimisticReadLockObjects
```
    Kept reference of read lock objects
  - modifyAllQueries
```
protected java.util.List modifyAllQueries
```
    lazy initialization done in storeModifyAllQuery. For UpdateAllQuery, only clones of all UpdateAllQuery's (deferred and non-deferred) are stored here for validation only.
  - deferredModifyAllQueries
```
protected java.util.List deferredModifyAllQueries
```
    Contains deferred ModifyAllQuery's that have translation row for execution only. At commit their clones will be added to modifyAllQueries for validation afterwards
  - cloneDepth
```
protected int cloneDepth
```
    Used during the cloning process to track the recursive depth in. This will be used to determine at which point the process can begin to wait on locks without being concerned about creating deadlock situations.
  - objectsLockedForClone
```
protected java.util.Map objectsLockedForClone
```
    This collection will be used to store those objects that are currently locked for the clone process. It should be populated with an TopLinkIdentityHashMap
  - transaction
```
protected java.lang.Object transaction
```
    PERF: Stores the JTA transaction to optimize activeUnitOfWork lookup.
  - shouldCheckWriteLock
```
protected boolean shouldCheckWriteLock
```
    PERF: Cache the write-lock check to avoid cost of checking in every register/clone.
  - resumeOnTransactionCompletion
```
protected boolean resumeOnTransactionCompletion
```
    True if UnitOfWork should be resumed on completion of transaction. Used when UnitOfWork is Synchronized with external transaction control
  - wasNonObjectLevelModifyQueryExecuted
```
protected boolean wasNonObjectLevelModifyQueryExecuted
```
    True if either DataModifyQuery or ModifyAllQuery was executed. Gets reset on commit, effects DoesExistQuery behaviour and reading.
  - shouldCascadeCloneToJoinedRelationship
```
protected boolean shouldCascadeCloneToJoinedRelationship
```
    True if the value holder for the joined attribute should be triggered. Required by ejb30 fetch join.
- Constructor Detail
  - UnitOfWorkImpl
```
public UnitOfWorkImpl(AbstractSession parent)
```
    INTERNAL: Create and return a new unit of work with the sesson as its parent.
- Method Detail
  - acquireUnitOfWork
```
public UnitOfWork acquireUnitOfWork()
```
    PUBLIC: Nested units of work are not supported in TopLink Essentials.
    
    Specified by:
    
    acquireUnitOfWork in interface Session
    
    Overrides:
    
    acquireUnitOfWork in class AbstractSession
    
    See Also:
    
    UnitOfWork
  - addNewAggregate
```
public void addNewAggregate(java.lang.Object originalObject)
```
    INTERNAL: Register a new aggregate object with the unit of work.
  - addObjectDeletedDuringCommit
```
public void addObjectDeletedDuringCommit(java.lang.Object object,
                                         ClassDescriptor descriptor)
```
    INTERNAL: Add object deleted during root commit of unit of work.
  - addReadOnlyClass
```
public void addReadOnlyClass(java.lang.Class theClass)
                      throws ValidationException
```
    PUBLIC: Adds the given Java class to the receiver's set of read-only classes. Cannot be called after objects have been registered in the unit of work.
    
    Specified by:
    
    addReadOnlyClass in interface UnitOfWork
    
    Throws:
    
    ValidationException
  - addReadOnlyClasses
```
public void addReadOnlyClasses(java.util.Vector classes)
```
    PUBLIC: Adds the classes in the given Vector to the existing set of read-only classes. Cannot be called after objects have been registered in the unit of work.
    
    Specified by:
    
    addReadOnlyClasses in interface UnitOfWork
  - addRemovedObject
```
public void addRemovedObject(java.lang.Object orignal)
```
    INTERNAL: Register that an object was removed in a nested unit of work.
  - assignSequenceNumber
```
public void assignSequenceNumber(java.lang.Object object)
                          throws DatabaseException
```
    ADVANCED: Assign sequence number to the object. This allows for an object's id to be assigned before commit. It can be used if the application requires to use the object id before the object exists on the database. Normally all ids are assigned during the commit automatically.
    
    Specified by:
    
    assignSequenceNumber in interface UnitOfWork
    
    Throws:
    
    DatabaseException
  - assignSequenceNumbers
```
public void assignSequenceNumbers()
                           throws DatabaseException
```
    ADVANCED: Assign sequence numbers to all new objects registered in this unit of work, or any new objects reference by any objects registered. This allows for an object's id to be assigned before commit. It can be used if the application requires to use the object id before the object exists on the database. Normally all ids are assigned during the commit automatically.
    
    Specified by:
    
    assignSequenceNumbers in interface UnitOfWork
    
    Throws:
    
    DatabaseException
  - beginEarlyTransaction
```
public void beginEarlyTransaction()
                           throws DatabaseException
```
    PUBLIC: Tell the unit of work to begin a transaction now. By default the unit of work will begin a transaction at commit time. The default is the recommended approach, however sometimes it is neccessary to start the transaction before commit time. When the unit of work commits, this transcation will be commited.
    
    Specified by:
    
    beginEarlyTransaction in interface UnitOfWork
    
    Throws:
    
    DatabaseException
    
    See Also:
    
    commit(), release()
  - beginTransaction
```
public void beginTransaction()
                      throws DatabaseException
```
    INTERNAL: This is internal to the uow, transactions should not be used explictly in a uow. The uow shares its parents transactions.
    
    Overrides:
    
    beginTransaction in class AbstractSession
    
    Throws:
    
    DatabaseException - if the database connection is lost or the begin is rejected.
    
    See Also:
    
    AbstractSession.isInTransaction()
  - buildOriginal
```
public java.lang.Object buildOriginal(java.lang.Object workingClone)
```
    INTERNAL: Unregistered new objects have no original so we must create one for commit and resume and to put into the parent. We can NEVER let the same copy of an object exist in multiple units of work.
  - calculateChanges
```
public UnitOfWorkChangeSet calculateChanges(IdentityHashtable allObjects,
                                            UnitOfWorkChangeSet changeSet)
```
    INTERNAL:
    This Method is designed to calculate the changes for all objects within the PendingObjects.
  - canChangeReadOnlySet
```
protected boolean canChangeReadOnlySet()
```
    INTERNAL: Checks whether the receiver has been used. i.e. objects have been registered.
    
    Returns:
    
    true or false depending on whether the read-only set can be changed or not.
  - checkForUnregisteredExistingObject
```
public boolean checkForUnregisteredExistingObject(java.lang.Object object)
```
    INTERNAL:
  - checkExistence
```
public java.lang.Object checkExistence(java.lang.Object object)
```
    INTERNAL: Register the object and return the clone if it is existing otherwise return null if it is new. The unit of work determines existence during registration, not during the commit.
  - checkIfAlreadyRegistered
```
protected java.lang.Object checkIfAlreadyRegistered(java.lang.Object object,
                                                    ClassDescriptor descriptor)
```
    INTERNAL: Return the value of the object if it already is registered, otherwise null.
  - cloneAndRegisterNewObject
```
protected java.lang.Object cloneAndRegisterNewObject(java.lang.Object original)
```
    ADVANCED: Register the new object with the unit of work. This will register the new object with cloning. Normally the registerObject method should be used for all registration of new and existing objects. This version of the register method can only be used for new objects. This method should only be used if a new object is desired to be registered without an existence Check.
    
    See Also:
    
    registerObject(Object)
  - cloneAndRegisterObject
```
public java.lang.Object cloneAndRegisterObject(java.lang.Object original,
                                               CacheKey cacheKey,
                                               JoinedAttributeManager joinedAttributeManager)
```
    INTERNAL: Clone and register the object. The cache key must the cache key from the session cache, as it will be used for locking.
  - collectAndPrepareObjectsForCommit
```
public IdentityHashtable collectAndPrepareObjectsForCommit()
```
    INTERNAL: Prepare for commit.
  - collectAndPrepareObjectsForNestedMerge
```
public IdentityHashtable collectAndPrepareObjectsForNestedMerge()
```
    INTERNAL: Prepare for merge in nested uow.
  - commit
```
public void commit()
            throws DatabaseException,
                   OptimisticLockException
```
    PUBLIC: Commit the unit of work to its parent. For a nested unit of work this will merge any changes to its objects with its parents. For a first level unit of work it will commit all changes to its objects to the database as a single transaction. If successful the changes to its objects will be merged to its parent's objects. If the commit fails the database transaction will be rolledback, and the unit of work will be released. If the commit is successful the unit of work is released, and a new unit of work must be acquired if further changes are desired.
    
    Specified by:
    
    commit in interface UnitOfWork
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
    
    See Also:
    
    commitAndResumeOnFailure(), commitAndResume(), release()
  - commitAndResume
```
public void commitAndResume()
                     throws DatabaseException,
                            OptimisticLockException
```
    PUBLIC: Commit the unit of work to its parent. For a nested unit of work this will merge any changes to its objects with its parents. For a first level unit of work it will commit all changes to its objects to the database as a single transaction. If successful the changes to its objects will be merged to its parent's objects. If the commit fails the database transaction will be rolledback, and the unit of work will be released. The normal commit releases the unit of work, forcing a new one to be acquired if further changes are desired. The resuming feature allows for the same unit of work (and working copies) to be continued to be used.
    
    Specified by:
    
    commitAndResume in interface UnitOfWork
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
    
    See Also:
    
    commitAndResumeOnFailure(), commit(), release()
  - commitAndResumeWithPreBuiltChangeSet
```
public void commitAndResumeWithPreBuiltChangeSet(UnitOfWorkChangeSet uowChangeSet)
                                          throws DatabaseException,
                                                 OptimisticLockException
```
    INTERNAL: This method is used by the MappingWorkbench for their read-only file feature this method must not be exposed to or used by customers until it has been revised and the feature revisited to support OptimisticLocking and Serialization
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - commitAndResumeOnFailure
```
public void commitAndResumeOnFailure()
                              throws DatabaseException,
                                     OptimisticLockException
```
    PUBLIC: Commit the unit of work to its parent. For a nested unit of work this will merge any changes to its objects with its parents. For a first level unit of work it will commit all changes to its objects to the database as a single transaction. If successful the changes to its objects will be merged to its parent's objects. If the commit fails the database transaction will be rolledback, but the unit of work will remain active. It can then be retried or released. The normal commit failure releases the unit of work, forcing a new one to be acquired if further changes are desired. The resuming feature allows for the same unit of work (and working copies) to be continued to be used if an error occurs.
    
    Specified by:
    
    commitAndResumeOnFailure in interface UnitOfWork
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
    
    See Also:
    
    commit(), release()
  - commitAfterWriteChanges
```
protected void commitAfterWriteChanges()
```
    INTERNAL: Commits a UnitOfWork where the commit process has already been initiated by all call to writeChanges().
    a.k.a finalizeCommit()
  - commitAndResumeAfterWriteChanges
```
protected void commitAndResumeAfterWriteChanges()
```
    INTERNAL: Commits and resumes a UnitOfWork where the commit process has already been initiated by all call to writeChanges().
    a.k.a finalizeCommit()
  - commitInternallyStartedExternalTransaction
```
protected boolean commitInternallyStartedExternalTransaction()
```
    PROTECTED: Used in commit and commit-like methods to commit internally started external transaction
  - commitRootUnitOfWork
```
public void commitRootUnitOfWork()
                          throws DatabaseException,
                                 OptimisticLockException
```
    INTERNAL: Commit the changes to any objects to the parent.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - commitRootUnitOfWorkWithPreBuiltChangeSet
```
public void commitRootUnitOfWorkWithPreBuiltChangeSet(UnitOfWorkChangeSet uowChangeSet)
                                               throws DatabaseException,
                                                      OptimisticLockException
```
    INTERNAL: This method is used by the MappingWorkbench read-only files feature It will commit a pre-built unitofwork change set to the database
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - commitToDatabase
```
protected void commitToDatabase(boolean commitTransaction)
```
    INTERNAL: CommitChanges To The Database from a calculated changeSet
    
    Parameters:
    
    commitTransaction - false if called by writeChanges as intent is not to finalize the transaction.
  - commitToDatabaseWithChangeSet
```
protected void commitToDatabaseWithChangeSet(boolean commitTransaction)
                                      throws DatabaseException,
                                             OptimisticLockException
```
    INTERNAL: Commit the changes to any objects to the parent.
    
    Parameters:
    
    commitTransaction - false if called by writeChanges as intent is not to finalize the transaction.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - commitToDatabaseWithPreBuiltChangeSet
```
protected void commitToDatabaseWithPreBuiltChangeSet(UnitOfWorkChangeSet uowChangeSet,
                                                     boolean commitTransaction)
                                              throws DatabaseException,
                                                     OptimisticLockException
```
    INTERNAL: Commit pre-built changeSet to the database changest to the database.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - commitTransaction
```
public void commitTransaction()
                       throws DatabaseException
```
    INTERNAL: This is internal to the uow, transactions should not be used explictly in a uow. The uow shares its parents transactions.
    
    Overrides:
    
    commitTransaction in class AbstractSession
    
    Throws:
    
    DatabaseException - most databases validate changes as they are done, normally errors do not occur on commit unless the disk fails or the connection is lost.
  - commitTransactionAfterWriteChanges
```
protected void commitTransactionAfterWriteChanges()
```
    INTERNAL: After writeChanges() everything has been done except for committing the transaction. This allows that execution path to 'catch up'.
  - copyReadOnlyClasses
```
public java.util.Vector copyReadOnlyClasses()
```
    INTERNAL: Copy the read only classes from the unit of work.
    
    Overrides:
    
    copyReadOnlyClasses in class AbstractSession
  - deepMergeClone
```
public java.lang.Object deepMergeClone(java.lang.Object rmiClone)
```
    PUBLIC: Merge the attributes of the clone into the unit of work copy. This can be used for objects that are returned from the client through RMI serialization or other serialization mechanisms, because the RMI object will be a clone this will merge its attributes correctly to preserve object identity within the unit of work and record its changes. Everything connected to this object (i.e. the entire object tree where rmiClone is the root) is also merged.
    
    Specified by:
    
    deepMergeClone in interface UnitOfWork
    
    Returns:
    
    the registered version for the clone being merged.
    
    See Also:
    
    mergeClone(Object), shallowMergeClone(Object)
  - deepRevertObject
```
public java.lang.Object deepRevertObject(java.lang.Object clone)
```
    PUBLIC: Revert the object's attributes from the parent. This reverts everything the object references.
    
    Specified by:
    
    deepRevertObject in interface UnitOfWork
    
    Returns:
    
    the object reverted.
    
    See Also:
    
    revertObject(Object), shallowRevertObject(Object)
  - deepUnregisterObject
```
public void deepUnregisterObject(java.lang.Object clone)
```
    ADVANCED: Unregister the object with the unit of work. This can be used to delete an object that was just created and is not yet persistent. Delete object can also be used, but will result in inserting the object and then deleting it. The method should be used carefully because it will delete all the reachable parts.
    
    Specified by:
    
    deepUnregisterObject in interface UnitOfWork
  - deleteAllObjects
```
public void deleteAllObjects(java.util.Vector domainObjects)
```
    PUBLIC: Delete all of the objects and all of their privately owned parts in the database. Delete operations are delayed in a unit of work until commit.
    
    Specified by:
    
    deleteAllObjects in interface UnitOfWork
    
    Overrides:
    
    deleteAllObjects in class AbstractSession
  - discoverAllUnregisteredNewObjects
```
protected void discoverAllUnregisteredNewObjects()
```
    INTERNAL: Search for any objects in the parent that have not been registered. These are required so that the nested unit of work does not add them to the parent clone mapping on commit, causing possible incorrect insertions if they are dereferenced.
  - discoverUnregisteredNewObjects
```
public void discoverUnregisteredNewObjects(java.lang.Object clone,
                                           IdentityHashtable knownNewObjects,
                                           IdentityHashtable unregisteredExistingObjects,
                                           IdentityHashtable visitedObjects)
```
    INTERNAL: Traverse the object to find references to objects not registered in this unit of work.
  - dontPerformValidation
```
public void dontPerformValidation()
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    dontPerformValidation in interface UnitOfWork
  - executeCall
```
public java.lang.Object executeCall(Call call,
                                    AbstractRecord translationRow,
                                    DatabaseQuery query)
                             throws DatabaseException
```
    INTERNAL: Override From session. Get the accessor based on the query, and execute call, this is here for session broker.
    
    Overrides:
    
    executeCall in class AbstractSession
    
    Throws:
    
    DatabaseException
  - forceUpdateToVersionField
```
public void forceUpdateToVersionField(java.lang.Object lockObject,
                                      boolean shouldModifyVersionField)
```
    ADVANCED: Set optmistic read lock on the object. This feature is overide by normal optimistic lock. when the object is changed in UnitOfWork. The cloneFromUOW must be the clone of from this UnitOfWork and it must implements version locking or timestamp locking. The SQL would look like the followings. If shouldModifyVersionField is true, "UPDATE EMPLOYEE SET VERSION = 2 WHERE EMP_ID = 9 AND VERSION = 1" If shouldModifyVersionField is false, "UPDATE EMPLOYEE SET VERSION = 1 WHERE EMP_ID = 9 AND VERSION = 1"
    
    Specified by:
    
    forceUpdateToVersionField in interface UnitOfWork
  - getAccessor
```
public Accessor getAccessor()
```
    INTERNAL: The uow does not store a local accessor but shares its parents.
    
    Overrides:
    
    getAccessor in class AbstractSession
  - getCommitManager
```
public CommitManager getCommitManager()
```
    INTERNAL: The commit manager is used to resolve referncial integrity on commits of multiple objects. The commit manage is lazy init from parent.
    
    Overrides:
    
    getCommitManager in class AbstractSession
  - getAccessor
```
public Accessor getAccessor(java.lang.Class domainClass)
```
    INTERNAL: The uow does not store a local accessor but shares its parents.
    
    Overrides:
    
    getAccessor in class AbstractSession
  - getAccessor
```
public Accessor getAccessor(java.lang.String sessionName)
```
    INTERNAL: The uow does not store a local accessor but shares its parents.
    
    Overrides:
    
    getAccessor in class AbstractSession
  - getActiveUnitOfWork
```
public UnitOfWork getActiveUnitOfWork()
```
    PUBLIC: Return the active unit of work for the current active external (JTS) transaction. This should only be used with JTS and will return null if no external transaction exists.
    
    Specified by:
    
    getActiveUnitOfWork in interface Session
    
    Overrides:
    
    getActiveUnitOfWork in class AbstractSession
  - getAllClones
```
protected IdentityHashtable getAllClones()
```
    INTERNAL: This method is used to get a copy of the collection of all clones in the UnitOfWork
    
    Returns:
    
    oracle.toplink.essentials.internal.helper.IdentityHashtable
  - getAllFromNewObjects
```
public java.util.Vector getAllFromNewObjects(Expression selectionCriteria,
                                             java.lang.Class theClass,
                                             AbstractRecord translationRow,
                                             InMemoryQueryIndirectionPolicy valueHolderPolicy)
```
    INTERNAL: Return any new objects matching the expression. Used for in-memory querying.
  - getBackupClone
```
public java.lang.Object getBackupClone(java.lang.Object clone)
                                throws QueryException
```
    INTERNAL: Return the backup clone for the working clone.
    
    Throws:
    
    QueryException
  - getBackupCloneForCommit
```
public java.lang.Object getBackupCloneForCommit(java.lang.Object clone)
```
    INTERNAL: Return the backup clone for the working clone.
  - getCurrentChanges
```
public UnitOfWorkChangeSet getCurrentChanges()
```
    ADVANCED: This method Will Calculate the chages for the UnitOfWork. Without assigning sequence numbers This is a Computationaly intensive operation and should be avoided unless necessary. A valid changeSet, with sequencenumbers can be collected from the UnitOfWork After the commit is complete by calling unitOfWork.getUnitOfWorkChangeSet()
    
    Specified by:
    
    getCurrentChanges in interface UnitOfWork
  - getParentIdentityMapSession
```
public AbstractSession getParentIdentityMapSession(DatabaseQuery query,
                                                   boolean canReturnSelf,
                                                   boolean terminalOnly)
```
    INTERNAL: Gets the next link in the chain of sessions followed by a query's check early return, the chain of sessions with identity maps all the way up to the root session.
    Used for session broker which delegates to registered sessions, or UnitOfWork which checks parent identity map also.
    
    Overrides:
    
    getParentIdentityMapSession in class AbstractSession
    
    Parameters:
    
    canReturnSelf - true when method calls itself. If the path starting at this is acceptable. Sometimes true if want to move to the first valid session, i.e. executing on ClientSession when really should be on ServerSession.
    
    terminalOnly - return the session we will execute the call on, not the next step towards it.
    
    Returns:
    
    this if there is no next link in the chain
  - getExecutionSession
```
public AbstractSession getExecutionSession(DatabaseQuery query)
```
    INTERNAL: Gets the session which this query will be executed on. Generally will be called immediately before the call is translated, which is immediately before session.executeCall.
    Since the execution session also knows the correct datasource platform to execute on, it is often used in the mappings where the platform is needed for type conversion, or where calls are translated.
    Is also the session with the accessor. Will return a ClientSession if it is in transaction and has a write connection.
    
    Overrides:
    
    getExecutionSession in class AbstractSession
    
    Parameters:
    
    query - may store session name or reference class for brokers case
    
    Returns:
    
    a session with a live accessor
  - getCloneMapping
```
public IdentityHashtable getCloneMapping()
```
    INTERNAL: Return the clone mapping. The clone mapping contains clone of all registered objects, this is required to store the original state of the objects when registered so that only what is changed will be commited to the database and the parent, (this is required to support parralel unit of work).
  - hasCloneMapping
```
protected boolean hasCloneMapping()
```
  - getCloneToOriginals
```
public IdentityHashtable getCloneToOriginals()
```
    INTERNAL: Hashtable used to avoid garbage collection in weak caches. ALSO, hashtable used as lookup when originals used for merge when original in identitymap can not be found. As in a CacheIdentityMap
  - hasCloneToOriginals
```
protected boolean hasCloneToOriginals()
```
  - hasNewObjects
```
public boolean hasNewObjects()
```
    INTERNAL: Return if there are any registered new objects. This is used for both newObjectsOriginalToClone and newObjectsCloneToOriginal as they are always in synch. PERF: Used to avoid initialization of new objects hashtable unless required.
  - getDefaultReadOnlyClasses
```
public java.util.Vector getDefaultReadOnlyClasses()
```
    INTERNAL: Returns the set of read-only classes that gets assigned to each newly created UnitOfWork.
    
    Overrides:
    
    getDefaultReadOnlyClasses in class AbstractSession
    
    See Also:
    
    Project.setDefaultReadOnlyClasses(Vector)
  - getDeletedObjects
```
public IdentityHashtable getDeletedObjects()
```
    INTERNAL: The deleted objects stores any objects removed during the unit of work. On commit they will all be removed from the database.
  - hasDeletedObjects
```
protected boolean hasDeletedObjects()
```
  - getDescriptorForAlias
```
public ClassDescriptor getDescriptorForAlias(java.lang.String alias)
```
    PUBLIC: Return the descriptor for the alias. UnitOfWork delegates this to the parent Introduced because of Bug#2610803
    
    Specified by:
    
    getDescriptorForAlias in interface Session
    
    Overrides:
    
    getDescriptorForAlias in class AbstractSession
  - getDescriptors
```
public java.util.Map getDescriptors()
```
    PUBLIC: Return all registered descriptors. The unit of work inherits its parent's descriptors. The each descriptor's Java Class is used as the key in the Hashtable returned.
    
    Specified by:
    
    getDescriptors in interface Session
    
    Overrides:
    
    getDescriptors in class AbstractSession
  - getLifecycle
```
public int getLifecycle()
```
    INTERNAL: The life cycle tracks if the unit of work is active and is used for JTS.
  - getMergeManager
```
public MergeManager getMergeManager()
```
    A reference to the last used merge manager. This is used to track locked objects.
  - getNewAggregates
```
public IdentityHashtable getNewAggregates()
```
    INTERNAL: The hashtable stores any new aggregates that have been cloned.
  - getNewObjectsCloneToOriginal
```
public IdentityHashtable getNewObjectsCloneToOriginal()
```
    INTERNAL: The new objects stores any objects newly created during the unit of work. On commit they will all be inserted into the database.
  - getNewObjectsOriginalToClone
```
public IdentityHashtable getNewObjectsOriginalToClone()
```
    INTERNAL: The new objects stores any objects newly created during the unit of work. On commit they will all be inserted into the database.
  - getSequencing
```
public Sequencing getSequencing()
```
    INTERNAL: Return the Sequencing object used by the session.
    
    Overrides:
    
    getSequencing in class AbstractSession
  - getServerPlatform
```
public ServerPlatform getServerPlatform()
```
    INTERNAL: Marked internal as this is not customer API but helper methods for accessing the server platform from within TopLink's other sessions types (ie not DatabaseSession)
    
    Overrides:
    
    getServerPlatform in class AbstractSession
  - getSessionTypeString
```
public java.lang.String getSessionTypeString()
```
    INTERNAL: Returns the type of session, its class.
    Override to hide from the user when they are using an internal subclass of a known class.
    A user does not need to know that their UnitOfWork is a non-deferred UnitOfWork, or that their ClientSession is an IsolatedClientSession.
    
    Overrides:
    
    getSessionTypeString in class AbstractSession
  - afterTransaction
```
public void afterTransaction(boolean committed,
                             boolean isExternalTransaction)
```
    INTERNAL: Called after transaction is completed (committed or rolled back)
    
    Overrides:
    
    afterTransaction in class AbstractSession
  - getObjectFromNewObjects
```
public java.lang.Object getObjectFromNewObjects(java.lang.Class theClass,
                                                java.util.Vector selectionKey)
```
    INTERNAL: Return any new object matching the expression. Used for in-memory querying.
  - getObjectFromNewObjects
```
public java.lang.Object getObjectFromNewObjects(Expression selectionCriteria,
                                                java.lang.Class theClass,
                                                AbstractRecord translationRow,
                                                InMemoryQueryIndirectionPolicy valueHolderPolicy)
```
    INTERNAL: Return any new object matching the expression. Used for in-memory querying.
  - getObjectsDeletedDuringCommit
```
public IdentityHashtable getObjectsDeletedDuringCommit()
```
    INTERNAL: Returns all the objects which are deleted during root commit of unit of work.
  - hasObjectsDeletedDuringCommit
```
protected boolean hasObjectsDeletedDuringCommit()
```
  - getOptimisticReadLockObjects
```
public java.util.Hashtable getOptimisticReadLockObjects()
```
    INTERNAL: Return optimistic read lock objects
  - getOriginalVersionOfNewObject
```
public java.lang.Object getOriginalVersionOfNewObject(java.lang.Object workingClone)
```
    INTERNAL: Return the original version of the new object (working clone).
  - getOriginalVersionOfObject
```
public java.lang.Object getOriginalVersionOfObject(java.lang.Object workingClone)
```
    ADVANCED: Return the original version of the object(clone) from the parent's identity map.
    
    Specified by:
    
    getOriginalVersionOfObject in interface UnitOfWork
  - getOriginalVersionOfObjectOrNull
```
public java.lang.Object getOriginalVersionOfObjectOrNull(java.lang.Object workingClone)
```
    ADVANCED: Return the original version of the object(clone) from the parent's identity map.
  - getParent
```
public AbstractSession getParent()
```
    PUBLIC: Return the parent. This is a unit of work if nested, otherwise a database session or client session.
    
    Specified by:
    
    getParent in interface UnitOfWork
  - getPlatform
```
public Platform getPlatform(java.lang.Class domainClass)
```
    INTERNAL: Return the platform for a particular class.
    
    Overrides:
    
    getPlatform in class AbstractSession
  - getShouldThrowConformExceptions
```
public int getShouldThrowConformExceptions()
```
    INTERNAL: Return whether to throw exceptions on conforming queries
  - getQuery
```
public DatabaseQuery getQuery(java.lang.String name,
                              java.util.Vector arguments)
```
    PUBLIC: Return the query from the session pre-defined queries with the given name. This allows for common queries to be pre-defined, reused and executed by name.
    
    Specified by:
    
    getQuery in interface Session
    
    Overrides:
    
    getQuery in class AbstractSession
    
    See Also:
    
    AbstractSession.getQuery(String)
  - getQuery
```
public DatabaseQuery getQuery(java.lang.String name)
```
    PUBLIC: Return the query from the session pre-defined queries with the given name. This allows for common queries to be pre-defined, reused and executed by name.
    
    Specified by:
    
    getQuery in interface Session
    
    Overrides:
    
    getQuery in class AbstractSession
  - getReadOnlyClasses
```
public java.util.Hashtable getReadOnlyClasses()
```
    INTERNAL: Returns the set of read-only classes for the receiver. Use this method with setReadOnlyClasses() to modify a UnitOfWork's set of read-only classes before using the UnitOfWork.
    
    Returns:
    
    Hashtable containing the Java Classes that are currently read-only.
    
    See Also:
    
    setReadOnlyClasses(Vector)
  - getRemovedObjects
```
protected IdentityHashtable getRemovedObjects()
```
    INTERNAL: The removed objects stores any newly registered objects removed during the nested unit of work. On commit they will all be removed from the parent unit of work.
  - hasRemovedObjects
```
protected boolean hasRemovedObjects()
```
  - hasModifyAllQueries
```
protected boolean hasModifyAllQueries()
```
  - hasDeferredModifyAllQueries
```
protected boolean hasDeferredModifyAllQueries()
```
  - getState
```
public int getState()
```
    INTERNAL: Find out what the lifecycle state of this UoW is in.
  - getTransaction
```
public java.lang.Object getTransaction()
```
    INTERNAL: PERF: Return the associated external transaction. Used to optimize activeUnitOfWork lookup.
  - setTransaction
```
public void setTransaction(java.lang.Object transaction)
```
    INTERNAL: PERF: Set the associated external transaction. Used to optimize activeUnitOfWork lookup.
  - getUnitOfWorkChangeSet
```
public UnitOfWorkChangeSet getUnitOfWorkChangeSet()
```
    ADVANCED: Returns the currentChangeSet from the UnitOfWork. This is only valid after the UnitOfWOrk has commited successfully
    
    Specified by:
    
    getUnitOfWorkChangeSet in interface UnitOfWork
  - getUnregisteredExistingObjects
```
public IdentityHashtable getUnregisteredExistingObjects()
```
    INTERNAL: Used to lazy Initialize the unregistered existing Objects collection.
    
    Returns:
    
    oracle.toplink.essentials.internal.helper.IdentityHashtable
  - getUnregisteredNewObjects
```
protected IdentityHashtable getUnregisteredNewObjects()
```
    INTERNAL: This is used to store unregistred objects discovered in the parent so that the child unit of work knows not to register them on commit.
  - getValidationLevel
```
public int getValidationLevel()
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    getValidationLevel in interface UnitOfWork
  - hasChanges
```
public boolean hasChanges()
```
    ADVANCED: The Unit of work is capable of preprocessing to determine if any on the clone have been changed. This is computationaly expensive and should be avoided on large object graphs.
    
    Specified by:
    
    hasChanges in interface UnitOfWork
  - hasModifications
```
protected boolean hasModifications()
```
    INTERNAL: Does this unit of work have any changes or anything that requires a write to the database and a transaction to be started. Should be called after changes are calculated internally by commit.
    Note if a transaction was begun prematurely it still needs to be committed.
  - initializeIdentityMapAccessor
```
public void initializeIdentityMapAccessor()
```
    INTERNAL: Set up the IdentityMapManager. This method allows subclasses of Session to override the default IdentityMapManager functionality.
    
    Overrides:
    
    initializeIdentityMapAccessor in class AbstractSession
  - internalExecuteQuery
```
public java.lang.Object internalExecuteQuery(DatabaseQuery query,
                                             AbstractRecord databaseRow)
                                      throws DatabaseException,
                                             QueryException
```
    INTERNAL: Return the results from exeucting the database query. the arguments should be a database row with raw data values.
    
    Overrides:
    
    internalExecuteQuery in class AbstractSession
    
    Throws:
    
    DatabaseException
    
    QueryException
  - internalRegisterObject
```
public java.lang.Object internalRegisterObject(java.lang.Object object,
                                               ClassDescriptor descriptor)
```
    INTERNAL: Register the object with the unit of work. This does not perform wrapping or unwrapping. This is used for internal registration in the merge manager.
  - isActive
```
public boolean isActive()
```
    PUBLIC: Return if the unit of work is active. (i.e. has not been released).
    
    Specified by:
    
    isActive in interface UnitOfWork
  - isClassReadOnly
```
public boolean isClassReadOnly(java.lang.Class theClass,
                               ClassDescriptor descriptor)
```
    PUBLIC: Checks to see if the specified class or descriptor is read-only or not in this UnitOfWork.
    
    Overrides:
    
    isClassReadOnly in class AbstractSession
    
    Returns:
    
    boolean, true if the class is read-only, false otherwise.
  - isCloneNewObject
```
public boolean isCloneNewObject(java.lang.Object clone)
```
    INTERNAL: Check if the object is already registered.
  - isCommitPending
```
public boolean isCommitPending()
```
    INTERNAL: Return if the unit of work is waiting to be committed or in the process of being committed.
  - isDead
```
public boolean isDead()
```
    INTERNAL: Return if the unit of work is dead.
  - isInTransaction
```
public boolean isInTransaction()
```
    PUBLIC: Return whether the session currently has a database transaction in progress.
    
    Overrides:
    
    isInTransaction in class AbstractSession
  - isMergePending
```
public boolean isMergePending()
```
    INTERNAL: Return if the unit of work is waiting to be merged or in the process of being merged.
  - isAfterWriteChangesButBeforeCommit
```
public boolean isAfterWriteChangesButBeforeCommit()
```
    INTERNAL: Has writeChanges() been attempted on this UnitOfWork? It may have either suceeded or failed but either way the UnitOfWork is in a highly restricted state.
  - isAfterWriteChangesFailed
```
protected boolean isAfterWriteChangesFailed()
```
    INTERNAL: Once writeChanges has failed all a user can do really is rollback.
  - isNestedUnitOfWork
```
public boolean isNestedUnitOfWork()
```
    PUBLIC: Return whether this session is a nested unit of work or not.
    
    Specified by:
    
    isNestedUnitOfWork in interface UnitOfWork
  - isObjectDeleted
```
public boolean isObjectDeleted(java.lang.Object object)
```
    INTERNAL: Return if the object has been deleted in this unit of work.
  - isObjectNew
```
public boolean isObjectNew(java.lang.Object clone)
```
    INTERNAL: This method is used to determine if the clone is a new Object in the UnitOfWork
  - isObjectRegistered
```
public boolean isObjectRegistered(java.lang.Object clone)
```
    INTERNAL: Return whether the clone object is already registered.
  - isOriginalNewObject
```
public boolean isOriginalNewObject(java.lang.Object original)
```
    INTERNAL: Return whether the original object is new. It was either registered as new or discovered as a new aggregate within another new object.
  - isSmartMerge
```
public static boolean isSmartMerge()
```
    INTERNAL: Return the status of smart merge
  - issueSQLbeforeCompletion
```
public void issueSQLbeforeCompletion()
```
    INTERNAL: For synchronized units of work, dump SQL to database. For cases where writes occur before the end of the transaction don't commit
  - issueSQLbeforeCompletion
```
public void issueSQLbeforeCompletion(boolean commitTransaction)
```
    INTERNAL: For synchronized units of work, dump SQL to database. For cases where writes occur before the end of the transaction don't commit
  - issueModifyAllQueryList
```
protected void issueModifyAllQueryList()
```
    INTERNAL: Will notify all the deferred ModifyAllQuery's (excluding UpdateAllQuery's) and deferred UpdateAllQuery's to execute.
  - isSynchronized
```
public boolean isSynchronized()
```
    INTERNAL: Return if this session is a synchronized unit of work.
  - isUnitOfWork
```
public boolean isUnitOfWork()
```
    PUBLIC: Return if this session is a unit of work.
    
    Specified by:
    
    isUnitOfWork in interface Session
    
    Overrides:
    
    isUnitOfWork in class AbstractSession
  - mergeChangesIntoParent
```
protected void mergeChangesIntoParent()
```
    INTERNAL: Merge the changes to all objects to the parent.
  - mergeClone
```
public java.lang.Object mergeClone(java.lang.Object rmiClone)
```
    PUBLIC: Merge the attributes of the clone into the unit of work copy. This can be used for objects that are returned from the client through RMI serialization (or another serialization mechanism), because the RMI object will be a clone this will merge its attributes correctly to preserve object identity within the unit of work and record its changes. The object and its private owned parts are merged.
    
    Specified by:
    
    mergeClone in interface UnitOfWork
    
    Returns:
    
    the registered version for the clone being merged.
    
    See Also:
    
    shallowMergeClone(Object), deepMergeClone(Object)
  - mergeClone
```
public java.lang.Object mergeClone(java.lang.Object rmiClone,
                                   int cascadeDepth)
```
    INTERNAL: Merge the attributes of the clone into the unit of work copy.
  - mergeClonesAfterCompletion
```
public void mergeClonesAfterCompletion()
```
    INTERNAL: for synchronized units of work, merge changes into parent
  - mergeCloneWithReferences
```
public java.lang.Object mergeCloneWithReferences(java.lang.Object rmiClone)
```
    PUBLIC: Merge the attributes of the clone into the unit of work copy. This can be used for objects that are returned from the client through RMI serialization (or another serialization mechanism), because the RMI object will be a clone this will merge its attributes correctly to preserve object identity within the unit of work and record its changes. The object and its private owned parts are merged. This will include references from dependent objects to independent objects.
    
    Specified by:
    
    mergeCloneWithReferences in interface UnitOfWork
    
    Returns:
    
    the registered version for the clone being merged.
    
    See Also:
    
    shallowMergeClone(Object), deepMergeClone(Object)
  - mergeCloneWithReferences
```
public java.lang.Object mergeCloneWithReferences(java.lang.Object rmiClone,
                                                 int cascadePolicy)
```
    PUBLIC: Merge the attributes of the clone into the unit of work copy. This can be used for objects that are returned from the client through RMI serialization (or another serialization mechanism), because the RMI object will be a clone this will merge its attributes correctly to preserve object identity within the unit of work and record its changes. The object and its private owned parts are merged. This will include references from dependent objects to independent objects.
    
    Returns:
    
    the registered version for the clone being merged.
    
    See Also:
    
    shallowMergeClone(Object), deepMergeClone(Object)
  - mergeCloneWithReferences
```
public java.lang.Object mergeCloneWithReferences(java.lang.Object rmiClone,
                                                 int cascadePolicy,
                                                 boolean forceCascade)
```
    INTERNAL: Merge the attributes of the clone into the unit of work copy. This can be used for objects that are returned from the client through RMI serialization (or another serialization mechanism), because the RMI object will be a clone this will merge its attributes correctly to preserve object identity within the unit of work and record its changes. The object and its private owned parts are merged. This will include references from dependent objects to independent objects.
    
    Returns:
    
    the registered version for the clone being merged.
    
    See Also:
    
    shallowMergeClone(Object), deepMergeClone(Object)
  - newInstance
```
public java.lang.Object newInstance(java.lang.Class theClass)
```
    PUBLIC: Return a new instance of the class registered in this unit of work. This can be used to ensure that new objects are registered correctly.
    
    Specified by:
    
    newInstance in interface UnitOfWork
  - performRemove
```
public void performRemove(java.lang.Object toBeDeleted,
                          IdentityHashtable visitedObjects)
```
    INTERNAL: This method will perform a delete operation on the provided objects pre-determing the objects that will be deleted by a commit of the UnitOfWork including privately owned objects. It does not execute a query for the deletion of these objects as the normal deleteobject operation does. Mainly implemented to provide EJB 3.0 deleteObject support.
  - performFullValidation
```
public void performFullValidation()
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    performFullValidation in interface UnitOfWork
  - performPartialValidation
```
public void performPartialValidation()
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    performPartialValidation in interface UnitOfWork
  - populateAndRegisterObject
```
protected void populateAndRegisterObject(java.lang.Object original,
                                         java.lang.Object workingClone,
                                         java.util.Vector primaryKey,
                                         ClassDescriptor descriptor,
                                         java.lang.Object writeLockValue,
                                         long readTime,
                                         JoinedAttributeManager joinedAttributeManager)
```
    INTERNAL: This method is called from clone and register. It includes the processing required to clone an object, including populating attributes, putting in UOW identitymap and building a backupclone
  - postMergeChanges
```
protected void postMergeChanges()
```
    INTERNAL: Remove objects from parent's identity map.
  - preMergeChanges
```
protected void preMergeChanges()
```
    INTERNAL: Remove objects deleted during commit from clone and new object cache so that these are not merged
  - printRegisteredObjects
```
public void printRegisteredObjects()
```
    PUBLIC: Print the objects in the unit of work. The output of this method will be logged to this unit of work's SessionLog at SEVERE level.
    
    Specified by:
    
    printRegisteredObjects in interface UnitOfWork
  - processDeleteObjectQuery
```
public java.lang.Object processDeleteObjectQuery(DeleteObjectQuery deleteQuery)
```
    INTERNAL: This method is used to process delete queries that pass through the unitOfWork It is extracted out of the internalExecuteQuery method to reduce duplication
  - basicPrintRegisteredObjects
```
protected void basicPrintRegisteredObjects()
```
    INTERNAL: Print the objects in the unit of work.
  - registerAllObjects
```
public java.util.Vector registerAllObjects(java.util.Collection domainObjects)
```
    PUBLIC: Register the objects with the unit of work. All newly created root domain objects must be registered to be inserted on commit. Also any existing objects that will be edited and were not read from this unit of work must also be registered. Once registered any changes to the objects will be commited to the database on commit.
    
    Specified by:
    
    registerAllObjects in interface UnitOfWork
    
    Returns:
    
    is the clones of the original objects, the return value must be used for editing. Editing the original is not allowed in the unit of work.
  - registerAllObjects
```
public java.util.Vector registerAllObjects(java.util.Vector domainObjects)
                                    throws DatabaseException,
                                           OptimisticLockException
```
    PUBLIC: Register the objects with the unit of work. All newly created root domain objects must be registered to be inserted on commit. Also any existing objects that will be edited and were not read from this unit of work must also be registered. Once registered any changes to the objects will be commited to the database on commit.
    
    Specified by:
    
    registerAllObjects in interface UnitOfWork
    
    Returns:
    
    is the clones of the original objects, the return value must be used for editing. Editing the original is not allowed in the unit of work.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - registerExistingObject
```
public java.lang.Object registerExistingObject(java.lang.Object existingObject,
                                               JoinedAttributeManager joinedAttributeManager)
```
    INTERNAL: Register the existing object with the unit of work. This is a advanced API that can be used if the application can guarentee the object exists on the database. When registerObject is called the unit of work determines existence through the descriptor's doesExist setting.
    
    Returns:
    
    The clone of the original object, the return value must be used for editing. Editing the original is not allowed in the unit of work.
  - registerExistingObject
```
public java.lang.Object registerExistingObject(java.lang.Object existingObject)
```
    ADVANCED: Register the existing object with the unit of work. This is a advanced API that can be used if the application can guarentee the object exists on the database. When registerObject is called the unit of work determines existence through the descriptor's doesExist setting.
    
    Specified by:
    
    registerExistingObject in interface UnitOfWork
    
    Returns:
    
    The clone of the original object, the return value must be used for editing. Editing the original is not allowed in the unit of work.
  - registerExistingObject
```
protected java.lang.Object registerExistingObject(java.lang.Object objectToRegister,
                                                  ClassDescriptor descriptor,
                                                  JoinedAttributeManager joinedAttributeManager)
```
    INTERNAL: Register the existing object with the unit of work. This is a advanced API that can be used if the application can guarentee the object exists on the database. When registerObject is called the unit of work determines existence through the descriptor's doesExist setting.
    
    Returns:
    
    The clone of the original object, the return value must be used for editing. Editing the original is not allowed in the unit of work.
  - registerNewObject
```
public java.lang.Object registerNewObject(java.lang.Object newObject)
```
    ADVANCED: Register the new object with the unit of work. This will register the new object without cloning. Normally the registerObject method should be used for all registration of new and existing objects. This version of the register method can only be used for new objects. This method should only be used if a new object is desired to be registered without cloning.
    
    Specified by:
    
    registerNewObject in interface UnitOfWork
    
    See Also:
    
    registerObject(Object)
  - registerNewObject
```
protected java.lang.Object registerNewObject(java.lang.Object implementation,
                                             ClassDescriptor descriptor)
```
    INTERNAL: Updated to allow passing in of the object's descriptor Register the new object with the unit of work. This will register the new object without cloning. Normally the registerObject method should be used for all registration of new and existing objects. This version of the register method can only be used for new objects. This method should only be used if a new object is desired to be registered without cloning.
    
    See Also:
    
    registerObject(Object)
  - registerNewObjectForPersist
```
public void registerNewObjectForPersist(java.lang.Object newObject,
                                        IdentityHashtable visitedObjects)
```
    INTERNAL: Register the new object with the unit of work. This will register the new object without cloning. Checks based on existence will be completed and the create will be cascaded based on the object's mappings cascade requirements. This is specific to EJB 3.0 support and is
    
    See Also:
    
    registerObject(Object)
  - registerNotRegisteredNewObjectForPersist
```
protected void registerNotRegisteredNewObjectForPersist(java.lang.Object newObject,
                                                        ClassDescriptor descriptor)
```
    INTERNAL: Called only by registerNewObjectForPersist method, and only if newObject is not already registered. Could be overridden in subclasses.
  - registerNewObjectClone
```
protected void registerNewObjectClone(java.lang.Object clone,
                                      java.lang.Object original)
```
    INTERNAL: Register the working copy of a new object and its original. The user must edit the working copy and the original is used to merge into the parent. This mapping is kept both ways because lookup is required in both directions.
  - registerNewObjectInIdentityMap
```
protected void registerNewObjectInIdentityMap(java.lang.Object clone,
                                              java.lang.Object original)
```
    INTERNAL: Add the new object to the cache if set to. This is useful for using mergeclone on new objects.
  - registerObject
```
public java.lang.Object registerObject(java.lang.Object object)
```
    PUBLIC: Register the object with the unit of work. All newly created root domain objects must be registered to be inserted on commit. Also any existing objects that will be edited and were not read from this unit of work must also be registered. Once registered any changes to the objects will be commited to the database on commit.
    
    Specified by:
    
    registerObject in interface UnitOfWork
    
    Returns:
    
    the clone of the original object, the return value must be used for editing, ** Editing the original is not allowed in the unit of work. **
  - registerObject
```
protected java.lang.Object registerObject(java.lang.Object object,
                                          ClassDescriptor descriptor)
```
    INTERNAL: Allows for calling method to provide the descriptor information for this object. Prevents double lookup of descriptor. Register the object with the unit of work. All newly created root domain objects must be registered to be inserted on commit. Also any existing objects that will be edited and were not read from this unit of work must also be registered. Once registered any changes to the objects will be commited to the database on commit. calling this method will also sort the objects into different different groups depending on if the object being registered is a bean or a regular Java object and if its updates are deferred, non-deferred or if all modifications are deferred.
    
    Returns:
    
    the clone of the original object, the return value must be used for editing,
  - registerWithTransactionIfRequired
```
public void registerWithTransactionIfRequired()
```
    INTERNAL: Register this UnitOfWork against an external transaction controller
  - release
```
public void release()
```
    PUBLIC: Release the unit of work. This terminates this unit of work. Because the unit of work operates on its own object space (clones) no work is required. The unit of work should no longer be used or referenced by the application beyond this point so that it can be garbage collected.
    
    Specified by:
    
    release in interface Session
    
    Specified by:
    
    release in interface UnitOfWork
    
    Overrides:
    
    release in class AbstractSession
    
    See Also:
    
    commit()
  - removeAllReadOnlyClasses
```
public void removeAllReadOnlyClasses()
                              throws ValidationException
```
    PUBLIC: Empties the set of read-only classes. It is illegal to call this method on nested UnitOfWork objects. A nested UnitOfWork cannot have a subset of its parent's set of read-only classes. Also removes classes which are read only because their descriptors are readonly
    
    Specified by:
    
    removeAllReadOnlyClasses in interface UnitOfWork
    
    Throws:
    
    ValidationException
  - removeForceUpdateToVersionField
```
public void removeForceUpdateToVersionField(java.lang.Object lockObject)
```
    ADVANCED: Remove optimistic read lock from the object See forceUpdateToVersionField(Object)
    
    Specified by:
    
    removeForceUpdateToVersionField in interface UnitOfWork
  - removeReadOnlyClass
```
public void removeReadOnlyClass(java.lang.Class theClass)
                         throws ValidationException
```
    PUBLIC: Removes a Class from the receiver's set of read-only classes. It is illegal to try to send this method to a nested UnitOfWork.
    
    Specified by:
    
    removeReadOnlyClass in interface UnitOfWork
    
    Throws:
    
    ValidationException
  - resetAllCloneCollection
```
protected void resetAllCloneCollection()
```
    INTERNAL: Used in the resume to reset the all clones collection
  - revertAndResume
```
public void revertAndResume()
```
    PUBLIC: Revert all changes made to any registered object. Clear all deleted and new objects. Revert should not be confused with release which it the normal compliment to commit. Revert is more similar to commit and resume, however reverts all changes and resumes. If you do not require to resume the unit of work release should be used instead.
    
    Specified by:
    
    revertAndResume in interface UnitOfWork
    
    See Also:
    
    commitAndResume(), release()
  - revertObject
```
public java.lang.Object revertObject(java.lang.Object clone)
```
    PUBLIC: Revert the object's attributes from the parent. This also reverts the object privately-owned parts.
    
    Specified by:
    
    revertObject in interface UnitOfWork
    
    Returns:
    
    the object reverted.
    
    See Also:
    
    shallowRevertObject(Object), deepRevertObject(Object)
  - revertObject
```
public java.lang.Object revertObject(java.lang.Object clone,
                                     int cascadeDepth)
```
    INTERNAL: Revert the object's attributes from the parent. This uses merging to merge the object changes.
  - rollbackTransaction
```
public void rollbackTransaction()
                         throws DatabaseException
```
    INTERNAL: This is internal to the uow, transactions should not be used explictly in a uow. The uow shares its parents transactions.
    
    Overrides:
    
    rollbackTransaction in class AbstractSession
    
    Throws:
    
    DatabaseException - if the database connection is lost or the rollback fails.
  - rollbackTransaction
```
protected void rollbackTransaction(boolean intendedToCommitTransaction)
                            throws DatabaseException
```
    INTERNAL: rollbackTransaction() with a twist for external transactions.
    writeChanges() is called outside the JTA beforeCompletion(), so the accompanying exception won't propogate up and cause a rollback by itself.
    Instead must mark the transaction for rollback only here.
    If internally started external transaction or no external transaction can still rollback normally.
    
    Parameters:
    
    intendedToCommitTransaction - whether we were inside a commit or just trying to write out changes early.
    
    Throws:
    
    DatabaseException
  - scanForConformingInstances
```
public IdentityHashtable scanForConformingInstances(Expression selectionCriteria,
                                                    java.lang.Class referenceClass,
                                                    AbstractRecord arguments,
                                                    ObjectLevelReadQuery query)
```
    INTERNAL: Scans the UnitOfWork identity map for conforming instances.
    Later this method can be made recursive to check all parent units of work also.
    
    Parameters:
    
    selectionCriteria - must be cloned and specially prepared for conforming
    
    Returns:
    
    IdentityHashtable to facilitate merging with conforming instances returned from a query on the database.
  - setAllClonesCollection
```
protected void setAllClonesCollection(IdentityHashtable objects)
```
    INTERNAL: Used to set the collections of all objects in the UnitOfWork.
    
    Parameters:
    
    newUnregisteredExistingObjects - oracle.toplink.essentials.internal.helper.IdentityHashtable
  - setCloneMapping
```
protected void setCloneMapping(IdentityHashtable cloneMapping)
```
    INTERNAL: Set the clone mapping. The clone mapping contains clone of all registered objects, this is required to store the original state of the objects when registered so that only what is changed will be commited to the database and the parent, (this is required to support parralel unit of work).
  - setDead
```
public void setDead()
```
    INTERNAL: set UoW lifecycle state variable to DEATH
  - setDeletedObjects
```
protected void setDeletedObjects(IdentityHashtable deletedObjects)
```
    INTERNAL: The deleted objects stores any objects removed during the unit of work. On commit they will all be removed from the database.
  - setLifecycle
```
protected void setLifecycle(int lifecycle)
```
    INTERNAL: The life cycle tracks if the unit of work is active and is used for JTS.
  - setMergeManager
```
public void setMergeManager(MergeManager mergeManager)
```
    INTERNAL: A reference to the last used merge manager. This is used to track locked objects.
  - setNewObjectsCloneToOriginal
```
protected void setNewObjectsCloneToOriginal(IdentityHashtable newObjects)
```
    INTERNAL: The new objects stores any objects newly created during the unit of work. On commit they will all be inserted into the database.
  - setNewObjectsOriginalToClone
```
protected void setNewObjectsOriginalToClone(IdentityHashtable newObjects)
```
    INTERNAL: The new objects stores any objects newly created during the unit of work. On commit they will all be inserted into the database.
  - setObjectsDeletedDuringCommit
```
public void setObjectsDeletedDuringCommit(IdentityHashtable deletedObjects)
```
    INTERNAL: Set the objects that have been deleted.
  - setParent
```
public void setParent(AbstractSession parent)
```
    INTERNAL: Set the parent. This is a unit of work if nested, otherwise a database session or client session.
  - setPendingMerge
```
public void setPendingMerge()
```
    INTERNAL: set UoW lifecycle state variable to PENDING_MERGE
  - setReadOnlyClasses
```
public void setReadOnlyClasses(java.util.Vector classes)
```
    INTERNAL: Gives a new set of read-only classes to the receiver. This set of classes given are checked that subclasses of a read-only class are also in the read-only set provided.
  - setRemovedObjects
```
protected void setRemovedObjects(IdentityHashtable removedObjects)
```
    INTERNAL: The removed objects stores any newly registered objects removed during the nested unit of work. On commit they will all be removed from the parent unit of work.
  - setResumeUnitOfWorkOnTransactionCompletion
```
public void setResumeUnitOfWorkOnTransactionCompletion(boolean resumeUnitOfWork)
```
    INTERNAL: Set if this UnitofWork should be resumed after the end of the transaction Used when UnitOfWork is synchronized with external transaction control
  - setShouldCascadeCloneToJoinedRelationship
```
public void setShouldCascadeCloneToJoinedRelationship(boolean shouldCascadeCloneToJoinedRelationship)
```
    INTERNAL: True if the value holder for the joined attribute should be triggered. Required by ejb30 fetch join.
  - setShouldNewObjectsBeCached
```
public void setShouldNewObjectsBeCached(boolean shouldNewObjectsBeCached)
```
    ADVANCED: By default new objects are not cached until the exist on the database. Occasionally if mergeClone is used on new objects and is required to allow multiple merges on the same new object, then if the new objects are not cached, each mergeClone will be interpretted as a different new object. By setting new objects to be cached mergeClone can be performed multiple times before commit. New objects cannot be cached unless they have a valid assigned primary key before being registered. New object with non-null invalid primary keys such as 0 or '' can cause problems and should not be used with this option.
    
    Specified by:
    
    setShouldNewObjectsBeCached in interface UnitOfWork
  - setShouldPerformDeletesFirst
```
public void setShouldPerformDeletesFirst(boolean shouldPerformDeletesFirst)
```
    ADVANCED: By default deletes are performed last in a unit of work. Sometimes you may want to have the deletes performed before other actions.
    
    Specified by:
    
    setShouldPerformDeletesFirst in interface UnitOfWork
  - setShouldThrowConformExceptions
```
public void setShouldThrowConformExceptions(int shouldThrowExceptions)
```
    ADVANCED: Conforming queries can be set to provide different levels of detail about the exceptions they encounter There are three levels: DO_NOT_THROW_CONFORM_EXCEPTIONS = 0; THROW_ALL_CONFORM_EXCEPTIONS = 1;
    
    Specified by:
    
    setShouldThrowConformExceptions in interface UnitOfWork
  - setSmartMerge
```
public static void setSmartMerge(boolean option)
```
    INTERNAL: Set smart merge flag. This feature is used in WL to merge dependent values without SessionAccessor
  - setSynchronized
```
public void setSynchronized(boolean synched)
```
    INTERNAL: Set isSynchronized flag to indicate that this session is a synchronized unit of work.
  - setUnitOfWorkChangeSet
```
public void setUnitOfWorkChangeSet(UnitOfWorkChangeSet unitOfWorkChangeSet)
```
    INTERNAL: Sets the current UnitOfWork change set to be the one passed in.
  - setUnregisteredExistingObjects
```
protected void setUnregisteredExistingObjects(IdentityHashtable newUnregisteredExistingObjects)
```
    INTERNAL: Used to set the unregistered existing objects vector used when validation has been turned off.
    
    Parameters:
    
    newUnregisteredExistingObjects - oracle.toplink.essentials.internal.helper.IdentityHashtable
  - setUnregisteredNewObjects
```
protected void setUnregisteredNewObjects(IdentityHashtable newObjects)
```
    INTERNAL:
  - setValidationLevel
```
public void setValidationLevel(int validationLevel)
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    setValidationLevel in interface UnitOfWork
  - setWasTransactionBegunPrematurely
```
public void setWasTransactionBegunPrematurely(boolean wasTransactionBegunPrematurely)
```
    INTERNAL: Set a flag in the root UOW to indicate that a pess. locking or non-selecting SQL query was executed and forced a transaction to be started.
  - shallowMergeClone
```
public java.lang.Object shallowMergeClone(java.lang.Object rmiClone)
```
    PUBLIC: Merge the attributes of the clone into the unit of work copy. This can be used for objects that are returned from the client through RMI serialization (or other serialization mechanisms), because the RMI object will be a clone this will merge its attributes correctly to preserve object identity within the unit of work and record its changes. Only direct attributes are merged.
    
    Specified by:
    
    shallowMergeClone in interface UnitOfWork
    
    Returns:
    
    the registered version for the clone being merged.
    
    See Also:
    
    mergeClone(Object), deepMergeClone(Object)
  - shallowRevertObject
```
public java.lang.Object shallowRevertObject(java.lang.Object clone)
```
    PUBLIC: Revert the object's attributes from the parent. This only reverts the object's direct attributes.
    
    Specified by:
    
    shallowRevertObject in interface UnitOfWork
    
    Returns:
    
    the object reverted.
    
    See Also:
    
    revertObject(Object), deepRevertObject(Object)
  - shallowUnregisterObject
```
public void shallowUnregisterObject(java.lang.Object clone)
```
    ADVANCED: Unregister the object with the unit of work. This can be used to delete an object that was just created and is not yet persistent. Delete object can also be used, but will result in inserting the object and then deleting it. The method will only unregister the clone, none of its parts.
    
    Specified by:
    
    shallowUnregisterObject in interface UnitOfWork
  - shouldCascadeCloneToJoinedRelationship
```
public boolean shouldCascadeCloneToJoinedRelationship()
```
    INTERNAL: True if the value holder for the joined attribute should be triggered. Required by ejb30 fetch join.
  - shouldNewObjectsBeCached
```
public boolean shouldNewObjectsBeCached()
```
    ADVANCED: By default new objects are not cached until the exist on the database. Occasionally if mergeClone is used on new objects and is required to allow multiple merges on the same new object, then if the new objects are not cached, each mergeClone will be interpretted as a different new object. By setting new objects to be cached mergeClone can be performed multiple times before commit. New objects cannot be cached unless they have a valid assigned primary key before being registered. New object with non-null invalid primary keys such as 0 or '' can cause problems and should not be used with this option.
    
    Specified by:
    
    shouldNewObjectsBeCached in interface UnitOfWork
  - shouldPerformDeletesFirst
```
public boolean shouldPerformDeletesFirst()
```
    ADVANCED: By default all objects are inserted and updated in the database before any object is deleted. If this flag is set to true, deletes will be performed before inserts and updates
    
    Specified by:
    
    shouldPerformDeletesFirst in interface UnitOfWork
  - shouldPerformFullValidation
```
public boolean shouldPerformFullValidation()
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    shouldPerformFullValidation in interface UnitOfWork
  - shouldPerformNoValidation
```
public boolean shouldPerformNoValidation()
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    shouldPerformNoValidation in interface UnitOfWork
  - shouldPerformPartialValidation
```
public boolean shouldPerformPartialValidation()
```
    ADVANCED: The unit of work performs validations such as, ensuring multiple copies of the same object don't exist in the same unit of work, ensuring deleted objects are not refered after commit, ensures that objects from the parent cache are not refered in the unit of work cache. The level of validation can be increased or decreased for debugging purposes or under advanced situation where the application requires/desires to violate clone identity in the unit of work. It is strongly suggested that clone identity not be violate in the unit of work.
    
    Specified by:
    
    shouldPerformPartialValidation in interface UnitOfWork
  - shouldResumeUnitOfWorkOnTransactionCompletion
```
public boolean shouldResumeUnitOfWorkOnTransactionCompletion()
```
    INTERNAL: Returns true if this UnitofWork should be resumed after the end of the transaction Used when UnitOfWork is synchronized with external transaction control
  - storeModifyAllQuery
```
public void storeModifyAllQuery(DatabaseQuery query)
```
    INTERNAL: Store the ModifyAllQuery's from the UoW in the list. They are always deferred to commit time
  - storeDeferredModifyAllQuery
```
public void storeDeferredModifyAllQuery(DatabaseQuery query,
                                        AbstractRecord translationRow)
```
    INTERNAL: Store the deferred UpdateAllQuery's from the UoW in the list.
  - synchronizeAndResume
```
public void synchronizeAndResume()
```
    INTERNAL Synchronize the clones and update their backup copies. Called after commit and commit and resume.
  - undeleteObject
```
protected void undeleteObject(java.lang.Object object)
```
    INTERNAL: THis method is used to transition an object from the deleted objects list to be simply be register.
  - unregisterObject
```
public void unregisterObject(java.lang.Object clone)
```
    PUBLIC: Unregister the object with the unit of work. This can be used to delete an object that was just created and is not yet persistent. Delete object can also be used, but will result in inserting the object and then deleting it. The method will only unregister the object and its privately owned parts
    
    Specified by:
    
    unregisterObject in interface UnitOfWork
  - unregisterObject
```
public void unregisterObject(java.lang.Object clone,
                             int cascadeDepth)
```
    INTERNAL: Unregister the object with the unit of work. This can be used to delete an object that was just created and is not yet persistent. Delete object can also be used, but will result in inserting the object and then deleting it.
  - updateChangeTrackersIfRequired
```
public void updateChangeTrackersIfRequired(java.lang.Object objectToWrite,
                                           ObjectChangeSet changeSetToWrite,
                                           UnitOfWorkImpl uow,
                                           ClassDescriptor descriptor)
```
    INTERNAL: This method is used internally to update the tracked objects if required
  - validateObjectSpace
```
public void validateObjectSpace()
```
    ADVANCED: This can be used to help debugging an object-space corruption. An object-space corruption is when your application has incorrectly related a clone to an original object. This method will validate that all registered objects are in a correct state and throw an error if not, it will contain the full stack of object references in the error message. If you call this method after each register or change you perform it will pin-point where the error was made.
    
    Specified by:
    
    validateObjectSpace in interface UnitOfWork
  - wasTransactionBegunPrematurely
```
public boolean wasTransactionBegunPrematurely()
```
    INTERNAL: Indicates if a transaction was begun by a pessimistic locking or non-selecting query. Traverse to the root UOW to get value.
  - writeChanges
```
public void writeChanges()
```
    ADVANCED: Writes all changes now before commit(). The commit process will begin and all changes will be written out to the datastore, but the datastore transaction will not be committed, nor will changes be merged into the global cache.
    A subsequent commit (on UnitOfWork or global transaction) will be required to finalize the commit process.
    As the commit process has begun any attempt to register objects, or execute object-level queries will generate an exception. Report queries, non-caching queries, and data read/modify queries are allowed.
    On exception any global transaction will be rolled back or marked rollback only. No recovery of this UnitOfWork will be possible.
    Can only be called once. It can not be used to write out changes in an incremental fashion.
    Use to partially commit a transaction outside of a JTA transaction's callbacks. Allows you to get back any exception directly.
    Use to commit a UnitOfWork in two stages.
    
    Specified by:
    
    writeChanges in interface UnitOfWork
  - writesCompleted
```
public void writesCompleted()
```
    INTERNAL: This method notifies the accessor that a particular sets of writes has completed. This notification can be used for such thing as flushing the batch mechanism
    
    Overrides:
    
    writesCompleted in class AbstractSession
  - getWorkingCopyFromUnitOfWorkIdentityMap
```
public java.lang.Object getWorkingCopyFromUnitOfWorkIdentityMap(java.lang.Object object,
                                                                java.util.Vector primaryKey)
```
    INTERNAL: Return the registered working copy from the unit of work identity map. If not registered in the unit of work yet, return null
  - getPessimisticLockedObjects
```
public IdentityHashtable getPessimisticLockedObjects()
```
    INTERNAL:
  - addPessimisticLockedClone
```
public void addPessimisticLockedClone(java.lang.Object clone)
```
    INTERNAL:
  - isPessimisticLocked
```
public boolean isPessimisticLocked(java.lang.Object clone)
```
    INTERNAL:
  - setWasNonObjectLevelModifyQueryExecuted
```
public void setWasNonObjectLevelModifyQueryExecuted(boolean wasNonObjectLevelModifyQueryExecuted)
```
    INTERNAL: True if either DataModifyQuery or ModifyAllQuery was executed. In absense of transaction the query execution starts one, therefore the flag may only be true in transaction, it's reset on commit or rollback.
  - wasNonObjectLevelModifyQueryExecuted
```
public boolean wasNonObjectLevelModifyQueryExecuted()
```
    INTERNAL: True if either DataModifyQuery or ModifyAllQuery was executed.
  - shouldReadFromDB
```
public boolean shouldReadFromDB()
```
    INTERNAL: Indicates whether readObject should return the object read from the db in case there is no object in uow cache (as opposed to fetching the object from parent's cache). Note that wasNonObjectLevelModifyQueryExecuted()==true implies inTransaction()==true.
  - clear
```
public void clear(boolean shouldClearCache)
```
    INTERNAL: This method will clear all registered objects from this UnitOfWork. If parameter value is 'true' then the cache(s) are cleared, too.
  - clearForClose
```
public void clearForClose(boolean shouldClearCache)
```
    INTERNAL: Call this method if the uow will no longer used for comitting transactions: all the changes sets will be dereferenced, and (optionally) the cache cleared. If the uow is not released, but rather kept around for ValueHolders, then identity maps shouldn't be cleared: the parameter value should be 'false'. The lifecycle set to Birth so that uow ValueHolder still could be used. Alternatively, if called from release method then everything should go and therefore parameter value should be 'true'. In this case lifecycle won't change - uow.release (optionally) calls this method when it (uow) is already dead. The reason for calling this method from release is to free maximum memory right away: the uow might still be referenced by objects using UOWValueHolders (though they shouldn't be around they still might).
  - shouldClearForCloseOnRelease
```
public boolean shouldClearForCloseOnRelease()
```
    INTERNAL: Indicates whether clearForClose methor should be called by release method.

Class UnitOfWorkImpl

Field Summary

Fields inherited from class oracle.toplink.essentials.internal.sessions.AbstractSession

Constructor Summary

Method Summary

Methods inherited from class oracle.toplink.essentials.internal.sessions.AbstractSession

Methods inherited from class java.lang.Object

Methods inherited from interface oracle.toplink.essentials.sessions.UnitOfWork

Methods inherited from interface oracle.toplink.essentials.sessions.Session

Field Detail

cloneToOriginals

parent

cloneMapping

newObjectsCloneToOriginal

newObjectsOriginalToClone

deletedObjects

allClones

objectsDeletedDuringCommit

removedObjects

unregisteredNewObjects

unregisteredExistingObjects

newAggregates

unitOfWorkChangeSet

pessimisticLockedObjects

lastUsedMergeManager

readOnlyClasses

wasTransactionBegunPrematurely

shouldNewObjectsBeCached

shouldPerformDeletesFirst

shouldThrowConformExceptions

validationLevel

None

Partial

Full

isSynchronized

lifecycle

Birth

CommitPending

CommitTransactionPending

WriteChangesFailed

MergePending

Death

AfterExternalTransactionRolledBack

DO_NOT_THROW_CONFORM_EXCEPTIONS

THROW_ALL_CONFORM_EXCEPTIONS

LOCK_QUERIES_PROPERTY

SmartMerge

optimisticReadLockObjects

modifyAllQueries

deferredModifyAllQueries

cloneDepth

objectsLockedForClone

transaction

shouldCheckWriteLock

resumeOnTransactionCompletion

wasNonObjectLevelModifyQueryExecuted

shouldCascadeCloneToJoinedRelationship

Constructor Detail

UnitOfWorkImpl

Method Detail

acquireUnitOfWork

addNewAggregate

addObjectDeletedDuringCommit

addReadOnlyClass

addReadOnlyClasses

addRemovedObject

assignSequenceNumber

assignSequenceNumbers

beginEarlyTransaction

beginTransaction

buildOriginal

calculateChanges

canChangeReadOnlySet

checkForUnregisteredExistingObject

checkExistence

checkIfAlreadyRegistered

cloneAndRegisterNewObject

cloneAndRegisterObject

collectAndPrepareObjectsForCommit

collectAndPrepareObjectsForNestedMerge