org.eclipse.persistence.mappings
Class AggregateCollectionMapping

java.lang.Object
  extended by org.eclipse.persistence.mappings.DatabaseMapping
      extended by org.eclipse.persistence.mappings.ForeignReferenceMapping
          extended by org.eclipse.persistence.mappings.CollectionMapping
              extended by 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.

Since:
TOPLink/Java 3.0
Author:
King (Yaoping) Wang
See Also:
Serialized Form

Nested Class Summary
 
Nested classes/interfaces inherited from class org.eclipse.persistence.mappings.DatabaseMapping
DatabaseMapping.WriteType
 
Field Summary
 
Fields inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping
INNER_JOIN, NONE, OUTER_JOIN
 
Constructor Summary
AggregateCollectionMapping()
          PUBLIC: Default constructor.
 
Method Summary
 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 addFieldNameTranslations(java.util.Map<java.lang.String,java.lang.String> 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,java.lang.String> map)
          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.
 java.lang.Object buildCloneForPartObject(java.lang.Object attributeValue, java.lang.Object original, java.lang.Object clone, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork, boolean isExisting)
          INTERNAL: Require for cloning, the part must be cloned.
 java.lang.Object buildElementClone(java.lang.Object element, java.lang.Object parent, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork, boolean isExisting)
          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)
          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.
 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.
 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.
 java.lang.Object createMapComponentFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord dbRow, ObjectBuildingQuery query, org.eclipse.persistence.internal.sessions.AbstractSession session)
          INTERNAL Called when a DatabaseMapping is used to map the key in a collection.
 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
 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:
 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.
 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.
 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 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 isPrivateOwned()
          INTERNAL:
 boolean isRelationalMapping()
          INTERNAL:
 void iterateOnElement(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, java.lang.Object element)
          INTERNAL: Iterate on the specified element.
 void mergeChangesIntoObject(java.lang.Object target, org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, java.lang.Object source, org.eclipse.persistence.internal.sessions.MergeManager mergeManager)
          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)
          INTERNAL: Merge changes from the source to the target object.
 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
 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 setIsListOrderFieldUpdatable(boolean isUpdatable)
          PUBLIC: indicates whether listOrderField value could be updated in the db.
 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
 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.
 java.lang.Object valueFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, org.eclipse.persistence.internal.sessions.AbstractSession executionSession)
          INTERNAL: Retrieves a value from the row for a particular query key
 boolean verifyDelete(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)
          INTERNAL: Checks if object is deleted from the database or not.
 
Methods inherited from class org.eclipse.persistence.mappings.CollectionMapping
addAggregateOrderBy, addAscendingOrdering, addDescendingOrdering, addOrderBy, buildChangeRecord, buildCopy, buildReferencesPKList, calculateDeferredChanges, cascadeMerge, compareCollectionsForChange, convertClassNamesToClasses, extractResultFromBatchQuery, fixRealObjectReferences, getContainerPolicy, getJoinCriteria, getListOrderField, getListOrderFieldExpression, getObjectCorrespondingTo, getOrderByQueryKeyExpressions, getOrderCorrectionType, getRealCollectionAttributeValueFromObject, getTargetPrimaryKeyFields, hasOrderBy, isAttributeValueInstantiatedOrChanged, isCollectionMapping, isListOrderFieldSupported, iterateOnRealAttributeValue, postCalculateChanges, postDelete, prepareNestedBatchQuery, preUpdate, recordPrivateOwnedRemovals, replaceValueHoldersIn, setChangeListener, setContainerPolicy, setCustomDeleteAllQuery, setDeleteAllCall, setDeleteAllSQLString, setListOrderField, setListOrderFieldName, setOrderCorrectionType, setSessionName, shouldUseListOrderFieldTableExpression, updateChangeRecord, updateCollectionChangeRecord, useCollectionClass, useCollectionClassName, useListClassName, useMapClass, useMapClass, useMapClassName, useSortedSetClass, useSortedSetClassName, useSortedSetClassName, useTransparentCollection, useTransparentList, useTransparentMap, useTransparentSet, validateBeforeInitialization, valueFromPKList
 
Methods inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping
buildBackupClone, buildClone, buildCloneFromRow, createUnitOfWorkValueHolder, dontUseBatchReading, dontUseIndirection, extendPessimisticLockScopeInSourceQuery, fixObjectReferences, getAttributeValueFromObject, getAttributeValueWithClonedValueHolders, getIndirectionPolicy, getJoinFetch, getRealAttributeValueFromAttribute, getReferenceClass, getReferenceClassName, getRelationshipPartner, getRelationshipPartnerAttributeName, getSelectionCriteria, getSelectionQuery, getValueFromRemoteValueHolder, hasCustomSelectionQuery, instantiateAttribute, isAttributeValueInstantiated, isCascadeDetach, isCascadeMerge, isCascadePersist, isCascadeRefresh, isCascadeRemove, isForeignReferenceMapping, isInnerJoinFetched, isJoinFetched, isLazy, isLockableMapping, isOuterJoinFetched, iterate, mergeRemoteValueHolder, preInitialize, privateOwnedRelationship, requiresTransientWeavedFields, setCascadeAll, setCascadeDetach, setCascadeMerge, setCascadePersist, setCascadeRefresh, setCascadeRemove, setCustomSelectionQuery, setForceInitializationOfSelectionCriteria, setIndirectionPolicy, setIsPrivateOwned, setJoinFetch, setRealAttributeValueInObject, setReferenceClass, setReferenceClassName, setRelationshipPartner, setRelationshipPartnerAttributeName, setRequiresTransientWeavedFields, setSelectionCall, setSelectionCriteria, setSelectionSQLString, setShouldExtendPessimisticLockScope, setUsesBatchReading, setUsesIndirection, shouldExtendPessimisticLockScope, shouldExtendPessimisticLockScopeInDedicatedQuery, shouldExtendPessimisticLockScopeInSourceQuery, shouldExtendPessimisticLockScopeInTargetQuery, shouldMergeCascadeParts, shouldUseBatchReading, trimRowForJoin, trimRowForJoin, useBasicIndirection, useBatchReading, useContainerIndirection, useInnerJoinFetch, useOuterJoinFetch, usesIndirection, useWeavedIndirection
 
