Top Description Inners Fields Constructors Methods
org.eclipse.persistence.mappings

public Class OneToOneMapping

extends ObjectReferenceMapping
implements RelationalMapping, MapKeyMapping
Class Inheritance
All Implemented Interfaces
org.eclipse.persistence.mappings.foundation.MapKeyMapping, org.eclipse.persistence.mappings.foundation.MapComponentMapping, org.eclipse.persistence.mappings.RelationalMapping
Known Direct Subclasses
org.eclipse.persistence.mappings.ManyToOneMapping
Imports
java.util.*, org.eclipse.persistence.annotations.CacheKeyType, org.eclipse.persistence.descriptors.ClassDescriptor, org.eclipse.persistence.exceptions.*, org.eclipse.persistence.expressions.*, org.eclipse.persistence.internal.helper.*, org.eclipse.persistence.internal.identitymaps.*, org.eclipse.persistence.internal.indirection.ProxyIndirectionPolicy, org.eclipse.persistence.internal.queries.ContainerPolicy, .JoinedAttributeManager, .MappedKeyMapContainerPolicy, org.eclipse.persistence.internal.sessions.*, org.eclipse.persistence.sessions.DatabaseRecord, org.eclipse.persistence.queries.*, org.eclipse.persistence.internal.descriptors.CascadeLockingPolicy, .DescriptorIterator, .ObjectBuilder, org.eclipse.persistence.internal.expressions.ConstantExpression, .ObjectExpression, .FieldExpression, .ParameterExpression, .QueryKeyExpression, .SQLSelectStatement, org.eclipse.persistence.mappings.foundation.MapKeyMapping, org.eclipse.persistence.mappings.querykeys.OneToOneQueryKey, .QueryKey

Purpose: One to one mappings are used to represent a pointer references between two java objects. This mappings is usually represented by a single pointer (stored in an instance variable) between the source and target objects. In the relational database tables, these mappings are normally implemented using foreign keys.

Author
Sati
Since
TOPLink/Java 1.0

Nested and Inner Type Summary

Modifier and TypeClass and Description
protected static enum
OneToOneMapping.ShallowMode

Mode for writeFromObjectIntoRowInternal method

Field Summary

Modifier and TypeField and Description
protected HashSet<DatabaseField>
insertableFields

Keep track of which fields are insertable and updatable.

protected boolean
isOneToOnePrimaryKeyRelationship

Defines if this mapping was built using primary key join columns.

protected boolean
isOneToOneRelationship

Define if this mapping is really for a OneToOne relationship.

public DatabaseTable
keyTableForMapKey

protected RelationTableMechanism
mechanism

Mechanism holds relationTable and all fields and queries associated with it.

protected transient Expression
privateOwnedCriteria

protected static final String
setObject

protected boolean
shouldVerifyDelete

These are used for non-unit of work modification to check if the value of the 1-1 was changed and a deletion is required.

protected transient List<Expression>
sourceExpressionsToPostInitialize

Keep a reference to the source and target expressions to post initialize when building a selection criteria early.

protected Map<DatabaseField, DatabaseField>
sourceToTargetKeyFields

Maps the source foreign/primary key fields to the target primary/foreign key fields.

protected transient List<Expression>
targetExpressionsToPostInitialize

protected Map<DatabaseField, DatabaseField>
targetToSourceKeyFields

Maps the target primary/foreign key fields to the source foreign/primary key fields.

protected HashSet<DatabaseField>
updatableFields

Inherited from org.eclipse.persistence.mappings.ObjectReferenceMapping:
foreignKeyFieldsisForeignKeyRelationship

Constructor Summary

AccessConstructor and Description
public
OneToOneMapping()

PUBLIC: Default constructor.

Method Summary

Modifier and TypeMethod and Description
public void
addAdditionalFieldsToQuery(ReadQuery selectionQuery, Expression baseExpression)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.addAdditionalFieldsToQuery.

INTERNAL: Used when initializing queries for mappings that use a Map.
public void
addFieldsForMapKey(AbstractRecord joinRow)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.addFieldsForMapKey.

INTERNAL: Used when initializing queries for mappings that use a Map Called when the insert query is being initialized to ensure the fields for the map key are in the insert query
public void
addForeignKeyField(DatabaseField sourceForeignKeyField, DatabaseField targetPrimaryKeyField)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.addForeignKeyField.

