AggregateCollectionMapping (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
      - org.eclipse.persistence.mappings.AggregateCollectionMapping

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, ContainerMapping, EmbeddableMapping, MapComponentMapping, RelationalMapping
```
public class AggregateCollectionMapping
extends CollectionMapping
implements RelationalMapping, MapComponentMapping, EmbeddableMapping
```
Purpose: The aggregate collection mapping is used to represent the aggregate relationship between a single source object and a collection of target objects. The target objects cannot exist without the existence of the source object (privately owned) Unlike the normal aggregate mapping, there is a target table being mapped from the target objects. Unlike normal 1:m mapping, there is no 1:1 back reference mapping, as foreign key constraints have been resolved by the aggregation.

See Also:
Serialized Form
Author:

King (Yaoping) Wang

Since:

TOPLink/Java 3.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 java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField>`	`aggregateToSourceFields` Map the name of a field in the aggregate collection descriptor to a field in the actual table specified in the mapping.
`protected static java.lang.String`	`bulk`
`protected DataModifyQuery`	`bulkUpdateListOrderFieldQuery`
`protected org.eclipse.persistence.internal.helper.DatabaseTable`	`defaultSourceTable` Default source table that should be used with the default source fields of this mapping.
`protected java.lang.Boolean`	`hasNestedIdentityReference` Indicates whether the mapping (or at least one of its nested mappings, at any nested depth) references an entity.
`protected boolean`	`isEntireObjectPK` Indicates whether the entire target object is primary key - in that case the object can't be updated in the db, but rather deleted and then re-inserted.
`protected boolean`	`isListOrderFieldUpdatable` indicates whether listOrderField value could be updated in the db.
`protected static java.lang.String`	`max`
`protected static java.lang.String`	`min`
`protected java.util.Map<java.lang.String,java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField>>`	`nestedAggregateToSourceFields` Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames that should be applied to this mapping.
`protected static java.lang.String`	`pk`
`protected DataModifyQuery`	`pkUpdateListOrderFieldQuery`
`protected ClassDescriptor`	`remoteReferenceDescriptor` In RemoteSession case the mapping needs the reference descriptor serialized from the server, but referenceDescriptor attribute defined as transient in the superclass.
`protected static java.lang.String`	`shift`
`protected java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`sourceKeyFields` This is a primary key in the source table that is used as foreign key in the target table
`protected java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`targetForeignKeyFields` This is a key in the target table which is a foreign key in the target table.
`protected java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField>`	`targetForeignKeyToSourceKeys` Foreign keys in the target table to the related keys in the source table
`protected DataModifyQuery`	`updateListOrderFieldQuery` These queries used to update listOrderField

Fields inherited from class org.eclipse.persistence.mappings.CollectionMapping
changeOrderTargetQuery, containerPolicy, deleteAllQuery, hasCustomDeleteAllQuery, hasOrderBy, isListOrderFieldSupported, isSynchronizeOnMerge, listOrderField, mustDeleteReferenceObjectsOneByOne, orderCorrectionType

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

AggregateCollectionMapping()
PUBLIC: Default constructor.

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

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addConverter(Converter converter, java.lang.String attributeName)` Add a converter to be applied to a mapping of the aggregate descriptor.
`void`	`addFieldNameTranslation(java.lang.String sourceFieldName, java.lang.String aggregateFieldName)` PUBLIC: Maps a field name in the aggregate descriptor to a field name in the source table.
`void`	`addFieldTranslation(org.eclipse.persistence.internal.helper.DatabaseField sourceField, java.lang.String aggregateField)` PUBLIC: Maps a field name in the aggregate descriptor to a field in the source table.
`void`	`addFieldTranslations(java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField> map)` PUBLIC: Maps a field name in the aggregate descriptor to a field name in the source table.
`void`	`addNestedFieldNameTranslation(java.lang.String attributeName, java.lang.String sourceFieldName, java.lang.String aggregateFieldName)` PUBLIC: Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames that should be applied to this mapping.
`void`	`addNestedFieldNameTranslations(java.lang.String attributeName, java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField> map)` PUBLIC: Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFields that should be applied to this mapping.
`void`	`addNestedFieldTranslation(java.lang.String attributeName, org.eclipse.persistence.internal.helper.DatabaseField sourceField, java.lang.String aggregateFieldName)` PUBLIC: Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames that should be applied to this mapping.
`void`	`addOverrideManyToManyMapping(ManyToManyMapping mapping)` INTERNAL: In JPA users may specify overrides to apply to a many to many mapping on a shared embeddable descriptor.
`void`	`addOverrideUnidirectionalOneToManyMapping(UnidirectionalOneToManyMapping mapping)` INTERNAL: In JPA users may specify overrides to apply to a unidirectional one to many mapping on a shared embeddable descriptor.
`void`	`addTargetForeignKeyField(org.eclipse.persistence.internal.helper.DatabaseField targetForeignKey, org.eclipse.persistence.internal.helper.DatabaseField sourceKey)` PUBLIC: Define the target foreign key relationship in the 1-M aggregate collection mapping.
`void`	`addTargetForeignKeyFieldName(java.lang.String targetForeignKey, java.lang.String sourceKey)` PUBLIC: Define the target foreign key relationship in the 1-M aggregate collection mapping.
`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.
`protected Expression`	`buildBatchCriteria(ExpressionBuilder builder, ObjectLevelReadQuery query)` INTERNAL: Return the selection criteria used to IN batch fetching.
`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.
`protected java.lang.Object`	`buildElementBackupClone(java.lang.Object element, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)` INTERNAL: Clone the aggregate collection, if necessary.
`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 aggregate collection, if necessary.
`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 registerNew for Create 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> cacheFields)` 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
`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 aggregate collections
`boolean`	`compareLists(java.util.List firstList, java.util.List secondList, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Compare the attributes belonging to this mapping for the objects.
`protected void`	`compareListsAndWrite_NonUpdatableListOrderField(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.
`protected void`	`compareListsAndWrite_UpdatableListOrderField(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.
`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.
`protected boolean`	`compareMapCollectionForChange(java.util.Map cloneObjectCollection, java.util.Map backUpCollection, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Determine if an AggregateCollection that is contained as a map has changed by comparing the values in the clone to the values in the backup.
`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 org.eclipse.persistence.internal.sessions.ChangeRecord`	`convertToChangeRecord(java.lang.Object cloneCollection, java.lang.Object backupCollection, org.eclipse.persistence.internal.sessions.ObjectChangeSet owner, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method is used to convert the contents of an aggregateCollection into a changeRecord
`protected java.lang.Object`	`copyElement(java.lang.Object original, CopyGroup group)` INTERNAL: Copies member's value
`java.lang.Object`	`createMapComponentFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord dbRow, ObjectBuildingQuery query, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, org.eclipse.persistence.internal.sessions.AbstractSession session, boolean isTargetProtected)` INTERNAL Called when a DatabaseMapping is used to map the key in a collection.
`protected void`	`deleteAll(DeleteObjectQuery query, org.eclipse.persistence.internal.sessions.AbstractSession session)` To delete all the entries matching the selection criteria from the table stored in the referenced descriptor
`protected void`	`executeEvent(int eventCode, ObjectLevelModifyQuery query)` INTERNAL: Execute a descriptor event for the specified event code.
`protected java.lang.Object`	`extractBatchKeyFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Extract the primary key value from the source row.
`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.
`org.eclipse.persistence.internal.sessions.AbstractRecord`	`getAggregateRow(ObjectLevelModifyQuery query, java.lang.Object object)` INTERNAL: return the aggregate Record with the primary keys from the source table and target table
`InsertObjectQuery`	`getAndPrepareModifyQueryForInsert(ObjectLevelModifyQuery originalQuery, java.lang.Object object)` INTERNAL: setup the modifyQuery for post insert/update and pre delete
`protected Expression`	`getDeleteAllCriteria(org.eclipse.persistence.internal.sessions.AbstractSession session)` Delete all criteria is created with target foreign keys and source keys.
`protected ModifyQuery`	`getDeleteAllQuery()` Overrides CollectionMappig because this mapping requires a DeleteAllQuery instead of a ModifyQuery.
`protected InsertObjectQuery`	`getInsertObjectQuery(org.eclipse.persistence.internal.sessions.AbstractSession session, ClassDescriptor desc)` INTERNAL: Returns clone of InsertObjectQuery from the reference descriptor, if it is not set - create it.
`ClassDescriptor`	`getReferenceDescriptor()` INTERNAL: Return the referenceDescriptor.
`ClassDescriptor`	`getReferenceDescriptor(java.lang.Class theClass, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: for inheritance purpose
`java.util.Vector`	`getReferenceObjectKeys(ObjectLevelModifyQuery query)` INTERNAL: get reference object keys
`java.util.Vector`	`getSourceKeyFieldNames()` PUBLIC: Return the source key field names associated with the mapping.
`java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`getSourceKeyFields()` INTERNAL: Return the source key names associated with the mapping
`java.util.Vector`	`getTargetForeignKeyFieldNames()` PUBLIC: Return the target foregin key field names associated with the mapping.
`java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`getTargetForeignKeyFields()` INTERNAL: Return the target foregin key fields associated with the mapping
`java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField>`	`getTargetForeignKeyToSourceKeys()` INTERNAL:
`boolean`	`hasNestedIdentityReference()` INTERNAL: Indicates whether the mapping (or at least one of its nested mappings, at any nested depth) references an entity.
`void`	`initialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: For aggregate collection mapping the reference descriptor is cloned.
`void`	`initializeChildInheritance(ClassDescriptor parentDescriptor, org.eclipse.persistence.internal.sessions.AbstractSession session, java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation, java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseTable,org.eclipse.persistence.internal.helper.DatabaseTable> tableTranslation)` INTERNAL: For aggregate mapping the reference descriptor is cloned.
`protected void`	`initializeDeleteAllQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initialize delete all query.
`void`	`initializeParentInheritance(ClassDescriptor parentDescriptor, ClassDescriptor childDescriptor, org.eclipse.persistence.internal.sessions.AbstractSession session, java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation, java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseTable,org.eclipse.persistence.internal.helper.DatabaseTable> tableTranslation)` INTERNAL: For aggregate mapping the reference descriptor is cloned.
`protected void`	`initializeReferenceDescriptor(org.eclipse.persistence.internal.sessions.AbstractSession session)` Initialize and set the descriptor for the referenced class in this mapping.
`protected void`	`initializeSelectionCriteria(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Selection criteria is created with target foreign keys and source keys.
`protected void`	`initializeTargetForeignKeyToSourceKeys(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: The foreign keys and the primary key names are converted to DatabaseFields and stored.
`protected void`	`initializeTargetForeignKeyToSourceKeysWithDefaults(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: The foreign keys and the primary key names are converted to DatabaseFields and stored.
`protected void`	`initializeUpdateListOrderQuery(org.eclipse.persistence.internal.sessions.AbstractSession session, java.lang.String queryType)`
`boolean`	`isAggregateCollectionMapping()` INTERNAL:
`boolean`	`isCandidateForPrivateOwnedRemoval()` INTERNAL: AggregateCollection contents should not be considered for addition to the UnitOfWork private owned objects list for removal.
`boolean`	`isCascadedLockingSupported()` INTERNAL Return true if this mapping supports cascaded version optimistic locking.
`boolean`	`isChangeTrackingSupported(Project project)` INTERNAL: Return if this mapping supports change tracking.
`boolean`	`isElementCollectionMapping()` INTERNAL:
`boolean`	`isJoiningSupported()` INTERNAL: Return if this mapping support joining.
`boolean`	`isListOrderFieldUpdatable()` PUBLIC: indicates whether listOrderField value could be updated in the db.
`boolean`	`isOwned()` INTERNAL:
`boolean`	`isRelationalMapping()` INTERNAL:
`protected boolean`	`isSourceKeySpecified()` Checks if source key is specified or not.
`void`	`iterateOnElement(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, java.lang.Object element)` INTERNAL: Iterate on the specified element.
`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 changeRecord, 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.
`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 int`	`objectChangedListOrderDuringUpdate(WriteObjectQuery query, int iMin, int iMax, int iShift)`
`protected int`	`objectChangedListOrderDuringUpdate(WriteObjectQuery query, java.lang.Object key, int newOrderValue)`
`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, java.util.Map backupCloneKeyedCache, java.lang.Object cachedKey)` 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.lang.Object backupClone)`
`void`	`postInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: For aggregate collection mapping the reference descriptor is cloned.
`void`	`postInsert(WriteObjectQuery query)` INTERNAL: Insert privately owned parts
`protected void`	`postPrepareNestedBatchQuery(ReadQuery batchQuery, ObjectLevelReadQuery query)` INTERNAL: Allow the mapping the do any further batch preparation.
`void`	`postUpdate(WriteObjectQuery writeQuery)` INTERNAL: Update the privately owned parts
`void`	`preDelete(DeleteObjectQuery query)` INTERNAL: Delete privately owned parts
`void`	`preInsert(WriteObjectQuery query)` INTERNAL: The message is passed to its reference class descriptor.
`void`	`prepareModifyQueryForDelete(ObjectLevelModifyQuery originalQuery, ObjectLevelModifyQuery modifyQuery, java.lang.Object wrappedObject, java.util.Map extraData)` INTERNAL: setup the modifyQuery for pre delete
`void`	`prepareModifyQueryForUpdate(ObjectLevelModifyQuery originalQuery, ObjectLevelModifyQuery modifyQuery, java.lang.Object object)` INTERNAL: setup the modifyQuery for update,
`ObjectLevelReadQuery`	`prepareNestedJoins(org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager, ObjectBuildingQuery baseQuery, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Clone and prepare the JoinedAttributeManager nested JoinedAttributeManager.
`void`	`remoteInitialization(DistributedSession session)` INTERNAL: Once a descriptor is serialized to the remote session, all its mappings and reference descriptors are traversed.
`void`	`setDefaultSourceTable(org.eclipse.persistence.internal.helper.DatabaseTable table)` PUBLIC: Set a default source table to use with the source fields of this mapping.
`void`	`setIsListOrderFieldUpdatable(boolean isUpdatable)` PUBLIC: indicates whether listOrderField value could be updated in the db.
`protected void`	`setReferenceDescriptor(ClassDescriptor aDescriptor)` INTERNAL: Set the referenceDescriptor.
`void`	`setSourceKeyFieldNames(java.util.Vector fieldNames)` PUBLIC: Set the source key field names associated with the mapping.
`void`	`setSourceKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields)` INTERNAL: set all the primary key names associated with this mapping
`void`	`setTargetForeignKeyFieldNames(java.util.Vector fieldNames)` PUBLIC: Set the target foregin key field names associated with the mapping.
`void`	`setTargetForeignKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyFields)` INTERNAL: set the target foregin key fields associated with the mapping
`protected void`	`setTargetForeignKeyToSourceKeys(java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyToSourceKeys)`
`protected boolean`	`shouldObjectModifyCascadeToParts(ObjectLevelModifyQuery query)` Returns true as any process leading to object modification should also affect its privately owned parts Usually used by write, insert, update and delete.
`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.
`protected static void`	`translateTablesAndFields(ClassDescriptor descriptor, java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation, java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseTable,org.eclipse.persistence.internal.helper.DatabaseTable> tableTranslation)` INTERNAL: Called in case fieldTranslation !
`protected void`	`updateNestedAggregateMappings(ClassDescriptor descriptor, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Called in case nestedAggregateToSourceFieldNames !
`boolean`	`verifyDelete(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Checks if object is deleted from the database or not.
`protected void`	`verifyDeleteForUpdate(DeleteObjectQuery query)` Verifying deletes make sure that all the records privately owned by this mapping are actually removed.

Methods inherited from class org.eclipse.persistence.mappings.CollectionMapping
addAggregateOrderBy, addAscendingOrdering, addDescendingOrdering, addOrderBy, buildChangeRecord, buildContainerClone, buildCopy, buildElementUnitOfWorkClone, buildListOrderField, buildReferencesPKList, calculateDeferredChanges, compareCollectionsForChange, compareLists, compareObjectsAndWrite, compareObjectsWithoutPrivateOwned, compareObjectsWithPrivateOwned, convertClassNamesToClasses, executeBatchQuery, extractResultFromBatchQuery, fixRealObjectReferences, getAdditionalFieldsBaseExpression, getContainerPolicy, getJoinCriteria, getListOrderField, getObjectCorrespondingTo, getOrderByQueryKeyExpressions, getOrderCorrectionType, getRealCollectionAttributeValueFromObject, getSelectionQueryContainerPolicy, getTargetPrimaryKeyFields, hasCustomDeleteAllQuery, hasOrderBy, initializeChangeOrderTargetQuery, initializeListOrderField, initializeListOrderFieldTable, isAttributeValueInstantiatedOrChanged, isCollectionMapping, isListOrderFieldSupported, isMapKeyObjectRelationship, iterateOnRealAttributeValue, mustDeleteReferenceObjectsOneByOne, objectOrderChangedDuringUpdate, objectUnchangedDuringUpdate, postCalculateChanges, postDelete, prepareTranslationRow, preUpdate, readPrivateOwnedForObject, recordPrivateOwnedRemovals, replaceValueHoldersIn, setChangeListener, setContainerPolicy, setCustomDeleteAllQuery, setDeleteAllCall, setDeleteAllQuery, setDeleteAllSQLString, setHasCustomDeleteAllQuery, setListOrderField, setListOrderFieldName, setMustDeleteReferenceObjectsOneByOne, setOrderCorrectionType, setSelectionQueryContainerPolicy, setSessionName, setUseLazyInstantiationForIndirectCollection, shouldUseLazyInstantiationForIndirectCollection, shouldUseListOrderFieldTableExpression, updateChangeRecord, updateChangeRecordForSelfMerge, updateCollectionChangeRecord, useCollectionClass, useCollectionClassName, useListClassName, useMapClass, useMapClass, useMapClassName, useSortedSetClass, useSortedSetClassName, useSortedSetClassName, useTransparentCollection, useTransparentList, useTransparentMap, useTransparentSet, validateBeforeInitialization, valueFromPKList, valueFromRowInternalWithJoin, writeChanges

Methods inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping
addForeignKeyField, batchedValueFromRow, buildBackupClone, buildClone, buildCloneFromRow, checkCacheForBatchKey, createCloneValueHolder, dontDoMerge, dontUseBatchReading, dontUseIndirection, extendPessimisticLockScopeInSourceQuery, extendPessimisticLockScopeInTargetQuery, fixObjectReferences, getAttributeValueFromObject, getAttributeValueWithClonedValueHolders, getBatchFetchType, getExtendPessimisticLockScopeDedicatedQuery, getFieldsForTranslationInAggregate, getIndirectionPolicy, getJoinFetch, getMappedBy, getOrderByNormalizedExpressions, getPartitioningPolicy, getPartitioningPolicyName, getRealAttributeValueFromAttribute, getReferenceClass, getReferenceClassName, getRelationshipPartner, getRelationshipPartnerAttributeName, getSelectionCriteria, getSelectionQuery, getTempSession, getValueFromRemoteValueHolder, hasCustomSelectionQuery, hasDependency, initializeSelectionQuery, instantiateAttribute, isAttributeValueFromObjectInstantiated, isAttributeValueFullyBuilt, isAttributeValueInstantiated, isCascadeDetach, isCascadeMerge, isCascadeOnDeleteSetOnDatabase, isCascadePersist, isCascadeRefresh, isCascadeRemove, isExtendingPessimisticLockScope, isForeignReferenceMapping, isInnerJoinFetched, isJoinFetched, isLazy, isLockableMapping, isOuterJoinFetched, isPrivateOwned, iterate, mergeRemoteValueHolder, preInitialize, prepareHistoricalQuery, prepareNestedBatchQuery, prepareNestedJoinQueryClone, privateOwnedRelationship, readFromRowIntoObject, requiresTransientWeavedFields, setBatchFetchType, setCascadeAll, setCascadeDetach, setCascadeMerge, setCascadePersist, setCascadeRefresh, setCascadeRemove, setCustomSelectionQuery, setForceInitializationOfSelectionCriteria, setHasCustomSelectionQuery, setIndirectionPolicy, setIsCacheable, setIsCascadeOnDeleteSetOnDatabase, setIsPrivateOwned, setJoinFetch, setMappedBy, setPartitioningPolicy, setPartitioningPolicyName, setRealAttributeValueInObject, setReferenceClass, setReferenceClassName, setRelationshipPartner, setRelationshipPartnerAttributeName, setRequiresTransientWeavedFields, setSelectionCall, setSelectionCriteria, setSelectionQuery, setSelectionSQLString, setShouldExtendPessimisticLockScope, setTempSession, setUsesBatchReading, setUsesIndirection, shouldExtendPessimisticLockScope, shouldExtendPessimisticLockScopeInDedicatedQuery, shouldExtendPessimisticLockScopeInSourceQuery, shouldExtendPessimisticLockScopeInTargetQuery, shouldForceInitializationOfSelectionCriteria, shouldInitializeSelectionCriteria, shouldMergeCascadeParts, shouldMergeCascadeReference, 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, isAggregateMapping, isAggregateObjectMapping, isCacheable, isCloningRequired, isDatabaseMapping, isDirectCollectionMapping, isDirectMapMapping, isDirectToFieldMapping, isDirectToXMLTypeMapping, isEISMapping, isInAndOutSopObject, isInOnlySopObject, isInSopObject, isJPAId, isManyToManyMapping, isManyToOneMapping, isMapKeyMapping, isMultitenantPrimaryKeyMapping, isNestedTableMapping, isObjectReferenceMapping, isOneToManyMapping, isOneToOneMapping, isOptional, isOutOnlySopObject, isOutSopObject, isPrimaryKeyMapping, isReadOnly, isReferenceMapping, isRemotelyInitialized, isStructureMapping, isTransformationMapping, isUnidirectionalOneToManyMapping, isUsingMethodAccess, isVariableOneToOneMapping, isWriteOnly, isXMLMapping, performDataModificationEvent, postCalculateChangesOnDeleted, 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

Methods inherited from interface org.eclipse.persistence.mappings.EmbeddableMapping
getAttributeName

Field Detail
- targetForeignKeyFields
```
protected java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyFields
```
  This is a key in the target table which is a foreign key in the target table.
- sourceKeyFields
```
protected java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields
```
  This is a primary key in the source table that is used as foreign key in the target table
- targetForeignKeyToSourceKeys
```
protected java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyToSourceKeys
```
  Foreign keys in the target table to the related keys in the source table
- aggregateToSourceFields
```
protected java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField> aggregateToSourceFields
```
  Map the name of a field in the aggregate collection descriptor to a field in the actual table specified in the mapping.
- nestedAggregateToSourceFields
```
protected java.util.Map<java.lang.String,java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField>> nestedAggregateToSourceFields
```
  Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames that should be applied to this mapping.
- remoteReferenceDescriptor
```
protected ClassDescriptor remoteReferenceDescriptor
```
  In RemoteSession case the mapping needs the reference descriptor serialized from the server, but referenceDescriptor attribute defined as transient in the superclass. To overcome that in non-remote case referenceDescriptor is assigned to remoteReferenceDescriptor; in remote - another way around.
- defaultSourceTable
```
protected org.eclipse.persistence.internal.helper.DatabaseTable defaultSourceTable
```
  Default source table that should be used with the default source fields of this mapping.
- isEntireObjectPK
```
protected boolean isEntireObjectPK
```
  Indicates whether the entire target object is primary key - in that case the object can't be updated in the db, but rather deleted and then re-inserted.
- updateListOrderFieldQuery
```
protected transient DataModifyQuery updateListOrderFieldQuery
```
  These queries used to update listOrderField
- bulkUpdateListOrderFieldQuery
```
protected transient DataModifyQuery bulkUpdateListOrderFieldQuery
```
- pkUpdateListOrderFieldQuery
```
protected transient DataModifyQuery pkUpdateListOrderFieldQuery
```
- isListOrderFieldUpdatable
```
protected boolean isListOrderFieldUpdatable
```
  indicates whether listOrderField value could be updated in the db. Used only if listOrderField!=null
- min
```
protected static final java.lang.String min
```
  See Also:
  Constant Field Values
- max
```
protected static final java.lang.String max
```
  See Also:
  Constant Field Values
- shift
```
protected static final java.lang.String shift
```
  See Also:
  Constant Field Values
- pk
```
protected static final java.lang.String pk
```
  See Also:
  Constant Field Values
- bulk
```
protected static final java.lang.String bulk
```
  See Also:
  Constant Field Values
- hasNestedIdentityReference
```
protected java.lang.Boolean hasNestedIdentityReference
```
  Indicates whether the mapping (or at least one of its nested mappings, at any nested depth) references an entity. To return true the mapping (or nested mapping) should be ForeignReferenceMapping with non-null and non-aggregate reference descriptor. Lazily initialized.

Constructor Detail
- AggregateCollectionMapping
```
public AggregateCollectionMapping()
```
  PUBLIC: Default constructor.

Method Detail

isRelationalMapping
```
public boolean isRelationalMapping()
```
INTERNAL:

Overrides:

isRelationalMapping in class DatabaseMapping

addOverrideManyToManyMapping
```
public void addOverrideManyToManyMapping(ManyToManyMapping mapping)
```
INTERNAL: In JPA users may specify overrides to apply to a many to many mapping on a shared embeddable descriptor. These settings are applied at initialize time, after the reference descriptor is cloned. In an aggregate collection case, this is not supported and currently silently ignored and does nothing.

Specified by:

addOverrideManyToManyMapping in interface EmbeddableMapping

addOverrideUnidirectionalOneToManyMapping
```
public void addOverrideUnidirectionalOneToManyMapping(UnidirectionalOneToManyMapping mapping)
```
INTERNAL: In JPA users may specify overrides to apply to a unidirectional one to many mapping on a shared embeddable descriptor. These settings are applied at initialize time, after the reference descriptor is cloned. In an aggregate collection case, this is not supported and currently silently ignored and does nothing.

Specified by:

addOverrideUnidirectionalOneToManyMapping in interface EmbeddableMapping

addConverter
```
public void addConverter(Converter converter,
                java.lang.String attributeName)
```
Add a converter to be applied to a mapping of the aggregate descriptor.

Specified by:

addConverter in interface EmbeddableMapping

addFieldNameTranslation

public void addFieldNameTranslation(java.lang.String sourceFieldName,
                           java.lang.String aggregateFieldName)

PUBLIC: Maps a field name in the aggregate descriptor to a field name in the source table.

addFieldTranslation
```
public void addFieldTranslation(org.eclipse.persistence.internal.helper.DatabaseField sourceField,
                       java.lang.String aggregateField)
```
PUBLIC: Maps a field name in the aggregate descriptor to a field in the source table.

Specified by:

addFieldTranslation in interface EmbeddableMapping

addFieldTranslations

public void addFieldTranslations(java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField> map)

PUBLIC: Maps a field name in the aggregate descriptor to a field name in the source table.

addNestedFieldNameTranslation

public void addNestedFieldNameTranslation(java.lang.String attributeName,
                                 java.lang.String sourceFieldName,
                                 java.lang.String aggregateFieldName)

PUBLIC: Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames that should be applied to this mapping.

addNestedFieldTranslation
```
public void addNestedFieldTranslation(java.lang.String attributeName,
                             org.eclipse.persistence.internal.helper.DatabaseField sourceField,
                             java.lang.String aggregateFieldName)
```
PUBLIC: Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames that should be applied to this mapping.

Specified by:

addNestedFieldTranslation in interface EmbeddableMapping

addNestedFieldNameTranslations

public void addNestedFieldNameTranslations(java.lang.String attributeName,
                                  java.util.Map<java.lang.String,org.eclipse.persistence.internal.helper.DatabaseField> map)

PUBLIC: Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFields that should be applied to this mapping.

addTargetForeignKeyField
```
public void addTargetForeignKeyField(org.eclipse.persistence.internal.helper.DatabaseField targetForeignKey,
                            org.eclipse.persistence.internal.helper.DatabaseField sourceKey)
```
PUBLIC: Define the target foreign key relationship in the 1-M aggregate collection mapping. Both the target foreign key field and the source primary key field must be specified.

Overrides:

addTargetForeignKeyField in class ForeignReferenceMapping

addTargetForeignKeyFieldName
```
public void addTargetForeignKeyFieldName(java.lang.String targetForeignKey,
                                java.lang.String sourceKey)
```
PUBLIC: Define the target foreign key relationship in the 1-M aggregate collection mapping. Both the target foreign key field name and the source primary key field name must be specified.

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.

Overrides:: buildBackupCloneForPartObject in class CollectionMapping

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. this is identical to the super class except that the element must be added to the new aggregates collection so that the referenced objects will be cloned correctly

Overrides:: buildCloneForPartObject in class CollectionMapping

buildElementBackupClone

protected java.lang.Object buildElementBackupClone(java.lang.Object element,
                                       org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)

INTERNAL: Clone the aggregate collection, 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 aggregate collection, if necessary.

Overrides:: buildElementClone in class CollectionMapping

collectQueryParameters
```
public void collectQueryParameters(java.util.Set<org.eclipse.persistence.internal.helper.DatabaseField> cacheFields)
```
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

Overrides:

collectQueryParameters in class CollectionMapping

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 CollectionMapping

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

Overrides:: cascadeRegisterNewIfRequired in class CollectionMapping

cascadePerformRemoveIfRequired

public void cascadePerformRemoveIfRequired(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

Overrides:: cascadePerformRemoveIfRequired in class CollectionMapping

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 CollectionMapping

clone
```
public java.lang.Object clone()
```
INTERNAL: The mapping clones itself to create deep copy.

Specified by:

clone in interface MapComponentMapping

Overrides:

clone in class CollectionMapping

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 aggregate collections

Overrides:: compareForChange in class CollectionMapping
Returns:: ChangeRecord

compareMapCollectionForChange

protected boolean compareMapCollectionForChange(java.util.Map cloneObjectCollection,
                                    java.util.Map backUpCollection,
                                    org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Determine if an AggregateCollection that is contained as a map has changed by comparing the values in the clone to the values in the backup.

Parameters:: cloneObjectCollection -; backUpCollection -; session -
Returns:

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. Called only if listOrderField != null

Overrides:: compareListsAndWrite in class CollectionMapping
Throws:: DatabaseException; OptimisticLockException

compareListsAndWrite_NonUpdatableListOrderField

protected void compareListsAndWrite_NonUpdatableListOrderField(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. Called only if listOrderField != null

Throws:: DatabaseException; OptimisticLockException

compareListsAndWrite_UpdatableListOrderField

protected void compareListsAndWrite_UpdatableListOrderField(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. Called only if listOrderField != null

Throws:: DatabaseException; OptimisticLockException

objectChangedListOrderDuringUpdate

protected int objectChangedListOrderDuringUpdate(WriteObjectQuery query,
                                     int iMin,
                                     int iMax,
                                     int iShift)

objectChangedListOrderDuringUpdate

protected int objectChangedListOrderDuringUpdate(WriteObjectQuery query,
                                     java.lang.Object key,
                                     int newOrderValue)

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 CollectionMapping

compareLists

public boolean compareLists(java.util.List firstList,
                   java.util.List secondList,
                   org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Compare the attributes belonging to this mapping for the objects.

convertToChangeRecord

protected org.eclipse.persistence.internal.sessions.ChangeRecord convertToChangeRecord(java.lang.Object cloneCollection,
                                                                           java.lang.Object backupCollection,
                                                                           org.eclipse.persistence.internal.sessions.ObjectChangeSet owner,
                                                                           org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: This method is used to convert the contents of an aggregateCollection into a changeRecord

Parameters:: owner - org.eclipse.persistence.internal.sessions.ObjectChangeSet the ChangeSet that uses this record; cloneCollection - Object the collection to convert; session - org.eclipse.persistence.internal.sessions.AbstractSession
Returns:: org.eclipse.persistence.internal.sessions.AggregateCollectionChangeRecord the changerecord representing this AggregateCollectionMapping

copyElement

protected java.lang.Object copyElement(java.lang.Object original,
                           CopyGroup group)

INTERNAL: Copies member's value

Overrides:: copyElement in class CollectionMapping

createMapComponentFromRow

public java.lang.Object createMapComponentFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord dbRow,
                                         ObjectBuildingQuery query,
                                         org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                                         org.eclipse.persistence.internal.sessions.AbstractSession session,
                                         boolean isTargetProtected)

INTERNAL Called when a DatabaseMapping is used to map the key in a collection. Returns the key.

Specified by:: createMapComponentFromRow in interface MapComponentMapping

deleteAll

protected void deleteAll(DeleteObjectQuery query,
             org.eclipse.persistence.internal.sessions.AbstractSession session)
                  throws DatabaseException

To delete all the entries matching the selection criteria from the table stored in the referenced descriptor

Throws:: DatabaseException

executeEvent

protected void executeEvent(int eventCode,
                ObjectLevelModifyQuery query)

INTERNAL: Execute a descriptor event for the specified event code.

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.

Overrides:

extractKeyFromTargetRow in class CollectionMapping

extractBatchKeyFromRow
```
protected java.lang.Object extractBatchKeyFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row,
                                      org.eclipse.persistence.internal.sessions.AbstractSession session)
```
INTERNAL: Extract the primary key value from the source row. Used for batch reading, most following same order and fields as in the mapping.

Overrides:

extractBatchKeyFromRow in class ForeignReferenceMapping

buildBatchCriteria

protected Expression buildBatchCriteria(ExpressionBuilder builder,
                            ObjectLevelReadQuery query)

INTERNAL: Return the selection criteria used to IN batch fetching.

Overrides:: buildBatchCriteria in class ForeignReferenceMapping

postPrepareNestedBatchQuery

protected void postPrepareNestedBatchQuery(ReadQuery batchQuery,
                               ObjectLevelReadQuery query)

INTERNAL: Allow the mapping the do any further batch preparation.

Overrides:: postPrepareNestedBatchQuery in class CollectionMapping

getAggregateRow

public org.eclipse.persistence.internal.sessions.AbstractRecord getAggregateRow(ObjectLevelModifyQuery query,
                                                                       java.lang.Object object)

INTERNAL: return the aggregate Record with the primary keys from the source table and target table

getDeleteAllCriteria
```
protected Expression getDeleteAllCriteria(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
Delete all criteria is created with target foreign keys and source keys. This criteria is then used to delete target records from the table.

getDeleteAllQuery
```
protected ModifyQuery getDeleteAllQuery()
```
Overrides CollectionMappig because this mapping requires a DeleteAllQuery instead of a ModifyQuery.

Overrides:

getDeleteAllQuery in class CollectionMapping

getReferenceDescriptor
```
public ClassDescriptor getReferenceDescriptor()
```
INTERNAL: Return the referenceDescriptor. This is a descriptor which is associated with the reference class. NOTE: If you are looking for the descriptor for a specific aggregate object, use #getReferenceDescriptor(Object). This will ensure you get the right descriptor if the object's descriptor is part of an inheritance tree.

Overrides:

getReferenceDescriptor in class ForeignReferenceMapping

getReferenceDescriptor

public ClassDescriptor getReferenceDescriptor(java.lang.Class theClass,
                                     org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: for inheritance purpose

getReferenceObjectKeys

public java.util.Vector getReferenceObjectKeys(ObjectLevelModifyQuery query)
                                        throws DatabaseException,
                                               OptimisticLockException

INTERNAL: get reference object keys

Throws:: DatabaseException; OptimisticLockException

getSourceKeyFieldNames
```
public java.util.Vector getSourceKeyFieldNames()
```
PUBLIC: Return the source key field names associated with the mapping. These are in-order with the targetForeignKeyFieldNames.

getSourceKeyFields

public java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> getSourceKeyFields()

INTERNAL: Return the source key names associated with the mapping

getTargetForeignKeyFieldNames
```
public java.util.Vector getTargetForeignKeyFieldNames()
```
PUBLIC: Return the target foregin key field names associated with the mapping. These are in-order with the sourceKeyFieldNames.

getTargetForeignKeyFields

public java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> getTargetForeignKeyFields()

INTERNAL: Return the target foregin key fields associated with the mapping

getTargetForeignKeyToSourceKeys

public java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> getTargetForeignKeyToSourceKeys()

INTERNAL:

initialize
```
public void initialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
                throws DescriptorException
```
INTERNAL: For aggregate collection mapping the reference descriptor is cloned. The cloned descriptor is then assigned primary keys and table names before initialize. Once cloned descriptor is initialized it is assigned as reference descriptor in the aggregate mapping. This is very specific behavior for aggregate mappings. The original descriptor is used only for creating clones and after that mapping never uses it. Some initialization is done in postInitialize to ensure the target descriptor's references are initialized.

Overrides:

initialize in class CollectionMapping

Throws:

DescriptorException

initializeReferenceDescriptor
```
protected void initializeReferenceDescriptor(org.eclipse.persistence.internal.sessions.AbstractSession session)
                                      throws DescriptorException
```
Initialize and set the descriptor for the referenced class in this mapping.

Overrides:

initializeReferenceDescriptor in class ForeignReferenceMapping

Throws:

DescriptorException

initializeUpdateListOrderQuery

protected void initializeUpdateListOrderQuery(org.eclipse.persistence.internal.sessions.AbstractSession session,
                                  java.lang.String queryType)

prepareNestedJoins

public ObjectLevelReadQuery prepareNestedJoins(org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager,
                                      ObjectBuildingQuery baseQuery,
                                      org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Clone and prepare the JoinedAttributeManager nested JoinedAttributeManager. This is used for nested joining as the JoinedAttributeManager passed to the joined build object.

Overrides:: prepareNestedJoins in class ForeignReferenceMapping

translateTablesAndFields

protected static void translateTablesAndFields(ClassDescriptor descriptor,
                            java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation,
                            java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseTable,org.eclipse.persistence.internal.helper.DatabaseTable> tableTranslation)

INTERNAL: Called in case fieldTranslation != null Sets new primary keys, tables, appends fieldTranslation to fieldMap so that all fields in mappings, inheritance etc. translated to the new ones.

updateNestedAggregateMappings
```
protected void updateNestedAggregateMappings(ClassDescriptor descriptor,
                                 org.eclipse.persistence.internal.sessions.AbstractSession session)
```
INTERNAL: Called in case nestedAggregateToSourceFieldNames != null Updates AggregateObjectMappings and AggregateCollectionMappings of the reference descriptor.

initializeChildInheritance
```
public void initializeChildInheritance(ClassDescriptor parentDescriptor,
                              org.eclipse.persistence.internal.sessions.AbstractSession session,
                              java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation,
                              java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseTable,org.eclipse.persistence.internal.helper.DatabaseTable> tableTranslation)
                                throws DescriptorException
```
INTERNAL: For aggregate mapping the reference descriptor is cloned. Also the involved inheritance descriptor, its children and parents all need to be cloned. The cloned descriptors are then assigned primary keys and table names before initialize. Once cloned descriptor is initialized it is assigned as reference descriptor in the aggregate mapping. This is very specific behavior for aggregate mappings. The original descriptor is used only for creating clones and after that mapping never uses it. Some initialization is done in postInitialize to ensure the target descriptor's references are initialized.

Throws:

DescriptorException

initializeDeleteAllQuery
```
protected void initializeDeleteAllQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
INTERNAL: Initialize delete all query. This query is used to delete the collection of objects from the target table.

initializeParentInheritance

public void initializeParentInheritance(ClassDescriptor parentDescriptor,
                               ClassDescriptor childDescriptor,
                               org.eclipse.persistence.internal.sessions.AbstractSession session,
                               java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation,
                               java.util.HashMap<org.eclipse.persistence.internal.helper.DatabaseTable,org.eclipse.persistence.internal.helper.DatabaseTable> tableTranslation)
                                 throws DescriptorException

INTERNAL: For aggregate mapping the reference descriptor is cloned. Also the involved inheritance descriptor, its children and parents all need to be cloned. The cloned descriptors are then assigned primary keys and table names before initialize. Once cloned descriptor is initialized it is assigned as reference descriptor in the aggregate mapping. This is very specific behavior for aggregate mappings. The original descriptor is used only for creating clones and after that mapping never uses it. Some initialization is done in postInitialize to ensure the target descriptor's references are initialized.

Throws:: DescriptorException

initializeSelectionCriteria
```
protected void initializeSelectionCriteria(org.eclipse.persistence.internal.sessions.AbstractSession session)
```
INTERNAL: Selection criteria is created with target foreign keys and source keys. This criteria is then used to read records from the target table.

initializeTargetForeignKeyToSourceKeys

protected void initializeTargetForeignKeyToSourceKeys(org.eclipse.persistence.internal.sessions.AbstractSession session)
                                               throws DescriptorException

INTERNAL: The foreign keys and the primary key names are converted to DatabaseFields and stored.

Throws:: DescriptorException

initializeTargetForeignKeyToSourceKeysWithDefaults
```
protected void initializeTargetForeignKeyToSourceKeysWithDefaults(org.eclipse.persistence.internal.sessions.AbstractSession session)
                                                           throws DescriptorException
```
INTERNAL: The foreign keys and the primary key names are converted to DatabaseFields and stored. The source keys are not specified by the user so primary keys are extracted from the reference descriptor.

Throws:

DescriptorException

iterateOnElement

public void iterateOnElement(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator,
                    java.lang.Object element)

INTERNAL: Iterate on the specified element.

Overrides:: iterateOnElement in class CollectionMapping

isAggregateCollectionMapping
```
public boolean isAggregateCollectionMapping()
```
INTERNAL:

Overrides:

isAggregateCollectionMapping in class DatabaseMapping

isElementCollectionMapping
```
public boolean isElementCollectionMapping()
```
INTERNAL:

Overrides:

isElementCollectionMapping in class DatabaseMapping

isJoiningSupported
```
public boolean isJoiningSupported()
```
INTERNAL: Return if this mapping support joining.

Overrides:

isJoiningSupported in class ForeignReferenceMapping

isOwned
```
public boolean isOwned()
```
INTERNAL:

Overrides:

isOwned in class DatabaseMapping

isSourceKeySpecified
```
protected boolean isSourceKeySpecified()
```
Checks if source key is specified or not.

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 CollectionMapping

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 CollectionMapping

mergeChangesIntoObject

public void mergeChangesIntoObject(java.lang.Object target,
                          org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                          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

Overrides:: mergeChangesIntoObject in class CollectionMapping

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.

Overrides:: mergeIntoObject in class CollectionMapping

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.

Overrides:: objectAddedDuringUpdate in class CollectionMapping
Throws:: DatabaseException; OptimisticLockException

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.

Overrides:: objectRemovedDuringUpdate in class CollectionMapping
Throws:: DatabaseException; OptimisticLockException

objectUnchangedDuringUpdate

protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query,
                               java.lang.Object object,
                               java.util.Map backupCloneKeyedCache,
                               java.lang.Object cachedKey)
                                    throws DatabaseException,
                                           OptimisticLockException

INTERNAL: An object is still in the collection, update it as it may have changed.

Overrides:: objectUnchangedDuringUpdate in class CollectionMapping
Throws:: DatabaseException; OptimisticLockException

objectUnchangedDuringUpdate

protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query,
                               java.lang.Object object,
                               java.lang.Object backupClone)
                                    throws DatabaseException,
                                           OptimisticLockException

Throws:: DatabaseException; OptimisticLockException

postInitialize
```
public void postInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
                    throws DescriptorException
```
INTERNAL: For aggregate collection mapping the reference descriptor is cloned. The cloned descriptor is then assigned primary keys and table names before initialize. Once the cloned descriptor is initialized it is assigned as reference descriptor in the aggregate mapping. This is a very specific behavior for aggregate mappings. The original descriptor is used only for creating clones and after that the aggregate mapping never uses it. Some initialization is done in postInitialize to ensure the target descriptor's references are initialized.

Overrides:

postInitialize in class CollectionMapping

Throws:

DescriptorException

postInsert

public void postInsert(WriteObjectQuery query)
                throws DatabaseException,
                       OptimisticLockException

INTERNAL: Insert privately owned parts

Overrides:: postInsert in class CollectionMapping
Throws:: DatabaseException; OptimisticLockException

postUpdate

public void postUpdate(WriteObjectQuery writeQuery)
                throws DatabaseException,
                       OptimisticLockException

INTERNAL: Update the privately owned parts

Overrides:: postUpdate in class DatabaseMapping
Throws:: DatabaseException; OptimisticLockException

preDelete

public void preDelete(DeleteObjectQuery query)
               throws DatabaseException,
                      OptimisticLockException

INTERNAL: Delete privately owned parts

Overrides:: preDelete in class DatabaseMapping
Throws:: DatabaseException; OptimisticLockException

preInsert
```
public void preInsert(WriteObjectQuery query)
               throws DatabaseException,
                      OptimisticLockException
```
INTERNAL: The message is passed to its reference class descriptor.

Overrides:

preInsert in class CollectionMapping

Throws:

DatabaseException

OptimisticLockException

getInsertObjectQuery

protected InsertObjectQuery getInsertObjectQuery(org.eclipse.persistence.internal.sessions.AbstractSession session,
                                     ClassDescriptor desc)

INTERNAL: Returns clone of InsertObjectQuery from the reference descriptor, if it is not set - create it.

getAndPrepareModifyQueryForInsert

public InsertObjectQuery getAndPrepareModifyQueryForInsert(ObjectLevelModifyQuery originalQuery,
                                                  java.lang.Object object)

INTERNAL: setup the modifyQuery for post insert/update and pre delete

prepareModifyQueryForDelete

public void prepareModifyQueryForDelete(ObjectLevelModifyQuery originalQuery,
                               ObjectLevelModifyQuery modifyQuery,
                               java.lang.Object wrappedObject,
                               java.util.Map extraData)

INTERNAL: setup the modifyQuery for pre delete

prepareModifyQueryForUpdate

public void prepareModifyQueryForUpdate(ObjectLevelModifyQuery originalQuery,
                               ObjectLevelModifyQuery modifyQuery,
                               java.lang.Object object)

INTERNAL: setup the modifyQuery for update,

setReferenceDescriptor
```
protected void setReferenceDescriptor(ClassDescriptor aDescriptor)
```
INTERNAL: Set the referenceDescriptor. This is a descriptor which is associated with the reference class.

Overrides:

setReferenceDescriptor in class ForeignReferenceMapping

setSourceKeyFieldNames
```
public void setSourceKeyFieldNames(java.util.Vector fieldNames)
```
PUBLIC: Set the source key field names associated with the mapping. These must be in-order with the targetForeignKeyFieldNames.

setSourceKeyFields

public void setSourceKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields)

INTERNAL: set all the primary key names associated with this mapping

setTargetForeignKeyFieldNames
```
public void setTargetForeignKeyFieldNames(java.util.Vector fieldNames)
```
PUBLIC: Set the target foregin key field names associated with the mapping. These must be in-order with the sourceKeyFieldNames.

setTargetForeignKeyFields

public void setTargetForeignKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyFields)

INTERNAL: set the target foregin key fields associated with the mapping

setTargetForeignKeyToSourceKeys

protected void setTargetForeignKeyToSourceKeys(java.util.Map<org.eclipse.persistence.internal.helper.DatabaseField,org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyToSourceKeys)

shouldObjectModifyCascadeToParts
```
protected boolean shouldObjectModifyCascadeToParts(ObjectLevelModifyQuery query)
```
Returns true as any process leading to object modification should also affect its privately owned parts Usually used by write, insert, update and delete.

Overrides:

shouldObjectModifyCascadeToParts in class ForeignReferenceMapping

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. PLEASE ENSURE that the changes have been made in the object model first.

Overrides:: simpleAddToCollectionChangeRecord in class CollectionMapping

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. PLEASE ENSURE that the changes have been made in the object model first.

Overrides:: simpleRemoveFromCollectionChangeRecord in class CollectionMapping

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 CollectionMapping
Throws:: DatabaseException

verifyDeleteForUpdate
```
protected void verifyDeleteForUpdate(DeleteObjectQuery query)
                              throws DatabaseException,
                                     OptimisticLockException
```
Verifying deletes make sure that all the records privately owned by this mapping are actually removed. If such records are found than those are all read and removed one by one taking their privately owned parts into account.

Throws:

DatabaseException

OptimisticLockException

isCandidateForPrivateOwnedRemoval
```
public boolean isCandidateForPrivateOwnedRemoval()
```
INTERNAL: AggregateCollection contents should not be considered for addition to the UnitOfWork private owned objects list for removal.

Overrides:

isCandidateForPrivateOwnedRemoval in class DatabaseMapping

isCascadedLockingSupported
```
public boolean isCascadedLockingSupported()
```
INTERNAL Return true if this mapping supports cascaded version optimistic locking.

Overrides:

isCascadedLockingSupported in class DatabaseMapping

isChangeTrackingSupported
```
public boolean isChangeTrackingSupported(Project project)
```
INTERNAL: Return if this mapping supports change tracking.

Overrides:

isChangeTrackingSupported in class CollectionMapping

remoteInitialization
```
public void remoteInitialization(DistributedSession session)
```
INTERNAL: Once a descriptor is serialized to the remote session, all its mappings and reference descriptors are traversed. Usually the mappings are initialized and the serialized reference descriptors are replaced with local descriptors if they already exist in the remote session.

Overrides:

remoteInitialization in class ForeignReferenceMapping

isListOrderFieldUpdatable
```
public boolean isListOrderFieldUpdatable()
```
PUBLIC: indicates whether listOrderField value could be updated in the db. Used only if listOrderField!=null

setIsListOrderFieldUpdatable
```
public void setIsListOrderFieldUpdatable(boolean isUpdatable)
```
PUBLIC: indicates whether listOrderField value could be updated in the db. Used only if listOrderField!=null Default value is true.

setDefaultSourceTable
```
public void setDefaultSourceTable(org.eclipse.persistence.internal.helper.DatabaseTable table)
```
PUBLIC: Set a default source table to use with the source fields of this mapping.

hasNestedIdentityReference
```
public boolean hasNestedIdentityReference()
```
INTERNAL: Indicates whether the mapping (or at least one of its nested mappings, at any nested depth) references an entity. To return true the mapping (or nested mapping) should be ForeignReferenceMapping with non-null and non-aggregate reference descriptor.

Overrides:

hasNestedIdentityReference in class ForeignReferenceMapping

Class AggregateCollectionMapping

Nested Class Summary

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

Field Summary

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

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.CollectionMapping

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

Methods inherited from interface org.eclipse.persistence.mappings.EmbeddableMapping

Field Detail

targetForeignKeyFields

sourceKeyFields

targetForeignKeyToSourceKeys

aggregateToSourceFields

nestedAggregateToSourceFields

remoteReferenceDescriptor

defaultSourceTable

isEntireObjectPK

updateListOrderFieldQuery

bulkUpdateListOrderFieldQuery

pkUpdateListOrderFieldQuery

isListOrderFieldUpdatable

min

max

shift

pk

bulk

hasNestedIdentityReference

Constructor Detail

AggregateCollectionMapping

Method Detail

isRelationalMapping

addOverrideManyToManyMapping

addOverrideUnidirectionalOneToManyMapping

addConverter

addFieldNameTranslation

addFieldTranslation

addFieldTranslations

addNestedFieldNameTranslation

addNestedFieldTranslation

addNestedFieldNameTranslations

addTargetForeignKeyField

addTargetForeignKeyFieldName

buildBackupCloneForPartObject

buildCloneForPartObject

buildElementBackupClone

buildElementClone

collectQueryParameters

cascadeDiscoverAndPersistUnregisteredNewObjects

cascadeRegisterNewIfRequired

cascadePerformRemoveIfRequired

cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired

clone

compareForChange

compareMapCollectionForChange

compareListsAndWrite

compareListsAndWrite_NonUpdatableListOrderField

compareListsAndWrite_UpdatableListOrderField

objectChangedListOrderDuringUpdate

objectChangedListOrderDuringUpdate

compareObjects

compareLists

convertToChangeRecord

copyElement

createMapComponentFromRow

deleteAll

executeEvent

extractKeyFromTargetRow

extractBatchKeyFromRow

buildBatchCriteria

postPrepareNestedBatchQuery

getAggregateRow

getDeleteAllCriteria

getDeleteAllQuery

getReferenceDescriptor