CollectionMapping (EclipseLink 2.5.1, build 'v20130918-f2b9fc5' API Reference)

java.lang.Object
- org.eclipse.persistence.core.mappings.CoreMapping<AttributeAccessor,org.eclipse.persistence.internal.sessions.AbstractSession,org.eclipse.persistence.internal.queries.ContainerPolicy,ClassDescriptor,org.eclipse.persistence.internal.helper.DatabaseField>
- - org.eclipse.persistence.mappings.DatabaseMapping
  - - org.eclipse.persistence.mappings.ForeignReferenceMapping
    - - org.eclipse.persistence.mappings.CollectionMapping

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, ContainerMapping

Direct Known Subclasses:

AggregateCollectionMapping, DirectCollectionMapping, EISOneToManyMapping, ManyToManyMapping, NestedTableMapping, OneToManyMapping
```
public abstract class CollectionMapping
extends ForeignReferenceMapping
implements ContainerMapping
```
Purpose: Abstract class for relationship mappings which store collection of objects

See Also:
Serialized Form
Author:

Sati

Since:

TOPLink/Java 1.0

Nested Class Summary
- Nested classes/interfaces inherited from class org.eclipse.persistence.mappings.DatabaseMapping
  DatabaseMapping.WriteType

Field Summary

Fields
Modifier and Type	Field and Description
`protected DataModifyQuery`	`changeOrderTargetQuery` Query used when order of list members is changed.
`protected org.eclipse.persistence.internal.queries.ContainerPolicy`	`containerPolicy`
`protected ModifyQuery`	`deleteAllQuery` Used for delete all in m-m, dc and delete all optimization in 1-m.
`protected boolean`	`hasCustomDeleteAllQuery`
`protected boolean`	`hasOrderBy`
`protected boolean`	`isListOrderFieldSupported` Indicates whether the mapping supports listOrderField, if it doesn't attempt to set listOrderField throws exception.
`protected static boolean`	`isSynchronizeOnMerge` Flag to indicate if collection needs to be synchronized instead of cloning during merge.
`protected org.eclipse.persistence.internal.helper.DatabaseField`	`listOrderField` Field holds the order of elements in the list in the db, requires collection of type List, may be not null only in case isListOrderFieldSupported==true
`protected java.lang.Boolean`	`mustDeleteReferenceObjectsOneByOne` Store if the mapping can batch delete reference objects.
`protected OrderCorrectionType`	`orderCorrectionType` Specifies what should be done if the list of values read from listOrserField is invalid (there should be no nulls, no duplicates, no "holes").

Fields inherited from class org.eclipse.persistence.mappings.DatabaseMapping
attributeAccessor, attributeName, derivedIdMapping, derivesId, descriptor, fields, isCacheable, isInSopObject, isJPAId, isLazy, isMapKeyMapping, isOptional, isPrimaryKeyMapping, isReadOnly, isRemotelyInitialized, mapsIdValue, NO_FIELDS, NO_WEIGHT, properties, unconvertedProperties, weight, WEIGHT_AGGREGATE, WEIGHT_DIRECT, WEIGHT_TO_ONE, WEIGHT_TRANSFORM

Constructor Summary

Constructors
Constructor and Description

CollectionMapping()
PUBLIC: Default constructor.