Methods inherited from class org.eclipse.persistence.mappings.DatabaseMapping
buildExpression, buildObjectJoinExpression, buildObjectJoinExpression, buildShallowOriginalFromRow, derivesId, earlyPreDelete, getAttributeAccessor, getAttributeClassification, getAttributeName, getDerivedIdMapping, getDescriptor, getField, getFieldClassification, getFields, getGetMethodName, getMapsIdValue, getProperties, getProperty, getRealAttributeValueFromObject, getSelectFields, getSelectTables, getSetMethodName, getWeight, hasConstraintDependency, hasDependency, hasInverseConstraintDependency, hasMapsIdValue, isAbstractCompositeCollectionMapping, isAbstractCompositeDirectCollectionMapping, isAbstractCompositeObjectMapping, isAbstractDirectMapping, isAggregateMapping, isAggregateObjectMapping, isCloningRequired, isDatabaseMapping, isDirectCollectionMapping, isDirectMapMapping, isDirectToFieldMapping, isDirectToXMLTypeMapping, isEISMapping, isJPAId, isManyToManyMapping, isMapKeyMapping, isNestedTableMapping, isObjectReferenceMapping, isOneToManyMapping, isOneToOneMapping, isOptional, isPrimaryKeyMapping, isReadOnly, isReferenceMapping, isStructureMapping, isTransformationMapping, isUnidirectionalOneToManyMapping, isUsingMethodAccess, isVariableOneToOneMapping, isWriteOnly, isXMLMapping, performDataModificationEvent, postCalculateChangesOnDeleted, prepareCascadeLockingPolicy, readFromResultSetIntoObject, readFromRowIntoObject, readOnly, readWrite, rehashFieldDependancies, setAttributeAccessor, setAttributeName, setAttributeValueInObject, setDerivedIdMapping, setDerivesId, setDescriptor, setGetMethodName, setIsJPAId, setIsLazy, setIsMapKeyMapping, setIsOptional, setIsPrimaryKeyMapping, setIsReadOnly, setMapsIdValue, setProperties, setProperty, setSetMethodName, setWeight, toString, validateAfterInitialization, valueFromObject, valueFromResultSet, valueFromRow, writeFromAttributeIntoRow, writeFromObjectIntoRow, writeFromObjectIntoRowForShallowInsert, writeFromObjectIntoRowForShallowInsertWithChangeRecord, writeFromObjectIntoRowForUpdate, writeFromObjectIntoRowForWhereClause, writeFromObjectIntoRowWithChangeRecord, writeInsertFieldsIntoRow, writeUpdateFieldsIntoRow
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface org.eclipse.persistence.mappings.EmbeddableMapping
getAttributeName
 

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

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.

Specified by:
addFieldNameTranslation in interface EmbeddableMapping

addFieldNameTranslations

public void addFieldNameTranslations(java.util.Map<java.lang.String,java.lang.String> 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.

Specified by:
addNestedFieldNameTranslation in interface EmbeddableMapping

addNestedFieldNameTranslations

public void addNestedFieldNameTranslations(java.lang.String attributeName,
                                           java.util.Map<java.lang.String,java.lang.String> map)
PUBLIC: Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames 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.


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,
                                                java.lang.Object clone,
                                                org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork,
                                                boolean isExisting)
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

buildElementClone

public java.lang.Object buildElementClone(java.lang.Object element,
                                          java.lang.Object parent,
                                          org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork,
                                          boolean isExisting)
INTERNAL: Clone the aggregate collection, if necessary.

Overrides:
buildElementClone 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)
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.

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

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.


createMapComponentFromRow

public java.lang.Object createMapComponentFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord dbRow,
                                                  ObjectBuildingQuery query,
                                                  org.eclipse.persistence.internal.sessions.AbstractSession session)
INTERNAL Called when a DatabaseMapping is used to map the key in a collection. Returns the key.

Specified by:
createMapComponentFromRow in interface MapComponentMapping

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


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

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

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

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

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

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

isPrivateOwned

public boolean isPrivateOwned()
INTERNAL:

Overrides:
isPrivateOwned in class ForeignReferenceMapping

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)
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)
INTERNAL: Merge changes from the source to the target object.

Overrides:
mergeIntoObject in class CollectionMapping

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

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,


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


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

valueFromRow

public java.lang.Object valueFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row,
                                     org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager,
                                     ObjectBuildingQuery sourceQuery,
                                     org.eclipse.persistence.internal.sessions.AbstractSession executionSession)
                              throws DatabaseException
INTERNAL: Retrieves a value from the row for a particular query key

Overrides:
valueFromRow in class ForeignReferenceMapping
Throws:
DatabaseException

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

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.