PUBLIC: Define the foreign key relationship in the 1-1 mapping.
public void
addForeignKeyFieldName(String sourceForeignKeyFieldName, String targetPrimaryKeyFieldName)

PUBLIC: Define the foreign key relationship in the 1-1 mapping.

public void
addKeyToDeletedObjectsList(Object object, Map<K, V> deletedObjects)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.addKeyToDeletedObjectsList.

INTERNAL: For mappings used as MapKeys in MappedKeyContainerPolicy.
public void
addTargetForeignKeyField(DatabaseField targetForeignKeyField, DatabaseField sourcePrimaryKeyField)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.addTargetForeignKeyField.

PUBLIC: Define the target foreign key relationship in the 1-1 mapping.
public void
addTargetForeignKeyFieldName(String targetForeignKeyFieldName, String sourcePrimaryKeyFieldName)

PUBLIC: Define the target foreign key relationship in the 1-1 mapping.

protected Expression
buildBatchCriteria(ExpressionBuilder builder, ObjectLevelReadQuery query)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.buildBatchCriteria.

INTERNAL: Return the selection criteria used to IN batch fetching.
public Object
buildElementClone(Object attributeValue, Object parent, CacheKey cacheKey, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.buildElementClone.

Build a clone of the given element in a unitOfWork.
public Expression
buildObjectJoinExpression(Expression
TODO
expression, Object
TODO
value, AbstractSession
TODO
session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.buildObjectJoinExpression.

INTERNAL: Used to allow object level comparisons.
public Expression
buildObjectJoinExpression(Expression
TODO
expression, Expression
TODO
argument, AbstractSession
TODO
session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.buildObjectJoinExpression.

INTERNAL: Used to allow object level comparisons.
public Expression
buildSelectionCriteria()

This method would allow customers to get the potential selection criteria for a mapping prior to initialization.

public Expression
buildSelectionCriteria(boolean useParameter, boolean usePreviousSelectionCriteria)

INTERNAL: Build the selection criteria for this mapping.

public ReadQuery
buildSelectionQueryForDirectCollectionKeyMapping(ContainerPolicy containerPolicy)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.buildSelectionQueryForDirectCollectionKeyMapping.

INTERNAL: Certain key mappings favor different types of selection query.
public void
buildShallowOriginalFromRow(AbstractRecord
TODO
databaseRow, Object
TODO
original, JoinedAttributeManager
TODO
joinManager, ObjectBuildingQuery
TODO
query, AbstractSession
TODO
executionSession)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.buildShallowOriginalFromRow.

INTERNAL: Builds a shallow original object.
protected Object
checkCacheForBatchKey(AbstractRecord sourceRow, Object foreignKey, Map<K, V> batchObjects, ReadQuery batchQuery, ObjectLevelReadQuery originalQuery, AbstractSession session)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.checkCacheForBatchKey.

INTERNAL: Check if the target object is in the cache if possible based on the target key value.
public Object
clone()

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.clone.

Implements org.eclipse.persistence.mappings.foundation.MapComponentMapping.clone.

INTERNAL: This methods clones all the fields and ensures that each collection refers to the same clones.
protected Vector<DatabaseField>
collectFields()

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.collectFields.

INTERNAL: Return all the fields populated by this mapping, these are foreign keys only.
public void
collectQueryParameters(Set<DatabaseField>
TODO
cacheFields)

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.collectQueryParameters.

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
public Object
createMapComponentFromJoinedRow(AbstractRecord dbRow, JoinedAttributeManager joinManager, ObjectBuildingQuery query, CacheKey parentCacheKey, AbstractSession session, boolean isTargetProtected)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.createMapComponentFromJoinedRow.

INTERNAL Called when a DatabaseMapping is used to map the key in a collection.
public Object
createMapComponentFromRow(AbstractRecord dbRow, ObjectBuildingQuery query, CacheKey parentCacheKey, AbstractSession session, boolean isTargetProtected)

Implements org.eclipse.persistence.mappings.foundation.MapComponentMapping.createMapComponentFromRow.

INTERNAL Called when a DatabaseMapping is used to map the key in a collection.
public List<Object>
createMapComponentsFromSerializableKeyInfo(Object[] keyInfo, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.createMapComponentsFromSerializableKeyInfo.

INTERNAL: Create an instance of the Key object from the key information extracted from the map.
public QueryKey
createQueryKeyForMapKey()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.createQueryKeyForMapKey.

INTERNAL: Create a query key that links to the map key
public Object
createSerializableMapKeyInfo(Object key, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.createSerializableMapKeyInfo.

INTERNAL: Creates the Array of simple types used to recreate this map.
public Object
createStubbedMapComponentFromSerializableKeyInfo(Object keyInfo, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.createStubbedMapComponentFromSerializableKeyInfo.

INTERNAL: Create an instance of the Key object from the key information extracted from the map.
public void
deleteMapKey(Object objectDeleted, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.deleteMapKey.

INTERNAL: For mappings used as MapKeys in MappedKeyContainerPolicy, Delete the passed object if necessary.
protected void
executeBatchQuery(DatabaseQuery query, CacheKey parentCacheKey, Map<K, V> referenceObjectsByKey, AbstractSession session, AbstractRecord translationRow)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.executeBatchQuery.

INTERNAL: Prepare and execute the batch query and store the results for each source object in a map keyed by the mappings source keys of the source objects.
public void
extendPessimisticLockScopeInSourceQuery(ObjectLevelReadQuery sourceQuery)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.extendPessimisticLockScopeInSourceQuery.

INTERNAL: Called only if both shouldExtendPessimisticLockScope and shouldExtendPessimisticLockScopeInSourceQuery are true.
protected void
extendPessimisticLockScopeInTargetQuery(ObjectLevelReadQuery targetQuery, ObjectBuildingQuery sourceQuery)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.extendPessimisticLockScopeInTargetQuery.

INTERNAL: Adds locking clause to the target query to extend pessimistic lock scope.
protected Object
extractBatchKeyFromRow(AbstractRecord row, AbstractSession session)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.extractBatchKeyFromRow.

INTERNAL: Extract the foreign key value from the source row.
public Map<K, V>
extractIdentityFieldsForQuery(Object object, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.extractIdentityFieldsForQuery.

INTERNAL: Extract the fields for the Map key from the object to use in a query
protected Object
extractKeyFromReferenceObject(Object object, AbstractSession session)

INTERNAL: Extract the key value from the reference object.

public Object
extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row)

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.extractPrimaryKeysForReferenceObjectFromRow.

INTERNAL: Return the primary key for the reference object (i.e. the object object referenced by domainObject and specified by mapping).
public Expression
getAdditionalSelectionCriteriaForMapKey()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getAdditionalSelectionCriteriaForMapKey.

INTERNAL: Return the selection criteria necessary to select the target object when this mapping is a map key.
public List<DatabaseTable>
getAdditionalTablesForJoinQuery()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getAdditionalTablesForJoinQuery.

INTERNAL: Return any tables that will be required when this mapping is used as part of a join query
public List<DatabaseField>
getAllFieldsForMapKey()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getAllFieldsForMapKey.

INTERNAL: Get all the fields for the map key
protected ReadQuery
getExtendPessimisticLockScopeDedicatedQuery(AbstractSession session, short lockMode)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.getExtendPessimisticLockScopeDedicatedQuery.

INTERNAL: Should be overridden by subclass that allows setting extendPessimisticLockScope to DEDICATED_QUERY.
public Class<?>
getFieldClassification(DatabaseField fieldToClassify)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.getFieldClassification.

INTERNAL: Return the classification for the field contained in the mapping.
public Collection<E>
getFieldsForTranslationInAggregate()

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.getFieldsForTranslationInAggregate.

INTERNAL: Return source key fields for translation by an AggregateObjectMapping
public Vector<E>
getForeignKeyFieldNames()

PUBLIC: Return the foreign key field names associated with the mapping.

public Map<DatabaseField, DatabaseField>
getForeignKeyFieldsForMapKey()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getForeignKeyFieldsForMapKey.

INTERNAL: Return a Map of any foreign keys defined within the the MapKey
protected Map<K, V>
getForeignKeysToPrimaryKeys()

Return the appropriate map that maps the "foreign keys" to the "primary keys".

public List<DatabaseField>
getIdentityFieldsForMapKey()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getIdentityFieldsForMapKey.

INTERNAL: Return the fields that make up the identity of the mapped object.
public Class<?>
getMapKeyTargetType()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getMapKeyTargetType.

INTERNAL: Return the class this key mapping maps or the descriptor for it
public ObjectLevelReadQuery
getNestedJoinQuery(JoinedAttributeManager joinManager, ObjectLevelReadQuery query, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getNestedJoinQuery.

INTERNAL: Return the query that is used when this mapping is part of a joined relationship This method is used when this mapping is used to map the key in a Map
public List<Expression>
getOrderByNormalizedExpressions(Expression base)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.getOrderByNormalizedExpressions.

INTERNAL: Order by foreign key fields if a foreign key mapping (avoids joins).
public Vector<E>
getOrderedForeignKeyFields()

INTERNAL: Return a vector of the foreign key fields in the same order as the corresponding primary key fields are in their descriptor.

protected ClassDescriptor
getPrimaryKeyDescriptor()

Return the descriptor for whichever side of the relation has the "primary key".

public Expression
getPrivateOwnedCriteria()

INTERNAL: The private owned criteria is only used outside of the unit of work to compare the previous value of the reference.

public DatabaseTable
getRelationTable()

PUBLIC: Return RelationTable.

public RelationTableMechanism
getRelationTableMechanism()

PUBLIC: Returns RelationTableMechanism that may be owned by the mapping, that allows to configure the mapping to use relation table (just like ManyToManyMapping).

public Vector<E>
getSourceToTargetKeyFieldAssociations()

INTERNAL: Return a collection of the source to target field value associations.

public Map<DatabaseField, DatabaseField>
getSourceToTargetKeyFields()

INTERNAL: Returns the source keys to target keys fields association.

public Map<DatabaseField, DatabaseField>
getTargetToSourceKeyFields()

INTERNAL: Returns the target keys to source keys fields association.

public Object
getTargetVersionOfSourceObject(Object object, Object parent, MergeManager mergeManager, AbstractSession targetSession)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.getTargetVersionOfSourceObject.

INTERNAL: If required, get the targetVersion of the source object from the merge manager Used with MapKeyContainerPolicy to abstract getting the target version of a source key
public boolean
hasRelationTable()

PUBLIC: Indicates whether the mapping has RelationTable.

public boolean
hasRelationTableMechanism()

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.hasRelationTableMechanism.

PUBLIC: Indicates whether the mapping has RelationTableMechanism.
public void
initialize(AbstractSession session)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.initialize.

INTERNAL: Initialize the mapping.
protected void
initializeForeignKeys(AbstractSession session)

INTERNAL: The foreign keys primary keys are stored as database fields in the map.

protected void
initializeForeignKeysWithDefaults(AbstractSession session)

INTERNAL: The foreign keys primary keys are stored as database fields in the map.

protected void
initializePrivateOwnedCriteria()

INTERNAL: Selection criteria is created with source foreign keys and target keys.

public boolean
isCascadedLockingSupported()

Overrides org.eclipse.persistence.mappings.DatabaseMapping.isCascadedLockingSupported.

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

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.isJoiningSupported.

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

Overrides org.eclipse.persistence.mappings.DatabaseMapping.isOneToOneMapping.

INTERNAL:
public boolean
isOneToOnePrimaryKeyRelationship()

Return if this mapping is mapped using primary key join columns.

public boolean
isOneToOneRelationship()

Return if this mapping is really for a OneToOne relationship.

public boolean
isOwned()

Overrides org.eclipse.persistence.mappings.DatabaseMapping.isOwned.

INTERNAL:
public boolean
isRelationalMapping()

Overrides org.eclipse.persistence.mappings.DatabaseMapping.isRelationalMapping.

INTERNAL:
public void
iterateOnMapKey(DescriptorIterator iterator, Object element)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.iterateOnMapKey.

INTERNAL: Called when iterating through descriptors to handle iteration on this mapping when it is used as a MapKey
public void
performDataModificationEvent(Object[] event, AbstractSession session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.performDataModificationEvent.

INTERNAL: Perform the commit event.
public void
postInitializeMapKey(MappedKeyMapContainerPolicy policy)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.postInitializeMapKey.

INTERNAL: Need to set the field type for the foreign key fields for a map key, as the fields are not contained in any descriptor.
public void
postInitializeSourceAndTargetExpressions()

Overrides org.eclipse.persistence.mappings.DatabaseMapping.postInitializeSourceAndTargetExpressions.

INTERNAL: Post-initialize source and target expression fields created when a mapping's selectionCriteria is created early with only partly initialized fields.
public void
postInsert(WriteObjectQuery query)

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.postInsert.

INTERNAL: Insert into relation table.
protected void
postPrepareNestedBatchQuery(ReadQuery batchQuery, ObjectLevelReadQuery query)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.postPrepareNestedBatchQuery.

INTERNAL: Allow the mapping the do any further batch preparation.
public void
postUpdate(WriteObjectQuery query)

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.postUpdate.

INTERNAL: Update the relation table with the entries related to this mapping.
public void
preDelete(DeleteObjectQuery query)

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.preDelete.

INTERNAL: Delete privately owned parts
public void
preinitializeMapKey(DatabaseTable table)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.preinitializeMapKey.

INTERNAL: Making any mapping changes necessary to use a the mapping as a map key prior to initializing the mapping
public void
prepareCascadeLockingPolicy()

Overrides org.eclipse.persistence.mappings.DatabaseMapping.prepareCascadeLockingPolicy.

INTERNAL: Prepare a cascade locking policy.
protected Object
readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery)

Overrides org.eclipse.persistence.mappings.ObjectReferenceMapping.readPrivateOwnedForObject.

INTERNAL: Reads the private owned object.
public void
rehashFieldDependancies(AbstractSession session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.rehashFieldDependancies.

INTERNAL: Rehash any map based on fields.
public boolean
requiresDataModificationEventsForMapKey()

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.requiresDataModificationEventsForMapKey.

INTERNAL: Return whether this mapping requires extra queries to update the rows if it is used as a key in a map.
public void
setForeignKeyFieldName(String sourceForeignKeyFieldName)

PUBLIC: Define the foreign key relationship in the 1-1 mapping.

public void
setForeignKeyFieldNames(Vector<E> fieldNames)

PUBLIC: Return the foreign key field names associated with the mapping.

public void
setIsOneToOnePrimaryKeyRelationship(boolean isOneToOnePrimaryKeyRelationship)

Set if this mapping is defined using primary key join columns.

public void
setIsOneToOneRelationship(boolean isOneToOneRelationship)

Define if this mapping is really for a OneToOne relationship.

protected void
setPrivateOwnedCriteria(Expression expression)

INTERNAL: Private owned criteria is used to verify the deletion of the target.

public void
setRelationTable(DatabaseTable relationTable)

PUBLIC: Set the relational table.

public void
setRelationTableMechanism(RelationTableMechanism mechanism)

PUBLIC: Set RelationTableMechanism into the mapping, that allows to configure the mapping to use relation table (just like ManyToManyMapping).

public void
setShouldVerifyDelete(boolean shouldVerifyDelete)

PUBLIC: Verify delete is used during delete and update on private 1:1's outside of a unit of work only.

public void
setSourceToTargetKeyFieldAssociations(Vector<E> sourceToTargetKeyFieldAssociations)

INTERNAL: Set a collection of the source to target field associations.

public void
setSourceToTargetKeyFields(Map<DatabaseField, DatabaseField> sourceToTargetKeyFields)

INTERNAL: Set the source keys to target keys fields association.

public void
setTargetForeignKeyFieldName(String targetForeignKeyFieldName)

PUBLIC: Define the target foreign key relationship in the 1-1 mapping.

public void
setTargetToSourceKeyFields(Map<DatabaseField, DatabaseField> targetToSourceKeyFields)

INTERNAL: Set the target keys to source keys fields association.

public boolean
shouldVerifyDelete()

PUBLIC: Verify delete is used during delete and update outside of a unit of work only.

protected boolean
shouldWriteField(DatabaseField field, DatabaseMapping.WriteType writeType)

INTERNAL: By default returns true.

public Object
unwrapKey(Object key, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.unwrapKey.

INTERNAL: Allow the key mapping to unwrap the object.
protected void
updateInsertableAndUpdatableFields(DatabaseField field)

INTERNAL: Add the field to the updatable and/or insertable list.

public Object
valueFromObject(Object
TODO
object, DatabaseField
TODO
field, AbstractSession
TODO
session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.valueFromObject.

INTERNAL: Get a value from the object and set that in the respective field of the row.
protected Object
valueFromRowInternal(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, AbstractSession executionSession, boolean
indicates whether sopObject stored in the row should be used to extract the value (and fields/values stored in the row ignored).
shouldUseSopObject)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.valueFromRowInternal.

INTERNAL: Return the value of the field from the row or a value holder on the query to obtain the object.
protected Object
valueFromRowInternalWithJoin(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, CacheKey parentCacheKey, AbstractSession executionSession, boolean isTargetProtected)

Overrides org.eclipse.persistence.mappings.ForeignReferenceMapping.valueFromRowInternalWithJoin.

INTERNAL: Return the value of the field from the row or a value holder on the query to obtain the object.
public Object
wrapKey(Object key, AbstractSession session)

Implements org.eclipse.persistence.mappings.foundation.MapKeyMapping.wrapKey.

INTERNAL: Allow the key mapping to wrap the object.
public void
writeFromAttributeIntoRow(Object attribute, AbstractRecord row, AbstractSession session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeFromAttributeIntoRow.

INTERNAL: A subclass should implement this method if it wants different behavior.
public void
writeFromObjectIntoRow(Object object, AbstractRecord databaseRow, AbstractSession session, DatabaseMapping.WriteType writeType)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeFromObjectIntoRow.

INTERNAL: Get a value from the object and set that in the respective field of the row.
public void
writeFromObjectIntoRowForShallowInsert(Object object, AbstractRecord databaseRow, AbstractSession session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeFromObjectIntoRowForShallowInsert.

INTERNAL: This row is built for shallow insert which happens in case of bidirectional inserts.
public void
writeFromObjectIntoRowForShallowInsertWithChangeRecord(ChangeRecord ChangeRecord, AbstractRecord databaseRow, AbstractSession session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeFromObjectIntoRowForShallowInsertWithChangeRecord.

INTERNAL: This row is built for shallow insert which happens in case of bidirectional inserts.
public void
writeFromObjectIntoRowForUpdateAfterShallowInsert(Object object, AbstractRecord databaseRow, AbstractSession session, DatabaseTable table)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeFromObjectIntoRowForUpdateAfterShallowInsert.

INTERNAL: This row is built for update after shallow insert which happens in case of bidirectional inserts.
public void
writeFromObjectIntoRowForUpdateBeforeShallowDelete(Object object, AbstractRecord databaseRow, AbstractSession session, DatabaseTable table)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeFromObjectIntoRowForUpdateBeforeShallowDelete.

INTERNAL: This row is built for update before shallow delete which happens in case of bidirectional inserts.
protected void
writeFromObjectIntoRowInternal(Object object, AbstractRecord databaseRow, AbstractSession session, OneToOneMapping.ShallowMode mode, DatabaseMapping.WriteType writeType)

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

public void
writeFromObjectIntoRowWithChangeRecord(ChangeRecord changeRecord, AbstractRecord databaseRow, AbstractSession session, DatabaseMapping.WriteType writeType)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeFromObjectIntoRowWithChangeRecord.

INTERNAL: Get a value from the object and set that in the respective field of the row.
public void
writeInsertFieldsIntoRow(AbstractRecord databaseRow, AbstractSession session)

Overrides org.eclipse.persistence.mappings.DatabaseMapping.writeInsertFieldsIntoRow.

INTERNAL: Write fields needed for insert into the template for with null values.
Inherited from org.eclipse.persistence.mappings.ObjectReferenceMapping:
buildBackupCloneForPartObjectbuildChangeRecordbuildCloneForPartObjectbuildCopybuildExpressionbuildReferencesPKListbuildTargetInterfacesbuildUnitofWorkCloneForPartObjectcascadeDiscoverAndPersistUnregisteredNewObjectscascadeDiscoverAndPersistUnregisteredNewObjectscascadePerformRemoveIfRequiredcascadePerformRemoveIfRequiredcascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequiredcascadeRegisterNewIfRequiredcascadeRegisterNewIfRequiredcompareForChangecompareObjectsWithoutPrivateOwnedcompareObjectsWithPrivateOwnedcreateCloneValueHolderearlyPreDeleteextractPrimaryKeyRowForSourceObjectextractPrimaryKeysForReferenceObjectextractPrimaryKeysFromRealReferenceObjectfixRealObjectReferencesgetDescriptorForTargetgetForeignKeyFieldsgetPrimaryKeyForObjectgetRealAttributeValueFromAttributehasConstraintDependencyinsertinternalBuildChangeRecordisChangeTrackingSupportedisForeignKeyRelationshipisObjectReferenceMappingiterateOnRealAttributeValueloadAllmergeChangesIntoObjectmergeIntoObjectpostCalculateChangespostDeletepreInitializepreInsertpreUpdaterecordPrivateOwnedRemovalssetForeignKeyFieldssetIsForeignKeyRelationshipsetNewValueInChangeRecordupdateupdateChangeRecordupdateChangeRecordForSelfMergeuseProxyIndirectionuseProxyIndirectionuseProxyIndirectionvalueFromPKListverifyDeletewriteFromObjectIntoRowForUpdatewriteFromObjectIntoRowForWhereClause