Package org.eclipse.persistence.mappings

Class DirectCollectionMapping

java.lang.Object
org.eclipse.persistence.core.mappings.CoreMapping<AttributeAccessor,org.eclipse.persistence.internal.sessions.AbstractSession,org.eclipse.persistence.internal.queries.ContainerPolicy,ClassDescriptor,org.eclipse.persistence.internal.helper.DatabaseField>
org.eclipse.persistence.mappings.DatabaseMapping
org.eclipse.persistence.mappings.ForeignReferenceMapping
org.eclipse.persistence.mappings.CollectionMapping
org.eclipse.persistence.mappings.DirectCollectionMapping
All Implemented Interfaces:
Serializable, Cloneable, ContainerMapping, RelationalMapping
Direct Known Subclasses:
DirectMapMapping
public class DirectCollectionMapping extends CollectionMapping implements RelationalMapping

Purpose: This mapping is used to store a collection of simple types (String, Number, Date, etc.) into a single table. The table must store the value and a foreign key to the source object. A converter can be used if the desired object type and the data type do not match.

See Also:
Author:
Sati

  • Field Details

    • Delete

      protected static final String Delete
      Used for data modification events.
      See Also:

    • Insert

      protected static final String Insert
      See Also:

    • DeleteAll

      protected static final String DeleteAll
      See Also:

    • DeleteAtIndex

      protected static final String DeleteAtIndex
      See Also:

    • UpdateAtIndex

      protected static final String UpdateAtIndex
      See Also:

    • valueConverter

      protected Converter valueConverter
      Allows user defined conversion between the object value and the database value.

    • valueConverterClassName

      protected String valueConverterClassName

    • orderByExpressions

      protected List<Expression> orderByExpressions

    • referenceTable

      protected org.eclipse.persistence.internal.helper.DatabaseTable referenceTable
      Stores the reference table

    • directField

      protected org.eclipse.persistence.internal.helper.DatabaseField directField
      The direct field name is converted and stored

    • sourceKeyFields

      protected Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields

    • referenceKeyFields

      protected Vector<org.eclipse.persistence.internal.helper.DatabaseField> referenceKeyFields

    • insertQuery

      protected DataModifyQuery insertQuery
      Used for insertion for m-m and dc, not used in 1-m.

    • changeSetDeleteQuery

      protected ModifyQuery changeSetDeleteQuery
      Used for deletion when ChangeSets are used

    • changeSetDeleteNullQuery

      protected transient ModifyQuery changeSetDeleteNullQuery

    • hasCustomDeleteQuery

      protected boolean hasCustomDeleteQuery

    • hasCustomInsertQuery

      protected boolean hasCustomInsertQuery

    • historyPolicy

      protected HistoryPolicy historyPolicy

    • deleteAtIndexQuery

      protected ModifyQuery deleteAtIndexQuery
      Used (only in case listOrderField != null) to delete object with particular orderFieldValue

    • updateAtIndexQuery

      protected ModifyQuery updateAtIndexQuery
      Used (only in case listOrderField != null) to update orderFieldValue of object with particular orderFieldValue

    • hasCustomDeleteAtIndexQuery

      protected boolean hasCustomDeleteAtIndexQuery

    • hasCustomUpdateAtIndexQuery

      protected boolean hasCustomUpdateAtIndexQuery

    • attributeClassification

      protected transient Class attributeClassification

    • attributeClassificationName

      protected String attributeClassificationName

  • Constructor Details

    • DirectCollectionMapping

      public DirectCollectionMapping()
      PUBLIC: Default constructor.

  • Method Details

    • addAscendingOrdering

      public void addAscendingOrdering()
      PUBLIC: Provide ascending order support for this direct collection mapping.

    • addDescendingOrdering

      public void addDescendingOrdering()
      PUBLIC: Provide descending order support for this direct collection mapping.

    • addOrdering

      public void addOrdering(Expression expression)
      ADVANCED: Used this method to add custom ordering expressions when fetching the collection. This could be things like expressions using a functions like UPPER or NULLS LAST etc.

    • isRelationalMapping

      public boolean isRelationalMapping()
      Description copied from class: DatabaseMapping
      INTERNAL: All relational mappings should implement this method to return true.
      Overrides:
      isRelationalMapping in class DatabaseMapping

    • getValueConverter

      public Converter getValueConverter()
      PUBLIC: Return the converter on the mapping. A converter can be used to convert between the direct collection's object value and database value.

    • setValueConverter

      public void setValueConverter(Converter valueConverter)
      PUBLIC: Set the converter on the mapping. A converter can be used to convert between the direct collection's object value and database value.

    • setValueConverterClassName

      public void setValueConverterClassName(String valueConverterClassName)
      PUBLIC: Set the converter class name on the mapping. Initialized in convertClassNamesToClasses. A converter can be used to convert between the direct collection's object value and database value.

    • addReferenceKeyField

      public void addReferenceKeyField(org.eclipse.persistence.internal.helper.DatabaseField referenceForeignKeyField, org.eclipse.persistence.internal.helper.DatabaseField sourcePrimaryKeyField)
      PUBLIC: Add the reference key field. This is used for composite reference keys. This is the foreign key field in the direct table referencing the primary key of the source object. Both the reference field and the source field that it references must be provided.

    • addReferenceKeyFieldName

      public void addReferenceKeyFieldName(String referenceForeignKeyFieldName, String sourcePrimaryKeyFieldName)
      PUBLIC: Add the name of the reference key field. This is used for composite reference keys. This is the foreign key field in the direct table referencing the primary key of the source object. Both the reference field name and the name of the source field that it references must be provided.

    • prepareNestedBatchQuery

      public ReadQuery prepareNestedBatchQuery(ObjectLevelReadQuery query)
      INTERNAL: Clone and prepare the selection query as a nested batch read query. This is used for nested batch reading.
      Overrides:
      prepareNestedBatchQuery in class ForeignReferenceMapping

    • 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 joined direct query. Since direct-collection does not build objects a nest query is not required.
      Overrides:
      prepareNestedJoins in class ForeignReferenceMapping

    • valueFromRowInternalWithJoin

      protected Object valueFromRowInternalWithJoin(org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, org.eclipse.persistence.internal.sessions.AbstractSession executionSession, boolean isTargetProtected) throws DatabaseException
      INTERNAL: Return the value of the field from the row or a value holder on the query to obtain the object.
      Overrides:
      valueFromRowInternalWithJoin in class CollectionMapping
      Throws:
      DatabaseException

    • buildCopy

      public void buildCopy(Object copy, 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 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 element, if necessary. DirectCollections hold on to objects that do not have Descriptors (e.g. int, String). These objects do not need to be cloned, unless they use a converter - they are immutable.
      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

    • buildListOrderField

      protected void buildListOrderField()
      INTERNAL: Verifies listOrderField's table: it must be reference table. Precondition: listOrderField != null.
      Overrides:
      buildListOrderField in class CollectionMapping

    • cascadePerformRemoveIfRequired

      public void cascadePerformRemoveIfRequired(Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, Map visitedObjects)
      INTERNAL: Cascade perform delete 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

    • 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

    • 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

    • clone

      public Object clone()
      INTERNAL: The mapping clones itself to create deep copy.
      Overrides:
      clone in class CollectionMapping

    • compareCollectionsForChange

      public void compareCollectionsForChange(Object oldCollection, Object newCollection, org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: This method is used to calculate the differences between two collections.
      Overrides:
      compareCollectionsForChange in class CollectionMapping

    • compareListsForChange

      public void compareListsForChange(List oldList, List newList, org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: This method is used to calculate the differences between two Lists.

    • 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 compares the changes between two direct collections. Comparisons are made on equality not identity.
      Overrides:
      compareForChange in class CollectionMapping
      Returns:
      prototype.changeset.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

      protected boolean compareLists(List firstList, List secondList)
      Compare two lists. For equality the order of the elements should be the same. Used only if listOrderField != null

    • 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 implemented by subclasses as necessary.
      Overrides:
      convertClassNamesToClasses in class CollectionMapping
      Parameters:
      classLoader -

    • extractKeyFromTargetRow

      protected Object extractKeyFromTargetRow(org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: Extract the source primary key value from the reference direct row. Used for batch reading, most following same order and fields as in the mapping.
      Overrides:
      extractKeyFromTargetRow in class CollectionMapping

    • extractBatchKeyFromRow

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

    • buildBatchCriteria

      protected Expression buildBatchCriteria(ExpressionBuilder builder, ObjectLevelReadQuery query)
      INTERNAL: Return the selection criteria used to IN batch fetching.
      Overrides:
      buildBatchCriteria in class ForeignReferenceMapping

    • executeBatchQuery

      protected void executeBatchQuery(DatabaseQuery query, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, Map referenceDataByKey, org.eclipse.persistence.internal.sessions.AbstractSession session, org.eclipse.persistence.internal.sessions.AbstractRecord translationRow)
      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.
      Overrides:
      executeBatchQuery in class CollectionMapping

    • fixRealObjectReferences

      public void fixRealObjectReferences(Object object, Map objectInformation, Map processedObjects, ObjectLevelReadQuery query, DistributedSession session)
      INTERNAL: At this point, we realize we don't have indirection; so we need to replace the reference object(s) with the corresponding object(s) from the remote session. The reference objects for a DirectCollectionMapping are primitives, so they do not need to be replaced.
      Overrides:
      fixRealObjectReferences in class CollectionMapping

    • getAttributeClassification

      public Class getAttributeClassification()
      PUBLIC: Some databases do not properly support all of the base data types. For these databases, the base data type must be explicitly specified in the mapping to tell EclipseLink to force the instance variable value to that data type.
      Overrides:
      getAttributeClassification in class DatabaseMapping

    • getAttributeClassificationName

      public String getAttributeClassificationName()
      INTERNAL: Return the class name of the attribute type. This is only used by the MW.

    • getDeleteQuery

      protected ModifyQuery getDeleteQuery()

    • getDeleteNullQuery

      protected ModifyQuery getDeleteNullQuery()

    • getDeleteAtIndexQuery

      protected ModifyQuery getDeleteAtIndexQuery()

    • getUpdateAtIndexQuery

      protected ModifyQuery getUpdateAtIndexQuery()

    • getSelectFields

      public Vector getSelectFields()
      INTERNAL: Returns the set of fields that should be selected to build this mapping's value(s). This is used by expressions to determine which fields to include in the select clause for non-object expressions.
      Overrides:
      getSelectFields in class DatabaseMapping

    • getSelectTables

      public Vector getSelectTables()
      INTERNAL: Returns the table(s) that should be selected to build this mapping's value(s). This is used by expressions to determine which tables to include in the from clause for non-object expressions.
      Overrides:
      getSelectTables in class DatabaseMapping

    • getDirectField

      public org.eclipse.persistence.internal.helper.DatabaseField getDirectField()
      INTERNAL: Return the direct field. This is the field in the direct table to store the values.

    • getDirectFieldName

      public String getDirectFieldName()
      PUBLIC: Returns the name of the field name in the reference table.

    • getInsertQuery

      protected DataModifyQuery getInsertQuery()

    • getJoinCriteria

      public Expression getJoinCriteria(org.eclipse.persistence.internal.expressions.ObjectExpression context, Expression base)
      INTERNAL: Returns the join criteria stored in the mapping selection query. This criteria is used to read reference objects across the tables from the database.
      Overrides:
      getJoinCriteria in class CollectionMapping

    • getObjectCorrespondingTo

      public Object getObjectCorrespondingTo(Object object, DistributedSession session, Map objectDescriptors, Map processedObjects, ObjectLevelReadQuery query)
      INTERNAL: return the object on the client corresponding to the specified object. DirectCollections do not have to worry about maintaining object identity.
      Overrides:
      getObjectCorrespondingTo in class CollectionMapping

    • getOrderByExpressions

      public List<Expression> getOrderByExpressions()
      PUBLIC: Return the order by expression.

    • getOrderByNormalizedExpressions

      public List<Expression> getOrderByNormalizedExpressions(Expression base)
      INTERNAL: Return null if this mapping is used in an order by.
      Overrides:
      getOrderByNormalizedExpressions in class ForeignReferenceMapping

    • getHistoryPolicy

      public HistoryPolicy getHistoryPolicy()
      PUBLIC: Allow history support on the reference table.

    • getSelectionQueryContainerPolicy

      protected org.eclipse.persistence.internal.queries.ContainerPolicy getSelectionQueryContainerPolicy()
      INTERNAL: Get the container policy from the selection query for this mapping.
      Overrides:
      getSelectionQueryContainerPolicy in class CollectionMapping

    • getReferenceClass

      public Class getReferenceClass()
      INTERNAL: This cannot be used with direct collection mappings.
      Overrides:
      getReferenceClass in class ForeignReferenceMapping

    • getReferenceClassName

      public String getReferenceClassName()
      Description copied from class: ForeignReferenceMapping
      INTERNAL: Returns the reference class name.
      Overrides:
      getReferenceClassName in class ForeignReferenceMapping

    • getReferenceDescriptor

      public ClassDescriptor getReferenceDescriptor()
      INTERNAL: There is none on direct collection.
      Overrides:
      getReferenceDescriptor in class ForeignReferenceMapping

    • getReferenceKeyFieldNames

      public Vector getReferenceKeyFieldNames()
      INTERNAL: Return the reference key field names associated with the mapping. These are in-order with the sourceKeyFieldNames.

    • getReferenceKeyFields

      public Vector<org.eclipse.persistence.internal.helper.DatabaseField> getReferenceKeyFields()
      INTERNAL: Return the reference key fields.

    • getReferenceTable

      public org.eclipse.persistence.internal.helper.DatabaseTable getReferenceTable()
      INTERNAL: Return the direct table. This is the table to store the values.

    • getReferenceTableName

      public String getReferenceTableName()
      PUBLIC: Returns the name of the reference table

    • getReferenceTableQualifiedName

      public String getReferenceTableQualifiedName()
      PUBLIC: Returns the qualified name of the reference table.

    • getRelationshipPartner

      public DatabaseMapping getRelationshipPartner()
      INTERNAL: Return the relationshipPartner mapping for this bi-directional mapping. If the relationshipPartner is null then this is a uni-directional mapping. DirectCollectionMapping can not be part of a bi-directional mapping
      Overrides:
      getRelationshipPartner in class ForeignReferenceMapping

    • getSourceKeyFieldNames

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

    • getSourceKeyFields

      public Vector<org.eclipse.persistence.internal.helper.DatabaseField> getSourceKeyFields()
      INTERNAL: Return the source key fields.

    • hasCustomDeleteQuery

      protected boolean hasCustomDeleteQuery()

    • hasCustomInsertQuery

      protected boolean hasCustomInsertQuery()

    • hasCustomDeleteAtIndexQuery

      protected boolean hasCustomDeleteAtIndexQuery()

    • hasCustomUpdateAtIndexQuery

      protected boolean hasCustomUpdateAtIndexQuery()

    • 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

    • initialize

      public void initialize(org.eclipse.persistence.internal.sessions.AbstractSession session) throws DescriptorException
      INTERNAL: Initialize and validate the mapping properties.
      Overrides:
      initialize in class CollectionMapping
      Throws:
      DescriptorException

    • initializeListOrderField

      protected void initializeListOrderField(org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: Initializes listOrderField. Precondition: listOrderField != null.
      Overrides:
      initializeListOrderField in class CollectionMapping

    • initializeDeleteAllQuery

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

    • initializeDeleteQuery

      protected void initializeDeleteQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)

    • initializeDeleteNullQuery

      protected void initializeDeleteNullQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)

    • initializeDeleteAtIndexQuery

      protected void initializeDeleteAtIndexQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)

    • initializeUpdateAtIndexQuery

      protected void initializeUpdateAtIndexQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)

    • shouldUseListOrderFieldTableExpression

      public boolean shouldUseListOrderFieldTableExpression()
      INTERNAL: Indicates whether getListOrderFieldExpression method should create field expression on table expression.
      Overrides:
      shouldUseListOrderFieldTableExpression in class CollectionMapping

    • createWhereClauseForDeleteQuery

      protected Expression createWhereClauseForDeleteQuery(ExpressionBuilder builder)

    • createWhereClauseForDeleteNullQuery

      protected Expression createWhereClauseForDeleteNullQuery(ExpressionBuilder builder)

    • initializeDirectField

      protected void initializeDirectField(org.eclipse.persistence.internal.sessions.AbstractSession session) throws DescriptorException
      The field name on the reference table is initialized and cached.
      Throws:
      DescriptorException

    • initializeInsertQuery

      protected void initializeInsertQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)
      Initialize insert query. This query is used to insert the collection of objects into the reference table.

    • initializeReferenceDescriptor

      protected void initializeReferenceDescriptor(org.eclipse.persistence.internal.sessions.AbstractSession session)
      There is no reference descriptor
      Overrides:
      initializeReferenceDescriptor in class ForeignReferenceMapping

    • initializeReferenceKeys

      protected void initializeReferenceKeys(org.eclipse.persistence.internal.sessions.AbstractSession session) throws DescriptorException
      The reference keys on the reference table are initialized
      Throws:
      DescriptorException

    • initializeReferenceTable

      protected void initializeReferenceTable(org.eclipse.persistence.internal.sessions.AbstractSession session) throws DescriptorException
      Set the table qualifier on the reference table if required
      Throws:
      DescriptorException

    • initializeSelectionCriteria

      protected void initializeSelectionCriteria(org.eclipse.persistence.internal.sessions.AbstractSession session)

    • initializeSelectionQuery

      protected void initializeSelectionQuery(org.eclipse.persistence.internal.sessions.AbstractSession session)
      The selection query is initialized
      Overrides:
      initializeSelectionQuery in class ForeignReferenceMapping

    • initializeSelectionStatement

      protected void initializeSelectionStatement(org.eclipse.persistence.internal.sessions.AbstractSession session)

    • initializeSourceKeys

      protected void initializeSourceKeys(org.eclipse.persistence.internal.sessions.AbstractSession session)
      The source keys are initialized

    • initializeSourceKeysWithDefaults

      protected void initializeSourceKeysWithDefaults(org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: If a user does not specify the source key then the primary keys of the source table are used.

    • getAdditionalFieldsBaseExpression

      protected Expression getAdditionalFieldsBaseExpression(ReadQuery query)
      INTERNAL: Return the base expression to use for adding fields to the query. This is the reference table.
      Overrides:
      getAdditionalFieldsBaseExpression in class CollectionMapping

    • isDirectCollectionMapping

      public boolean isDirectCollectionMapping()
      INTERNAL:
      Overrides:
      isDirectCollectionMapping 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

    • isKeyForSourceSpecified

      protected boolean isKeyForSourceSpecified()
      INTERNAL: Checks if source and target keys are mentioned by the user or not.

    • isLockableMapping

      public boolean isLockableMapping()
      INTERNAL: Return whether this mapping should be traversed when we are locking
      Overrides:
      isLockableMapping in class ForeignReferenceMapping
      Returns:

    • isOwned

      public boolean isOwned()
      INTERNAL:
      Overrides:
      isOwned in class DatabaseMapping

    • iterateOnRealAttributeValue

      public void iterateOnRealAttributeValue(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, Object realAttributeValue)
      INTERNAL: Iterate on the attribute value. The value holder has already been processed. PERF: Avoid iteration if not required.
      Overrides:
      iterateOnRealAttributeValue in class CollectionMapping

    • iterateOnElement

      public void iterateOnElement(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, Object element)
      INTERNAL: Iterate on the specified element.
      Overrides:
      iterateOnElement 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

    • mergeAddRemoveChanges

      protected void mergeAddRemoveChanges(Object valueOfTarget, Object delegateTarget, org.eclipse.persistence.internal.sessions.DirectCollectionChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.MergeManager mergeManager, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: Merge changes by adding and removing from the change record to the target object, and its delegate object if instance of IndirectCollection. It will also reorder the collection if required.

    • 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

    • performDataModificationEvent

      public void performDataModificationEvent(Object[] event, org.eclipse.persistence.internal.sessions.AbstractSession session) throws DatabaseException, DescriptorException
      INTERNAL: Perform the commit event. This is used in the uow to delay data modifications.
      Overrides:
      performDataModificationEvent in class DatabaseMapping
      Throws:
      DatabaseException
      DescriptorException

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

    • postInsert

      public void postInsert(WriteObjectQuery query) throws DatabaseException
      INTERNAL: Insert the private owned object.
      Overrides:
      postInsert in class CollectionMapping
      Throws:
      DatabaseException

    • getFieldValue

      public Object getFieldValue(Object attributeValue, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: Convert the attribute value to a field value. Process any converter if defined.

    • getObjectValue

      public Object getObjectValue(Object fieldValue, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: Convert the field value to an attribute value. Process any converter if defined.

    • getFieldsForTranslationInAggregate

      public Vector getFieldsForTranslationInAggregate()
      INTERNAL: Return source key fields for translation by an AggregateObjectMapping
      Overrides:
      getFieldsForTranslationInAggregate in class ForeignReferenceMapping

    • postUpdate

      public void postUpdate(WriteObjectQuery writeQuery) throws DatabaseException
      INTERNAL: Update private owned part.
      Overrides:
      postUpdate in class DatabaseMapping
      Throws:
      DatabaseException

    • postUpdateWithChangeSet

      protected void postUpdateWithChangeSet(WriteObjectQuery writeQuery) throws DatabaseException
      INTERNAL: Update private owned part.
      Throws:
      DatabaseException

    • postUpdateWithChangeSetListOrder

      protected void postUpdateWithChangeSetListOrder(WriteObjectQuery writeQuery) throws DatabaseException
      INTERNAL: Update private owned part.
      Throws:
      DatabaseException

    • preDelete

      public void preDelete(DeleteObjectQuery query) throws DatabaseException
      INTERNAL: Delete private owned part. Which is a collection of objects from the reference table.
      Overrides:
      preDelete in class DatabaseMapping
      Throws:
      DatabaseException

    • prepareTranslationRow

      protected void prepareTranslationRow(org.eclipse.persistence.internal.sessions.AbstractRecord translationRow, Object object, ClassDescriptor descriptor, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: The translation row may require additional fields than the primary key if the mapping in not on the primary key.
      Overrides:
      prepareTranslationRow in class CollectionMapping

    • initOrRebuildSelectQuery

      protected void initOrRebuildSelectQuery()
      INTERNAL: Used by DirectMapMapping to rebuild select query.

    • recordPrivateOwnedRemovals

      public void recordPrivateOwnedRemovals(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 CollectionMapping

    • remoteInitialization

      public void remoteInitialization(DistributedSession session)
      INTERNAL: Once descriptors are serialized to the remote session. All its mappings and reference descriptors are traversed. Usually mappings are initialized and serialized reference descriptors are replaced with local descriptors if they already exist on the remote session.
      Overrides:
      remoteInitialization in class ForeignReferenceMapping

    • replaceValueHoldersIn

      public Map replaceValueHoldersIn(Object object, org.eclipse.persistence.internal.sessions.remote.RemoteSessionController controller)
      INTERNAL: replace the value holders in the specified reference object(s)
      Overrides:
      replaceValueHoldersIn in class CollectionMapping

    • setAttributeClassification

      public void setAttributeClassification(Class attributeClassification)
      PUBLIC: Some databases do not properly support all of the base data types. For these databases, the base data type must be explicitly specified in the mapping to tell EclipseLink to force the instance variable value to that data type.

    • setAttributeClassificationName

      public void setAttributeClassificationName(String attributeClassificationName)
      INTERNAL: Set the name of the class for MW usage.

    • setDeleteQuery

      protected void setDeleteQuery(ModifyQuery query)

    • setDeleteSQLString

      public void setDeleteSQLString(String sqlString)
      PUBLIC: Set the receiver's delete SQL string. This allows the user to override the SQL generated by TopLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. This SQL is responsible for doing the deletion required by the mapping, such as deletion from join table for M-M. Example, 'delete from RESPONS where EMP_ID = #EMP_ID and DESCRIP = #DESCRIP'.

    • setContainerPolicy

      public void setContainerPolicy(org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy)
      ADVANCED: Configure the mapping to use a container policy. The policy manages the access to the collection.
      Specified by:
      setContainerPolicy in interface ContainerMapping
      Overrides:
      setContainerPolicy in class CollectionMapping

    • setCustomDeleteQuery

      public void setCustomDeleteQuery(ModifyQuery query)
      PUBLIC: The default delete query for this mapping can be overridden by specifying the new query. This query is responsible for doing the deletion required by the mapping, such as deletion from join table for M-M. The query should delete a specific row from the DirectCollectionTable bases on the DirectField.

    • setCustomDeleteAtIndexQuery

      public void setCustomDeleteAtIndexQuery(ModifyQuery query)
      PUBLIC: The default delete by index query for this mapping can be overridden by specifying the new query. This query used (only in case listOrderField != null) to delete object with particular orderFieldValue.

    • setCustomInsertQuery

      public void setCustomInsertQuery(DataModifyQuery query)
      PUBLIC: The default insert query for mapping can be overridden by specifying the new query. This query inserts the row into the direct table.

    • setCustomUpdateAtIndexQuery

      public void setCustomUpdateAtIndexQuery(ModifyQuery query)
      PUBLIC: The default delete by index query for this mapping can be overridden by specifying the new query. This query used (only in case listOrderField != null) to update orderFieldValue of object with particular orderFieldValue.

    • setDirectField

      public void setDirectField(org.eclipse.persistence.internal.helper.DatabaseField field)
      PUBLIC: Set the direct field in the reference table. This is the field that the primitive data value is stored in.

    • setDirectFieldClassification

      public void setDirectFieldClassification(Class fieldType)
      ADVANCED: Set the class type of the field value. This can be used if field value differs from the object value, has specific typing requirements such as usage of java.sql.Blob or NChar. This must be called after the field name has been set.

    • setDirectFieldClassificationName

      public void setDirectFieldClassificationName(String className)
      ADVANCED: Set the class type of the field value. This can be used if field value differs from the object value, has specific typing requirements such as usage of java.sql.Blob or NChar. This must be called after the field name has been set.

    • setDirectFieldName

      public void setDirectFieldName(String fieldName)
      PUBLIC: Set the direct field name in the reference table. This is the field that the primitive data value is stored in.

    • setHasCustomDeleteQuery

      protected void setHasCustomDeleteQuery(boolean bool)

    • setHasCustomInsertQuery

      protected void setHasCustomInsertQuery(boolean bool)

    • setInsertQuery

      protected void setInsertQuery(DataModifyQuery insertQuery)

    • setInsertSQLString

      public void setInsertSQLString(String sqlString)
      PUBLIC: Set the receiver's insert SQL string. This allows the user to override the SQL generated by TopLink, with there own SQL or procedure call. The arguments are translated from the fields of the source row, through replacing the field names marked by '#' with the values for those fields. This is used to insert an entry into the direct table.

      Example, 'insert into RESPONS (EMP_ID, RES_DESC) values (#EMP_ID, #RES_DESC)'.

    • setReferenceClass

      public void setReferenceClass(Class referenceClass)
      INTERNAL: This cannot be used with direct collection mappings.
      Overrides:
      setReferenceClass in class ForeignReferenceMapping

    • setReferenceClassName

      public void setReferenceClassName(String referenceClassName)
      Description copied from class: ForeignReferenceMapping
      INTERNAL: Used by MW.
      Overrides:
      setReferenceClassName in class ForeignReferenceMapping

    • setReferenceKeyFieldName

      public void setReferenceKeyFieldName(String fieldName)
      PUBLIC: Set the name of the reference key field. This is the foreign key field in the direct table referencing the primary key of the source object. This method is used if the reference key consists of only a single field.

    • setReferenceKeyFieldNames

      public void setReferenceKeyFieldNames(Vector fieldNames)
      INTERNAL: Set the reference key field names associated with the mapping. These must be in-order with the sourceKeyFieldNames.

    • setReferenceKeyFields

      public void setReferenceKeyFields(Vector<org.eclipse.persistence.internal.helper.DatabaseField> aVector)
      INTERNAL: Set the reference fields.

    • setReferenceTable

      public void setReferenceTable(org.eclipse.persistence.internal.helper.DatabaseTable table)
      INTERNAL: Set the reference table.

    • setSelectionCriteria

      public void setSelectionCriteria(Expression anExpression)
      PUBLIC: Sets the selection criteria to be used as a where clause to read reference objects. This criteria is automatically generated by the TopLink if not explicitly specified by the user.
      Overrides:
      setSelectionCriteria in class ForeignReferenceMapping

    • setReferenceTableName

      public void setReferenceTableName(String tableName)
      PUBLIC: Set the reference table name.

    • setSelectionQueryContainerPolicy

      protected void setSelectionQueryContainerPolicy(org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy)
      INTERNAL: Set the container policy on the selection query for this mapping.
      Overrides:
      setSelectionQueryContainerPolicy in class CollectionMapping

    • setHistoryPolicy

      public void setHistoryPolicy(HistoryPolicy policy)
      PUBLIC: Support history on the reference table.

    • setSessionName

      public void setSessionName(String name)
      PUBLIC: Set the name of the session to execute the mapping's queries under. This can be used by the session broker to override the default session to be used for the target class.
      Overrides:
      setSessionName in class CollectionMapping

    • setSourceKeyFieldNames

      public void setSourceKeyFieldNames(Vector fieldNames)
      INTERNAL: Set the source key field names associated with the mapping. These must be in-order with the referenceKeyFieldNames.

    • setSourceKeyFields

      public void setSourceKeyFields(Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields)
      INTERNAL: Set the source fields.

    • 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

    • calculateDeferredChanges

      public void calculateDeferredChanges(org.eclipse.persistence.internal.sessions.ChangeRecord changeRecord, org.eclipse.persistence.internal.sessions.AbstractSession session)
      INTERNAL: Used by AttributeLevelChangeTracking to update a changeRecord with calculated changes as apposed to detected changes. If an attribute can not be change tracked it's changes can be detected through this process.
      Overrides:
      calculateDeferredChanges in class CollectionMapping

    • simpleAddToCollectionChangeRecord

      public void simpleAddToCollectionChangeRecord(Object referenceKey, Object objectToAdd, 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.
      Overrides:
      simpleAddToCollectionChangeRecord in class CollectionMapping

    • simpleAddToCollectionChangeRecord

      protected void simpleAddToCollectionChangeRecord(Object objectToAdd, Integer index, boolean isSet, org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, org.eclipse.persistence.internal.sessions.AbstractSession session, boolean isChangeApplied)

    • simpleRemoveFromCollectionChangeRecord

      public void simpleRemoveFromCollectionChangeRecord(Object referenceKey, Object objectToRemove, 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.
      Overrides:
      simpleRemoveFromCollectionChangeRecord in class CollectionMapping

    • simpleRemoveFromCollectionChangeRecord

      protected void simpleRemoveFromCollectionChangeRecord(Object objectToRemove, Integer index, boolean isSet, org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, org.eclipse.persistence.internal.sessions.AbstractSession session, boolean isChangeApplied)

    • updateChangeRecord

      public void updateChangeRecord(Object clone, Object newValue, 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 with the new value. This is used by attribute change tracking. Specifically in a collection mapping this will be called when the customer Set a new collection. In this case we will need to mark the change record with the new and the old versions of the collection. And mark the ObjectChangeSet with the attribute name then when the changes are calculated force a compare on the collections to determine changes.
      Overrides:
      updateChangeRecord in class CollectionMapping

    • updateCollectionChangeRecord

      public void updateCollectionChangeRecord(CollectionChangeEvent event, org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow)
      INTERNAL: Add or removes a new value and its change set to the collection change record based on the event passed in. This is used by attribute change tracking.
      Overrides:
      updateCollectionChangeRecord in class CollectionMapping

    • useMapClass

      public void useMapClass(Class concreteClass, String methodName)
      PUBLIC: It is illegal to use a Map as the container of a DirectCollectionMapping. Only Collection containers are supported for DirectCollectionMappings.
      Specified by:
      useMapClass in interface ContainerMapping
      Overrides:
      useMapClass in class CollectionMapping
      See Also:

    • valueFromRow

      public Object valueFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row, org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey, org.eclipse.persistence.internal.sessions.AbstractSession session, boolean isTargetProtected, Boolean[] wasCacheUsed) throws DatabaseException
      INTERNAL: Return the value of the reference attribute or a value holder. Check whether the mapping's attribute should be optimized through batch and joining. Overridden to support flashback/historical queries.
      Overrides:
      valueFromRow in class ForeignReferenceMapping
      Throws:
      DatabaseException

    • 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: DirectCollectionMapping 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