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,
                           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​(String sourceFieldName,
                                      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,
                                  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​(Map<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​(String attributeName,
                                            String sourceFieldName,
                                            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​(String attributeName,
                                        org.eclipse.persistence.internal.helper.DatabaseField sourceField,
                                        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​(String attributeName,
                                             Map<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​(String targetForeignKey,
                                           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 Object buildBackupCloneForPartObject​(Object attributeValue,
                                              Object clone,
                                              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 Object buildCloneForPartObject​(Object attributeValue,
                                        Object original,
                                        org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey,
                                        Object clone,
                                        org.eclipse.persistence.internal.sessions.AbstractSession cloningSession,
                                        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

• buildElementClone

  public Object buildElementClone​(Object element,
                                  Object parent,
                                  org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                                  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

• buildExpression

  public Expression buildExpression​(Object queryObject,
                                    QueryByExamplePolicy policy,
                                    Expression expressionBuilder,
                                    Map processedObjects,
                                    org.eclipse.persistence.internal.sessions.AbstractSession session)

  INTERNAL: In case Query By Example is used, this method builds and returns an expression that corresponds to a single attribute and it's value.

  Overrides:

  buildExpression in class CollectionMapping

• collectQueryParameters

  public void collectQueryParameters​(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

• convertClassNamesToClasses

  public void convertClassNamesToClasses​(ClassLoader classLoader)

  INTERNAL: Convert all the class-name-based settings in this mapping to actual class-based settings. This method is used when converting a project that has been built with class names to a project with classes.

  Overrides:

  convertClassNamesToClasses in class CollectionMapping

  Parameters:

  classLoader - Where to search for classes.

• cascadeDiscoverAndPersistUnregisteredNewObjects

  public void cascadeDiscoverAndPersistUnregisteredNewObjects​(Object object,
                                                              Map newObjects,
                                                              Map unregisteredExistingObjects,
                                                              Map visitedObjects,
                                                              org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                                              Set cascadeErrors)

  INTERNAL: Cascade discover and persist new objects during commit.

  Overrides:

  cascadeDiscoverAndPersistUnregisteredNewObjects in class CollectionMapping

• cascadeRegisterNewIfRequired

  public void cascadeRegisterNewIfRequired​(Object object,
                                           org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                           Map visitedObjects)

  INTERNAL: Cascade registerNew for Create through mappings that require the cascade

  Overrides:

  cascadeRegisterNewIfRequired in class CollectionMapping

• cascadePerformRemoveIfRequired

  public void cascadePerformRemoveIfRequired​(Object object,
                                             org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                             Map visitedObjects)

  INTERNAL: Cascade registerNew for Create through mappings that require the cascade

  Overrides:

  cascadePerformRemoveIfRequired in class CollectionMapping

• cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired

  public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired​(Object object,
                                                                            org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                                                            Map visitedObjects)

  INTERNAL: Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet

  Overrides:

  cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired in class CollectionMapping

• clone

  public 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​(Object clone,
                                                                                 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​(Object firstObject,
                                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​(List firstList,
                              List secondList,
                              org.eclipse.persistence.internal.sessions.AbstractSession session)

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

• createMapComponentFromRow

  public 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

• getAggregateRow

  public org.eclipse.persistence.internal.sessions.AbstractRecord getAggregateRow​(ObjectLevelModifyQuery query,
                                                                                  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​(Class theClass,
                                                org.eclipse.persistence.internal.sessions.AbstractSession session)

  INTERNAL: for inheritance purpose

• getReferenceObjectKeys

  public Vector getReferenceObjectKeys​(ObjectLevelModifyQuery query)
                                throws DatabaseException,
                                       OptimisticLockException

  INTERNAL: get reference object keys

  Throws:

  DatabaseException

  OptimisticLockException

• getSourceKeyFieldNames

  public Vector getSourceKeyFieldNames()

  PUBLIC: Return the source key field names associated with the mapping. These are in-order with the targetForeignKeyFieldNames.

• getSourceKeyFields

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

  INTERNAL: Return the source key names associated with the mapping

• getTargetForeignKeyFieldNames

  public Vector getTargetForeignKeyFieldNames()

  PUBLIC: Return the target foregin key field names associated with the mapping. These are in-order with the sourceKeyFieldNames.

• getTargetForeignKeyFields

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

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

• getTargetForeignKeyToSourceKeys

  public 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,
                                         HashMap<org.eclipse.persistence.internal.helper.DatabaseField,​org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation,
                                         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,
                                          HashMap<org.eclipse.persistence.internal.helper.DatabaseField,​org.eclipse.persistence.internal.helper.DatabaseField> fieldTranslation,
                                          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,
                               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

• load

  public void load​(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​(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​(Object target,
                                     org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                                     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​(Object target,
                              boolean isTargetUnInitialized,
                              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

• 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,
                                                             Object object)

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

• prepareModifyQueryForDelete

  public void prepareModifyQueryForDelete​(ObjectLevelModifyQuery originalQuery,
                                          ObjectLevelModifyQuery modifyQuery,
                                          Object wrappedObject,
                                          Map extraData)

  INTERNAL: setup the modifyQuery for pre delete

• prepareModifyQueryForUpdate

  public void prepareModifyQueryForUpdate​(ObjectLevelModifyQuery originalQuery,
                                          ObjectLevelModifyQuery modifyQuery,
                                          Object object)

  INTERNAL: setup the modifyQuery for update,

• setSourceKeyFieldNames

  public void setSourceKeyFieldNames​(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​(Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields)

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

• setTargetForeignKeyFieldNames

  public void setTargetForeignKeyFieldNames​(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​(Vector<org.eclipse.persistence.internal.helper.DatabaseField> targetForeignKeyFields)

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

• simpleAddToCollectionChangeRecord

  public void simpleAddToCollectionChangeRecord​(Object referenceKey,
                                                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​(Object referenceKey,
                                                     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​(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.

• 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