ObjectReferenceMapping (EclipseLink 2.6.0, 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.ObjectReferenceMapping

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable

Direct Known Subclasses:

EISOneToOneMapping, OneToOneMapping, ReferenceMapping, VariableOneToOneMapping
```
public abstract class ObjectReferenceMapping
extends ForeignReferenceMapping
```
Purpose: Abstract class for 1:1, variable 1:1 and reference mappings

See Also:
Serialized Form

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.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`foreignKeyFields` Keeps track of which fields are foreign keys on a per field basis (can have mixed foreign key relationships).
`protected boolean`	`isForeignKeyRelationship` Keeps track if any of the fields are foreign keys.

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
Modifier Constructor and Description

protected ObjectReferenceMapping()

Constructors
Modifier	Constructor and Description
`protected`	`ObjectReferenceMapping()`

Method Summary

Methods
Modifier and Type	Method and Description
`java.lang.Object`	`buildBackupCloneForPartObject(java.lang.Object attributeValue, java.lang.Object clone, java.lang.Object backup, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)` INTERNAL: Used during building the backup shallow copy to copy the vector without re-registering the target objects.
`org.eclipse.persistence.internal.sessions.ChangeRecord`	`buildChangeRecord(java.lang.Object clone, org.eclipse.persistence.internal.sessions.ObjectChangeSet owner, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Directly build a change record without comparison
`java.lang.Object`	`buildCloneForPartObject(java.lang.Object attributeValue, java.lang.Object original, org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey, java.lang.Object clone, org.eclipse.persistence.internal.sessions.AbstractSession cloningSession, java.lang.Integer refreshCascade, boolean isExisting, boolean isFromSharedCache)` INTERNAL: Require for cloning, the part must be cloned.
`void`	`buildCopy(java.lang.Object copy, java.lang.Object original, CopyGroup group)` INTERNAL: Copy of the attribute of the object.
`Expression`	`buildExpression(java.lang.Object queryObject, QueryByExamplePolicy policy, Expression expressionBuilder, java.util.Map processedObjects, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: In case Query By Example is used, this method generates an expression from a attribute value pair.
`java.lang.Object[]`	`buildReferencesPKList(java.lang.Object entity, java.lang.Object attribute, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method will access the target relationship and create a list of PKs of the target entities.
`java.util.Collection`	`buildTargetInterfaces(java.lang.Class aClass, java.util.Collection targetInterfacesCol)` INTERNAL: Build a list of all the interfaces and super interfaces for a given class.
`java.lang.Object`	`buildUnitofWorkCloneForPartObject(java.lang.Object attributeValue, java.lang.Object original, java.lang.Object clone, java.lang.Integer refreshCascade, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork, boolean isExisting)` INTERNAL: Require for cloning, the part must be cloned.
`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, boolean getAttributeValueFromObject, java.util.Set cascadeErrors)` INTERNAL: Cascade discover and persist new objects during commit.
`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`	`cascadePerformRemoveIfRequired(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Map visitedObjects, boolean getAttributeValueFromObject)` INTERNAL: Cascade remove 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 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
`void`	`cascadeRegisterNewIfRequired(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Map visitedObjects, boolean getAttributeValueFromObject)` INTERNAL: Cascade registerNew for Create through mappings that require the cascade
`protected java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`collectFields()` INTERNAL: Return all the fields populated by this mapping, these are foreign keys only.
`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: Return an ObjectReferenceChangeRecord describing the change, or null if no change.
`protected boolean`	`compareObjectsWithoutPrivateOwned(java.lang.Object firstObject, java.lang.Object secondObject, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Compare the references of the two objects are the same, not the objects themselves.
`protected boolean`	`compareObjectsWithPrivateOwned(java.lang.Object firstObject, java.lang.Object secondObject, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Compare the references of the two objects are the same, and the objects themselves are the same.
`org.eclipse.persistence.internal.indirection.DatabaseValueHolder`	`createCloneValueHolder(ValueHolderInterface attributeValue, java.lang.Object original, java.lang.Object clone, org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.sessions.AbstractSession cloningSession, boolean buildDirectlyFromRow)` INTERNAL: Builder the unit of work value holder.
`void`	`earlyPreDelete(DeleteObjectQuery query, java.lang.Object object)` INTERNAL: Record deletion dependencies for foreign key constraints.
`org.eclipse.persistence.internal.sessions.AbstractRecord`	`extractPrimaryKeyRowForSourceObject(java.lang.Object domainObject, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Extract the reference pk for rvh usage in remote model.
`java.lang.Object`	`extractPrimaryKeysForReferenceObject(java.lang.Object domainObject, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Extract the reference pk for rvh usage in remote model.
`java.lang.Object`	`extractPrimaryKeysForReferenceObjectFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row)` INTERNAL: Return the primary key for the reference object (i.e. the object object referenced by domainObject and specified by mapping).
`java.lang.Object`	`extractPrimaryKeysFromRealReferenceObject(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Extract the reference pk for rvh usage in remote model.
`void`	`fixRealObjectReferences(java.lang.Object object, java.util.Map objectDescriptors, java.util.Map processedObjects, ObjectLevelReadQuery query, DistributedSession session)` INTERNAL: We are not using a remote valueholder so we need to replace the reference object(s) with the corresponding object(s) from the remote session.
`ClassDescriptor`	`getDescriptorForTarget(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Return a descriptor for the target of this mapping
`java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`getForeignKeyFields()` INTERNAL: Returns the foreign key names associated with the mapping.
`protected java.lang.Object`	`getPrimaryKeyForObject(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL:
`java.lang.Object`	`getRealAttributeValueFromAttribute(java.lang.Object attributeValue, java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Object reference must unwrap the reference object if required.
`boolean`	`hasConstraintDependency()` INTERNAL: The returns if the mapping has any constraint dependencies, such as foreign keys and join tables.
`boolean`	`hasRelationTableMechanism()` PUBLIC: Indicates whether the mapping has RelationTableMechanism.
`protected void`	`insert(WriteObjectQuery query)` INTERNAL: Insert privately owned parts
`org.eclipse.persistence.internal.sessions.ObjectReferenceChangeRecord`	`internalBuildChangeRecord(java.lang.Object newValue, org.eclipse.persistence.internal.sessions.ObjectChangeSet owner, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Directly build a change record based on the newValue without comparison
`boolean`	`isChangeTrackingSupported(Project project)` INTERNAL: Return if this mapping supports change tracking.
`boolean`	`isForeignKeyRelationship()` INTERNAL: Return if the 1-1 mapping has a foreign key dependency to its target.
`boolean`	`isObjectReferenceMapping()` INTERNAL: Related mapping should implement this method to return true.
`void`	`iterateOnRealAttributeValue(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, java.lang.Object realAttributeValue)` INTERNAL: Iterate on the attribute value.
`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.
`void`	`postCalculateChanges(ChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.
`void`	`postDelete(DeleteObjectQuery query)` INTERNAL: Delete privately owned parts
`void`	`postInsert(WriteObjectQuery query)` INTERNAL: Insert privately owned parts
`void`	`postUpdate(WriteObjectQuery query)` INTERNAL: Update privately owned parts
`void`	`preDelete(DeleteObjectQuery query)` INTERNAL: Delete privately owned parts
`void`	`preInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initialize the state of mapping.
`void`	`preInsert(WriteObjectQuery query)` INTERNAL: Insert privately owned parts
`void`	`preUpdate(WriteObjectQuery query)` INTERNAL: Update privately owned parts
`protected java.lang.Object`	`readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery)` INTERNAL: Reads the private owned object.
`void`	`recordPrivateOwnedRemovals(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.
`protected void`	`setForeignKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> foreignKeyFields)` INTERNAL: Set the foreign key fields associated with the mapping.
`void`	`setIsForeignKeyRelationship(boolean isForeignKeyRelationship)` INTERNAL: Set if the 1-1 mapping has a foreign key dependency to its target.
`void`	`setNewValueInChangeRecord(java.lang.Object newValue, org.eclipse.persistence.internal.sessions.ObjectReferenceChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.ObjectChangeSet owner, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Set the newValue in the change record
`protected void`	`update(WriteObjectQuery query)` INTERNAL: Update the private owned part.
`void`	`updateChangeRecord(java.lang.Object clone, java.lang.Object newValue, java.lang.Object oldValue, org.eclipse.persistence.internal.sessions.ObjectChangeSet objectChangeSet, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)` INTERNAL: Either create a new change record or update the change record with the new value.
`void`	`updateChangeRecordForSelfMerge(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, java.lang.Object source, java.lang.Object target, org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet parentUOWChangeSet, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)` INTERNAL: Update a ChangeRecord to replace the ChangeSet for the old entity with the changeSet for the new Entity.
`void`	`useProxyIndirection()` PUBLIC: Set this mapping to use Proxy Indirection.
`void`	`useProxyIndirection(java.lang.Class targetInterface)` PUBLIC: Set this mapping to use Proxy Indirection.
`void`	`useProxyIndirection(java.lang.Class[] targetInterfaces)` PUBLIC: Set this mapping to use Proxy Indirection.
`java.lang.Object`	`valueFromPKList(java.lang.Object[] pks, org.eclipse.persistence.internal.sessions.AbstractRecord foreignKeys, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method is used to load a relationship from a list of PKs.
`boolean`	`verifyDelete(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: To verify if the specified object is deleted or not.
`void`	`writeFromObjectIntoRowForUpdate(WriteObjectQuery query, org.eclipse.persistence.internal.sessions.AbstractRecord databaseRow)` INTERNAL: Get a value from the object and set that in the respective field of the row.
`void`	`writeFromObjectIntoRowForWhereClause(ObjectLevelModifyQuery query, org.eclipse.persistence.internal.sessions.AbstractRecord databaseRow)` INTERNAL: Get a value from the object and set that in the respective field of the row.

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

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

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

Field Detail
- isForeignKeyRelationship
```
protected boolean isForeignKeyRelationship
```
  Keeps track if any of the fields are foreign keys.
- foreignKeyFields
```
protected java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> foreignKeyFields
```
  Keeps track of which fields are foreign keys on a per field basis (can have mixed foreign key relationships).

Constructor Detail
- ObjectReferenceMapping
```
protected ObjectReferenceMapping()
```

Method Detail

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. For 1-1 or ref the reference is from the clone so it is already registered.

Specified by:: buildBackupCloneForPartObject in class ForeignReferenceMapping

buildCloneForPartObject

public java.lang.Object buildCloneForPartObject(java.lang.Object attributeValue,
                                       java.lang.Object original,
                                       org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey,
                                       java.lang.Object clone,
                                       org.eclipse.persistence.internal.sessions.AbstractSession cloningSession,
                                       java.lang.Integer refreshCascade,
                                       boolean isExisting,
                                       boolean isFromSharedCache)

INTERNAL: Require for cloning, the part must be cloned. Ignore the objects, use the attribute value.

Specified by:: buildCloneForPartObject in class ForeignReferenceMapping

buildUnitofWorkCloneForPartObject

public java.lang.Object buildUnitofWorkCloneForPartObject(java.lang.Object attributeValue,
                                                 java.lang.Object original,
                                                 java.lang.Object clone,
                                                 java.lang.Integer refreshCascade,
                                                 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.

buildCopy
```
public void buildCopy(java.lang.Object copy,
             java.lang.Object original,
             CopyGroup group)
```
INTERNAL: Copy of the attribute of the object. This is NOT used for unit of work but for templatizing an object.

Overrides:

buildCopy in class DatabaseMapping

buildExpression

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

INTERNAL: In case Query By Example is used, this method generates an expression from a attribute value pair. Since this is a ObjectReference mapping, a recursive call is made to the buildExpressionFromExample method of ObjectBuilder.

Overrides:: buildExpression in class DatabaseMapping

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: Return an ObjectReferenceChangeRecord describing the change, or null if no change. Used to compute changes for deferred change tracking.

Specified by:: compareForChange in class DatabaseMapping
Returns:: prototype.changeset.ChangeRecord

internalBuildChangeRecord

public org.eclipse.persistence.internal.sessions.ObjectReferenceChangeRecord internalBuildChangeRecord(java.lang.Object newValue,
                                                                                              org.eclipse.persistence.internal.sessions.ObjectChangeSet owner,
                                                                                              org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Directly build a change record based on the newValue without comparison

setNewValueInChangeRecord

public void setNewValueInChangeRecord(java.lang.Object newValue,
                             org.eclipse.persistence.internal.sessions.ObjectReferenceChangeRecord changeRecord,
                             org.eclipse.persistence.internal.sessions.ObjectChangeSet owner,
                             org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Set the newValue in the change record

compareObjectsWithoutPrivateOwned
```
protected boolean compareObjectsWithoutPrivateOwned(java.lang.Object firstObject,
                                        java.lang.Object secondObject,
                                        org.eclipse.persistence.internal.sessions.AbstractSession session)
```
INTERNAL: Compare the references of the two objects are the same, not the objects themselves. Used for independent relationships. This is used for testing and validation purposes.

Specified by:

compareObjectsWithoutPrivateOwned in class ForeignReferenceMapping

compareObjectsWithPrivateOwned
```
protected boolean compareObjectsWithPrivateOwned(java.lang.Object firstObject,
                                     java.lang.Object secondObject,
                                     org.eclipse.persistence.internal.sessions.AbstractSession session)
```
INTERNAL: Compare the references of the two objects are the same, and the objects themselves are the same. Used for private relationships. This is used for testing and validation purposes.

Specified by:

compareObjectsWithPrivateOwned in class ForeignReferenceMapping

fixRealObjectReferences

public void fixRealObjectReferences(java.lang.Object object,
                           java.util.Map objectDescriptors,
                           java.util.Map processedObjects,
                           ObjectLevelReadQuery query,
                           DistributedSession session)

INTERNAL: We are not using a remote valueholder so we need to replace the reference object(s) with the corresponding object(s) from the remote session. ObjectReferenceMappings need to unwrap and wrap the reference object.

Overrides:: fixRealObjectReferences in class DatabaseMapping

getDescriptorForTarget

public ClassDescriptor getDescriptorForTarget(java.lang.Object object,
                                     org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Return a descriptor for the target of this mapping

See Also:: Bug 2612571

getRealAttributeValueFromAttribute

public java.lang.Object getRealAttributeValueFromAttribute(java.lang.Object attributeValue,
                                                  java.lang.Object object,
                                                  org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Object reference must unwrap the reference object if required.

Overrides:: getRealAttributeValueFromAttribute in class ForeignReferenceMapping

isObjectReferenceMapping
```
public boolean isObjectReferenceMapping()
```
INTERNAL: Related mapping should implement this method to return true.

Overrides:

isObjectReferenceMapping in class DatabaseMapping

iterateOnRealAttributeValue
```
public void iterateOnRealAttributeValue(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator,
                               java.lang.Object realAttributeValue)
```
INTERNAL: Iterate on the attribute value. The value holder has already been processed.

Specified by:

iterateOnRealAttributeValue in class ForeignReferenceMapping

loadAll

public void loadAll(java.lang.Object object,
           org.eclipse.persistence.internal.sessions.AbstractSession session,
           org.eclipse.persistence.internal.helper.IdentityHashSet loaded)

Force instantiation of all indirections.

Overrides:: loadAll in class DatabaseMapping

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. Which is the original from the parent UnitOfWork

Specified by:: mergeChangesIntoObject in class DatabaseMapping

mergeIntoObject

public void mergeIntoObject(java.lang.Object target,
                   boolean isTargetUnInitialized,
                   java.lang.Object source,
                   org.eclipse.persistence.internal.sessions.MergeManager mergeManager,
                   org.eclipse.persistence.internal.sessions.AbstractSession targetSession)

INTERNAL: Merge changes from the source to the target object.

Specified by:: mergeIntoObject in class DatabaseMapping

collectFields
```
protected java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> collectFields()
```
INTERNAL: Return all the fields populated by this mapping, these are foreign keys only.

Overrides:

collectFields in class DatabaseMapping

getForeignKeyFields
```
public java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> getForeignKeyFields()
```
INTERNAL: Returns the foreign key names associated with the mapping. These are the fields that will be populated by the 1-1 mapping when writing.

setForeignKeyFields
```
protected void setForeignKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> foreignKeyFields)
```
INTERNAL: Set the foreign key fields associated with the mapping. These are the fields that will be populated by the 1-1 mapping when writing.

isForeignKeyRelationship
```
public boolean isForeignKeyRelationship()
```
INTERNAL: Return if the 1-1 mapping has a foreign key dependency to its target. This is true if any of the foreign key fields are true foreign keys, i.e. populated on write from the targets primary key.

setIsForeignKeyRelationship
```
public void setIsForeignKeyRelationship(boolean isForeignKeyRelationship)
```
INTERNAL: Set if the 1-1 mapping has a foreign key dependency to its target. This is true if any of the foreign key fields are true foreign keys, i.e. populated on write from the targets primary key.

preInsert

public void preInsert(WriteObjectQuery query)
               throws DatabaseException,
                      OptimisticLockException

INTERNAL: Insert privately owned parts

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

readPrivateOwnedForObject

protected java.lang.Object readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery)
                                              throws DatabaseException

INTERNAL: Reads the private owned object.

Throws:: DatabaseException

preUpdate

public void preUpdate(WriteObjectQuery query)
               throws DatabaseException,
                      OptimisticLockException

INTERNAL: Update privately owned parts

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

postCalculateChanges
```
public void postCalculateChanges(ChangeRecord changeRecord,
                        org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.

Overrides:

postCalculateChanges in class DatabaseMapping

recordPrivateOwnedRemovals
```
public void recordPrivateOwnedRemovals(java.lang.Object object,
                              org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
```
INTERNAL: Overridden by mappings that require additional processing of the change record after the record has been calculated.

Overrides:

recordPrivateOwnedRemovals in class DatabaseMapping

postDelete

public void postDelete(DeleteObjectQuery query)
                throws DatabaseException,
                       OptimisticLockException

INTERNAL: Delete privately owned parts

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

postInsert

public void postInsert(WriteObjectQuery query)
                throws DatabaseException,
                       OptimisticLockException

INTERNAL: Insert privately owned parts

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

postUpdate

public void postUpdate(WriteObjectQuery query)
                throws DatabaseException,
                       OptimisticLockException

INTERNAL: Update 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

earlyPreDelete
```
public void earlyPreDelete(DeleteObjectQuery query,
                  java.lang.Object object)
```
INTERNAL: Record deletion dependencies for foreign key constraints. This is used during deletion to resolve deletion cycles.

Overrides:

earlyPreDelete in class DatabaseMapping

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

Specified by:: cascadePerformRemoveIfRequired in class DatabaseMapping

cascadePerformRemoveIfRequired

public void cascadePerformRemoveIfRequired(java.lang.Object object,
                                  org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                  java.util.Map visitedObjects,
                                  boolean getAttributeValueFromObject)

INTERNAL: Cascade remove through mappings that require the cascade.

Parameters:: object - is either the source object, or attribute value if getAttributeValueFromObject is true.

cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired

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

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

Overrides:: cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired in class DatabaseMapping

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

Specified by:

collectQueryParameters in class ForeignReferenceMapping

cascadeDiscoverAndPersistUnregisteredNewObjects

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

INTERNAL: Cascade discover and persist new objects during commit.

Overrides:: cascadeDiscoverAndPersistUnregisteredNewObjects in class DatabaseMapping

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,
                                                   boolean getAttributeValueFromObject,
                                                   java.util.Set cascadeErrors)

INTERNAL: Cascade discover and persist new objects during commit.

cascadeRegisterNewIfRequired

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

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

Specified by:: cascadeRegisterNewIfRequired in class DatabaseMapping

cascadeRegisterNewIfRequired

public void cascadeRegisterNewIfRequired(java.lang.Object object,
                                org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                java.util.Map visitedObjects,
                                boolean getAttributeValueFromObject)

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

Parameters:: object - is either the source object, or attribute value if getAttributeValueFromObject is true.

getPrimaryKeyForObject

protected java.lang.Object getPrimaryKeyForObject(java.lang.Object object,
                                      org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL:

hasConstraintDependency
```
public boolean hasConstraintDependency()
```
INTERNAL: The returns if the mapping has any constraint dependencies, such as foreign keys and join tables.

Overrides:

hasConstraintDependency in class DatabaseMapping

createCloneValueHolder

public org.eclipse.persistence.internal.indirection.DatabaseValueHolder createCloneValueHolder(ValueHolderInterface attributeValue,
                                                                                      java.lang.Object original,
                                                                                      java.lang.Object clone,
                                                                                      org.eclipse.persistence.internal.sessions.AbstractRecord row,
                                                                                      org.eclipse.persistence.internal.sessions.AbstractSession cloningSession,
                                                                                      boolean buildDirectlyFromRow)

INTERNAL: Builder the unit of work value holder.

Overrides:: createCloneValueHolder in class ForeignReferenceMapping
Parameters:: buildDirectlyFromRow - indicates that we are building the clone directly from a row as opposed to building the original from the row, putting it in the shared cache, and then cloning the original.

extractPrimaryKeyRowForSourceObject

public org.eclipse.persistence.internal.sessions.AbstractRecord extractPrimaryKeyRowForSourceObject(java.lang.Object domainObject,
                                                                                           org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Extract the reference pk for rvh usage in remote model.

extractPrimaryKeysForReferenceObject

public java.lang.Object extractPrimaryKeysForReferenceObject(java.lang.Object domainObject,
                                                    org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Extract the reference pk for rvh usage in remote model.

extractPrimaryKeysForReferenceObjectFromRow
```
public java.lang.Object extractPrimaryKeysForReferenceObjectFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row)
```
INTERNAL: Return the primary key for the reference object (i.e. the object object referenced by domainObject and specified by mapping). This key will be used by a RemoteValueHolder.

extractPrimaryKeysFromRealReferenceObject

public java.lang.Object extractPrimaryKeysFromRealReferenceObject(java.lang.Object object,
                                                         org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Extract the reference pk for rvh usage in remote model.

preInitialize

public void preInitialize(org.eclipse.persistence.internal.sessions.AbstractSession session)
                   throws DescriptorException

INTERNAL: Initialize the state of mapping.

Overrides:: preInitialize in class ForeignReferenceMapping
Throws:: DescriptorException

insert

protected void insert(WriteObjectQuery query)
               throws DatabaseException,
                      OptimisticLockException

INTERNAL: Insert privately owned parts

Throws:: DatabaseException; OptimisticLockException

update

protected void update(WriteObjectQuery query)
               throws DatabaseException,
                      OptimisticLockException

INTERNAL: Update the private owned part.

Throws:: DatabaseException; OptimisticLockException

hasRelationTableMechanism
```
public boolean hasRelationTableMechanism()
```
PUBLIC: Indicates whether the mapping has RelationTableMechanism.

useProxyIndirection
```
public void useProxyIndirection()
```
PUBLIC: Set this mapping to use Proxy Indirection. Proxy Indirection uses the Proxy and InvocationHandler features of JDK 1.3 to provide "transparent indirection" for 1:1 relationships. In order to use Proxy Indirection:
- The target class must implement at least one public interface
- The attribute on the source class must be typed as that public interface
- get() and set() methods for the attribute must use the interface
With this policy, proxy objects are returned during object creation. When a message other than toString is called on the proxy the real object data is retrieved from the database. By default, use the target class' full list of interfaces for the proxy.

buildReferencesPKList
```
public java.lang.Object[] buildReferencesPKList(java.lang.Object entity,
                                       java.lang.Object attribute,
                                       org.eclipse.persistence.internal.sessions.AbstractSession session)
```
INTERNAL: This method will access the target relationship and create a list of PKs of the target entities. This method is used in combination with the CachedValueHolder to store references to PK's to be loaded from a cache instead of a query.

Specified by:

buildReferencesPKList in class ForeignReferenceMapping

See Also:
ContainerPolicy.buildReferencesPKList(java.lang.Object, org.eclipse.persistence.internal.sessions.AbstractSession), MappedKeyMapContainerPolicy

buildTargetInterfaces

public java.util.Collection buildTargetInterfaces(java.lang.Class aClass,
                                         java.util.Collection targetInterfacesCol)

INTERNAL: Build a list of all the interfaces and super interfaces for a given class.

useProxyIndirection
```
public void useProxyIndirection(java.lang.Class[] targetInterfaces)
```
PUBLIC: Set this mapping to use Proxy Indirection. Proxy Indirection uses the Proxy and InvocationHandler features of JDK 1.3 to provide "transparent indirection" for 1:1 relationships. In order to use Proxy Indirection:
- The target class must implement at least one public interface
- The attribute on the source class must be typed as that public interface
- get() and set() methods for the attribute must use the interface
With this policy, proxy objects are returned during object creation. When a message other than toString is called on the proxy the real object data is retrieved from the database.
Parameters:
targetInterfaces - The interfaces that the target class implements. The attribute must be typed as one of these interfaces.

useProxyIndirection
```
public void useProxyIndirection(java.lang.Class targetInterface)
```
PUBLIC: Set this mapping to use Proxy Indirection. Proxy Indirection uses the Proxy and InvocationHandler features of JDK 1.3 to provide "transparent indirection" for 1:1 relationships. In order to use Proxy Indirection:
- The target class must implement at least one public interface
- The attribute on the source class must be typed as that public interface
- get() and set() methods for the attribute must use the interface
With this policy, proxy objects are returned during object creation. When a message other than toString is called on the proxy the real object data is retrieved from the database.
Parameters:
targetInterface - The interface that the target class implements. The attribute must be typed as this interface.

valueFromPKList

public java.lang.Object valueFromPKList(java.lang.Object[] pks,
                               org.eclipse.persistence.internal.sessions.AbstractRecord foreignKeys,
                               org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: This method is used to load a relationship from a list of PKs. This list may be available if the relationship has been cached.

Specified by:: valueFromPKList in class ForeignReferenceMapping

verifyDelete

public boolean verifyDelete(java.lang.Object object,
                   org.eclipse.persistence.internal.sessions.AbstractSession session)
                     throws DatabaseException

INTERNAL: To verify if the specified object is deleted or not.

Overrides:: verifyDelete in class DatabaseMapping
Throws:: DatabaseException

writeFromObjectIntoRowForUpdate
```
public void writeFromObjectIntoRowForUpdate(WriteObjectQuery query,
                                   org.eclipse.persistence.internal.sessions.AbstractRecord databaseRow)
```
INTERNAL: Get a value from the object and set that in the respective field of the row. But before that check if the reference object is instantiated or not.

Overrides:

writeFromObjectIntoRowForUpdate in class DatabaseMapping

writeFromObjectIntoRowForWhereClause

public void writeFromObjectIntoRowForWhereClause(ObjectLevelModifyQuery query,
                                        org.eclipse.persistence.internal.sessions.AbstractRecord databaseRow)

INTERNAL: Get a value from the object and set that in the respective field of the row.

Overrides:: writeFromObjectIntoRowForWhereClause in class DatabaseMapping

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

Overrides:

isChangeTrackingSupported in class DatabaseMapping

updateChangeRecord

public void updateChangeRecord(java.lang.Object clone,
                      java.lang.Object newValue,
                      java.lang.Object oldValue,
                      org.eclipse.persistence.internal.sessions.ObjectChangeSet objectChangeSet,
                      org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)

INTERNAL: Either create a new change record or update the change record with the new value. This is used by attribute change tracking.

Overrides:: updateChangeRecord in class DatabaseMapping

updateChangeRecordForSelfMerge

public void updateChangeRecordForSelfMerge(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord,
                                  java.lang.Object source,
                                  java.lang.Object target,
                                  org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet parentUOWChangeSet,
                                  org.eclipse.persistence.internal.sessions.UnitOfWorkImpl unitOfWork)

INTERNAL: Update a ChangeRecord to replace the ChangeSet for the old entity with the changeSet for the new Entity. This is used when an Entity is merged into itself and the Entity reference new or detached entities.

Specified by:: updateChangeRecordForSelfMerge in class ForeignReferenceMapping

buildChangeRecord

public org.eclipse.persistence.internal.sessions.ChangeRecord buildChangeRecord(java.lang.Object clone,
                                                                       org.eclipse.persistence.internal.sessions.ObjectChangeSet owner,
                                                                       org.eclipse.persistence.internal.sessions.AbstractSession session)

INTERNAL: Directly build a change record without comparison

Overrides:: buildChangeRecord in class DatabaseMapping

Class ObjectReferenceMapping

Nested Class Summary

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

Field Summary

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

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Field Detail

isForeignKeyRelationship

foreignKeyFields

Constructor Detail

ObjectReferenceMapping

Method Detail

buildBackupCloneForPartObject

buildCloneForPartObject

buildUnitofWorkCloneForPartObject

buildCopy

buildExpression

compareForChange

internalBuildChangeRecord

setNewValueInChangeRecord

compareObjectsWithoutPrivateOwned

compareObjectsWithPrivateOwned

fixRealObjectReferences

getDescriptorForTarget

getRealAttributeValueFromAttribute

isObjectReferenceMapping

iterateOnRealAttributeValue

loadAll

mergeChangesIntoObject

mergeIntoObject

collectFields

getForeignKeyFields

setForeignKeyFields

isForeignKeyRelationship

setIsForeignKeyRelationship

preInsert

readPrivateOwnedForObject

preUpdate

postCalculateChanges

recordPrivateOwnedRemovals

postDelete

postInsert

postUpdate

preDelete

earlyPreDelete

cascadePerformRemoveIfRequired

cascadePerformRemoveIfRequired

cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired

collectQueryParameters

cascadeDiscoverAndPersistUnregisteredNewObjects

cascadeDiscoverAndPersistUnregisteredNewObjects

cascadeRegisterNewIfRequired

cascadeRegisterNewIfRequired

getPrimaryKeyForObject

hasConstraintDependency

createCloneValueHolder

extractPrimaryKeyRowForSourceObject

extractPrimaryKeysForReferenceObject

extractPrimaryKeysForReferenceObjectFromRow

extractPrimaryKeysFromRealReferenceObject

preInitialize

insert

update

hasRelationTableMechanism

useProxyIndirection

buildReferencesPKList

buildTargetInterfaces

useProxyIndirection

useProxyIndirection

valueFromPKList

verifyDelete

writeFromObjectIntoRowForUpdate

writeFromObjectIntoRowForWhereClause

isChangeTrackingSupported

updateChangeRecord