DirectCollectionMapping (Oracle Fusion Middleware Java API Reference for Oracle TopLink)

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:

java.io.Serializable, java.lang.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.

Since:

TOPLink/Java 1.0 09/18/2009-2.0 Michael O'Brien - 266912: JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API) add support for passing BasicMap value type to MapAttributeImpl via new attributeClassification field

Author:

Sati

See Also:

Converter, ObjectTypeConverter, TypeConversionConverter, SerializedObjectConverter, Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class org.eclipse.persistence.mappings.DatabaseMapping
  DatabaseMapping.WriteType

Field Summary
- Fields inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping
  INNER_JOIN, NONE, OUTER_JOIN, QUERY_BATCH_PARAMETER

Constructor Summary

Constructors
Constructor and Description

DirectCollectionMapping()
PUBLIC: Default constructor.

Constructors
Constructor and Description
`DirectCollectionMapping()` PUBLIC: Default constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAscendingOrdering()` PUBLIC: Provide ascending order support for this direct collection mapping.
`void`	`addDescendingOrdering()` PUBLIC: Provide descending order support for this direct collection mapping.
`void`	`addOrdering(Expression expression)` ADVANCED: Used this method to add custom ordering expressions when fetching the collection.
`void`	`addReferenceKeyField(org.eclipse.persistence.internal.helper.DatabaseField referenceForeignKeyField, org.eclipse.persistence.internal.helper.DatabaseField sourcePrimaryKeyField)` PUBLIC: Add the reference key field.
`void`	`addReferenceKeyFieldName(java.lang.String referenceForeignKeyFieldName, java.lang.String sourcePrimaryKeyFieldName)` PUBLIC: Add the name of the reference key field.
`void`	`buildCopy(java.lang.Object copy, java.lang.Object original, CopyGroup group)` INTERNAL: Copy of the attribute of the object.
`java.lang.Object`	`buildElementClone(java.lang.Object element, java.lang.Object parent, org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey, java.lang.Integer refreshCascade, org.eclipse.persistence.internal.sessions.AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache)` INTERNAL: Clone the element, if necessary.
`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 builds and returns an expression that corresponds to a single attribute and it's value.
`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.
`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 perform delete through mappings that require the cascade
`void`	`cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Map visitedObjects)` INTERNAL: Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet
`void`	`cascadeRegisterNewIfRequired(java.lang.Object object, org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow, java.util.Map visitedObjects)` INTERNAL: Cascade registerNew for Create through mappings that require the cascade
`java.lang.Object`	`clone()` INTERNAL: The mapping clones itself to create deep copy.
`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
`void`	`compareCollectionsForChange(java.lang.Object oldCollection, java.lang.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.
`org.eclipse.persistence.internal.sessions.ChangeRecord`	`compareForChange(java.lang.Object clone, java.lang.Object backUp, org.eclipse.persistence.internal.sessions.ObjectChangeSet owner, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: This method compares the changes between two direct collections.
`void`	`compareListsForChange(java.util.List oldList, java.util.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.
`boolean`	`compareObjects(java.lang.Object firstObject, java.lang.Object secondObject, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Compare the attributes belonging to this mapping for the objects.
`void`	`convertClassNamesToClasses(java.lang.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.
`void`	`fixRealObjectReferences(java.lang.Object object, java.util.Map objectInformation, java.util.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.
`java.lang.Class`	`getAttributeClassification()` PUBLIC: Some databases do not properly support all of the base data types.
`java.lang.String`	`getAttributeClassificationName()` INTERNAL: Return the class name of the attribute type.
`org.eclipse.persistence.internal.helper.DatabaseField`	`getDirectField()` INTERNAL: Return the direct field.
`java.lang.String`	`getDirectFieldName()` PUBLIC: Returns the name of the field name in the reference table.
`java.util.Vector`	`getFieldsForTranslationInAggregate()` INTERNAL: Return source key fields for translation by an AggregateObjectMapping
`java.lang.Object`	`getFieldValue(java.lang.Object attributeValue, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Convert the attribute value to a field value.
`HistoryPolicy`	`getHistoryPolicy()` PUBLIC: Allow history support on the reference table.
`Expression`	`getJoinCriteria(org.eclipse.persistence.internal.expressions.ObjectExpression context, Expression base)` INTERNAL: Returns the join criteria stored in the mapping selection query.
`java.lang.Object`	`getObjectCorrespondingTo(java.lang.Object object, DistributedSession session, java.util.Map objectDescriptors, java.util.Map processedObjects, ObjectLevelReadQuery query)` INTERNAL: return the object on the client corresponding to the specified object.
`java.util.List<Expression>`	`getOrderByExpressions()` PUBLIC: Return the order by expression.
`java.lang.Class`	`getReferenceClass()` INTERNAL: This cannot be used with direct collection mappings.
`java.lang.String`	`getReferenceClassName()` INTERNAL: Returns the reference class name.
`ClassDescriptor`	`getReferenceDescriptor()` INTERNAL: There is none on direct collection.
`java.util.Vector`	`getReferenceKeyFieldNames()` INTERNAL: Return the reference key field names associated with the mapping.
`java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`getReferenceKeyFields()` INTERNAL: Return the reference key fields.
`org.eclipse.persistence.internal.helper.DatabaseTable`	`getReferenceTable()` INTERNAL: Return the direct table.
`java.lang.String`	`getReferenceTableName()` PUBLIC: Returns the name of the reference table
`java.lang.String`	`getReferenceTableQualifiedName()` PUBLIC: Returns the qualified name of the reference table.
`DatabaseMapping`	`getRelationshipPartner()` INTERNAL: Return the relationshipPartner mapping for this bi-directional mapping.
`java.util.Vector`	`getSelectFields()` INTERNAL: Returns the set of fields that should be selected to build this mapping's value(s).
`java.util.Vector`	`getSelectTables()` INTERNAL: Returns the table(s) that should be selected to build this mapping's value(s).
`java.util.Vector`	`getSourceKeyFieldNames()` PUBLIC: Return the source key field names associated with the mapping.
`java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField>`	`getSourceKeyFields()` INTERNAL: Return the source key fields.
`Converter`	`getValueConverter()` PUBLIC: Return the converter on the mapping.
`boolean`	`hasNestedIdentityReference()` INTERNAL: Indicates whether the mapping (or at least one of its nested mappings, at any nested depth) references an entity.
`void`	`initialize(org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Initialize and validate the mapping properties.
`boolean`	`isCandidateForPrivateOwnedRemoval()` INTERNAL: DirectCollectionMapping contents should not be considered for addition to the UnitOfWork private owned objects list for removal.
`boolean`	`isCascadedLockingSupported()` INTERNAL Return true if this mapping supports cascaded version optimistic locking.
`boolean`	`isDirectCollectionMapping()` INTERNAL:
`boolean`	`isElementCollectionMapping()` INTERNAL:
`boolean`	`isJoiningSupported()` INTERNAL: Return if this mapping support joining.
`boolean`	`isLockableMapping()` INTERNAL: Return whether this mapping should be traversed when we are locking
`boolean`	`isOwned()` INTERNAL:
`boolean`	`isRelationalMapping()` INTERNAL: All relational mappings should implement this method to return true.
`void`	`iterateOnElement(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, java.lang.Object element)` INTERNAL: Iterate on the specified element.
`void`	`iterateOnRealAttributeValue(org.eclipse.persistence.internal.descriptors.DescriptorIterator iterator, java.lang.Object realAttributeValue)` INTERNAL: Iterate on the attribute value.
`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`	`performDataModificationEvent(java.lang.Object[] event, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Perform the commit event.
`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`	`postInsert(WriteObjectQuery query)` INTERNAL: Insert the private owned object.
`void`	`postUpdate(WriteObjectQuery writeQuery)` INTERNAL: Update private owned part.
`void`	`preDelete(DeleteObjectQuery query)` INTERNAL: Delete private owned part.
`ReadQuery`	`prepareNestedBatchQuery(ObjectLevelReadQuery query)` INTERNAL: Clone and prepare the selection query as a nested batch read query.
`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.
`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.
`void`	`remoteInitialization(DistributedSession session)` INTERNAL: Once descriptors are serialized to the remote session.
`java.util.Map`	`replaceValueHoldersIn(java.lang.Object object, org.eclipse.persistence.internal.sessions.remote.RemoteSessionController controller)` INTERNAL: replace the value holders in the specified reference object(s)
`void`	`setAttributeClassification(java.lang.Class attributeClassification)` PUBLIC: Some databases do not properly support all of the base data types.
`void`	`setAttributeClassificationName(java.lang.String attributeClassificationName)` INTERNAL: Set the name of the class for MW usage.
`void`	`setContainerPolicy(org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy)` ADVANCED: Configure the mapping to use a container policy.
`void`	`setCustomDeleteAtIndexQuery(ModifyQuery query)` PUBLIC: The default delete by index query for this mapping can be overridden by specifying the new query.
`void`	`setCustomDeleteQuery(ModifyQuery query)` PUBLIC: The default delete query for this mapping can be overridden by specifying the new query.
`void`	`setCustomInsertQuery(DataModifyQuery query)` PUBLIC: The default insert query for mapping can be overridden by specifying the new query.
`void`	`setCustomUpdateAtIndexQuery(ModifyQuery query)` PUBLIC: The default delete by index query for this mapping can be overridden by specifying the new query.
`void`	`setDeleteSQLString(java.lang.String sqlString)` PUBLIC: Set the receiver's delete SQL string.
`void`	`setDirectField(org.eclipse.persistence.internal.helper.DatabaseField field)` PUBLIC: Set the direct field in the reference table.
`void`	`setDirectFieldClassification(java.lang.Class fieldType)` ADVANCED: Set the class type of the field value.
`void`	`setDirectFieldClassificationName(java.lang.String className)` ADVANCED: Set the class type of the field value.
`void`	`setDirectFieldName(java.lang.String fieldName)` PUBLIC: Set the direct field name in the reference table.
`void`	`setHistoryPolicy(HistoryPolicy policy)` PUBLIC: Support history on the reference table.
`void`	`setInsertSQLString(java.lang.String sqlString)` PUBLIC: Set the receiver's insert SQL string.
`void`	`setReferenceClass(java.lang.Class referenceClass)` INTERNAL: This cannot be used with direct collection mappings.
`void`	`setReferenceClassName(java.lang.String referenceClassName)` INTERNAL: Used by MW.
`void`	`setReferenceKeyFieldName(java.lang.String fieldName)` PUBLIC: Set the name of the reference key field.
`void`	`setReferenceKeyFieldNames(java.util.Vector fieldNames)` INTERNAL: Set the reference key field names associated with the mapping.
`void`	`setReferenceKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> aVector)` INTERNAL: Set the reference fields.
`void`	`setReferenceTable(org.eclipse.persistence.internal.helper.DatabaseTable table)` INTERNAL: Set the reference table.
`void`	`setReferenceTableName(java.lang.String tableName)` PUBLIC: Set the reference table name.
`void`	`setSelectionCriteria(Expression anExpression)` PUBLIC: Sets the selection criteria to be used as a where clause to read reference objects.
`void`	`setSessionName(java.lang.String name)` PUBLIC: Set the name of the session to execute the mapping's queries under.
`void`	`setSourceKeyFieldNames(java.util.Vector fieldNames)` INTERNAL: Set the source key field names associated with the mapping.
`void`	`setSourceKeyFields(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields)` INTERNAL: Set the source fields.
`void`	`setValueConverter(Converter valueConverter)` PUBLIC: Set the converter on the mapping.
`void`	`setValueConverterClassName(java.lang.String valueConverterClassName)` PUBLIC: Set the converter class name on the mapping.
`boolean`	`shouldUseListOrderFieldTableExpression()` INTERNAL: Indicates whether getListOrderFieldExpression method should create field expression on table expression.
`void`	`simpleAddToCollectionChangeRecord(java.lang.Object referenceKey, java.lang.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.
`void`	`simpleRemoveFromCollectionChangeRecord(java.lang.Object referenceKey, java.lang.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.
`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 with the new value.
`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.
`void`	`useMapClass(java.lang.Class concreteClass, java.lang.String methodName)` PUBLIC: It is illegal to use a Map as the container of a DirectCollectionMapping.
`java.lang.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, java.lang.Boolean[] wasCacheUsed)` INTERNAL: Return the value of the reference attribute or a value holder.
`boolean`	`verifyDelete(java.lang.Object object, org.eclipse.persistence.internal.sessions.AbstractSession session)` INTERNAL: Checks if object is deleted from the database or not.

Methods inherited from class org.eclipse.persistence.mappings.CollectionMapping
addAggregateOrderBy, addAscendingOrdering, addDescendingOrdering, addOrderBy, buildBackupCloneForPartObject, buildChangeRecord, buildCloneForPartObject, buildContainerClone, buildElementUnitOfWorkClone, buildReferencesPKList, extractResultFromBatchQuery, getContainerPolicy, getListOrderField, getOrderByQueryKeyExpressions, getOrderCorrectionType, getRealCollectionAttributeValueFromObject, getTargetPrimaryKeyFields, hasOrderBy, isAttributeValueInstantiatedOrChanged, isChangeTrackingSupported, isCollectionMapping, isListOrderFieldSupported, isMapKeyObjectRelationship, load, loadAll, mustDeleteReferenceObjectsOneByOne, postDelete, postInitialize, preInsert, preUpdate, setChangeListener, setCustomDeleteAllQuery, setDeleteAllCall, setDeleteAllSQLString, setListOrderField, setListOrderFieldName, setMustDeleteReferenceObjectsOneByOne, setOrderCorrectionType, setUseLazyInstantiationForIndirectCollection, shouldUseLazyInstantiationForIndirectCollection, updateChangeRecordForSelfMerge, useCollectionClass, useCollectionClassName, useListClassName, useMapClass, useMapClassName, useSortedSetClass, useSortedSetClassName, useSortedSetClassName, useTransparentCollection, useTransparentList, useTransparentMap, useTransparentSet, validateBeforeInitialization, valueFromPKList, writeChanges

Methods inherited from class org.eclipse.persistence.mappings.ForeignReferenceMapping
addForeignKeyField, addTargetForeignKeyField, buildBackupClone, buildClone, buildCloneFromRow, createCloneValueHolder, dontUseBatchReading, dontUseIndirection, extendPessimisticLockScopeInSourceQuery, fixObjectReferences, getAttributeValueFromObject, getAttributeValueWithClonedValueHolders, getBatchFetchType, getIndirectionPolicy, getJoinFetch, getMappedBy, getOrderByNormalizedExpressions, getPartitioningPolicy, getPartitioningPolicyName, getRealAttributeValueFromAttribute, getRelationshipPartnerAttributeName, getSelectionCriteria, getSelectionQuery, getValueFromRemoteValueHolder, hasCustomSelectionQuery, hasDependency, instantiateAttribute, isAttributeValueFromObjectInstantiated, isAttributeValueFullyBuilt, isAttributeValueInstantiated, isCascadeDetach, isCascadeMerge, isCascadeOnDeleteSetOnDatabase, isCascadePersist, isCascadeRefresh, isCascadeRemove, isForeignReferenceMapping, isInnerJoinFetched, isJoinFetched, isLazy, isOuterJoinFetched, isPrivateOwned, iterate, mergeRemoteValueHolder, preInitialize, privateOwnedRelationship, readFromRowIntoObject, requiresTransientWeavedFields, setBatchFetchType, setCascadeAll, setCascadeDetach, setCascadeMerge, setCascadePersist, setCascadeRefresh, setCascadeRemove, setCustomSelectionQuery, setForceInitializationOfSelectionCriteria, setIndirectionPolicy, setIsCacheable, setIsCascadeOnDeleteSetOnDatabase, setIsPrivateOwned, setJoinFetch, setMappedBy, setPartitioningPolicy, setPartitioningPolicyName, setRealAttributeValueInObject, setRelationshipPartner, setRelationshipPartnerAttributeName, setRequiresTransientWeavedFields, setSelectionCall, setSelectionSQLString, setShouldExtendPessimisticLockScope, setUsesBatchReading, setUsesIndirection, shouldExtendPessimisticLockScope, shouldExtendPessimisticLockScopeInDedicatedQuery, shouldExtendPessimisticLockScopeInSourceQuery, shouldExtendPessimisticLockScopeInTargetQuery, shouldMergeCascadeParts, shouldRefreshCascadeParts, shouldUseBatchReading, trimRowForJoin, trimRowForJoin, useBasicIndirection, useBatchReading, useContainerIndirection, useInnerJoinFetch, useOuterJoinFetch, usesIndirection, useWeavedIndirection

Methods inherited from class org.eclipse.persistence.mappings.DatabaseMapping
addUnconvertedProperty, buildObjectJoinExpression, buildObjectJoinExpression, buildShallowOriginalFromRow, derivesId, earlyPreDelete, getAttributeAccessor, getAttributeName, getDerivedIdMapping, getDescriptor, getField, getFieldClassification, getFields, getGetMethodName, getMapsIdValue, getProperties, getProperty, getRealAttributeValueFromObject, getSetMethodName, getUnconvertedProperties, getWeight, hasConstraintDependency, hasInverseConstraintDependency, hasMapsIdValue, hasUnconvertedProperties, isAbstractColumnMapping, isAbstractCompositeCollectionMapping, isAbstractCompositeDirectCollectionMapping, isAbstractCompositeObjectMapping, isAbstractDirectMapping, isAggregateCollectionMapping, isAggregateMapping, isAggregateObjectMapping, isCacheable, isCloningRequired, isDatabaseMapping, isDirectMapMapping, isDirectToFieldMapping, isDirectToXMLTypeMapping, isEISMapping, isInAndOutSopObject, isInOnlySopObject, isInSopObject, isJPAId, isManyToManyMapping, isManyToOneMapping, isMapKeyMapping, isMultitenantPrimaryKeyMapping, isNestedTableMapping, isObjectReferenceMapping, isOneToManyMapping, isOneToOneMapping, isOptional, isOutOnlySopObject, isOutSopObject, isPrimaryKeyMapping, isReadOnly, isReferenceMapping, isStructureMapping, isTransformationMapping, isUnidirectionalOneToManyMapping, isUsingMethodAccess, isVariableOneToOneMapping, isWriteOnly, isXMLMapping, postCalculateChangesOnDeleted, postInitializeSourceAndTargetExpressions, prepareCascadeLockingPolicy, readFromResultSetIntoObject, readOnly, readWrite, rehashFieldDependancies, setAttributeAccessor, setAttributeName, setAttributeValueInObject, setDerivedIdMapping, setDerivesId, setDescriptor, setGetMethodName, setIsInAndOutSopObject, setIsInSopObject, setIsJPAId, setIsLazy, setIsMapKeyMapping, setIsOptional, setIsOutSopObject, setIsPrimaryKeyMapping, setIsReadOnly, setMapsIdValue, setProperties, setProperty, setSetMethodName, setWeight, toString, validateAfterInitialization, valueFromObject, valueFromResultSet, valueFromRow, writeFromAttributeIntoRow, writeFromObjectIntoRow, writeFromObjectIntoRowForShallowInsert, writeFromObjectIntoRowForShallowInsertWithChangeRecord, writeFromObjectIntoRowForUpdate, writeFromObjectIntoRowForUpdateAfterShallowInsert, writeFromObjectIntoRowForUpdateBeforeShallowDelete, writeFromObjectIntoRowForWhereClause, writeFromObjectIntoRowWithChangeRecord, writeInsertFieldsIntoRow, writeUpdateFieldsIntoRow

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

- Constructor Detail
  - DirectCollectionMapping
```
public DirectCollectionMapping()
```
    PUBLIC: Default constructor.
- Method Detail
  - 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(java.lang.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(java.lang.String referenceForeignKeyFieldName,
                            java.lang.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
  - 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 CollectionMapping
  - buildElementClone
```
public java.lang.Object buildElementClone(java.lang.Object element,
                                 java.lang.Object parent,
                                 org.eclipse.persistence.internal.identitymaps.CacheKey parentCacheKey,
                                 java.lang.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(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 builds and returns an expression that corresponds to a single attribute and it's value.
    
    Overrides:
    
    buildExpression in class CollectionMapping
  - cascadePerformRemoveIfRequired
```
public void cascadePerformRemoveIfRequired(java.lang.Object object,
                                  org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                  java.util.Map visitedObjects)
```
    INTERNAL: Cascade perform delete through mappings that require the cascade
    
    Overrides:
    
    cascadePerformRemoveIfRequired in class CollectionMapping
  - cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired
```
public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(java.lang.Object object,
                                                                 org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                                                 java.util.Map visitedObjects)
```
    INTERNAL: Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet
    
    Overrides:
    
    cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired in class CollectionMapping
  - cascadeRegisterNewIfRequired
```
public void cascadeRegisterNewIfRequired(java.lang.Object object,
                                org.eclipse.persistence.internal.sessions.UnitOfWorkImpl uow,
                                java.util.Map visitedObjects)
```
    INTERNAL: Cascade registerNew for Create through mappings that require the cascade
    
    Overrides:
    
    cascadeRegisterNewIfRequired in class CollectionMapping
  - 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 CollectionMapping
  - clone
```
public java.lang.Object clone()
```
    INTERNAL: The mapping clones itself to create deep copy.
    
    Overrides:
    
    clone in class CollectionMapping
  - compareCollectionsForChange
```
public void compareCollectionsForChange(java.lang.Object oldCollection,
                               java.lang.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(java.util.List oldList,
                         java.util.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(java.lang.Object clone,
                                                                      java.lang.Object backUp,
                                                                      org.eclipse.persistence.internal.sessions.ObjectChangeSet owner,
                                                                      org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: This method 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(java.lang.Object firstObject,
                     java.lang.Object secondObject,
                     org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Compare the attributes belonging to this mapping for the objects.
    
    Overrides:
    
    compareObjects in class CollectionMapping
  - convertClassNamesToClasses
```
public void convertClassNamesToClasses(java.lang.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 -
  - fixRealObjectReferences
```
public void fixRealObjectReferences(java.lang.Object object,
                           java.util.Map objectInformation,
                           java.util.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 java.lang.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
    
    Since:
    
    Java Persistence API 2.0
  - getAttributeClassificationName
```
public java.lang.String getAttributeClassificationName()
```
    INTERNAL: Return the class name of the attribute type. This is only used by the MW.
    
    Since:
    
    Java Persistence API 2.0
  - getSelectFields
```
public java.util.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 java.util.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 java.lang.String getDirectFieldName()
```
    PUBLIC: Returns the name of the field name in the reference table.
  - 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 java.lang.Object getObjectCorrespondingTo(java.lang.Object object,
                                        DistributedSession session,
                                        java.util.Map objectDescriptors,
                                        java.util.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 java.util.List<Expression> getOrderByExpressions()
```
    PUBLIC: Return the order by expression.
  - getHistoryPolicy
```
public HistoryPolicy getHistoryPolicy()
```
    PUBLIC: Allow history support on the reference table.
  - getReferenceClass
```
public java.lang.Class getReferenceClass()
```
    INTERNAL: This cannot be used with direct collection mappings.
    
    Overrides:
    
    getReferenceClass in class ForeignReferenceMapping
  - getReferenceClassName
```
public java.lang.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 java.util.Vector getReferenceKeyFieldNames()
```
    INTERNAL: Return the reference key field names associated with the mapping. These are in-order with the sourceKeyFieldNames.
  - getReferenceKeyFields
```
public java.util.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 java.lang.String getReferenceTableName()
```
    PUBLIC: Returns the name of the reference table
  - getReferenceTableQualifiedName
```
public java.lang.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 java.util.Vector getSourceKeyFieldNames()
```
    PUBLIC: Return the source key field names associated with the mapping. These are in-order with the referenceKeyFieldNames.
  - getSourceKeyFields
```
public java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> getSourceKeyFields()
```
    INTERNAL: Return the source key fields.
  - 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
  - shouldUseListOrderFieldTableExpression
```
public boolean shouldUseListOrderFieldTableExpression()
```
    INTERNAL: Indicates whether getListOrderFieldExpression method should create field expression on table expression.
    
    Overrides:
    
    shouldUseListOrderFieldTableExpression 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
  - 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,
                               java.lang.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,
                    java.lang.Object element)
```
    INTERNAL: Iterate on the specified element.
    
    Overrides:
    
    iterateOnElement in class CollectionMapping
  - 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. Because this is a collection mapping, values are added to or removed from the collection based on the changeset
    
    Overrides:
    
    mergeChangesIntoObject in class CollectionMapping
  - mergeIntoObject
```
public void mergeIntoObject(java.lang.Object target,
                   boolean isTargetUnInitialized,
                   java.lang.Object source,
                   org.eclipse.persistence.internal.sessions.MergeManager mergeManager,
                   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(java.lang.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 java.lang.Object getFieldValue(java.lang.Object attributeValue,
                             org.eclipse.persistence.internal.sessions.AbstractSession session)
```
    INTERNAL: Convert the attribute value to a field value. Process any converter if defined.
  - getFieldsForTranslationInAggregate
```
public java.util.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
  - 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
  - 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 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 java.util.Map replaceValueHoldersIn(java.lang.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(java.lang.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.
    
    Since:
    
    Java Persistence API 2.0 Migrated from AbstractDirectMapping
  - setAttributeClassificationName
```
public void setAttributeClassificationName(java.lang.String attributeClassificationName)
```
    INTERNAL: Set the name of the class for MW usage.
    
    Since:
    
    Java Persistence API 2.0 Migrated from AbstractDirectMapping
  - setDeleteSQLString
```
public void setDeleteSQLString(java.lang.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(java.lang.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(java.lang.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(java.lang.String fieldName)
```
    PUBLIC: Set the direct field name in the reference table. This is the field that the primitive data value is stored in.
  - setInsertSQLString
```
public void setInsertSQLString(java.lang.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(java.lang.Class referenceClass)
```
    INTERNAL: This cannot be used with direct collection mappings.
    
    Overrides:
    
    setReferenceClass in class ForeignReferenceMapping
  - setReferenceClassName
```
public void setReferenceClassName(java.lang.String referenceClassName)
```
    Description copied from class: ForeignReferenceMapping
    
    INTERNAL: Used by MW.
    
    Overrides:
    
    setReferenceClassName in class ForeignReferenceMapping
  - setReferenceKeyFieldName
```
public void setReferenceKeyFieldName(java.lang.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(java.util.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(java.util.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(java.lang.String tableName)
```
    PUBLIC: Set the reference table name.
  - setHistoryPolicy
```
public void setHistoryPolicy(HistoryPolicy policy)
```
    PUBLIC: Support history on the reference table.
  - setSessionName
```
public void setSessionName(java.lang.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(java.util.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(java.util.Vector<org.eclipse.persistence.internal.helper.DatabaseField> sourceKeyFields)
```
    INTERNAL: Set the source fields.
  - 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
    
    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(java.lang.Object referenceKey,
                                     java.lang.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
  - simpleRemoveFromCollectionChangeRecord
```
public void simpleRemoveFromCollectionChangeRecord(java.lang.Object referenceKey,
                                          java.lang.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
  - 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 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(java.lang.Class concreteClass,
               java.lang.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:
    
    DirectMapMapping
  - valueFromRow
```
public java.lang.Object valueFromRow(org.eclipse.persistence.internal.sessions.AbstractRecord row,
                            org.eclipse.persistence.internal.queries.JoinedAttributeManager joinManager,
                            ObjectBuildingQuery sourceQuery,
                            org.eclipse.persistence.internal.identitymaps.CacheKey cacheKey,
                            org.eclipse.persistence.internal.sessions.AbstractSession session,
                            boolean isTargetProtected,
                            java.lang.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(java.lang.Object object,
                   org.eclipse.persistence.internal.sessions.AbstractSession session)
                     throws DatabaseException
```
    INTERNAL: Checks if object is deleted from the database or not.
    
    Overrides:
    
    verifyDelete in class CollectionMapping
    
    Throws:
    
    DatabaseException
  - isCandidateForPrivateOwnedRemoval
```
public boolean isCandidateForPrivateOwnedRemoval()
```
    INTERNAL: 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

Class DirectCollectionMapping

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

Constructor Summary

Method Summary

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

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

Constructor Detail

DirectCollectionMapping

Method Detail

addAscendingOrdering

addDescendingOrdering

addOrdering

isRelationalMapping

getValueConverter

setValueConverter

setValueConverterClassName

addReferenceKeyField

addReferenceKeyFieldName

prepareNestedBatchQuery

prepareNestedJoins

buildCopy

buildElementClone

buildExpression

cascadePerformRemoveIfRequired

cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired

cascadeRegisterNewIfRequired

cascadeDiscoverAndPersistUnregisteredNewObjects

clone

compareCollectionsForChange

compareListsForChange

compareForChange

compareObjects

convertClassNamesToClasses

fixRealObjectReferences

getAttributeClassification

getAttributeClassificationName

getSelectFields

getSelectTables

getDirectField

getDirectFieldName

getJoinCriteria

getObjectCorrespondingTo

getOrderByExpressions

getHistoryPolicy

getReferenceClass

getReferenceClassName

getReferenceDescriptor

getReferenceKeyFieldNames

getReferenceKeyFields

getReferenceTable

getReferenceTableName

getReferenceTableQualifiedName

getRelationshipPartner

getSourceKeyFieldNames

getSourceKeyFields

hasNestedIdentityReference

initialize

shouldUseListOrderFieldTableExpression

isDirectCollectionMapping

isElementCollectionMapping

isJoiningSupported

isLockableMapping

isOwned

iterateOnRealAttributeValue

iterateOnElement

mergeChangesIntoObject

mergeIntoObject

performDataModificationEvent

postCalculateChanges

postInsert

getFieldValue

getFieldsForTranslationInAggregate

postUpdate

preDelete

recordPrivateOwnedRemovals