Constructors
Constructor and Description
`CollectionMapping()` PUBLIC: Default constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAggregateOrderBy(java.lang.String aggregateName, java.lang.String queryKeyName, boolean isDescending)` PUBLIC: Provide order support for queryKeyName in ascending or descending order.
`void`	`addAscendingOrdering(java.lang.String queryKeyName)` PUBLIC: Provide order support for queryKeyName in ascending order
`void`	`addDescendingOrdering(java.lang.String queryKeyName)` PUBLIC: Provide order support for queryKeyName in descending order.
`void`	`addOrderBy(java.lang.String queryKeyName, boolean isDescending)` PUBLIC: Provide order support for queryKeyName in descending or ascending order.
`java.lang.Object`	`buildBackupCloneForPartObject(java.lang.Object attributeValue, java.lang.Object clone, java.lang.Object backup, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)` INTERNAL: Used during building the backup shallow copy to copy the vector without re-registering the target objects.
`org.eclipse.persistence.internal.sessions.ChangeRecord`	`buildChangeRecord(java.lang.Object clone, org.eclipse.persistence.internal.sessions.ObjectChangeSet owner, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Directly build a change record without comparison
`java.lang.Object`	`buildCloneForPartObject(java.lang.Object attributeValue, java.lang.Object original, org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey, java.lang.Object clone, org.eclipse.persistence.internal.sessions.AbstractSession cloningSession, java.lang.Integer refreshCascade, boolean isExisting, boolean isFromSharedCache)` INTERNAL: Require for cloning, the part must be cloned.
`java.lang.Object`	`buildContainerClone(java.lang.Object attributeValue, org.eclipse.persistence.internal.sessions.AbstractSession cloningSession)` INTERNAL: Performs a first level clone of the attribute.
`void`	`buildCopy(java.lang.Object copy, java.lang.Object original, CopyGroup group)` INTERNAL: Copy of the attribute of the object.
`java.lang.Object`	`buildElementClone(java.lang.Object element, java.lang.Object parent, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, java.lang.Integer refreshCascade, org.eclipse.persistence.internal.sessions.AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache)` INTERNAL: Clone the element, if necessary.
`java.lang.Object`	`buildElementUnitOfWorkClone(java.lang.Object element, java.lang.Object parent, java.lang.Integer refreshCascade, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork, boolean isExisting, boolean isFromSharedCache)` INTERNAL: Clone the element, if necessary.
`protected void`	`buildListOrderField()` INTERNAL: Verifies listOrderField's table, if none found sets the default one.
`java.lang.Object[]`	`buildReferencesPKList(java.lang.Object entity, java.lang.Object attribute, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method will access the target relationship and create a list of information to rebuild the relationship.
`void`	`calculateDeferredChanges(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Used by AttributeLevelChangeTracking to update a changeRecord with calculated changes as apposed to detected changes.
`void`	`cascadeDiscoverAndPersistUnregisteredNewObjects(java.lang.Object object, java.util.Map newObjects, java.util.Map unregisteredExistingObjects, java.util.Map visitedObjects, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Set cascadeErrors)` INTERNAL: Cascade discover and persist new objects during commit.
`void`	`cascadePerformRemoveIfRequired(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Map visitedObjects)` INTERNAL: Cascade perform delete through mappings that require the cascade
`void`	`cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Map visitedObjects)` INTERNAL: Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet
`void`	`cascadeRegisterNewIfRequired(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Map visitedObjects)` INTERNAL: Cascade registerNew for Create through mappings that require the cascade
`java.lang.Object`	`clone()` INTERNAL: The mapping clones itself to create deep copy.
`void`	`collectQueryParameters(java.util.Set<org.eclipse.persistence.internal.helper.DatabaseField> record)` INTERNAL: This method is used to store the FK fields that can be cached that correspond to noncacheable mappings the FK field values will be used to re-issue the query when cloning the shared cache entity
`void`	`compareCollectionsForChange(java.lang.Object oldCollection, java.lang.Object newCollection, org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method is used to calculate the differences between two collections.
`org.eclipse.persistence.internal.sessions.ChangeRecord`	`compareForChange(java.lang.Object clone, java.lang.Object backUp, org.eclipse.persistence.internal.sessions.ObjectChangeSet owner, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method is used to create a change record from comparing two collections.
`protected boolean`	`compareLists(java.util.List firstList, java.util.List secondList, org.eclipse.persistence.internal.sessions.AbstractSession session, boolean withPrivateOwned)` Compare two lists.
`protected void`	`compareListsAndWrite(java.util.List previousList, java.util.List currentList, WriteObjectQuery query)` INTERNAL: Old and new lists are compared and only the changes are written to the database.
`boolean`	`compareObjects(java.lang.Object firstObject, java.lang.Object secondObject, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Compare the attributes belonging to this mapping for the objects.
`protected void`	`compareObjectsAndWrite(WriteObjectQuery query)` INTERNAL: The memory objects are compared and only the changes are written to the database.
`protected boolean`	`compareObjectsWithoutPrivateOwned(java.lang.Object firstCollection, java.lang.Object secondCollection, org.eclipse.persistence.internal.sessions.AbstractSession session)` Compare two objects if their parts are not private owned
`protected boolean`	`compareObjectsWithPrivateOwned(java.lang.Object firstCollection, java.lang.Object secondCollection, org.eclipse.persistence.internal.sessions.AbstractSession session)` Compare two objects if their parts are private owned
`void`	`convertClassNamesToClasses(java.lang.ClassLoader classLoader)` INTERNAL: Convert all the class-name-based settings in this mapping to actual class-based settings This method is implemented by subclasses as necessary.
`protected java.lang.Object`	`copyElement(java.lang.Object original, CopyGroup group)` INTERNAL: Copies member's value
`protected void`	`executeBatchQuery(DatabaseQuery query, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, java.util.Map referenceObjectsByKey, org.eclipse.persistence.internal.sessions.AbstractSession session, org.eclipse.persistence.internal.sessions.AbstractRecord translationRow)` INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.
`protected java.lang.Object`	`extractKeyFromTargetRow(org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Extract the source primary key value from the target row.
`java.lang.Object`	`extractResultFromBatchQuery(ReadQuery batchQuery, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, org.eclipse.persistence.internal.sessions.AbstractRecord sourceRow, org.eclipse.persistence.internal.sessions.AbstractSession session, ObjectLevelReadQuery originalQuery)` INTERNAL: Extract the value from the batch optimized query, this should be supported by most query types.
`void`	`fixRealObjectReferences(java.lang.Object object, java.util.Map objectDescriptors, java.util.Map processedObjects, ObjectLevelReadQuery query, DistributedSession session)` INTERNAL: We are not using a remote valueholder so we need to replace the reference object(s) with the corresponding object(s) from the remote session.
`protected Expression`	`getAdditionalFieldsBaseExpression(ReadQuery query)` INTERNAL: Return the base expression to use for adding fields to the query.
`org.eclipse.persistence.internal.queries.ContainerPolicy`	`getContainerPolicy()` INTERNAL: Returns the receiver's containerPolicy.
`protected ModifyQuery`	`getDeleteAllQuery()`
`Expression`	`getJoinCriteria(org.eclipse.persistence.internal.expressions.ObjectExpression context, Expression base)` INTERNAL: Returns the join criteria stored in the mapping selection query.
`org.eclipse.persistence.internal.helper.DatabaseField`	`getListOrderField()` PUBLIC: Field holds the order of elements in the list in the db, requires collection of type List; may be not null only in case isListOrderFieldSupported==true.
`java.lang.Object`	`getObjectCorrespondingTo(java.lang.Object object, DistributedSession session, java.util.Map objectDescriptors, java.util.Map processedObjects, ObjectLevelReadQuery query)` INTERNAL: return the object on the client corresponding to the specified object.
`java.util.List<Expression>`	`getOrderByQueryKeyExpressions()` INTERNAL: Return the ordering query keys.
`OrderCorrectionType`	`getOrderCorrectionType()` PUBLIC: Specifies what should be done if the list of values read from listOrserField is invalid (there should be no nulls, no duplicates, no "holes").
`java.lang.Object`	`getRealCollectionAttributeValueFromObject(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` Convenience method.
`protected org.eclipse.persistence.internal.queries.ContainerPolicy`	`getSelectionQueryContainerPolicy()` INTERNAL: Get the container policy from the selection query for this mapping.
`java.util.List<org.eclipse.persistence.internal.helper.DatabaseField>`	`getTargetPrimaryKeyFields()` INTERNAL: Returns list of primary key fields from the reference descriptor.
`protected boolean`	`hasCustomDeleteAllQuery()`
`boolean`	`hasOrderBy()` INTERNAL: Return true if ascending or descending ordering has been set on this mapping via the @OrderBy annotation.
`void`	`initialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initialize the state of mapping.
`protected void`	`initializeChangeOrderTargetQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initialize changeOrderTargetQuery.
`protected void`	`initializeListOrderField(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initializes listOrderField.
`protected void`	`initializeListOrderFieldTable(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initializes listOrderField's table, does nothing by default.
`boolean`	`isAttributeValueInstantiatedOrChanged(java.lang.Object object)` INTERNAL: The referenced object is checked if it is instantiated or not, also check if it has been changed (as indirect collections avoid instantiation on add/remove.
`boolean`	`isChangeTrackingSupported(Project project)` INTERNAL: Return if this mapping supports change tracking.
`boolean`	`isCollectionMapping()` INTERNAL: Return whether this mapping is a Collection type.
`boolean`	`isListOrderFieldSupported()` PUBLIC: indicates whether the mapping supports listOrderField, if it doesn't attempt to set listOrderField throws exception.
`boolean`	`isMapKeyObjectRelationship()` INTERNAL: Return if this mapping has a mapped key that uses a OneToOne (object).
`void`	`iterateOnElement(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, java.lang.Object element)` INTERNAL: Iterate on the specified element.
`void`	`iterateOnRealAttributeValue(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, java.lang.Object realAttributeValue)` INTERNAL: Iterate on the attribute value.
`void`	`load(java.lang.Object object, org.eclipse.persistence.internal.queries.AttributeItem item, org.eclipse.persistence.internal.sessions.AbstractSession session, boolean fromFetchGroup)` Force instantiation of the load group.
`void`	`loadAll(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session, org.eclipse.persistence.internal.helper.IdentityHashSet loaded)` Force instantiation of all indirections.
`void`	`mergeChangesIntoObject(java.lang.Object target, org.eclipse.persistence.internal.sessions.ChangeRecord chgRecord, java.lang.Object source, org.eclipse.persistence.internal.sessions.MergeManager mergeManager, org.eclipse.persistence.internal.sessions.AbstractSession targetSession)` INTERNAL: Merge changes from the source to the target object.
`void`	`mergeIntoObject(java.lang.Object target, boolean isTargetUnInitialized, java.lang.Object source, org.eclipse.persistence.internal.sessions.MergeManager mergeManager, org.eclipse.persistence.internal.sessions.AbstractSession targetSession)` INTERNAL: Merge changes from the source to the target object.
`boolean`	`mustDeleteReferenceObjectsOneByOne()` ADVANCED: Return whether the reference objects must be deleted one by one, as opposed to with a single DELETE statement.
`protected void`	`objectAddedDuringUpdate(ObjectLevelModifyQuery query, java.lang.Object objectAdded, org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, java.util.Map extraData)` INTERNAL: An object was added to the collection during an update, insert it if private.
`protected void`	`objectOrderChangedDuringUpdate(WriteObjectQuery query, java.lang.Object orderChangedObject, int orderIndex)`
`protected void`	`objectRemovedDuringUpdate(ObjectLevelModifyQuery query, java.lang.Object objectDeleted, java.util.Map extraData)` INTERNAL: An object was removed to the collection during an update, delete it if private.
`protected void`	`objectUnchangedDuringUpdate(ObjectLevelModifyQuery query, java.lang.Object object)` INTERNAL: An object is still in the collection, update it as it may have changed.
`protected void`	`objectUnchangedDuringUpdate(ObjectLevelModifyQuery query, java.lang.Object object, java.util.Map backupclones, java.lang.Object key)` INTERNAL: An object is still in the collection, update it as it may have changed.
`void`	`postCalculateChanges(ChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.
`void`	`postDelete(DeleteObjectQuery query)` INTERNAL: A subclass should implement this method if it wants different behavior.
`void`	`postInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Ensure the container policy is post initialized
`void`	`postInsert(WriteObjectQuery query)` INTERNAL: A subclass should implement this method if it wants different behavior.
`protected void`	`postPrepareNestedBatchQuery(ReadQuery batchQuery, ObjectLevelReadQuery query)` INTERNAL: Add additional fields
`void`	`preInsert(WriteObjectQuery query)` INTERNAL: Propagate preInsert event to container policy if necessary
`protected void`	`prepareTranslationRow(org.eclipse.persistence.internal.sessions.AbstractRecord translationRow, java.lang.Object object, ClassDescriptor descriptor, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: copies the non primary key information into the row currently used only in ManyToMany
`void`	`preUpdate(WriteObjectQuery query)` INTERNAL: Propagate preUpdate event to container policy if necessary
`protected java.lang.Object`	`readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery)` INTERNAL: All the privately owned parts are read
`void`	`recordPrivateOwnedRemovals(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.
`java.util.Map`	`replaceValueHoldersIn(java.lang.Object object, org.eclipse.persistence.internal.sessions.remote.RemoteSessionController controller)` INTERNAL: replace the value holders in the specified reference object(s)
`void`	`setChangeListener(java.lang.Object clone, java.beans.PropertyChangeListener listener, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Set the change listener in the collection.
`void`	`setContainerPolicy(org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy)` ADVANCED: Configure the mapping to use a container policy.
`void`	`setCustomDeleteAllQuery(ModifyQuery query)` PUBLIC: The default delete all query for mapping can be overridden by specifying the new query.
`void`	`setDeleteAllCall(Call call)` PUBLIC: Set the receiver's delete all call.
`protected void`	`setDeleteAllQuery(ModifyQuery query)`
`void`	`setDeleteAllSQLString(java.lang.String sqlString)` PUBLIC: Set the receiver's delete all SQL string.
`protected void`	`setHasCustomDeleteAllQuery(boolean bool)`
`void`	`setListOrderField(org.eclipse.persistence.internal.helper.DatabaseField field)` PUBLIC: Field holds the order of elements in the list in the db, requires collection of type List.
`void`	`setListOrderFieldName(java.lang.String fieldName)` PUBLIC: Field holds the order of elements in the list in the db, requires collection of type List.
`void`	`setMustDeleteReferenceObjectsOneByOne(java.lang.Boolean deleteOneByOne)` ADVANCED:: Return whether the reference objects must be deleted one by one, as opposed to with a single DELETE statement.
`void`	`setOrderCorrectionType(OrderCorrectionType orderCorrectionType)` PUBLIC: Specifies what should be done if the list of values read from listOrserField is invalid (there should be no nulls, no duplicates, no "holes").
`protected void`	`setSelectionQueryContainerPolicy(org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy)` INTERNAL: Set the container policy on the selection query for this mapping.
`void`	`setSessionName(java.lang.String name)` PUBLIC: Set the name of the session to execute the mapping's queries under.
`void`	`setUseLazyInstantiationForIndirectCollection(java.lang.Boolean useLazyInstantiation)` ADVANCED: Calling this method will only affect behavior of mappings using transparent indirection This method should only be called after this mapping's indirection policy has been set IndirectList and IndirectSet can be configured not to instantiate the list from the database when you add and remove from them.
`java.lang.Boolean`	`shouldUseLazyInstantiationForIndirectCollection()` ADVANCED: This method should only be called after this mapping's indirection policy has been set IndirectList and IndirectSet can be configured not to instantiate the list from the database when you add and remove from them.
`boolean`	`shouldUseListOrderFieldTableExpression()` INTERNAL: Indicates whether getListOrderFieldExpression method should create field expression based on table expression.
`void`	`simpleAddToCollectionChangeRecord(java.lang.Object referenceKey, java.lang.Object changeSetToAdd, org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, org.eclipse.persistence.internal.sessions.AbstractSession session)` ADVANCED: This method is used to have an object add to a collection once the changeSet is applied The referenceKey parameter should only be used for direct Maps.
`void`	`simpleRemoveFromCollectionChangeRecord(java.lang.Object referenceKey, java.lang.Object changeSetToRemove, org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, org.eclipse.persistence.internal.sessions.AbstractSession session)` ADVANCED: This method is used to have an object removed from a collection once the changeSet is applied The referenceKey parameter should only be used for direct Maps.
`void`	`updateChangeRecord(java.lang.Object clone, java.lang.Object newValue, java.lang.Object oldValue, org.eclipse.persistence.internal.sessions.ObjectChangeSet objectChangeSet, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Either create a new change record or update with the new value.
`void`	`updateChangeRecordForSelfMerge(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, java.lang.Object source, java.lang.Object target, org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet parentUOWChangeSet, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)` INTERNAL: Update a ChangeRecord to replace the ChangeSet for the old entity with the changeSet for the new Entity.
`void`	`updateCollectionChangeRecord(CollectionChangeEvent event, org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Add or removes a new value and its change set to the collection change record based on the event passed in.
`void`	`useCollectionClass(java.lang.Class concreteClass)` PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects.
`void`	`useCollectionClassName(java.lang.String concreteClassName)` INTERNAL: Used to set the collection class by name.
`void`	`useListClassName(java.lang.String concreteClassName)` INTERNAL: Used to set the collection class by name.
`void`	`useMapClass(java.lang.Class concreteClass)` PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects.
`void`	`useMapClass(java.lang.Class concreteClass, java.lang.String keyName)` PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects.
`void`	`useMapClassName(java.lang.String concreteClassName, java.lang.String methodName)` INTERNAL: Not sure were this is used, MW?
`void`	`useSortedSetClass(java.lang.Class concreteClass, java.util.Comparator comparator)` PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects.
`void`	`useSortedSetClassName(java.lang.String className)` INTERNAL: Configure the mapping to use an instance of the specified container class name to hold the target objects.
`void`	`useSortedSetClassName(java.lang.String className, java.lang.String comparatorClassName)` INTERNAL: Configure the mapping to use an instance of the specified container class name to hold the target objects.
`void`	`useTransparentCollection()` PUBLIC: If transparent indirection is used, a special collection will be placed in the source object's attribute.
`void`	`useTransparentList()` PUBLIC: If transparent indirection is used, a special collection will be placed in the source object's attribute.
`void`	`useTransparentMap(java.lang.String methodName)` PUBLIC: If transparent indirection is used, a special map will be placed in the source object's attribute.
`void`	`useTransparentSet()` PUBLIC: If transparent indirection is used, a special collection will be placed in the source object's attribute.
`void`	`validateBeforeInitialization(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: To validate mappings declaration
`java.lang.Object`	`valueFromPKList(java.lang.Object[] pks, org.eclipse.persistence.internal.sessions.AbstractRecord foreignKeys, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method is used to load a relationship from a list of PKs.
`protected java.lang.Object`	`valueFromRowInternalWithJoin(org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, org.eclipse.persistence.internal.sessions.AbstractSession executionSession, boolean isTargetProtected)` INTERNAL: Return the value of the field from the row or a value holder on the query to obtain the object.
`boolean`	`verifyDelete(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Checks if object is deleted from the database or not.
`void`	`writeChanges(org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, WriteObjectQuery query)` INTERNAL: Write the changes defined in the change set for the mapping.

Methods inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping
addForeignKeyField, addTargetForeignKeyField, batchedValueFromRow, buildBackupClone, buildBatchCriteria, buildClone, buildCloneFromRow, checkCacheForBatchKey, createCloneValueHolder, dontDoMerge, dontUseBatchReading, dontUseIndirection, extendPessimisticLockScopeInSourceQuery, extendPessimisticLockScopeInTargetQuery, extractBatchKeyFromRow, fixObjectReferences, getAttributeValueFromObject, getAttributeValueWithClonedValueHolders, getBatchFetchType, getExtendPessimisticLockScopeDedicatedQuery, getFieldsForTranslationInAggregate, getIndirectionPolicy, getJoinFetch, getMappedBy, getOrderByNormalizedExpressions, getPartitioningPolicy, getPartitioningPolicyName, getRealAttributeValueFromAttribute, getReferenceClass, getReferenceClassName, getReferenceDescriptor, getRelationshipPartner, getRelationshipPartnerAttributeName, getSelectionCriteria, getSelectionQuery, getTempSession, getValueFromRemoteValueHolder, hasCustomSelectionQuery, hasDependency, hasNestedIdentityReference, initializeReferenceDescriptor, initializeSelectionQuery, instantiateAttribute, isAttributeValueFromObjectInstantiated, isAttributeValueFullyBuilt, isAttributeValueInstantiated, isCascadeDetach, isCascadeMerge, isCascadeOnDeleteSetOnDatabase, isCascadePersist, isCascadeRefresh, isCascadeRemove, isExtendingPessimisticLockScope, isForeignReferenceMapping, isInnerJoinFetched, isJoinFetched, isJoiningSupported, isLazy, isLockableMapping, isOuterJoinFetched, isPrivateOwned, iterate, mergeRemoteValueHolder, preInitialize, prepareHistoricalQuery, prepareNestedBatchQuery, prepareNestedJoinQueryClone, prepareNestedJoins, privateOwnedRelationship, readFromRowIntoObject, remoteInitialization, requiresTransientWeavedFields, setBatchFetchType, setCascadeAll, setCascadeDetach, setCascadeMerge, setCascadePersist, setCascadeRefresh, setCascadeRemove, setCustomSelectionQuery, setForceInitializationOfSelectionCriteria, setHasCustomSelectionQuery, setIndirectionPolicy, setIsCacheable, setIsCascadeOnDeleteSetOnDatabase, setIsPrivateOwned, setJoinFetch, setMappedBy, setPartitioningPolicy, setPartitioningPolicyName, setRealAttributeValueInObject, setReferenceClass, setReferenceClassName, setReferenceDescriptor, setRelationshipPartner, setRelationshipPartnerAttributeName, setRequiresTransientWeavedFields, setSelectionCall, setSelectionCriteria, setSelectionQuery, setSelectionSQLString, setShouldExtendPessimisticLockScope, setTempSession, setUsesBatchReading, setUsesIndirection, shouldExtendPessimisticLockScope, shouldExtendPessimisticLockScopeInDedicatedQuery, shouldExtendPessimisticLockScopeInSourceQuery, shouldExtendPessimisticLockScopeInTargetQuery, shouldForceInitializationOfSelectionCriteria, shouldInitializeSelectionCriteria, shouldMergeCascadeParts, shouldMergeCascadeReference, shouldObjectModifyCascadeToParts, shouldRefreshCascadeParts, shouldUseBatchReading, shouldUseValueFromRowWithJoin, trimRowForJoin, trimRowForJoin, useBasicIndirection, useBatchReading, useContainerIndirection, useInnerJoinFetch, useOuterJoinFetch, usesIndirection, useWeavedIndirection, valueFromRow, valueFromRowInternal, valueFromRowInternal

Methods inherited from class org.eclipse.persistence.mappings.DatabaseMapping
addUnconvertedProperty, buildExpression, buildObjectJoinExpression, buildObjectJoinExpression, buildShallowOriginalFromRow, cloneFields, collectFields, convertConverterClassNamesToClasses, derivesId, earlyPreDelete, extractNestedExpressions, getAttributeAccessor, getAttributeClassification, getAttributeName, getDerivedIdMapping, getDescriptor, getField, getFieldClassification, getFields, getGetMethodName, getMapsIdValue, getProperties, getProperty, getRealAttributeValueFromObject, getSelectFields, getSelectTables, getSetMethodName, getUnconvertedProperties, getWeight, hasConstraintDependency, hasInverseConstraintDependency, hasMapsIdValue, hasRootExpressionThatShouldUseOuterJoin, hasUnconvertedProperties, isAbstractColumnMapping, isAbstractCompositeCollectionMapping, isAbstractCompositeDirectCollectionMapping, isAbstractCompositeObjectMapping, isAbstractDirectMapping, isAggregateCollectionMapping, isAggregateMapping, isAggregateObjectMapping, isCacheable, isCandidateForPrivateOwnedRemoval, isCascadedLockingSupported, isCloningRequired, isDatabaseMapping, isDirectCollectionMapping, isDirectMapMapping, isDirectToFieldMapping, isDirectToXMLTypeMapping, isEISMapping, isElementCollectionMapping, isInAndOutSopObject, isInOnlySopObject, isInSopObject, isJPAId, isManyToManyMapping, isManyToOneMapping, isMapKeyMapping, isMultitenantPrimaryKeyMapping, isNestedTableMapping, isObjectReferenceMapping, isOneToManyMapping, isOneToOneMapping, isOptional, isOutOnlySopObject, isOutSopObject, isOwned, isPrimaryKeyMapping, isReadOnly, isReferenceMapping, isRelationalMapping, isRemotelyInitialized, isStructureMapping, isTransformationMapping, isUnidirectionalOneToManyMapping, isUsingMethodAccess, isVariableOneToOneMapping, isWriteOnly, isXMLMapping, performDataModificationEvent, postCalculateChangesOnDeleted, postUpdate, preDelete, prepareCascadeLockingPolicy, readFromResultSetIntoObject, readOnly, readWrite, rehashFieldDependancies, remotelyInitialized, setAttributeAccessor, setAttributeName, setAttributeValueInObject, setDerivedIdMapping, setDerivesId, setDescriptor, setFields, setGetMethodName, setIsInAndOutSopObject, setIsInSopObject, setIsJPAId, setIsLazy, setIsMapKeyMapping, setIsOptional, setIsOutSopObject, setIsPrimaryKeyMapping, setIsReadOnly, setMapsIdValue, setProperties, setProperty, setSetMethodName, setWeight, toString, validateAfterInitialization, valueFromObject, valueFromResultSet, valueFromRow, writeFromAttributeIntoRow, writeFromObjectIntoRow, writeFromObjectIntoRowForShallowInsert, writeFromObjectIntoRowForShallowInsertWithChangeRecord, writeFromObjectIntoRowForUpdate, writeFromObjectIntoRowForUpdateAfterShallowInsert, writeFromObjectIntoRowForUpdateBeforeShallowDelete, writeFromObjectIntoRowForWhereClause, writeFromObjectIntoRowWithChangeRecord, writeInsertFieldsIntoRow, writeUpdateFieldsIntoRow

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

- Field Detail
  - deleteAllQuery
```
protected transient ModifyQuery deleteAllQuery
```
    Used for delete all in m-m, dc and delete all optimization in 1-m.
  - hasCustomDeleteAllQuery
```
protected transient boolean hasCustomDeleteAllQuery
```
  - containerPolicy
```
protected org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
  - hasOrderBy
```
protected boolean hasOrderBy
```
  - listOrderField
```
protected org.eclipse.persistence.internal.helper.DatabaseField listOrderField
```
    Field holds the order of elements in the list in the db, requires collection of type List, may be not null only in case isListOrderFieldSupported==true
  - isListOrderFieldSupported
```
protected boolean isListOrderFieldSupported
```
    Indicates whether the mapping supports listOrderField, if it doesn't attempt to set listOrderField throws exception.
  - changeOrderTargetQuery
```
protected transient DataModifyQuery changeOrderTargetQuery
```
    Query used when order of list members is changed. Used only if listOrderField!=null
  - orderCorrectionType
```
protected OrderCorrectionType orderCorrectionType
```
    Specifies what should be done if the list of values read from listOrserField is invalid (there should be no nulls, no duplicates, no "holes").
  - mustDeleteReferenceObjectsOneByOne
```
protected java.lang.Boolean mustDeleteReferenceObjectsOneByOne
```
    Store if the mapping can batch delete reference objects.
  - isSynchronizeOnMerge
```
protected static boolean isSynchronizeOnMerge
```
    Flag to indicate if collection needs to be synchronized instead of cloning during merge.
- Constructor Detail
  - CollectionMapping
```
public CollectionMapping()
```
    PUBLIC: Default constructor.
- Method Detail
  - addAscendingOrdering
```
public void addAscendingOrdering(java.lang.String queryKeyName)
```
    PUBLIC: Provide order support for queryKeyName in ascending order
  - addDescendingOrdering
```
public void addDescendingOrdering(java.lang.String queryKeyName)
```
    PUBLIC: Provide order support for queryKeyName in descending order.
  - addOrderBy
```
public void addOrderBy(java.lang.String queryKeyName,
              boolean isDescending)
```
    PUBLIC: Provide order support for queryKeyName in descending or ascending order. Called from the jpa metadata processing of an order by value.
  - addAggregateOrderBy
```
public void addAggregateOrderBy(java.lang.String aggregateName,
                       java.lang.String queryKeyName,
                       boolean isDescending)
```
    PUBLIC: Provide order support for queryKeyName in ascending or descending order. Called from the jpa metadata processing of an order by value. The aggregate name may be chained through the dot notation.
  - buildBackupCloneForPartObject
```
public java.lang.Object buildBackupCloneForPartObject(java.lang.Object attributeValue,
                                             java.lang.Object clone,
                                             java.lang.Object backup,
                                             org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)
```
    INTERNAL: Used during building the backup shallow copy to copy the vector without re-registering the target objects.
    
    Specified by:
    
    buildBackupCloneForPartObject in class ForeignReferenceMapping
  - buildCloneForPartObject
```
public java.lang.Object buildCloneForPartObject(java.lang.Object attributeValue,
                                       java.lang.Object original,
                                       org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey,
                                       java.lang.Object clone,
                                       org.eclipse.persistence.internal.sessions.AbstractSession cloningSession,
                                       java.lang.Integer refreshCascade,
                                       boolean isExisting,
                                       boolean isFromSharedCache)
```
    INTERNAL: Require for cloning, the part must be cloned. Ignore the objects, use the attribute value.
    
    Specified by:
    
    buildCloneForPartObject in class ForeignReferenceMapping
  - buildContainerClone
```
public java.lang.Object buildContainerClone(java.lang.Object attributeValue,
                                   org.eclipse.persistence.internal.sessions.AbstractSession cloningSession)
```
    INTERNAL: Performs a first level clone of the attribute. This generally means on the container will be cloned.
    
    Overrides:
    
    buildContainerClone in class DatabaseMapping
  - buildCopy
```
public void buildCopy(java.lang.Object copy,
             java.lang.Object original,
             CopyGroup group)
```
    INTERNAL: Copy of the attribute of the object. This is NOT used for unit of work but for templatizing an object.
    
    Overrides:
    
    buildCopy in class DatabaseMapping
  - copyElement
```
protected java.lang.Object copyElement(java.lang.Object original,
                           CopyGroup group)
```
    INTERNAL: Copies member's value
  - buildElementUnitOfWorkClone
```
public java.lang.Object buildElementUnitOfWorkClone(java.lang.Object element,
                                           java.lang.Object parent,
                                           java.lang.Integer refreshCascade,
                                           org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork,
                                           boolean isExisting,
                                           boolean isFromSharedCache)
```
    INTERNAL: Clone the element, if necessary.
  - buildElementClone
```
public java.lang.Object buildElementClone(java.lang.Object element,
                                 java.lang.Object parent,
                                 org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                                 java.lang.Integer refreshCascade,
                                 org.eclipse.persistence.internal.sessions.AbstractSession cloningSession,
                                 boolean isExisting,
                                 boolean isFromSharedCache)
```
    INTERNAL: Clone the element, if necessary.
  - buildReferencesPKList
```
public java.lang.Object[] buildReferencesPKList(java.lang.Object entity,
                                       java.lang.Object attribute,
                                       org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: This method will access the target relationship and create a list of information to rebuild the relationship. This method is used in combination with the CachedValueHolder to store references to PK's to be loaded from a cache instead of a query.
    
    Specified by:
    
    buildReferencesPKList in class ForeignReferenceMapping
  - cascadePerformRemoveIfRequired
```
public void cascadePerformRemoveIfRequired(java.lang.Object object,
                                  org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                  java.util.Map visitedObjects)
```
    INTERNAL: Cascade perform delete through mappings that require the cascade
    
    Specified by:
    
    cascadePerformRemoveIfRequired in class DatabaseMapping
  - cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired
```
public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(java.lang.Object object,
                                                                 org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                                                 java.util.Map visitedObjects)
```
    INTERNAL: Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet
    
    Overrides:
    
    cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired in class DatabaseMapping
  - cascadeDiscoverAndPersistUnregisteredNewObjects
```
public void cascadeDiscoverAndPersistUnregisteredNewObjects(java.lang.Object object,
                                                   java.util.Map newObjects,
                                                   java.util.Map unregisteredExistingObjects,
                                                   java.util.Map visitedObjects,
                                                   org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                                   java.util.Set cascadeErrors)
```
    INTERNAL: Cascade discover and persist new objects during commit.
    
    Overrides:
    
    cascadeDiscoverAndPersistUnregisteredNewObjects in class DatabaseMapping
  - cascadeRegisterNewIfRequired
```
public void cascadeRegisterNewIfRequired(java.lang.Object object,
                                org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                java.util.Map visitedObjects)
```
    INTERNAL: Cascade registerNew for Create through mappings that require the cascade
    
    Specified by:
    
    cascadeRegisterNewIfRequired in class DatabaseMapping
  - collectQueryParameters
```
public void collectQueryParameters(java.util.Set<org.eclipse.persistence.internal.helper.DatabaseField> record)
```
    INTERNAL: This method is used to store the FK fields that can be cached that correspond to noncacheable mappings the FK field values will be used to re-issue the query when cloning the shared cache entity
    
    Specified by:
    
    collectQueryParameters in class ForeignReferenceMapping
  - calculateDeferredChanges
```
public void calculateDeferredChanges(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                            org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Used by AttributeLevelChangeTracking to update a changeRecord with calculated changes as apposed to detected changes. If an attribute can not be change tracked it's changes can be detected through this process.
    
    Overrides:
    
    calculateDeferredChanges in class DatabaseMapping
  - clone
```
public java.lang.Object clone()
```
    INTERNAL: The mapping clones itself to create deep copy.
    
    Overrides:
    
    clone in class ForeignReferenceMapping
  - compareCollectionsForChange
```
public void compareCollectionsForChange(java.lang.Object oldCollection,
                               java.lang.Object newCollection,
                               org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                               org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: This method is used to calculate the differences between two collections.
  - compareForChange
```
public org.eclipse.persistence.internal.sessions.ChangeRecord compareForChange(java.lang.Object clone,
                                                                      java.lang.Object backUp,
                                                                      org.eclipse.persistence.internal.sessions.ObjectChangeSet owner,
                                                                      org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: This method is used to create a change record from comparing two collections.
    
    Specified by:
    
    compareForChange in class DatabaseMapping
    
    Returns:
    prototype.changeset.ChangeRecord
  - compareObjects
```
public boolean compareObjects(java.lang.Object firstObject,
                     java.lang.Object secondObject,
                     org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Compare the attributes belonging to this mapping for the objects.
    
    Overrides:
    
    compareObjects in class ForeignReferenceMapping
  - writeChanges
```
public void writeChanges(org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet,
                WriteObjectQuery query)
                  throws DatabaseException,
                         OptimisticLockException
```
    INTERNAL: Write the changes defined in the change set for the mapping. Mapping added or removed events are raised to allow the mapping to write the changes as required.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - compareObjectsAndWrite
```
protected void compareObjectsAndWrite(WriteObjectQuery query)
                               throws DatabaseException,
                                      OptimisticLockException
```
    INTERNAL: The memory objects are compared and only the changes are written to the database.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - compareListsAndWrite
```
protected void compareListsAndWrite(java.util.List previousList,
                        java.util.List currentList,
                        WriteObjectQuery query)
                             throws DatabaseException,
                                    OptimisticLockException
```
    INTERNAL: Old and new lists are compared and only the changes are written to the database. Currently there's no support for listOrderField in CollectionMapping in case there's no change sets, so this method currently never called (currently only overriding method in AggregateCollectionMapping is called). This method should be implemented to support listOrderField functionality without change sets.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - compareObjectsWithoutPrivateOwned
```
protected boolean compareObjectsWithoutPrivateOwned(java.lang.Object firstCollection,
                                        java.lang.Object secondCollection,
                                        org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    Compare two objects if their parts are not private owned
    
    Specified by:
    
    compareObjectsWithoutPrivateOwned in class ForeignReferenceMapping
  - compareObjectsWithPrivateOwned
```
protected boolean compareObjectsWithPrivateOwned(java.lang.Object firstCollection,
                                     java.lang.Object secondCollection,
                                     org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    Compare two objects if their parts are private owned
    
    Specified by:
    
    compareObjectsWithPrivateOwned in class ForeignReferenceMapping
  - compareLists
```
protected boolean compareLists(java.util.List firstList,
                   java.util.List secondList,
                   org.eclipse.persistence.internal.sessions.AbstractSession session,
                   boolean withPrivateOwned)
```
    Compare two lists. For equality the order of the elements should be the same. Used only if listOrderField != null
  - convertClassNamesToClasses
```
public void convertClassNamesToClasses(java.lang.ClassLoader classLoader)
```
    INTERNAL: Convert all the class-name-based settings in this mapping to actual class-based settings This method is implemented by subclasses as necessary.
    
    Overrides:
    
    convertClassNamesToClasses in class ForeignReferenceMapping
    
    Parameters:
    classLoader -
  - extractResultFromBatchQuery
```
public java.lang.Object extractResultFromBatchQuery(ReadQuery batchQuery,
                                           org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                                           org.eclipse.persistence.internal.sessions.AbstractRecord sourceRow,
                                           org.eclipse.persistence.internal.sessions.AbstractSession session,
                                           ObjectLevelReadQuery originalQuery)
                                             throws QueryException
```
    INTERNAL: Extract the value from the batch optimized query, this should be supported by most query types.
    
    Overrides:
    
    extractResultFromBatchQuery in class ForeignReferenceMapping
    
    Throws:
    
    QueryException
  - executeBatchQuery
```
protected void executeBatchQuery(DatabaseQuery query,
                     org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                     java.util.Map referenceObjectsByKey,
                     org.eclipse.persistence.internal.sessions.AbstractSession session,
                     org.eclipse.persistence.internal.sessions.AbstractRecord translationRow)
```
    INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.
    
    Overrides:
    
    executeBatchQuery in class ForeignReferenceMapping
  - extractKeyFromTargetRow
```
protected java.lang.Object extractKeyFromTargetRow(org.eclipse.persistence.internal.sessions.AbstractRecord row,
                                       org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Extract the source primary key value from the target row. Used for batch reading, most following same order and fields as in the mapping. The method should be overridden by classes that support batch reading.
  - fixRealObjectReferences
```
public void fixRealObjectReferences(java.lang.Object object,
                           java.util.Map objectDescriptors,
                           java.util.Map processedObjects,
                           ObjectLevelReadQuery query,
                           DistributedSession session)
```
    INTERNAL: We are not using a remote valueholder so we need to replace the reference object(s) with the corresponding object(s) from the remote session.
    
    Overrides:
    
    fixRealObjectReferences in class DatabaseMapping
  - getContainerPolicy
```
public org.eclipse.persistence.internal.queries.ContainerPolicy getContainerPolicy()
```
    INTERNAL: Returns the receiver's containerPolicy.
    
    Specified by:
    
    getContainerPolicy in interface ContainerMapping
    
    Overrides:
    
    getContainerPolicy in class DatabaseMapping
  - getDeleteAllQuery
```
protected ModifyQuery getDeleteAllQuery()
```
  - getJoinCriteria
```
public Expression getJoinCriteria(org.eclipse.persistence.internal.expressions.ObjectExpression context,
                         Expression base)
```
    INTERNAL: Returns the join criteria stored in the mapping selection query. This criteria is used to read reference objects across the tables from the database.
    
    Overrides:
    
    getJoinCriteria in class ForeignReferenceMapping
  - getObjectCorrespondingTo
```
public java.lang.Object getObjectCorrespondingTo(java.lang.Object object,
                                        DistributedSession session,
                                        java.util.Map objectDescriptors,
                                        java.util.Map processedObjects,
                                        ObjectLevelReadQuery query)
```
    INTERNAL: return the object on the client corresponding to the specified object. CollectionMappings have to worry about maintaining object identity.
    
    Overrides:
    
    getObjectCorrespondingTo in class ForeignReferenceMapping
  - getOrderByQueryKeyExpressions
```
public java.util.List<Expression> getOrderByQueryKeyExpressions()
```
    INTERNAL: Return the ordering query keys. Used for Workbench integration.
  - getSelectionQueryContainerPolicy
```
protected org.eclipse.persistence.internal.queries.ContainerPolicy getSelectionQueryContainerPolicy()
```
    INTERNAL: Get the container policy from the selection query for this mapping. This method is overridden in DirectCollectionMapping since its selection query is a DataReadQuery.
  - getRealCollectionAttributeValueFromObject
```
public java.lang.Object getRealCollectionAttributeValueFromObject(java.lang.Object object,
                                                         org.eclipse.persistence.internal.sessions.AbstractSession session)
                                                           throws DescriptorException
```
    Convenience method. Return the value of an attribute, unwrapping value holders if necessary. If the value is null, build a new container.
    
    Overrides:
    
    getRealCollectionAttributeValueFromObject in class DatabaseMapping
    
    Throws:
    
    DescriptorException
  - getListOrderField
```
public org.eclipse.persistence.internal.helper.DatabaseField getListOrderField()
```
    PUBLIC: Field holds the order of elements in the list in the db, requires collection of type List; may be not null only in case isListOrderFieldSupported==true.
  - getTargetPrimaryKeyFields
```
public java.util.List<org.eclipse.persistence.internal.helper.DatabaseField> getTargetPrimaryKeyFields()
```
    INTERNAL: Returns list of primary key fields from the reference descriptor.
  - getOrderCorrectionType
```
public OrderCorrectionType getOrderCorrectionType()
```
    PUBLIC: Specifies what should be done if the list of values read from listOrserField is invalid (there should be no nulls, no duplicates, no "holes").
  - hasCustomDeleteAllQuery
```
protected boolean hasCustomDeleteAllQuery()
```
  - hasOrderBy
```
public boolean hasOrderBy()
```
    INTERNAL: Return true if ascending or descending ordering has been set on this mapping via the @OrderBy annotation.
  - initialize
```
public void initialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
                throws DescriptorException
```
    INTERNAL: Initialize the state of mapping.
    
    Overrides:
    
    initialize in class ForeignReferenceMapping
    
    Throws:
    
    DescriptorException
  - initializeListOrderField
```
protected void initializeListOrderField(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Initializes listOrderField. Precondition: listOrderField != null.
  - initializeListOrderFieldTable
```
protected void initializeListOrderFieldTable(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Initializes listOrderField's table, does nothing by default. Precondition: listOrderField != null.
  - buildListOrderField
```
protected void buildListOrderField()
```
    INTERNAL: Verifies listOrderField's table, if none found sets the default one. Precondition: listOrderField != null.
  - shouldUseLazyInstantiationForIndirectCollection
```
public java.lang.Boolean shouldUseLazyInstantiationForIndirectCollection()
```
    ADVANCED: This method should only be called after this mapping's indirection policy has been set IndirectList and IndirectSet can be configured not to instantiate the list from the database when you add and remove from them. IndirectList defaults to this behavior. When Set to true, the collection associated with this TransparentIndirection will be setup so as not to instantiate for adds and removes. The weakness of this setting for an IndirectSet is that when the set is not instantiated, if a duplicate element is added, it will not be detected until commit time.
  - shouldUseListOrderFieldTableExpression
```
public boolean shouldUseListOrderFieldTableExpression()
```
    INTERNAL: Indicates whether getListOrderFieldExpression method should create field expression based on table expression.
  - initializeChangeOrderTargetQuery
```
protected void initializeChangeOrderTargetQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Initialize changeOrderTargetQuery.
  - isCollectionMapping
```
public boolean isCollectionMapping()
```
    INTERNAL: Return whether this mapping is a Collection type.
    
    Overrides:
    
    isCollectionMapping in class DatabaseMapping
  - isMapKeyObjectRelationship
```
public boolean isMapKeyObjectRelationship()
```
    INTERNAL: Return if this mapping has a mapped key that uses a OneToOne (object).
  - isAttributeValueInstantiatedOrChanged
```
public boolean isAttributeValueInstantiatedOrChanged(java.lang.Object object)
```
    INTERNAL: The referenced object is checked if it is instantiated or not, also check if it has been changed (as indirect collections avoid instantiation on add/remove.
  - iterateOnElement
```
public void iterateOnElement(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator,
                    java.lang.Object element)
```
    INTERNAL: Iterate on the specified element.
  - iterateOnRealAttributeValue
```
public void iterateOnRealAttributeValue(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator,
                               java.lang.Object realAttributeValue)
```
    INTERNAL: Iterate on the attribute value. The value holder has already been processed.
    
    Specified by:
    
    iterateOnRealAttributeValue in class ForeignReferenceMapping
  - load
```
public void load(java.lang.Object object,
        org.eclipse.persistence.internal.queries.AttributeItem item,
        org.eclipse.persistence.internal.sessions.AbstractSession session,
        boolean fromFetchGroup)
```
    Force instantiation of the load group.
    
    Overrides:
    
    load in class ForeignReferenceMapping
  - loadAll
```
public void loadAll(java.lang.Object object,
           org.eclipse.persistence.internal.sessions.AbstractSession session,
           org.eclipse.persistence.internal.helper.IdentityHashSet loaded)
```
    Force instantiation of all indirections.
    
    Overrides:
    
    loadAll in class DatabaseMapping
  - mustDeleteReferenceObjectsOneByOne
```
public boolean mustDeleteReferenceObjectsOneByOne()
```
    ADVANCED: Return whether the reference objects must be deleted one by one, as opposed to with a single DELETE statement.
  - mergeChangesIntoObject
```
public void mergeChangesIntoObject(java.lang.Object target,
                          org.eclipse.persistence.internal.sessions.ChangeRecord chgRecord,
                          java.lang.Object source,
                          org.eclipse.persistence.internal.sessions.MergeManager mergeManager,
                          org.eclipse.persistence.internal.sessions.AbstractSession targetSession)
```
    INTERNAL: Merge changes from the source to the target object. Because this is a collection mapping, values are added to or removed from the collection based on the changeset
    
    Specified by:
    
    mergeChangesIntoObject in class DatabaseMapping
  - mergeIntoObject
```
public void mergeIntoObject(java.lang.Object target,
                   boolean isTargetUnInitialized,
                   java.lang.Object source,
                   org.eclipse.persistence.internal.sessions.MergeManager mergeManager,
                   org.eclipse.persistence.internal.sessions.AbstractSession targetSession)
```
    INTERNAL: Merge changes from the source to the target object. This merge is only called when a changeSet for the target does not exist or the target is uninitialized
    
    Specified by:
    
    mergeIntoObject in class DatabaseMapping
  - objectAddedDuringUpdate
```
protected void objectAddedDuringUpdate(ObjectLevelModifyQuery query,
                           java.lang.Object objectAdded,
                           org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet,
                           java.util.Map extraData)
                                throws DatabaseException,
                                       OptimisticLockException
```
    INTERNAL: An object was added to the collection during an update, insert it if private.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - objectOrderChangedDuringUpdate
```
protected void objectOrderChangedDuringUpdate(WriteObjectQuery query,
                                  java.lang.Object orderChangedObject,
                                  int orderIndex)
```
  - objectRemovedDuringUpdate
```
protected void objectRemovedDuringUpdate(ObjectLevelModifyQuery query,
                             java.lang.Object objectDeleted,
                             java.util.Map extraData)
                                  throws DatabaseException,
                                         OptimisticLockException
```
    INTERNAL: An object was removed to the collection during an update, delete it if private.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - objectUnchangedDuringUpdate
```
protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query,
                               java.lang.Object object)
                                    throws DatabaseException,
                                           OptimisticLockException
```
    INTERNAL: An object is still in the collection, update it as it may have changed.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - postCalculateChanges
```
public void postCalculateChanges(ChangeRecord changeRecord,
                        org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
    INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.
    
    Overrides:
    
    postCalculateChanges in class DatabaseMapping
  - recordPrivateOwnedRemovals
```
public void recordPrivateOwnedRemovals(java.lang.Object object,
                              org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
    INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.
    
    Overrides:
    
    recordPrivateOwnedRemovals in class DatabaseMapping
  - postPrepareNestedBatchQuery
```
protected void postPrepareNestedBatchQuery(ReadQuery batchQuery,
                               ObjectLevelReadQuery query)
```
    INTERNAL: Add additional fields
    
    Overrides:
    
    postPrepareNestedBatchQuery in class ForeignReferenceMapping
  - getAdditionalFieldsBaseExpression
```
protected Expression getAdditionalFieldsBaseExpression(ReadQuery query)
```
    INTERNAL: Return the base expression to use for adding fields to the query. Normally this is the query's builder, but may be the join table for m-m.
  - prepareTranslationRow
```
protected void prepareTranslationRow(org.eclipse.persistence.internal.sessions.AbstractRecord translationRow,
                         java.lang.Object object,
                         ClassDescriptor descriptor,
                         org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: copies the non primary key information into the row currently used only in ManyToMany
  - postDelete
```
public void postDelete(DeleteObjectQuery query)
                throws DatabaseException
```
    INTERNAL: A subclass should implement this method if it wants different behavior. Recurse thru the parts to delete the reference objects after the actual object is deleted.
    
    Overrides:
    
    postDelete in class DatabaseMapping
    
    Throws:
    
    DatabaseException
  - postInitialize
```
public void postInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Ensure the container policy is post initialized
    
    Overrides:
    
    postInitialize in class DatabaseMapping
  - postInsert
```
public void postInsert(WriteObjectQuery query)
                throws DatabaseException
```
    INTERNAL: A subclass should implement this method if it wants different behavior. Recurse thru the parts to delete the reference objects after the actual object is deleted.
    
    Overrides:
    
    postInsert in class DatabaseMapping
    
    Throws:
    
    DatabaseException
  - preInsert
```
public void preInsert(WriteObjectQuery query)
               throws DatabaseException,
                      OptimisticLockException
```
    INTERNAL: Propagate preInsert event to container policy if necessary
    
    Overrides:
    
    preInsert in class DatabaseMapping
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - preUpdate
```
public void preUpdate(WriteObjectQuery query)
               throws DatabaseException
```
    INTERNAL: Propagate preUpdate event to container policy if necessary
    
    Overrides:
    
    preUpdate in class DatabaseMapping
    
    Throws:
    
    DatabaseException
  - objectUnchangedDuringUpdate
```
protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query,
                               java.lang.Object object,
                               java.util.Map backupclones,
                               java.lang.Object key)
                                    throws DatabaseException,
                                           OptimisticLockException
```
    INTERNAL: An object is still in the collection, update it as it may have changed.
    
    Throws:
    
    DatabaseException
    
    OptimisticLockException
  - readPrivateOwnedForObject
```
protected java.lang.Object readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery)
                                              throws DatabaseException
```
    INTERNAL: All the privately owned parts are read
    
    Throws:
    
    DatabaseException
  - replaceValueHoldersIn
```
public java.util.Map replaceValueHoldersIn(java.lang.Object object,
                                  org.eclipse.persistence.internal.sessions.remote.RemoteSessionController controller)
```
    INTERNAL: replace the value holders in the specified reference object(s)
    
    Overrides:
    
    replaceValueHoldersIn in class ForeignReferenceMapping
  - setContainerPolicy
```
public void setContainerPolicy(org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy)
```
    ADVANCED: Configure the mapping to use a container policy. The policy manages the access to the collection.
    
    Specified by:
    
    setContainerPolicy in interface ContainerMapping
  - setCustomDeleteAllQuery
```
public void setCustomDeleteAllQuery(ModifyQuery query)
```
    PUBLIC: The default delete all query for mapping can be overridden by specifying the new query. This query is responsible for doing the deletion required by the mapping, such as deletion of all the rows from join table for M-M, or optimized delete all of target objects for 1-M.
  - setDeleteAllQuery
```
protected void setDeleteAllQuery(ModifyQuery query)
```
  - setDeleteAllSQLString
```
public void setDeleteAllSQLString(java.lang.String sqlString)
```
    PUBLIC: Set the receiver's delete all SQL string. This allows the user to override the SQL generated by TopLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. This SQL is responsible for doing the deletion required by the mapping, such as deletion of all the rows from join table for M-M, or optimized delete all of target objects for 1-M. Example, 'delete from PROJ_EMP where EMP_ID = #EMP_ID'.
  - setDeleteAllCall
```
public void setDeleteAllCall(Call call)
```
    PUBLIC: Set the receiver's delete all call. This allows the user to override the SQL generated by TopLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row. This call is responsible for doing the deletion required by the mapping, such as deletion of all the rows from join table for M-M, or optimized delete all of target objects for 1-M. Example, 'new SQLCall("delete from PROJ_EMP where EMP_ID = #EMP_ID")'.
  - setHasCustomDeleteAllQuery
```
protected void setHasCustomDeleteAllQuery(boolean bool)
```
  - setSelectionQueryContainerPolicy
```
protected void setSelectionQueryContainerPolicy(org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy)
```
    INTERNAL: Set the container policy on the selection query for this mapping. This method is overridden in DirectCollectionMapping since its selection query is a DataReadQuery.
  - setSessionName
```
public void setSessionName(java.lang.String name)
```
    PUBLIC: Set the name of the session to execute the mapping's queries under. This can be used by the session broker to override the default session to be used for the target class.
  - setUseLazyInstantiationForIndirectCollection
```
public void setUseLazyInstantiationForIndirectCollection(java.lang.Boolean useLazyInstantiation)
```
    ADVANCED: Calling this method will only affect behavior of mappings using transparent indirection This method should only be called after this mapping's indirection policy has been set IndirectList and IndirectSet can be configured not to instantiate the list from the database when you add and remove from them. IndirectList defaults to this behavior. When Set to true, the collection associated with this TransparentIndirection will be setup so as not to instantiate for adds and removes. The weakness of this setting for an IndirectSet is that when the set is not instantiated, if a duplicate element is added, it will not be detected until commit time.
  - simpleAddToCollectionChangeRecord
```
public void simpleAddToCollectionChangeRecord(java.lang.Object referenceKey,
                                     java.lang.Object changeSetToAdd,
                                     org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet,
                                     org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    ADVANCED: This method is used to have an object add to a collection once the changeSet is applied The referenceKey parameter should only be used for direct Maps.
    
    Overrides:
    
    simpleAddToCollectionChangeRecord in class DatabaseMapping
  - simpleRemoveFromCollectionChangeRecord
```
public void simpleRemoveFromCollectionChangeRecord(java.lang.Object referenceKey,
                                          java.lang.Object changeSetToRemove,
                                          org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet,
                                          org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    ADVANCED: This method is used to have an object removed from a collection once the changeSet is applied The referenceKey parameter should only be used for direct Maps.
    
    Overrides:
    
    simpleRemoveFromCollectionChangeRecord in class DatabaseMapping
  - updateChangeRecord
```
public void updateChangeRecord(java.lang.Object clone,
                      java.lang.Object newValue,
                      java.lang.Object oldValue,
                      org.eclipse.persistence.internal.sessions.ObjectChangeSet objectChangeSet,
                      org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
    INTERNAL: Either create a new change record or update with the new value. This is used by attribute change tracking. Specifically in a collection mapping this will be called when the customer Set a new collection. In this case we will need to mark the change record with the new and the old versions of the collection. And mark the ObjectChangeSet with the attribute name then when the changes are calculated force a compare on the collections to determine changes.
    
    Overrides:
    
    updateChangeRecord in class DatabaseMapping
  - updateChangeRecordForSelfMerge
```
public void updateChangeRecordForSelfMerge(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                                  java.lang.Object source,
                                  java.lang.Object target,
                                  org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet parentUOWChangeSet,
                                  org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)
```
    INTERNAL: Update a ChangeRecord to replace the ChangeSet for the old entity with the changeSet for the new Entity. This is used when an Entity is merged into itself and the Entity reference new or detached entities.
    
    Specified by:
    
    updateChangeRecordForSelfMerge in class ForeignReferenceMapping
  - updateCollectionChangeRecord
```
public void updateCollectionChangeRecord(CollectionChangeEvent event,
                                org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet,
                                org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
    INTERNAL: Add or removes a new value and its change set to the collection change record based on the event passed in. This is used by attribute change tracking.
    
    Overrides:
    
    updateCollectionChangeRecord in class DatabaseMapping
  - setChangeListener
```
public void setChangeListener(java.lang.Object clone,
                     java.beans.PropertyChangeListener listener,
                     org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
    INTERNAL: Set the change listener in the collection. If the collection is not indirect it must be re-built. This is used for resuming or flushing units of work.
    
    Overrides:
    
    setChangeListener in class DatabaseMapping
  - isListOrderFieldSupported
```
public boolean isListOrderFieldSupported()
```
    PUBLIC: indicates whether the mapping supports listOrderField, if it doesn't attempt to set listOrderField throws exception.
  - setListOrderField
```
public void setListOrderField(org.eclipse.persistence.internal.helper.DatabaseField field)
```
    PUBLIC: Field holds the order of elements in the list in the db, requires collection of type List. Throws exception if the mapping doesn't support listOrderField.
  - setListOrderFieldName
```
public void setListOrderFieldName(java.lang.String fieldName)
```
    PUBLIC: Field holds the order of elements in the list in the db, requires collection of type List. Throws exception if the mapping doesn't support listOrderField.
  - setMustDeleteReferenceObjectsOneByOne
```
public void setMustDeleteReferenceObjectsOneByOne(java.lang.Boolean deleteOneByOne)
```
    ADVANCED:: Return whether the reference objects must be deleted one by one, as opposed to with a single DELETE statement. Note: Calling this method disables an optimization of the delete behavior
  - setOrderCorrectionType
```
public void setOrderCorrectionType(OrderCorrectionType orderCorrectionType)
```
    PUBLIC: Specifies what should be done if the list of values read from listOrserField is invalid (there should be no nulls, no duplicates, no "holes").
  - useCollectionClass
```
public void useCollectionClass(java.lang.Class concreteClass)
```
    PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects. Note that if listOrderField is used then setListOrderField method should be called before this method.
    The container class must implement (directly or indirectly) the java.util.Collection interface.
    
    Specified by:
    
    useCollectionClass in interface ContainerMapping
  - useSortedSetClass
```
public void useSortedSetClass(java.lang.Class concreteClass,
                     java.util.Comparator comparator)
```
    PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects.
    The container class must implement (directly or indirectly) the java.util.SortedSet interface.
  - useSortedSetClassName
```
public void useSortedSetClassName(java.lang.String className)
```
    INTERNAL: Configure the mapping to use an instance of the specified container class name to hold the target objects. This method is used by MW.
    The container class must implement (directly or indirectly) the java.util.SortedSet interface.
  - useSortedSetClassName
```
public void useSortedSetClassName(java.lang.String className,
                         java.lang.String comparatorClassName)
```
    INTERNAL: Configure the mapping to use an instance of the specified container class name to hold the target objects. This method is used by MW.
    The container class must implement (directly or indirectly) the java.util.SortedSet interface.
  - useCollectionClassName
```
public void useCollectionClassName(java.lang.String concreteClassName)
```
    INTERNAL: Used to set the collection class by name. This is required when building from metadata to allow the correct class loader to be used.
    
    Specified by:
    
    useCollectionClassName in interface ContainerMapping
  - useListClassName
```
public void useListClassName(java.lang.String concreteClassName)
```
    INTERNAL: Used to set the collection class by name. This is required when building from metadata to allow the correct class loader to be used.
    
    Specified by:
    
    useListClassName in interface ContainerMapping
  - useMapClass
```
public void useMapClass(java.lang.Class concreteClass,
               java.lang.String keyName)
```
    PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects. The key used to index a value in the Map is the value returned by a call to the specified zero-argument method. The method must be implemented by the class (or a superclass) of any value to be inserted into the Map.
    The container class must implement (directly or indirectly) the java.util.Map interface.
    To facilitate resolving the method, the mapping's referenceClass must set before calling this method.
    
    Specified by:
    
    useMapClass in interface ContainerMapping
  - useMapClass
```
public void useMapClass(java.lang.Class concreteClass)
```
    PUBLIC: Configure the mapping to use an instance of the specified container class to hold the target objects. The key used to index a value in the Map is an instance of the composite primary key class.
    To facilitate resolving the primary key class, the mapping's referenceClass must set before calling this method.
    The container class must implement (directly or indirectly) the java.util.Map interface.
  - useMapClassName
```
public void useMapClassName(java.lang.String concreteClassName,
                   java.lang.String methodName)
```
    INTERNAL: Not sure were this is used, MW?
    
    Specified by:
    
    useMapClassName in interface ContainerMapping
  - useTransparentCollection
```
public void useTransparentCollection()
```
    PUBLIC: If transparent indirection is used, a special collection will be placed in the source object's attribute. Fetching of the contents of the collection from the database will be delayed until absolutely necessary. (Any message sent to the collection will cause the contents to be faulted in from the database.) This can result in rather significant performance gains, without having to change the source object's attribute from Collection (or List or Vector) to ValueHolderInterface.
  - useTransparentSet
```
public void useTransparentSet()
```
    PUBLIC: If transparent indirection is used, a special collection will be placed in the source object's attribute. Fetching of the contents of the collection from the database will be delayed until absolutely necessary. (Any message sent to the collection will cause the contents to be faulted in from the database.) This can result in rather significant performance gains, without having to change the source object's attribute from Set to ValueHolderInterface.
  - useTransparentList
```
public void useTransparentList()
```
    PUBLIC: If transparent indirection is used, a special collection will be placed in the source object's attribute. Fetching of the contents of the collection from the database will be delayed until absolutely necessary. (Any message sent to the collection will cause the contents to be faulted in from the database.) This can result in rather significant performance gains, without having to change the source object's attribute from List to ValueHolderInterface.
  - useTransparentMap
```
public void useTransparentMap(java.lang.String methodName)
```
    PUBLIC: If transparent indirection is used, a special map will be placed in the source object's attribute. Fetching of the contents of the map from the database will be delayed until absolutely necessary. (Any message sent to the map will cause the contents to be faulted in from the database.) This can result in rather significant performance gains, without having to change the source object's attribute from Map (or Map or Hashtable) to ValueHolderInterface.
    The key used in the Map is the value returned by a call to the zero parameter method named methodName. The method should be a zero argument method implemented (or inherited) by the value to be inserted into the Map.
  - validateBeforeInitialization
```
public void validateBeforeInitialization(org.eclipse.persistence.internal.sessions.AbstractSession session)
                                  throws DescriptorException
```
    INTERNAL: To validate mappings declaration
    
    Overrides:
    
    validateBeforeInitialization in class ForeignReferenceMapping
    
    Throws:
    
    DescriptorException
  - verifyDelete
```
public boolean verifyDelete(java.lang.Object object,
                   org.eclipse.persistence.internal.sessions.AbstractSession session)
                     throws DatabaseException
```
    INTERNAL: Checks if object is deleted from the database or not.
    
    Overrides:
    
    verifyDelete in class DatabaseMapping
    
    Throws:
    
    DatabaseException
  - isChangeTrackingSupported
```
public boolean isChangeTrackingSupported(Project project)
```
    INTERNAL: Return if this mapping supports change tracking.
    
    Overrides:
    
    isChangeTrackingSupported in class DatabaseMapping
  - buildChangeRecord
```
public org.eclipse.persistence.internal.sessions.ChangeRecord buildChangeRecord(java.lang.Object clone,
                                                                       org.eclipse.persistence.internal.sessions.ObjectChangeSet owner,
                                                                       org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Directly build a change record without comparison
    
    Overrides:
    
    buildChangeRecord in class DatabaseMapping
  - valueFromPKList
```
public java.lang.Object valueFromPKList(java.lang.Object[] pks,
                               org.eclipse.persistence.internal.sessions.AbstractRecord foreignKeys,
                               org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: This method is used to load a relationship from a list of PKs. This list may be available if the relationship has been cached.
    
    Specified by:
    
    valueFromPKList in class ForeignReferenceMapping
  - valueFromRowInternalWithJoin
```
protected java.lang.Object valueFromRowInternalWithJoin(org.eclipse.persistence.internal.sessions.AbstractRecord row,
                                            org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager,
                                            ObjectBuildingQuery sourceQuery,
                                            org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                                            org.eclipse.persistence.internal.sessions.AbstractSession executionSession,
                                            boolean isTargetProtected)
                                                 throws DatabaseException
```
    INTERNAL: Return the value of the field from the row or a value holder on the query to obtain the object. To get here the mapping's isJoiningSupported() should return true.
    
    Overrides:
    
    valueFromRowInternalWithJoin in class ForeignReferenceMapping
    
    Throws:
    
    DatabaseException

Class CollectionMapping

Nested Class Summary

Nested classes/interfaces inherited from class org.eclipse.persistence.mappings.DatabaseMapping

Field Summary

Fields inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping

Fields inherited from class org.eclipse.persistence.mappings.DatabaseMapping

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping

Methods inherited from class org.eclipse.persistence.mappings.DatabaseMapping

Methods inherited from class java.lang.Object

Field Detail

deleteAllQuery

hasCustomDeleteAllQuery

containerPolicy

hasOrderBy

listOrderField

isListOrderFieldSupported

changeOrderTargetQuery

orderCorrectionType

mustDeleteReferenceObjectsOneByOne

isSynchronizeOnMerge

Constructor Detail

CollectionMapping

Method Detail

addAscendingOrdering

addDescendingOrdering

addOrderBy

addAggregateOrderBy

buildBackupCloneForPartObject

buildCloneForPartObject

buildContainerClone

buildCopy

copyElement

buildElementUnitOfWorkClone

buildElementClone

buildReferencesPKList

cascadePerformRemoveIfRequired

cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired

cascadeDiscoverAndPersistUnregisteredNewObjects

cascadeRegisterNewIfRequired

collectQueryParameters

calculateDeferredChanges

clone

compareCollectionsForChange

compareForChange

compareObjects

writeChanges

compareObjectsAndWrite

compareListsAndWrite

compareObjectsWithoutPrivateOwned

compareObjectsWithPrivateOwned

compareLists

convertClassNamesToClasses

extractResultFromBatchQuery

executeBatchQuery

extractKeyFromTargetRow

fixRealObjectReferences

getContainerPolicy

getDeleteAllQuery

getJoinCriteria

getObjectCorrespondingTo

getOrderByQueryKeyExpressions

getSelectionQueryContainerPolicy

getRealCollectionAttributeValueFromObject

getListOrderField

getTargetPrimaryKeyFields

getOrderCorrectionType

hasCustomDeleteAllQuery

hasOrderBy

initialize

initializeListOrderField

initializeListOrderFieldTable

buildListOrderField

shouldUseLazyInstantiationForIndirectCollection

shouldUseListOrderFieldTableExpression

initializeChangeOrderTargetQuery

isCollectionMapping

isMapKeyObjectRelationship

isAttributeValueInstantiatedOrChanged