Serialized Form (EclipseLink 2.6.1, API Reference)

Package javax.persistence
- Class javax.persistence.EntityExistsException extends PersistenceException implements Serializable
- Class javax.persistence.EntityNotFoundException extends PersistenceException implements Serializable
- Class javax.persistence.LockTimeoutException extends PersistenceException implements Serializable
  - Serialized Fields
    - entity
```
java.lang.Object entity
```
      The object that caused the exception
- Class javax.persistence.NonUniqueResultException extends PersistenceException implements Serializable
- Class javax.persistence.NoResultException extends PersistenceException implements Serializable
- Class javax.persistence.OptimisticLockException extends PersistenceException implements Serializable
  - Serialized Fields
    - entity
```
java.lang.Object entity
```
      The object that caused the exception
- Class javax.persistence.PersistenceException extends java.lang.RuntimeException implements Serializable
- Class javax.persistence.PessimisticLockException extends PersistenceException implements Serializable
  - Serialized Fields
    - entity
```
java.lang.Object entity
```
      The object that caused the exception
- Class javax.persistence.QueryTimeoutException extends PersistenceException implements Serializable
  - Serialized Fields
    - query
```
Query query
```
      The query object that caused the exception
- Class javax.persistence.RollbackException extends PersistenceException implements Serializable
- Class javax.persistence.TransactionRequiredException extends PersistenceException implements Serializable
Package javax.xml.bind
- Class javax.xml.bind.DataBindingException extends java.lang.RuntimeException implements Serializable
- Class javax.xml.bind.JAXBElement extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - name
```
javax.xml.namespace.QName name
```
      xml element tag name
    - declaredType
```
java.lang.Class<T> declaredType
```
      Java datatype binding for xml element declaration's type.
    - scope
```
java.lang.Class<T> scope
```
      Scope of xml element declaration representing this xml element instance. Can be one of the following values: - JAXBElement.GlobalScope for global xml element declaration. - local element declaration has a scope set to the Java class representation of complex type defintion containing xml element declaration.
    - value
```
java.lang.Object value
```
      xml element value. Represents content model and attributes of an xml element instance.
    - nil
```
boolean nil
```
      true iff the xml element instance has xsi:nil="true".
- Class javax.xml.bind.JAXBException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  -5621384651494307979L
  - Serialized Fields
    - errorCode
```
java.lang.String errorCode
```
      Vendor specific error code
    - linkedException
```
java.lang.Throwable linkedException
```
      Exception reference
- Class javax.xml.bind.JAXBPermission extends java.security.BasicPermission implements Serializable
  
  serialVersionUID:
  
  1L
- Class javax.xml.bind.MarshalException extends JAXBException implements Serializable
- Class javax.xml.bind.PropertyException extends JAXBException implements Serializable
- Class javax.xml.bind.TypeConstraintException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -3059799699420143848L
  - Serialized Fields
    - errorCode
```
java.lang.String errorCode
```
      Vendor specific error code
    - linkedException
```
java.lang.Throwable linkedException
```
      Exception reference
- Class javax.xml.bind.UnmarshalException extends JAXBException implements Serializable
- Class javax.xml.bind.ValidationException extends JAXBException implements Serializable

Package org.eclipse.persistence.core.descriptors

Class org.eclipse.persistence.core.descriptors.CoreDescriptor extends java.lang.Object implements Serializable

Serialized Fields

eventManager

CoreDescriptorEventManager<DESCRIPTOR_EVENT extends CoreDescriptorEvent> eventManager

field

org.eclipse.persistence.internal.core.helper.CoreField field

instantiationPolicy

org.eclipse.persistence.internal.core.descriptors.CoreInstantiationPolicy instantiationPolicy

inheritancePolicy

CoreInheritancePolicy<ABSTRACT_RECORD extends org.eclipse.persistence.internal.core.sessions.CoreAbstractRecord,ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,DESCRIPTOR extends CoreDescriptor,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField> inheritancePolicy

objectBuilder

org.eclipse.persistence.internal.core.descriptors.CoreObjectBuilder<ABSTRACT_RECORD extends org.eclipse.persistence.internal.core.sessions.CoreAbstractRecord,ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField,MAPPING extends CoreMapping> objectBuilder

attributeGroups
```
java.util.Map<K,V> attributeGroups
```

Package org.eclipse.persistence.core.mappings.transformers
Package org.eclipse.persistence.core.queries
- Class org.eclipse.persistence.core.queries.CoreAttributeGroup extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
      Name of the group. This is used in subclasses where the groups are stored and can be used within a query by name as with FetchGroup. For dynamic groups the name has no functional value.
    - typeName
```
java.lang.String typeName
```
      The name of the class represented by this AttrbuteGroup. Used to specify overriding groups for subclasses.
    - type
```
java.lang.Class<T> type
```
      The class represented by this AttrbuteGroup. Used to specify overriding groups for subclasses.
    - superClassGroup
```
CoreAttributeGroup<ATTRIBUTE_ITEM extends CoreAttributeItem,DESCRIPTOR extends CoreDescriptor> superClassGroup
```
      To add inheritance support the two following attrbutes are used to create a model of the inheritance tree This attribute points to the parent AttributeGroup of this attribute group.
    - allsubclasses
```
java.util.Map<K,V> allsubclasses
```
      This attribute is used to store all of the classes in this hierarchy keyed by type. It is used to find the correct graph for polymorphic groups.
    - items
```
java.util.Map<K,V> items
```
      Specified attributes in the group mapped to their AttributeItems
    - isValidated
```
boolean isValidated
```
      Marks this AttributeGroup as having been validated by the builder and does not require further validation
- Class org.eclipse.persistence.core.queries.CoreAttributeItem extends java.lang.Object implements Serializable
  - Serialized Fields
    - attributeName
```
java.lang.String attributeName
```
    - parent
```
CoreAttributeGroup<ATTRIBUTE_ITEM extends CoreAttributeItem,DESCRIPTOR extends CoreDescriptor> parent
```
    - group
```
CoreAttributeGroup<ATTRIBUTE_ITEM extends CoreAttributeItem,DESCRIPTOR extends CoreDescriptor> group
```
    - keyGroup
```
CoreAttributeGroup<ATTRIBUTE_ITEM extends CoreAttributeItem,DESCRIPTOR extends CoreDescriptor> keyGroup
```
    - subGroups
```
java.util.Map<K,V> subGroups
```
    - keyGroups
```
java.util.Map<K,V> keyGroups
```
Package org.eclipse.persistence.core.sessions
- Class org.eclipse.persistence.core.sessions.CoreProject extends java.lang.Object implements Serializable
Package org.eclipse.persistence.dbws
- Class org.eclipse.persistence.dbws.DBWSModelProject extends Project implements Serializable
  - Serialized Fields
    - ns
```
NamespaceResolver ns
```
Package org.eclipse.persistence.descriptors
- Class org.eclipse.persistence.descriptors.AllFieldsLockingPolicy extends FieldsLockingPolicy implements Serializable
- Class org.eclipse.persistence.descriptors.CacheIndex extends java.lang.Object implements Serializable
  - Serialized Fields
    - isUpdateable
```
boolean isUpdateable
```
    - isInsertable
```
boolean isInsertable
```
    - fields
```
java.util.List<E> fields
```
    - cacheSize
```
int cacheSize
```
      Allows the cache size to be set.
    - cacheType
```
java.lang.Class<T> cacheType
```
      Allows the identity map class type to be set.
- Class org.eclipse.persistence.descriptors.CachePolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - identityMapClass
```
java.lang.Class<T> identityMapClass
```
    - identityMapSize
```
int identityMapSize
```
    - shouldAlwaysRefreshCache
```
boolean shouldAlwaysRefreshCache
```
    - shouldOnlyRefreshCacheIfNewerVersion
```
boolean shouldOnlyRefreshCacheIfNewerVersion
```
    - shouldDisableCacheHits
```
boolean shouldDisableCacheHits
```
    - remoteIdentityMapClass
```
java.lang.Class<T> remoteIdentityMapClass
```
    - remoteIdentityMapSize
```
int remoteIdentityMapSize
```
    - shouldAlwaysRefreshCacheOnRemote
```
boolean shouldAlwaysRefreshCacheOnRemote
```
    - shouldDisableCacheHitsOnRemote
```
boolean shouldDisableCacheHitsOnRemote
```
    - cacheable
```
java.lang.Boolean cacheable
```
      Entity @Cacheable annotation value. This value contains Boolean value equal to annotation value or null when no annotation was set for entity. Parent values are ignored, value refers to current class only. This value is set only when SharedCacheMode allows to override caching on entity level (DISABLE_SELECTIVE or ENABLE_SELECTIVE). Default value is null what means no annotation is present in current class.
    - cacheIsolation
```
CacheIsolationType cacheIsolation
```
    - cacheSynchronizationType
```
int cacheSynchronizationType
```
      Configures how objects will be sent via cache synchronization, if synchronization is enabled.
    - unitOfWorkCacheIsolationLevel
```
int unitOfWorkCacheIsolationLevel
```
      Configures how the unit of work uses the session cache.
    - wasDefaultUnitOfWorkCacheIsolationLevel
```
boolean wasDefaultUnitOfWorkCacheIsolationLevel
```
    - cacheKeyType
```
CacheKeyType cacheKeyType
```
      Allow cache key type to be configured.
    - cacheInterceptorClass
```
java.lang.Class<T> cacheInterceptorClass
```
    - cacheInterceptorClassName
```
java.lang.String cacheInterceptorClassName
```
    - fullyMergeEntity
```
boolean fullyMergeEntity
```
      This flag controls how the MergeManager should merge an Entity when merging into the shared cache.
    - prefetchCacheKeys
```
boolean prefetchCacheKeys
```
      In certain cases and cache types it is more efficient to preFetch the cache keys from the cache when building the results of the query. Set this flag to true to prefetch the results.
    - cacheIndexes
```
java.util.Map<K,V> cacheIndexes
```
    - databaseChangeNotificationType
```
DatabaseChangeNotificationType databaseChangeNotificationType
```
      Allows configuration of database change event notification.
- Class org.eclipse.persistence.descriptors.ChangedFieldsLockingPolicy extends FieldsLockingPolicy implements Serializable
- Class org.eclipse.persistence.descriptors.ClassDescriptor extends CoreDescriptor<AttributeGroup,DescriptorEventManager,org.eclipse.persistence.internal.helper.DatabaseField,InheritancePolicy,org.eclipse.persistence.internal.descriptors.InstantiationPolicy,java.util.Vector,org.eclipse.persistence.internal.descriptors.ObjectBuilder> implements Serializable
  - Serialized Fields
    - javaClass
```
java.lang.Class<T> javaClass
```
    - javaClassName
```
java.lang.String javaClassName
```
    - tables
```
java.util.Vector<E> tables
```
    - primaryKeyFields
```
java.util.List<E> primaryKeyFields
```
    - additionalTablePrimaryKeyFields
```
java.util.Map<K,V> additionalTablePrimaryKeyFields
```
    - multipleTableForeignKeys
```
java.util.Map<K,V> multipleTableForeignKeys
```
    - isCascadeOnDeleteSetOnDatabaseOnSecondaryTables
```
boolean isCascadeOnDeleteSetOnDatabaseOnSecondaryTables
```
      Support delete cascading on the database for multiple and inheritance tables.
    - mappings
```
java.util.Vector<E> mappings
```
    - referencingClasses
```
java.util.Set<E> referencingClasses
```
    - lockableMappings
```
java.util.List<E> lockableMappings
```
    - queryKeys
```
java.util.Map<K,V> queryKeys
```
    - sequenceNumberName
```
java.lang.String sequenceNumberName
```
    - sequenceNumberField
```
org.eclipse.persistence.internal.helper.DatabaseField sequenceNumberField
```
    - amendmentClassName
```
java.lang.String amendmentClassName
```
    - alias
```
java.lang.String alias
```
    - shouldBeReadOnly
```
boolean shouldBeReadOnly
```
    - shouldAlwaysConformResultsInUnitOfWork
```
boolean shouldAlwaysConformResultsInUnitOfWork
```
    - shouldRegisterResultsInUnitOfWork
```
boolean shouldRegisterResultsInUnitOfWork
```
    - queryManager
```
DescriptorQueryManager queryManager
```
    - copyPolicy
```
CopyPolicy copyPolicy
```
    - copyPolicyClassName
```
java.lang.String copyPolicyClassName
```
    - interfacePolicy
```
InterfacePolicy interfacePolicy
```
    - optimisticLockingPolicy
```
org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy optimisticLockingPolicy
```
    - cascadeLockingPolicies
```
java.util.List<E> cascadeLockingPolicies
```
    - wrapperPolicy
```
WrapperPolicy wrapperPolicy
```
    - changePolicy
```
ObjectChangePolicy changePolicy
```
    - returningPolicy
```
ReturningPolicy returningPolicy
```
    - historyPolicy
```
HistoryPolicy historyPolicy
```
    - partitioningPolicyName
```
java.lang.String partitioningPolicyName
```
    - partitioningPolicy
```
PartitioningPolicy partitioningPolicy
```
    - cmpPolicy
```
CMPPolicy cmpPolicy
```
    - cachePolicy
```
CachePolicy cachePolicy
```
    - multitenantPolicy
```
MultitenantPolicy multitenantPolicy
```
    - serializedObjectPolicy
```
SerializedObjectPolicy serializedObjectPolicy
```
    - fetchGroupManager
```
FetchGroupManager fetchGroupManager
```
    - properties
```
java.util.Map<K,V> properties
```
      Additional properties may be added.
    - unconvertedProperties
```
java.util.Map<K,V> unconvertedProperties
```
      Allow the user to defined un-converted properties which will be initialized at runtime.
    - descriptorType
```
int descriptorType
```
    - shouldOrderMappings
```
boolean shouldOrderMappings
```
    - cacheInvalidationPolicy
```
CacheInvalidationPolicy cacheInvalidationPolicy
```
    - shouldAcquireCascadedLocks
```
boolean shouldAcquireCascadedLocks
```
      PERF: Used to optimize cache locking to only acquire deferred locks when required (no-indirection).
    - cascadedLockingInitialized
```
boolean cascadedLockingInitialized
```
      INTERNAL: flag to indicate the initialization state of cascade locking for this descriptor
    - hasSimplePrimaryKey
```
boolean hasSimplePrimaryKey
```
      PERF: Compute and store if the primary key is simple (direct-mapped) to allow fast extraction.
    - hasMultipleTableConstraintDependecy
```
boolean hasMultipleTableConstraintDependecy
```
      Defines if any mapping reference a field in a secondary table. This is used to disable deferring multiple table writes.
    - isNativeConnectionRequired
```
boolean isNativeConnectionRequired
```
      Allow connection unwrapping to be configured.
    - idValidation
```
IdValidation idValidation
```
      Allow zero primary key validation to be configured.
    - primaryKeyIdValidations
```
java.util.List<E> primaryKeyIdValidations
```
      Allow zero primary key validation to be configured per field.
    - derivesIdMappings
```
java.util.Map<K,V> derivesIdMappings
```
    - defaultQueryRedirector
```
QueryRedirector defaultQueryRedirector
```
    - defaultReadAllQueryRedirector
```
QueryRedirector defaultReadAllQueryRedirector
```
    - defaultReadObjectQueryRedirector
```
QueryRedirector defaultReadObjectQueryRedirector
```
    - defaultReportQueryRedirector
```
QueryRedirector defaultReportQueryRedirector
```
    - defaultUpdateObjectQueryRedirector
```
QueryRedirector defaultUpdateObjectQueryRedirector
```
    - defaultInsertObjectQueryRedirector
```
QueryRedirector defaultInsertObjectQueryRedirector
```
    - defaultDeleteObjectQueryRedirector
```
QueryRedirector defaultDeleteObjectQueryRedirector
```
    - defaultQueryRedirectorClassName
```
java.lang.String defaultQueryRedirectorClassName
```
    - defaultReadAllQueryRedirectorClassName
```
java.lang.String defaultReadAllQueryRedirectorClassName
```
    - defaultReadObjectQueryRedirectorClassName
```
java.lang.String defaultReadObjectQueryRedirectorClassName
```
    - defaultReportQueryRedirectorClassName
```
java.lang.String defaultReportQueryRedirectorClassName
```
    - defaultUpdateObjectQueryRedirectorClassName
```
java.lang.String defaultUpdateObjectQueryRedirectorClassName
```
    - defaultInsertObjectQueryRedirectorClassName
```
java.lang.String defaultInsertObjectQueryRedirectorClassName
```
    - defaultDeleteObjectQueryRedirectorClassName
```
java.lang.String defaultDeleteObjectQueryRedirectorClassName
```
    - sequence
```
Sequence sequence
```
      Store the Sequence used for the descriptor.
    - mappingsPostCalculateChanges
```
java.util.List<E> mappingsPostCalculateChanges
```
      Mappings that require postCalculateChanges method to be called
    - mappingsPostCalculateChangesOnDeleted
```
java.util.List<E> mappingsPostCalculateChangesOnDeleted
```
      Mappings that require postCalculateChangesOnDeleted method to be called
    - preDeleteMappings
```
java.util.List<E> preDeleteMappings
```
      stores a list of mappings that require preDelete as a group prior to the delete individually
    - hasRelationships
```
boolean hasRelationships
```
      whether this descriptor has any relationships through its mappings, through inheritance, or through aggregates
    - foreignKeyValuesForCaching
```
java.util.Set<E> foreignKeyValuesForCaching
```
      Stores a set of FK fields that will be cached to later retrieve noncacheable mappings
    - hasNoncacheableMappings
```
boolean hasNoncacheableMappings
```
      caches if this descriptor has any non cacheable mappings
    - weavingUsesPropertyAccess
```
boolean weavingUsesPropertyAccess
```
      This flag stores whether this descriptor is using Property access based on JPA semantics. It is used to modify the behavior of our weaving functionality as it pertains to adding annotations to fields
    - virtualAttributeMethods
```
java.util.List<E> virtualAttributeMethods
```
      A list of methods that are used by virtual mappings. This list is used to control weaving of methods used for virtual access
    - accessorTree
```
java.util.List<E> accessorTree
```
      A list of AttributeAccessors in order of access from root to leaf to arrive at current AggregateDescriptor. Only application for Aggregate Descriptors.
    - descriptorCustomizerClassName
```
java.lang.String descriptorCustomizerClassName
```
      JPA DescriptorCustomizer list stored here to preserve it when caching the project
    - shouldLockForClone
```
boolean shouldLockForClone
```
      This flag controls if a UOW should acquire locks for clone or simple clone the instance passed to registerExistingObject. If the IdentityMap type does not have concurrent access this can save a return to the identity map for cloning.
- Class org.eclipse.persistence.descriptors.CMPPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - forceUpdate
```
java.lang.Boolean forceUpdate
```
    - updateAllFields
```
java.lang.Boolean updateAllFields
```
    - pessimisticLockingPolicy
```
PessimisticLockingPolicy pessimisticLockingPolicy
```
      Allow the bean to always be locked as it enters a new transaction.
    - mappedClass
```
java.lang.Class<T> mappedClass
```
      Class originally mapped, before anything was generated.
    - descriptor
```
ClassDescriptor descriptor
```
    - modificationDeferralLevel
```
int modificationDeferralLevel
```
      The object deferral level. This controls when objects changes will be sent to the Database.
    - nonDeferredCreateTime
```
int nonDeferredCreateTime
```
      This setting will allow customers to control when Toplink will issue the insert SQL for CMP beans.
- Class org.eclipse.persistence.descriptors.CMPPolicy.KeyIsElementAccessor extends java.lang.Object implements Serializable
  - Serialized Fields
    - attributeName
```
java.lang.String attributeName
```
    - databaseField
```
org.eclipse.persistence.internal.helper.DatabaseField databaseField
```
    - mapping
```
DatabaseMapping mapping
```
- Class org.eclipse.persistence.descriptors.DescriptorEvent extends java.util.EventObject implements Serializable
  - Serialized Fields
    - eventCode
```
int eventCode
```
      The code of the descriptor event being raised. This is an integer constant value from DescriptorEventManager.
    - query
```
DatabaseQuery query
```
      The query causing the event.
    - record
```
Record record
```
      Optionally a database row may be provided on some events, (such as aboutToUpdate).
    - descriptor
```
ClassDescriptor descriptor
```
    - originalObject
```
java.lang.Object originalObject
```
      The source object represents the object the event is being raised on, some events also require a second object, for example the original object in a postClone.
    - changeSet
```
org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet
```
      For the post merge event it is possible that there has been a change set generated. This attribute will store the changeSet for the object just merged
    - session
```
org.eclipse.persistence.internal.sessions.AbstractSession session
```
      The session in which the event is raised.
- Class org.eclipse.persistence.descriptors.DescriptorEventManager extends CoreDescriptorEventManager<DescriptorEvent> implements Serializable
  - Serialized Fields
    - descriptor
```
ClassDescriptor descriptor
```
    - eventSelectors
```
java.util.Vector<E> eventSelectors
```
    - excludeDefaultListeners
```
boolean excludeDefaultListeners
```
    - excludeSuperclassListeners
```
boolean excludeSuperclassListeners
```
    - descriptorEventHolders
```
java.util.List<E> descriptorEventHolders
```
    - hasAnyEventListeners
```
boolean hasAnyEventListeners
```
      PERF: Cache if any events listener exist.
- Class org.eclipse.persistence.descriptors.DescriptorQueryManager extends java.lang.Object implements Serializable
  - Serialized Fields
    - insertQuery
```
InsertObjectQuery insertQuery
```
    - updateQuery
```
UpdateObjectQuery updateQuery
```
    - readObjectQuery
```
ReadObjectQuery readObjectQuery
```
    - readAllQuery
```
ReadAllQuery readAllQuery
```
    - deleteQuery
```
DeleteObjectQuery deleteQuery
```
    - doesExistQuery
```
DoesExistQuery doesExistQuery
```
    - descriptor
```
ClassDescriptor descriptor
```
    - hasCustomMultipleTableJoinExpression
```
boolean hasCustomMultipleTableJoinExpression
```
    - additionalCriteria
```
java.lang.String additionalCriteria
```
    - queries
```
java.util.Map<K,V> queries
```
    - queryTimeout
```
int queryTimeout
```
- Class org.eclipse.persistence.descriptors.FetchGroupManager extends java.lang.Object implements Serializable
  - Serialized Fields
    - fetchGroups
```
java.util.Map<K,V> fetchGroups
```
    - defaultFetchGroup
```
FetchGroup defaultFetchGroup
```
    - defaultEntityFetchGroup
```
org.eclipse.persistence.internal.queries.EntityFetchGroup defaultEntityFetchGroup
```
    - fullFetchGroup
```
FetchGroup fullFetchGroup
```
    - minimalFetchGroup
```
FetchGroup minimalFetchGroup
```
    - idEntityFetchGroup
```
org.eclipse.persistence.internal.queries.EntityFetchGroup idEntityFetchGroup
```
    - nonReferenceEntityFetchGroup
```
org.eclipse.persistence.internal.queries.EntityFetchGroup nonReferenceEntityFetchGroup
```
    - descriptor
```
ClassDescriptor descriptor
```
    - shouldUseInheritedDefaultFetchGroup
```
boolean shouldUseInheritedDefaultFetchGroup
```
- Class org.eclipse.persistence.descriptors.FieldsLockingPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - descriptor
```
ClassDescriptor descriptor
```
    - allNonPrimaryKeyFields
```
java.util.List<E> allNonPrimaryKeyFields
```
- Class org.eclipse.persistence.descriptors.InheritancePolicy extends CoreInheritancePolicy<org.eclipse.persistence.internal.sessions.AbstractRecord,org.eclipse.persistence.internal.sessions.AbstractSession,ClassDescriptor,org.eclipse.persistence.internal.helper.DatabaseField> implements Serializable
  - Serialized Fields
    - parentClass
```
java.lang.Class<T> parentClass
```
    - parentClassName
```
java.lang.String parentClassName
```
    - parentDescriptor
```
ClassDescriptor parentDescriptor
```
    - childDescriptors
```
java.util.List<E> childDescriptors
```
    - classIndicatorField
```
org.eclipse.persistence.internal.helper.DatabaseField classIndicatorField
```
    - classNameIndicatorMapping
```
java.util.Map<K,V> classNameIndicatorMapping
```
    - readAllSubclassesView
```
org.eclipse.persistence.internal.helper.DatabaseTable readAllSubclassesView
```
    - classExtractorName
```
java.lang.String classExtractorName
```
      Allow for class extraction method to be specified.
    - descriptor
```
ClassDescriptor descriptor
```
    - shouldAlwaysUseOuterJoin
```
boolean shouldAlwaysUseOuterJoin
```
    - useDescriptorsToValidateInheritedObjects
```
boolean useDescriptorsToValidateInheritedObjects
```
    - shouldOuterJoinSubclasses
```
boolean shouldOuterJoinSubclasses
```
      Define if an outer join should be used to read subclasses.
    - isJoinedStrategy
```
boolean isJoinedStrategy
```
    - rootParentDescriptor
```
ClassDescriptor rootParentDescriptor
```
      PERF: Cache root descriptor.
    - describesNonPersistentSubclasses
```
boolean describesNonPersistentSubclasses
```
- Class org.eclipse.persistence.descriptors.InterfacePolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - parentInterfaces
```
java.util.List<E> parentInterfaces
```
    - parentInterfaceNames
```
java.util.List<E> parentInterfaceNames
```
    - parentDescriptors
```
java.util.List<E> parentDescriptors
```
    - childDescriptors
```
java.util.List<E> childDescriptors
```
    - descriptor
```
ClassDescriptor descriptor
```
    - implementorDescriptor
```
java.lang.Class<T> implementorDescriptor
```
    - implementorDescriptorClassName
```
java.lang.String implementorDescriptorClassName
```
- Class org.eclipse.persistence.descriptors.PessimisticLockingPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - lockingMode
```
short lockingMode
```
- Class org.eclipse.persistence.descriptors.RelationalDescriptor extends ClassDescriptor implements Serializable
- Class org.eclipse.persistence.descriptors.ReturningPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - descriptor
```
ClassDescriptor descriptor
```
      owner of the policy
    - infos
```
java.util.List<E> infos
```
      Stores an object of type Info for every call to any of addField.. methods. Should be filled out before initialize() is called: fields added after initialization are ignored.
    - main
```
java.util.Collection<E>[][] main
```
      The following attributes are initialized by initialize() method. Contains the actual DatabaseFields to be returned. Populated during descriptor initialization using infos. Here's the order:
      main[INSERT][RETURN_ONLY] main[INSERT][WRITE_RETURN] main[INSERT][MAPPED] main[INSERT][UNMAPPED] main[INSERT][ALL] main[UPDATE][RETURN_ONLY] main[UPDATE][WRITE_RETURN] main[UPDATE][MAPPED] main[UPDATE][UNMAPPED] main[UPDATE][ALL]
      After initialization main[UPDATE,WRITE_RETURN] will contain all DatabaseFields that should be returned on Update as read-write.
      main[i][RETURN_ONLY] + main[i][WRITE_RETURN] = main[i][MAPPED] main[i][MAPPED] + main[i][UNMAPPED] = main[i][ALL]
    - tableToFieldsForGenerationMap
```
java.util.Map<K,V>[] tableToFieldsForGenerationMap
```
      maps ClassDescriptor's tables into Vectors of fields to be used for call generation. Lazily initialized array [NUM_OPERATIONS]
    - isUsedToSetPrimaryKey
```
boolean isUsedToSetPrimaryKey
```
      indicates whether ReturningPolicy is used for generation of the PK.
    - fieldsNotFromDescriptor_DefaultTable
```
java.util.Map<K,V> fieldsNotFromDescriptor_DefaultTable
```
      contains all default table the returning fields that are either unmapped or mapped supplied with types.
    - fieldsNotFromDescriptor_OtherTables
```
java.util.Map<K,V> fieldsNotFromDescriptor_OtherTables
```
      contains all the other tables returning fields that are either unmapped or mapped supplied with types.
- Class org.eclipse.persistence.descriptors.SchemaPerMultitenantPolicy extends TablePerMultitenantPolicy implements Serializable
  - Serialized Fields
    - useSharedCache
```
boolean useSharedCache
```
    - useSharedEMF
```
boolean useSharedEMF
```
- Class org.eclipse.persistence.descriptors.SelectedFieldsLockingPolicy extends FieldsLockingPolicy implements Serializable
  - Serialized Fields
    - lockFieldsByTable
```
java.util.Map<K,V> lockFieldsByTable
```
    - lockFields
```
java.util.List<E> lockFields
```
- Class org.eclipse.persistence.descriptors.SingleTableMultitenantPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - includeTenantCriteria
```
boolean includeTenantCriteria
```
    - descriptor
```
ClassDescriptor descriptor
```
    - tenantDiscriminatorFields
```
java.util.Map<K,V> tenantDiscriminatorFields
```
    - tenantDiscriminatorFieldsKeyedOnContext
```
java.util.Map<K,V> tenantDiscriminatorFieldsKeyedOnContext
```
- Class org.eclipse.persistence.descriptors.TablePerClassPolicy extends InterfacePolicy implements Serializable
- Class org.eclipse.persistence.descriptors.TablePerMultitenantPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - descriptor
```
ClassDescriptor descriptor
```
    - tablePerTenantTables
```
java.util.Map<K,V> tablePerTenantTables
```
    - type
```
TenantTableDiscriminatorType type
```
    - contextProperty
```
java.lang.String contextProperty
```
    - contextTenant
```
java.lang.String contextTenant
```
- Class org.eclipse.persistence.descriptors.TimestampLockingPolicy extends VersionLockingPolicy implements Serializable
  - Serialized Fields
    - retrieveTimeFrom
```
int retrieveTimeFrom
```
- Class org.eclipse.persistence.descriptors.VersionLockingPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - writeLockField
```
org.eclipse.persistence.internal.helper.DatabaseField writeLockField
```
    - isCascaded
```
boolean isCascaded
```
    - lockValueStored
```
int lockValueStored
```
    - descriptor
```
ClassDescriptor descriptor
```
    - lockMapping
```
AbstractDirectMapping lockMapping
```
      PERF: Cache the lock mapping if mapped with a direct mapping.
    - lockOnChangeMode
```
org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy.LockOnChange lockOnChangeMode
```
- Class org.eclipse.persistence.descriptors.VPDMultitenantPolicy extends SingleTableMultitenantPolicy implements Serializable
  - Serialized Fields
    - vpdIdentifier
```
java.lang.String vpdIdentifier
```
    - vpdIdentifierFieldName
```
java.lang.String vpdIdentifierFieldName
```
Package org.eclipse.persistence.descriptors.changetracking
- Class org.eclipse.persistence.descriptors.changetracking.AttributeChangeTrackingPolicy extends ObjectChangeTrackingPolicy implements Serializable
- Class org.eclipse.persistence.descriptors.changetracking.CollectionChangeEvent extends java.beans.PropertyChangeEvent implements Serializable
  - Serialized Fields
    - changeType
```
int changeType
```
      INTERNAL: Change type is either add or remove
    - index
```
java.lang.Integer index
```
      INTERNAL: index is the location of the change in the collection
    - isSet
```
boolean isSet
```
      INTERNAL: Set operation in IndirectList results in raising two events: removal of the old value and addition of the new one at the same index: oldValue = list.set(i, newValue); raiseRemoveEvent(i, oldValue, true); raiseAddEvent(i, newValue, true); This flag indicates whether the event was raised by set operation on the list.
    - isChangeApplied
```
boolean isChangeApplied
```
      INTERNAL: This flag will indicate if the object has already been removed or added to the collection before raising an event. The object is not removed or added before raising an event during merge.
- Class org.eclipse.persistence.descriptors.changetracking.DeferredChangeDetectionPolicy extends java.lang.Object implements Serializable
- Class org.eclipse.persistence.descriptors.changetracking.MapChangeEvent extends CollectionChangeEvent implements Serializable
  - Serialized Fields
    - key
```
java.lang.Object key
```
      INTERNAL: The value of the key that was updated.
- Class org.eclipse.persistence.descriptors.changetracking.ObjectChangeTrackingPolicy extends DeferredChangeDetectionPolicy implements Serializable
Package org.eclipse.persistence.descriptors.copying
- Class org.eclipse.persistence.descriptors.copying.AbstractCopyPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - descriptor
```
ClassDescriptor descriptor
```
- Class org.eclipse.persistence.descriptors.copying.CloneCopyPolicy extends AbstractCopyPolicy implements Serializable
  - Serialized Fields
    - methodName
```
java.lang.String methodName
```
      Allow for clone method to be specified.
    - workingCopyMethodName
```
java.lang.String workingCopyMethodName
```
- Class org.eclipse.persistence.descriptors.copying.InstantiationCopyPolicy extends AbstractCopyPolicy implements Serializable
- Class org.eclipse.persistence.descriptors.copying.PersistenceEntityCopyPolicy extends AbstractCopyPolicy implements Serializable
Package org.eclipse.persistence.descriptors.invalidation
- Class org.eclipse.persistence.descriptors.invalidation.CacheInvalidationPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - shouldUpdateReadTimeOnUpdate
```
boolean shouldUpdateReadTimeOnUpdate
```
      This will represent objects that do not expire.
    - shouldRefreshInvalidObjectsOnClone
```
boolean shouldRefreshInvalidObjectsOnClone
```
      Determines if expired object registered in the unit of work should be refreshed, default true.
    - isInvalidationRandomized
```
boolean isInvalidationRandomized
```
      Allows the timeToLive to be randomized to avoid bottlenecks.
    - random
```
java.util.Random random
```
      Random used for randomized invalidation.
- Class org.eclipse.persistence.descriptors.invalidation.DailyCacheInvalidationPolicy extends CacheInvalidationPolicy implements Serializable
  - Serialized Fields
    - expiryTime
```
java.util.Calendar expiryTime
```
    - previousExpiry
```
java.util.Calendar previousExpiry
```
- Class org.eclipse.persistence.descriptors.invalidation.NoExpiryCacheInvalidationPolicy extends CacheInvalidationPolicy implements Serializable
- Class org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy extends CacheInvalidationPolicy implements Serializable
  - Serialized Fields
    - timeToLive
```
long timeToLive
```
      Number of milliseconds before invalidation.
Package org.eclipse.persistence.descriptors.partitioning
- Class org.eclipse.persistence.descriptors.partitioning.CustomPartitioningPolicy extends PartitioningPolicy implements Serializable
  - Serialized Fields
    - partitioningClasName
```
java.lang.String partitioningClasName
```
    - policy
```
PartitioningPolicy policy
```
- Class org.eclipse.persistence.descriptors.partitioning.FieldPartitioningPolicy extends PartitioningPolicy implements Serializable
  - Serialized Fields
    - partitionField
```
org.eclipse.persistence.internal.helper.DatabaseField partitionField
```
      The column to partition by.
    - unionUnpartitionableQueries
```
boolean unionUnpartitionableQueries
```
      If query does not have the partition field in it, should the query be sent to all databases.
- Class org.eclipse.persistence.descriptors.partitioning.HashPartitioningPolicy extends FieldPartitioningPolicy implements Serializable
  - Serialized Fields
    - connectionPools
```
java.util.List<E> connectionPools
```
- Class org.eclipse.persistence.descriptors.partitioning.PartitioningPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
      The persistent unit unique name for the policy.
- Class org.eclipse.persistence.descriptors.partitioning.PinnedPartitioningPolicy extends PartitioningPolicy implements Serializable
  - Serialized Fields
    - connectionPool
```
java.lang.String connectionPool
```
- Class org.eclipse.persistence.descriptors.partitioning.RangePartitioningPolicy extends FieldPartitioningPolicy implements Serializable
  - Serialized Fields
    - partitions
```
java.util.List<E> partitions
```
- Class org.eclipse.persistence.descriptors.partitioning.ReplicationPartitioningPolicy extends PartitioningPolicy implements Serializable
  - Serialized Fields
    - connectionPools
```
java.util.List<E> connectionPools
```
- Class org.eclipse.persistence.descriptors.partitioning.RoundRobinPartitioningPolicy extends ReplicationPartitioningPolicy implements Serializable
  - Serialized Fields
    - currentIndex
```
int currentIndex
```
    - replicateWrites
```
boolean replicateWrites
```
- Class org.eclipse.persistence.descriptors.partitioning.UnionPartitioningPolicy extends ReplicationPartitioningPolicy implements Serializable
  - Serialized Fields
    - replicateWrites
```
boolean replicateWrites
```
- Class org.eclipse.persistence.descriptors.partitioning.ValuePartitioningPolicy extends FieldPartitioningPolicy implements Serializable
  - Serialized Fields
    - partitions
```
java.util.Map<K,V> partitions
```
      Store the value partitions. Each partition maps a value to a connectionPool.
    - partitionNames
```
java.util.Map<K,V> partitionNames
```
      Store the value partitions by name. Initialized at runtime.
    - partitionValueTypeName
```
java.lang.String partitionValueTypeName
```
      The type name of the partition value names. Initialized at runtime
    - partitionValueType
```
java.lang.Class<T> partitionValueType
```
      The type of the partition values. Initialized from the type name at runtime.
    - orderedPartitions
```
java.util.List<E> orderedPartitions
```
      Use to track order for compute UCP index.
    - defaultConnectionPool
```
java.lang.String defaultConnectionPool
```
      The default connection pool is used for any unmapped values.
Package org.eclipse.persistence.eis
- Class org.eclipse.persistence.eis.EISCollectionChangeRecord extends org.eclipse.persistence.internal.sessions.CollectionChangeRecord implements Serializable
  - Serialized Fields
    - adds
```
java.util.List<E> adds
```
      The added stuff.
    - removes
```
java.util.List<E> removes
```
      The removed stuff.
    - changedMapKeys
```
java.util.List<E> changedMapKeys
```
      The stuff whose Map keys have changed.
- Class org.eclipse.persistence.eis.EISConnectionSpec extends java.lang.Object implements Serializable
  - Serialized Fields
    - connectionSpec
```
javax.resource.cci.ConnectionSpec connectionSpec
```
    - connectionFactory
```
javax.resource.cci.ConnectionFactory connectionFactory
```
    - context
```
javax.naming.Context context
```
    - name
```
javax.naming.Name name
```
    - log
```
java.io.Writer log
```
- Class org.eclipse.persistence.eis.EISDescriptor extends ClassDescriptor implements Serializable
  - Serialized Fields
    - dataFormat
```
java.lang.String dataFormat
```
      Define the type of data the descriptor maps to.
    - namespaceResolver
```
NamespaceResolver namespaceResolver
```
      Allow namespaces to be specified for XML type descriptors.
- Class org.eclipse.persistence.eis.EISDOMRecord extends DOMRecord implements Serializable
  - Serialized Fields
    - record
```
javax.resource.cci.Record record
```
      The original adapter record.
    - recordName
```
java.lang.String recordName
```
      The record name.
    - recordShortDescription
```
java.lang.String recordShortDescription
```
      The record name.
- Class org.eclipse.persistence.eis.EISException extends DatabaseException implements Serializable
- Class org.eclipse.persistence.eis.EISLogin extends DatasourceLogin implements Serializable
- Class org.eclipse.persistence.eis.EISMappedRecord extends org.eclipse.persistence.internal.sessions.AbstractRecord implements Serializable
  - Serialized Fields
    - record
```
java.util.Map<K,V> record
```
    - accessor
```
EISAccessor accessor
```
- Class org.eclipse.persistence.eis.EISObjectPersistenceXMLProject extends org.eclipse.persistence.internal.sessions.factories.NamespaceResolvableProject implements Serializable
- Class org.eclipse.persistence.eis.EISOrderedCollectionChangeRecord extends org.eclipse.persistence.internal.sessions.CollectionChangeRecord implements Serializable
  - Serialized Fields
    - adds
```
java.util.List<E> adds
```
      The added stuff.
    - addIndexes
```
int[] addIndexes
```
      The indexes into the new collection of the elements that were added.
    - moves
```
java.util.List<E> moves
```
      The moved stuff.
    - moveIndexPairs
```
int[][] moveIndexPairs
```
      The index pairs of the elements that were moved (before and after indexes).
    - removes
```
java.util.List<E> removes
```
      The removed stuff.
    - removeIndexes
```
int[] removeIndexes
```
      The indexes into the old collection of the elements that were removed.
- Class org.eclipse.persistence.eis.EISPlatform extends org.eclipse.persistence.internal.databaseaccess.DatasourcePlatform implements Serializable
  - Serialized Fields
    - isIndexedRecordSupported
```
boolean isIndexedRecordSupported
```
    - isMappedRecordSupported
```
boolean isMappedRecordSupported
```
    - isDOMRecordSupported
```
boolean isDOMRecordSupported
```
    - shouldConvertDataToStrings
```
boolean shouldConvertDataToStrings
```
      Can be used for adapters that only support String data/XML.
    - supportsLocalTransactions
```
boolean supportsLocalTransactions
```
      Allows for usage of transaction to be disabled if not supported.
    - requiresAutoCommit
```
boolean requiresAutoCommit
```
      Can be used if a commit is required after every interaction outside of a local transaction.
    - recordConverter
```
RecordConverter recordConverter
```
      Can be used to convert from an adapter specific record.
    - domMethod
```
java.lang.reflect.Method domMethod
```
      Used to reflectively provide XML record support as DOMRecord is not part of the JCA-CCI spec.
    - xmlConversionManager
```
org.eclipse.persistence.internal.oxm.XMLConversionManager xmlConversionManager
```
      For XML usage, an XMLConversionManager instance is required
- Class org.eclipse.persistence.eis.EISSequence extends QuerySequence implements Serializable
Package org.eclipse.persistence.eis.interactions
- Class org.eclipse.persistence.eis.interactions.EISInteraction extends org.eclipse.persistence.internal.databaseaccess.DatasourceCall implements Serializable
  - Serialized Fields
    - interactionSpec
```
javax.resource.cci.InteractionSpec interactionSpec
```
      Adapter specific interaction spec.
    - functionName
```
java.lang.String functionName
```
      Name of the function the interaction describes.
    - inputRecordName
```
java.lang.String inputRecordName
```
      Name to pass to the input record creation.
    - properties
```
java.util.Map<K,V> properties
```
      Adapter specific properties may be added.
    - inputRow
```
org.eclipse.persistence.internal.sessions.AbstractRecord inputRow
```
      Holds database row of input values.
    - arguments
```
java.util.Vector<E> arguments
```
      Defines the arguments to the interaction, these can be the values or argument names/fields the values come from.
    - outputArgumentNames
```
java.util.Vector<E> outputArgumentNames
```
      Defines the output argument names as defined in the output record for the interaction. This is shared as indexed interaction may still have mapped results.
    - outputArguments
```
java.util.Vector<E> outputArguments
```
      Defines the field values the output arguments of the interaction map to. These are order dependent with the names.
    - outputResultPath
```
java.lang.String outputResultPath
```
      Path to the desired output record if nested.
- Class org.eclipse.persistence.eis.interactions.IndexedInteraction extends EISInteraction implements Serializable
- Class org.eclipse.persistence.eis.interactions.MappedInteraction extends EISInteraction implements Serializable
  - Serialized Fields
    - inputResultPath
```
java.lang.String inputResultPath
```
    - argumentNames
```
java.util.Vector<E> argumentNames
```
- Class org.eclipse.persistence.eis.interactions.QueryStringInteraction extends MappedInteraction implements Serializable
  - Serialized Fields
    - queryString
```
java.lang.String queryString
```
- Class org.eclipse.persistence.eis.interactions.XMLInteraction extends MappedInteraction implements Serializable
  - Serialized Fields
    - inputRootElementName
```
java.lang.String inputRootElementName
```
      The root element name to use for the input DOM.
    - outputRootElementName
```
java.lang.String outputRootElementName
```
      The root element name to use for the output DOM.
- Class org.eclipse.persistence.eis.interactions.XQueryInteraction extends XMLInteraction implements Serializable
  - Serialized Fields
    - xQueryString
```
java.lang.String xQueryString
```
Package org.eclipse.persistence.eis.mappings
- Class org.eclipse.persistence.eis.mappings.EISCompositeCollectionMapping extends AbstractCompositeCollectionMapping implements Serializable
- Class org.eclipse.persistence.eis.mappings.EISCompositeDirectCollectionMapping extends AbstractCompositeDirectCollectionMapping implements Serializable
- Class org.eclipse.persistence.eis.mappings.EISCompositeObjectMapping extends AbstractCompositeObjectMapping implements Serializable
- Class org.eclipse.persistence.eis.mappings.EISDirectMapping extends AbstractDirectMapping implements Serializable
- Class org.eclipse.persistence.eis.mappings.EISOneToManyMapping extends CollectionMapping implements Serializable
  - Serialized Fields
    - isForeignKeyRelationship
```
boolean isForeignKeyRelationship
```
      Keeps track if any of the fields are foreign keys.
    - foreignKeyGroupingElement
```
org.eclipse.persistence.internal.helper.DatabaseField foreignKeyGroupingElement
```
      The grouping-element field.
- Class org.eclipse.persistence.eis.mappings.EISOneToOneMapping extends ObjectReferenceMapping implements Serializable
  - Serialized Fields
    - sourceToTargetKeyFields
```
java.util.Map<K,V> sourceToTargetKeyFields
```
      Maps the source foreign/primary key fields to the target primary/foreign key fields.
    - targetToSourceKeyFields
```
java.util.Map<K,V> targetToSourceKeyFields
```
      Maps the target primary/foreign key fields to the source foreign/primary key fields.
    - shouldVerifyDelete
```
boolean shouldVerifyDelete
```
      These are used for non-unit of work modification to check if the value of the 1-1 was changed and a deletion is required.
- Class org.eclipse.persistence.eis.mappings.EISTransformationMapping extends AbstractTransformationMapping implements Serializable
Package org.eclipse.persistence.exceptions
- Class org.eclipse.persistence.exceptions.BeanValidationException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.CommunicationException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.ConcurrencyException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.ConversionException extends EclipseLinkException implements Serializable
  - Serialized Fields
    - classToConvertTo
```
java.lang.Class<T> classToConvertTo
```
- Class org.eclipse.persistence.exceptions.DatabaseException extends EclipseLinkException implements Serializable
  - Serialized Fields
    - exception
```
java.sql.SQLException exception
```
    - isCommunicationFailure
```
boolean isCommunicationFailure
```
- Class org.eclipse.persistence.exceptions.DBWSException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.DescriptorException extends ValidationException implements Serializable
- Class org.eclipse.persistence.exceptions.DiscoveryException extends RemoteCommandManagerException implements Serializable
- Class org.eclipse.persistence.exceptions.DynamicException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.EclipseLinkException extends java.lang.RuntimeException implements Serializable
  - Serialized Fields
    - internalException
```
java.lang.Throwable internalException
```
    - indentationString
```
java.lang.String indentationString
```
    - errorCode
```
int errorCode
```
    - hasBeenLogged
```
boolean hasBeenLogged
```
- Class org.eclipse.persistence.exceptions.EntityManagerSetupException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.IntegrityChecker extends java.lang.Object implements Serializable
  - Serialized Fields
    - caughtExceptions
```
java.util.Vector<E> caughtExceptions
```
      To add all the Descriptor exceptions
    - tables
```
java.util.Vector<E> tables
```
      To load the tables from database
    - shouldCatchExceptions
```
boolean shouldCatchExceptions
```
      To know that should we catch all the descriptors exceptions or not
    - shouldCheckDatabase
```
boolean shouldCheckDatabase
```
      To know that should we check database tables or not
    - shouldCheckInstantiationPolicy
```
boolean shouldCheckInstantiationPolicy
```
      To know that should we check InstantiationPolicy or not
- Class org.eclipse.persistence.exceptions.IntegrityException extends ValidationException implements Serializable
  - Serialized Fields
    - integrityChecker
```
IntegrityChecker integrityChecker
```
- Class org.eclipse.persistence.exceptions.JAXBException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.JPQLException extends EclipseLinkException implements Serializable
  - Serialized Fields
    - internalExceptions
```
java.util.Collection<E> internalExceptions
```
- Class org.eclipse.persistence.exceptions.OptimisticLockException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.PersistenceUnitLoadingException extends EclipseLinkException implements Serializable
  - Serialized Fields
    - resourceName
```
java.lang.String resourceName
```
- Class org.eclipse.persistence.exceptions.QueryException extends ValidationException implements Serializable
- Class org.eclipse.persistence.exceptions.RemoteCommandManagerException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.SDOException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.ServerPlatformException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.SessionLoaderException extends EclipseLinkException implements Serializable
  - Serialized Fields
    - exceptionList
```
java.util.Vector<E> exceptionList
```
- Class org.eclipse.persistence.exceptions.StaticWeaveException extends EclipseLinkException implements Serializable
  - Serialized Fields
    - resourceName
```
java.lang.String resourceName
```
- Class org.eclipse.persistence.exceptions.TransactionException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.ValidationException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.XMLConversionException extends EclipseLinkException implements Serializable
- Class org.eclipse.persistence.exceptions.XMLMarshalException extends ValidationException implements Serializable
- Class org.eclipse.persistence.exceptions.XMLParseException extends EclipseLinkException implements Serializable
Package org.eclipse.persistence.expressions
- Class org.eclipse.persistence.expressions.Expression extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5979150600092006081L
  - Serialized Fields
    - selectIfOrderedBy
```
boolean selectIfOrderedBy
```
    - hashCode
```
int hashCode
```
      PERF: Cache the hashCode.
- Class org.eclipse.persistence.expressions.ExpressionBuilder extends org.eclipse.persistence.internal.expressions.ObjectExpression implements Serializable
  - Serialized Fields
    - queryClass
```
java.lang.Class<T> queryClass
```
    - statement
```
org.eclipse.persistence.internal.expressions.SQLSelectStatement statement
```
    - viewTable
```
org.eclipse.persistence.internal.helper.DatabaseTable viewTable
```
    - aliasedViewTable
```
org.eclipse.persistence.internal.helper.DatabaseTable aliasedViewTable
```
    - wasQueryClassSetInternally
```
boolean wasQueryClassSetInternally
```
    - wasAdditionJoinCriteriaUsed
```
boolean wasAdditionJoinCriteriaUsed
```
- Class org.eclipse.persistence.expressions.ExpressionOperator extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7066100204792043980L
  - Serialized Fields
    - selector
```
int selector
```
    - name
```
java.lang.String name
```
    - databaseStrings
```
java.lang.String[] databaseStrings
```
    - isPrefix
```
boolean isPrefix
```
    - isRepeating
```
boolean isRepeating
```
    - nodeClass
```
java.lang.Class<T> nodeClass
```
    - type
```
int type
```
    - argumentIndices
```
int[] argumentIndices
```
    - javaStrings
```
java.lang.String[] javaStrings
```
    - isBindingSupported
```
boolean isBindingSupported
```
      Allow operator to disable binding.
- Class org.eclipse.persistence.expressions.ListExpressionOperator extends ExpressionOperator implements Serializable
  - Serialized Fields
    - startStrings
```
java.lang.String[] startStrings
```
    - separators
```
java.lang.String[] separators
```
    - terminationStrings
```
java.lang.String[] terminationStrings
```
    - numberOfItems
```
int numberOfItems
```
    - isComplete
```
boolean isComplete
```
Package org.eclipse.persistence.history
- Class org.eclipse.persistence.history.AsOfClause extends java.lang.Object implements Serializable
  - Serialized Fields
    - value
```
java.lang.Object value
```
- Class org.eclipse.persistence.history.AsOfSCNClause extends AsOfClause implements Serializable
- Class org.eclipse.persistence.history.HistoryPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - descriptor
```
ClassDescriptor descriptor
```
    - mapping
```
DatabaseMapping mapping
```
    - historicalTables
```
java.util.List<E> historicalTables
```
    - startFields
```
java.util.List<E> startFields
```
    - endFields
```
java.util.List<E> endFields
```
    - shouldHandleWrites
```
boolean shouldHandleWrites
```
    - usesLocalTime
```
boolean usesLocalTime
```
Package org.eclipse.persistence.indirection
- Class org.eclipse.persistence.indirection.IndirectList extends java.util.Vector<E> implements Serializable
  - Serialized Fields
    - delegate
```
java.util.Vector<E> delegate
```
      Reduce type casting.
    - valueHolder
```
ValueHolderInterface valueHolder
```
      Delegate indirection behavior to a value holder.
    - initialCapacity
```
int initialCapacity
```
      Store initial size for lazy init.
    - isRegistered
```
boolean isRegistered
```
      PERF: Quick check flag if has been registered in a unit of work.
    - isListOrderBrokenInDb
```
boolean isListOrderBrokenInDb
```
      If the mapping using IndirectList has listOrderfield != null then this flag indicates whether the list in the db has invalid order: either row(s) with null order value(s) or/and "holes" in order. The flag may be set to true when the objects are read from the db. When collection is updated the flag set to true causes updating of listOrderField of all rows in the db. After update is complete the flag is set back to false.
    - useLazyInstantiation
```
boolean useLazyInstantiation
```
      This value is used to determine if we should attempt to do adds and removes from the list without actually instantiating the list from the database. By default this is set to true.
- Class org.eclipse.persistence.indirection.IndirectMap extends java.util.Hashtable<K,V> implements Serializable
  - Serialized Fields
    - delegate
```
java.util.Hashtable<K,V> delegate
```
      Reduce type casting
    - valueHolder
```
ValueHolderInterface valueHolder
```
      Delegate indirection behavior to a value holder
    - initialCapacity
```
int initialCapacity
```
      Store initial size for lazy init.
    - loadFactor
```
float loadFactor
```
      Store load factor for lazy init.
- Class org.eclipse.persistence.indirection.IndirectSet extends java.lang.Object implements Serializable
  - Serialized Fields
    - delegate
```
java.util.Set<E> delegate
```
      Reduce type casting
    - valueHolder
```
ValueHolderInterface valueHolder
```
      Delegate indirection behavior to a value holder
    - attributeName
```
java.lang.String attributeName
```
      The mapping attribute name, used to raise change events.
    - initialCapacity
```
int initialCapacity
```
      Store initial size for lazy init.
    - loadFactor
```
float loadFactor
```
      Store load factor for lazy init.
    - useLazyInstantiation
```
boolean useLazyInstantiation
```
      This value is used to determine if we should attempt to do adds and removes from the list without actually instantiating the list from the database. By default, this is set to false. When set to true, adding duplicate elements to the set will result in the element being added when the transaction is committed.
- Class org.eclipse.persistence.indirection.ValueHolder extends java.lang.Object implements Serializable
  - Serialized Fields
    - value
```
java.lang.Object value
```
      Stores the wrapped object.
    - isCoordinatedWithProperty
```
boolean isCoordinatedWithProperty
```
      The two variable below are used as part of the implementation of WeavedAttributeValueHolderInterface They are used to track whether a valueholder that has been weaved into a class is coordinated with the underlying property
    - isNewlyWeavedValueHolder
```
boolean isNewlyWeavedValueHolder
```
Package org.eclipse.persistence.jaxb
- Class org.eclipse.persistence.jaxb.JAXBEnumTypeConverter extends ObjectTypeConverter implements Serializable
  - Serialized Fields
    - m_enumClass
```
java.lang.Class<T> m_enumClass
```
    - m_enumClassName
```
java.lang.String m_enumClassName
```
    - m_usesOrdinalValues
```
boolean m_usesOrdinalValues
```
- Class org.eclipse.persistence.jaxb.JAXBTypeElement extends JAXBElement implements Serializable
  - Serialized Fields
    - type
```
java.lang.reflect.Type type
```
- Class org.eclipse.persistence.jaxb.JAXBTypesafeEnumConverter extends java.lang.Object implements Serializable
  - Serialized Fields
    - enumClassName
```
java.lang.String enumClassName
```
    - enumClass
```
java.lang.Class<T> enumClass
```
    - fromStringMethod
```
java.lang.reflect.Method fromStringMethod
```
Package org.eclipse.persistence.jpa.dynamic
- Class org.eclipse.persistence.jpa.dynamic.DynamicIdentityPolicy extends org.eclipse.persistence.internal.jpa.CMP3Policy implements Serializable
Package org.eclipse.persistence.jpa.jpql
- Class org.eclipse.persistence.jpa.jpql.Assert.AssertException extends java.lang.RuntimeException implements Serializable
Package org.eclipse.persistence.jpa.jpql.tools.utility.filter
- Class org.eclipse.persistence.jpa.jpql.tools.utility.filter.AndFilter extends CompoundFilter<T> implements Serializable
  
  serialVersionUID:
  
  1L
- Class org.eclipse.persistence.jpa.jpql.tools.utility.filter.CompoundFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - filter1
```
Filter<T> filter1
```
      The first Filter used to accept the value.
    - filter2
```
Filter<T> filter2
```
      The second Filter used to accept the value.
Package org.eclipse.persistence.jpa.jpql.tools.utility.iterable
- Class org.eclipse.persistence.jpa.jpql.tools.utility.iterable.EmptyIterable extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readResolve
```
private java.lang.Object readResolve()
```
Package org.eclipse.persistence.jpa.jpql.tools.utility.iterator
- Class org.eclipse.persistence.jpa.jpql.tools.utility.iterator.CloneIterator.Remover.ReadOnly extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readResolve
```
private java.lang.Object readResolve()
```
Package org.eclipse.persistence.jpa.jpql.utility.iterator
- Class org.eclipse.persistence.jpa.jpql.utility.iterator.CloneListIterator.Mutator.ReadOnly extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readResolve
```
private java.lang.Object readResolve()
```
Package org.eclipse.persistence.jpa.rs.exceptions
- Class org.eclipse.persistence.jpa.rs.exceptions.JPARSException extends EclipseLinkException implements Serializable
  - Serialized Fields
    - httpStatusCode
```
javax.ws.rs.core.Response.Status httpStatusCode
```
Package org.eclipse.persistence.logging
- Class org.eclipse.persistence.logging.DefaultSessionLog extends AbstractSessionLog implements Serializable
  - Serialized Fields
    - fileName
```
java.lang.String fileName
```
      The filename associated with this DefaultSessionLog, if it is being written out to a file
    - categoryLogLevelMap
```
java.util.Map<K,V> categoryLogLevelMap
```
      Represents the Map that stores log levels per the name space strings. The keys are category names. The values are log levels.
- Class org.eclipse.persistence.logging.EclipseLinkLogRecord extends java.util.logging.LogRecord implements Serializable
  - Serialized Fields
    - sessionString
```
java.lang.String sessionString
```
    - connection
```
org.eclipse.persistence.internal.databaseaccess.Accessor connection
```
    - shouldLogExceptionStackTrace
```
boolean shouldLogExceptionStackTrace
```
    - shouldPrintDate
```
boolean shouldPrintDate
```
    - shouldPrintThread
```
boolean shouldPrintThread
```
- Class org.eclipse.persistence.logging.SessionLogEntry extends java.lang.Object implements Serializable
  - Serialized Fields
    - date
```
java.util.Date date
```
    - message
```
java.lang.String message
```
    - throwable
```
java.lang.Throwable throwable
```
    - level
```
int level
```
    - nameSpace
```
java.lang.String nameSpace
```
    - parameters
```
java.lang.Object[] parameters
```
    - shouldTranslate
```
boolean shouldTranslate
```
Package org.eclipse.persistence.mappings
- Class org.eclipse.persistence.mappings.AggregateCollectionMapping extends CollectionMapping implements Serializable
  - Serialized Fields
    - targetForeignKeyFields
```
java.util.Vector<E> targetForeignKeyFields
```
      This is a key in the target table which is a foreign key in the target table.
    - sourceKeyFields
```
java.util.Vector<E> sourceKeyFields
```
      This is a primary key in the source table that is used as foreign key in the target table
    - targetForeignKeyToSourceKeys
```
java.util.Map<K,V> targetForeignKeyToSourceKeys
```
      Foreign keys in the target table to the related keys in the source table
    - aggregateToSourceFields
```
java.util.Map<K,V> aggregateToSourceFields
```
      Map the name of a field in the aggregate collection descriptor to a field in the actual table specified in the mapping.
    - nestedAggregateToSourceFields
```
java.util.Map<K,V> nestedAggregateToSourceFields
```
      Map the name of an attribute of the reference descriptor mapped with AggregateCollectionMapping to aggregateToSourceFieldNames that should be applied to this mapping.
    - converters
```
java.util.Map<K,V> converters
```
      List of converters to apply at initialize time to their cloned aggregate mappings.
    - remoteReferenceDescriptor
```
ClassDescriptor remoteReferenceDescriptor
```
      In RemoteSession case the mapping needs the reference descriptor serialized from the server, but referenceDescriptor attribute defined as transient in the superclass. To overcome that in non-remote case referenceDescriptor is assigned to remoteReferenceDescriptor; in remote - another way around.
    - defaultSourceTable
```
org.eclipse.persistence.internal.helper.DatabaseTable defaultSourceTable
```
      Default source table that should be used with the default source fields of this mapping.
    - isEntireObjectPK
```
boolean isEntireObjectPK
```
      Indicates whether the entire target object is primary key - in that case the object can't be updated in the db, but rather deleted and then re-inserted.
    - isListOrderFieldUpdatable
```
boolean isListOrderFieldUpdatable
```
      indicates whether listOrderField value could be updated in the db. Used only if listOrderField!=null
    - hasNestedIdentityReference
```
java.lang.Boolean hasNestedIdentityReference
```
      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. Lazily initialized.
- Class org.eclipse.persistence.mappings.AggregateMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - referenceClass
```
java.lang.Class<T> referenceClass
```
      Stores a reference class
    - referenceClassName
```
java.lang.String referenceClassName
```
    - referenceDescriptor
```
ClassDescriptor referenceDescriptor
```
      The descriptor of the reference class
    - hasNestedIdentityReference
```
java.lang.Boolean hasNestedIdentityReference
```
      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. Lazily initialized.
- Class org.eclipse.persistence.mappings.AggregateObjectMapping extends AggregateMapping implements Serializable
  - Serialized Fields
    - isNullAllowed
```
boolean isNullAllowed
```
      If all the fields in the database row for the aggregate object are NULL, then, by default, the mapping will place a null in the appropriate source object (as opposed to an aggregate object filled with nulls). To change this behavior, set the value of this variable to false. Then the mapping will build a new instance of the aggregate object that is filled with nulls and place it in the source object.
    - aggregateKeyTable
```
org.eclipse.persistence.internal.helper.DatabaseTable aggregateKeyTable
```
    - aggregateToSourceFields
```
java.util.Map<K,V> aggregateToSourceFields
```
      322233 - changed to store the source DatabaseField to hold Case and other colunm info
    - nestedFieldTranslations
```
java.util.Map<K,V> nestedFieldTranslations
```
      Map of nested attributes that need to apply an override name to their a nested aggregate mapping's database field. Aggregate to source fields map is the existing EclipseLink functionality and works well when all embeddable mappings have unique database fields. This map adds specific attribute to database field override.
      
      See Also:
      AggregateObjectMapping.addFieldTranslation(org.eclipse.persistence.internal.helper.DatabaseField, java.lang.String)
    - overrideManyToManyMappings
```
java.util.List<E> overrideManyToManyMappings
```
      List of many to many mapping overrides to apply at initialize time to their cloned aggregate mappings.
    - overrideUnidirectionalOneToManyMappings
```
java.util.List<E> overrideUnidirectionalOneToManyMappings
```
      List of unidirectional one to many mapping overrides to apply at initialize time to their cloned aggregate mappings.
    - converters
```
java.util.Map<K,V> converters
```
      List of converters to apply at initialize time to their cloned aggregate mappings.
    - mapsIdMappings
```
java.util.List<E> mapsIdMappings
```
      List of maps id mappings that need to be set to read only at initialize time on their cloned aggregate mappings.
- Class org.eclipse.persistence.mappings.AttributeAccessor extends java.lang.Object implements Serializable
  - Serialized Fields
    - attributeName
```
java.lang.String attributeName
```
      Stores the name of the attribute
    - isWriteOnly
```
boolean isWriteOnly
```
    - isReadOnly
```
boolean isReadOnly
```
- Class org.eclipse.persistence.mappings.CollectionMapping extends ForeignReferenceMapping implements Serializable
  - Serialized Fields
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
    - hasOrderBy
```
boolean hasOrderBy
```
    - listOrderField
```
org.eclipse.persistence.internal.helper.DatabaseField listOrderField
```
      Field holds the order of elements in the list in the db, requires collection of type List, may be not null only in case isListOrderFieldSupported==true
    - isListOrderFieldSupported
```
boolean isListOrderFieldSupported
```
      Indicates whether the mapping supports listOrderField, if it doesn't attempt to set listOrderField throws exception.
    - orderCorrectionType
```
OrderCorrectionType orderCorrectionType
```
      Specifies what should be done if the list of values read from listOrserField is invalid (there should be no nulls, no duplicates, no "holes").
    - mustDeleteReferenceObjectsOneByOne
```
java.lang.Boolean mustDeleteReferenceObjectsOneByOne
```
      Store if the mapping can batch delete reference objects.
- Class org.eclipse.persistence.mappings.DatabaseMapping extends CoreMapping<AttributeAccessor,org.eclipse.persistence.internal.sessions.AbstractSession,org.eclipse.persistence.internal.queries.ContainerPolicy,ClassDescriptor,org.eclipse.persistence.internal.helper.DatabaseField> implements Serializable
  - Serialized Fields
    - descriptor
```
ClassDescriptor descriptor
```
      ClassDescriptor to which this mapping belongs to
    - attributeAccessor
```
AttributeAccessor attributeAccessor
```
      Wrapper to store the reference objects.
    - isReadOnly
```
boolean isReadOnly
```
      Makes this mapping read only. No write are performed on it. Default is false
    - isOptional
```
boolean isOptional
```
      Specifies whether this mapping is optional (i.e. field may be null). Used for DDL generation.
    - isLazy
```
java.lang.Boolean isLazy
```
      Specifies whether this mapping is lazy, this means not included in the default fetch group.
    - fields
```
java.util.Vector<E> fields
```
      Fields associated with the mappings are cached
    - isRemotelyInitialized
```
boolean isRemotelyInitialized
```
      It is needed only in remote initialization and mapping is in parent descriptor
    - weight
```
java.lang.Integer weight
```
      This is a TopLink defined attribute that allows us to sort the mappings
    - properties
```
java.util.Map<K,V> properties
```
      Allow user defined properties.
    - unconvertedProperties
```
java.util.Map<K,V> unconvertedProperties
```
      Allow the user to defined un-converted properties which will be initialized at runtime.
    - derivesId
```
boolean derivesId
```
      Used by the CMP3Policy to see if this mapping should be used in processing pk classes for find methods
    - isJPAId
```
boolean isJPAId
```
    - mapsIdValue
```
java.lang.String mapsIdValue
```
      A mapsId value.
    - derivedIdMapping
```
DatabaseMapping derivedIdMapping
```
      The id mapping this mapping derives. Used by the CMP3Policy to see if this mapping should be used in processing pk classes for find methods.
    - isPrimaryKeyMapping
```
boolean isPrimaryKeyMapping
```
      PERF: Used as a quick check to see if this mapping is a primary key mapping, set by the object builder during initialization.
    - attributeName
```
java.lang.String attributeName
```
      PERF: Cache the mappings attribute name.
    - isMapKeyMapping
```
boolean isMapKeyMapping
```
      Records if this mapping is being used as a MapKeyMapping. This is important for recording main mappings
    - isCacheable
```
boolean isCacheable
```
    - isInSopObject
```
java.lang.Boolean isInSopObject
```
      Irrelevant (and not set) unless descriptor has SerializedObjectPolicy (SOP). If descriptor has SOP, then ObjectLevelReadQuery (with shouldUseSerializedObjectPolicy flag set to true) reads in row that contain both field/value pairs and sopObject. This flag indicates whether the data for this mapping is contained in the row's sopObject or in fields/values. Boolean.TRUE - sopObject (in sopObject) Boolean.FALSE - fields/values (out sopObject); null - both sopObject and fields/values (both in and out sopObject). While writing to the data base the mapping will be used for writing into sopObject unless this flag is set to Boolean.FALSE;
- Class org.eclipse.persistence.mappings.DirectCollectionMapping extends CollectionMapping implements Serializable
  - Serialized Fields
    - valueConverter
```
Converter valueConverter
```
      Allows user defined conversion between the object value and the database value.
    - valueConverterClassName
```
java.lang.String valueConverterClassName
```
    - orderByExpressions
```
java.util.List<E> orderByExpressions
```
    - referenceTable
```
org.eclipse.persistence.internal.helper.DatabaseTable referenceTable
```
      Stores the reference table
    - directField
```
org.eclipse.persistence.internal.helper.DatabaseField directField
```
      The direct field name is converted and stored
    - sourceKeyFields
```
java.util.Vector<E> sourceKeyFields
```
    - referenceKeyFields
```
java.util.Vector<E> referenceKeyFields
```
    - insertQuery
```
DataModifyQuery insertQuery
```
      Used for insertion for m-m and dc, not used in 1-m.
    - changeSetDeleteQuery
```
ModifyQuery changeSetDeleteQuery
```
      Used for deletion when ChangeSets are used
    - hasCustomDeleteQuery
```
boolean hasCustomDeleteQuery
```
    - hasCustomInsertQuery
```
boolean hasCustomInsertQuery
```
    - historyPolicy
```
HistoryPolicy historyPolicy
```
    - deleteAtIndexQuery
```
ModifyQuery deleteAtIndexQuery
```
      Used (only in case listOrderField != null) to delete object with particular orderFieldValue
    - updateAtIndexQuery
```
ModifyQuery updateAtIndexQuery
```
      Used (only in case listOrderField != null) to update orderFieldValue of object with particular orderFieldValue
    - hasCustomDeleteAtIndexQuery
```
boolean hasCustomDeleteAtIndexQuery
```
    - hasCustomUpdateAtIndexQuery
```
boolean hasCustomUpdateAtIndexQuery
```
    - attributeClassificationName
```
java.lang.String attributeClassificationName
```
- Class org.eclipse.persistence.mappings.DirectMapMapping extends DirectCollectionMapping implements Serializable
- Class org.eclipse.persistence.mappings.DirectToFieldMapping extends AbstractDirectMapping implements Serializable
- Class org.eclipse.persistence.mappings.ForeignReferenceMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - referenceClass
```
java.lang.Class<T> referenceClass
```
      This is used only in descriptor proxy in remote session
    - referenceClassName
```
java.lang.String referenceClassName
```
    - selectionQuery
```
ReadQuery selectionQuery
```
      This query is used to read referenced objects for this mapping.
    - isPrivateOwned
```
boolean isPrivateOwned
```
      Indicates whether the referenced object is privately owned or not.
    - batchFetchType
```
BatchFetchType batchFetchType
```
      Indicates whether the referenced object should always be batch read on read all queries, and defines the type of batch fetch to use.
    - indirectionPolicy
```
org.eclipse.persistence.internal.indirection.IndirectionPolicy indirectionPolicy
```
      Implements indirection behavior
    - relationshipPartner
```
DatabaseMapping relationshipPartner
```
      Used to reference the other half of a bi-directional relationship.
    - relationshipPartnerAttributeName
```
java.lang.String relationshipPartnerAttributeName
```
      Set by users, used to retrieve the backpointer for this mapping
    - cascadePersist
```
boolean cascadePersist
```
      Cascading flags used by the EntityManager
    - cascadeMerge
```
boolean cascadeMerge
```
    - cascadeRefresh
```
boolean cascadeRefresh
```
    - cascadeRemove
```
boolean cascadeRemove
```
    - cascadeDetach
```
boolean cascadeDetach
```
    - requiresTransientWeavedFields
```
boolean requiresTransientWeavedFields
```
      Flag used to determine if we need to weave the transient annotation on weaved fields.
    - joinFetch
```
int joinFetch
```
      Define if the relationship should always be join fetched.
    - forceInitializationOfSelectionCriteria
```
boolean forceInitializationOfSelectionCriteria
```
      This is a way (after cloning) to force the initialization of the selection criteria
    - extendPessimisticLockScope
```
org.eclipse.persistence.mappings.ForeignReferenceMapping.ExtendPessimisticLockScope extendPessimisticLockScope
```
    - isCascadeOnDeleteSetOnDatabase
```
boolean isCascadeOnDeleteSetOnDatabase
```
      Support delete cascading on the database relationship constraint.
    - partitioningPolicy
```
PartitioningPolicy partitioningPolicy
```
      Allow the mapping's queries to be targeted at specific connection pools.
    - partitioningPolicyName
```
java.lang.String partitioningPolicyName
```
      Allow the mapping's queries to be targeted at specific connection pools.
    - mappedBy
```
java.lang.String mappedBy
```
      Stores JPA metadata about whether another mapping is the owning mapping. Only populated for JPA models
- Class org.eclipse.persistence.mappings.ManyToManyMapping extends CollectionMapping implements Serializable
  - Serialized Fields
    - mechanism
```
RelationTableMechanism mechanism
```
      Mechanism holds relationTable and all fields and queries associated with it.
    - historyPolicy
```
HistoryPolicy historyPolicy
```
    - isDefinedAsOneToManyMapping
```
boolean isDefinedAsOneToManyMapping
```
      266912: Since: EclipseLink 2.0 for the Metamodel API For 1:1 and m:m mappings - track the original externally defined mapping if different Note: This field will provide differentiation for the following external to internal representations for mapping types
      - A OneToManyMapping will be represented by a ManyToManyMapping if unidirectional
      - A ManyToOneMapping will be represented by a OneToOneMapping (without a FK constraint)
- Class org.eclipse.persistence.mappings.ManyToOneMapping extends OneToOneMapping implements Serializable
- Class org.eclipse.persistence.mappings.MultitenantPrimaryKeyMapping extends AbstractColumnMapping implements Serializable
  - Serialized Fields
    - accessor
```
org.eclipse.persistence.internal.descriptors.MultitenantPrimaryKeyAccessor accessor
```
- Class org.eclipse.persistence.mappings.ObjectReferenceMapping extends ForeignReferenceMapping implements Serializable
  - Serialized Fields
    - isForeignKeyRelationship
```
boolean isForeignKeyRelationship
```
      Keeps track if any of the fields are foreign keys.
    - foreignKeyFields
```
java.util.Vector<E> foreignKeyFields
```
      Keeps track of which fields are foreign keys on a per field basis (can have mixed foreign key relationships).
- Class org.eclipse.persistence.mappings.OneToManyMapping extends CollectionMapping implements Serializable
  - Serialized Fields
    - targetForeignKeyFields
```
java.util.Vector<E> targetForeignKeyFields
```
      The target foreign key fields that reference the sourceKeyFields.
    - sourceKeyFields
```
java.util.Vector<E> sourceKeyFields
```
      The (typically primary) source key fields that are referenced by the targetForeignKeyFields.
    - addTargetQuery
```
DataModifyQuery addTargetQuery
```
      Query used to update a single target row setting its foreign key to point to the source. Run once for each target added to the source. Example: for Employee with managedEmployees attribute mapped with UnidirectionalOneToMany the query looks like: UPDATE EMPLOYEE SET MANAGER_ID = 1 WHERE (EMP_ID = 2) where 1 is id of the source, and 2 is the id of the target to be added. Used only in case data modification events required.
    - hasCustomAddTargetQuery
```
boolean hasCustomAddTargetQuery
```
    - removeTargetQuery
```
DataModifyQuery removeTargetQuery
```
      Query used to update a single target row changing its foreign key value from the one pointing to the source to null. Run once for each target removed from the source. Example: for Employee with managedEmployees attribute mapped with UnidirectionalOneToMany the query looks like: UPDATE EMPLOYEE SET MANAGER_ID = null WHERE ((MANAGER_ID = 1) AND (EMP_ID = 2)) where 1 is id of the source, and 2 is the id of the target to be removed. Used only in case data modification events required.
    - hasCustomRemoveTargetQuery
```
boolean hasCustomRemoveTargetQuery
```
    - removeAllTargetsQuery
```
DataModifyQuery removeAllTargetsQuery
```
      Query used to update all target rows changing target foreign key value from the one pointing to the source to null. Run before the source object is deleted. Example: for Employee with managedEmployees attribute mapped with UnidirectionalOneToMany the query looks like: UPDATE EMPLOYEE SET MANAGER_ID = null WHERE (MANAGER_ID = 1) where 1 is id of the source to be deleted. Used only in case data modification events required.
    - hasCustomRemoveAllTargetsQuery
```
boolean hasCustomRemoveAllTargetsQuery
```
- Class org.eclipse.persistence.mappings.OneToOneMapping extends ObjectReferenceMapping implements Serializable
  - Serialized Fields
    - sourceToTargetKeyFields
```
java.util.Map<K,V> sourceToTargetKeyFields
```
      Maps the source foreign/primary key fields to the target primary/foreign key fields.
    - targetToSourceKeyFields
```
java.util.Map<K,V> targetToSourceKeyFields
```
      Maps the target primary/foreign key fields to the source foreign/primary key fields.
    - shouldVerifyDelete
```
boolean shouldVerifyDelete
```
      These are used for non-unit of work modification to check if the value of the 1-1 was changed and a deletion is required.
    - keyTableForMapKey
```
org.eclipse.persistence.internal.helper.DatabaseTable keyTableForMapKey
```
    - mechanism
```
RelationTableMechanism mechanism
```
      Mechanism holds relationTable and all fields and queries associated with it.
    - isOneToOneRelationship
```
boolean isOneToOneRelationship
```
      Define if this mapping is really for a OneToOne relationship. This is a backward compatibility issue, in that before the ManyToOneMapping was created OneToOneMapping was used for both.
    - isOneToOnePrimaryKeyRelationship
```
boolean isOneToOnePrimaryKeyRelationship
```
      Defines if this mapping was built using primary key join columns.
    - insertableFields
```
java.util.HashSet<E> insertableFields
```
      Keep track of which fields are insertable and updatable.
    - updatableFields
```
java.util.HashSet<E> updatableFields
```
- Class org.eclipse.persistence.mappings.RelationTableMechanism extends java.lang.Object implements Serializable
  - Serialized Fields
    - relationTable
```
org.eclipse.persistence.internal.helper.DatabaseTable relationTable
```
      The intermediate relation table.
    - sourceKeyFields
```
java.util.Vector<E> sourceKeyFields
```
      The field in the source table that corresponds to the key in the relation table
    - targetKeyFields
```
java.util.Vector<E> targetKeyFields
```
      The field in the target table that corresponds to the key in the relation table
    - sourceRelationKeyFields
```
java.util.Vector<E> sourceRelationKeyFields
```
      The field in the intermediate table that corresponds to the key in the source table
    - targetRelationKeyFields
```
java.util.Vector<E> targetRelationKeyFields
```
      The field in the intermediate table that corresponds to the key in the target table
    - deleteQuery
```
DataModifyQuery deleteQuery
```
      Query used for single row deletion.
    - hasCustomDeleteQuery
```
boolean hasCustomDeleteQuery
```
    - insertQuery
```
DataModifyQuery insertQuery
```
      Used for insertion.
    - hasCustomInsertQuery
```
boolean hasCustomInsertQuery
```
    - lockRelationTableQuery
```
ReadQuery lockRelationTableQuery
```
- Class org.eclipse.persistence.mappings.TransformationMapping extends AbstractTransformationMapping implements Serializable
- Class org.eclipse.persistence.mappings.UnidirectionalOneToManyMapping extends OneToManyMapping implements Serializable
  - Serialized Fields
    - shouldIncrementTargetLockValueOnAddOrRemoveTarget
```
boolean shouldIncrementTargetLockValueOnAddOrRemoveTarget
```
      Indicates whether target's optimistic locking value should be incremented on target being added to / removed from a source.
    - shouldIncrementTargetLockValueOnDeleteSource
```
boolean shouldIncrementTargetLockValueOnDeleteSource
```
      Indicates whether target's optimistic locking value should be incremented on the source deletion. Note that if the flag is set to true then the indirection will be triggered on source delete - in order to verify all targets' versions.
- Class org.eclipse.persistence.mappings.VariableOneToOneMapping extends ObjectReferenceMapping implements Serializable
  - Serialized Fields
    - typeField
```
org.eclipse.persistence.internal.helper.DatabaseField typeField
```
    - sourceToTargetQueryKeyNames
```
java.util.Map<K,V> sourceToTargetQueryKeyNames
```
    - typeIndicatorTranslation
```
java.util.Map<K,V> typeIndicatorTranslation
```
    - typeIndicatorNameTranslation
```
java.util.Map<K,V> typeIndicatorNameTranslation
```
      parallel table typeIndicatorTranslation used prior to initialization to avoid type indicators on Mapping Workbench
Package org.eclipse.persistence.mappings.converters
- Class org.eclipse.persistence.mappings.converters.ClassInstanceConverter extends java.lang.Object implements Serializable
  - Serialized Fields
    - mapping
```
DatabaseMapping mapping
```
- Class org.eclipse.persistence.mappings.converters.ConverterClass extends java.lang.Object implements Serializable
  - Serialized Fields
    - isForMapKey
```
boolean isForMapKey
```
    - disableConversion
```
boolean disableConversion
```
    - fieldClassification
```
java.lang.Class<T> fieldClassification
```
    - fieldClassificationName
```
java.lang.String fieldClassificationName
```
    - attributeConverterClassName
```
java.lang.String attributeConverterClassName
```
    - attributeConverter
```
AttributeConverter<X,Y> attributeConverter
```
- Class org.eclipse.persistence.mappings.converters.EnumTypeConverter extends ObjectTypeConverter implements Serializable
  - Serialized Fields
    - m_enumClass
```
java.lang.Class<T> m_enumClass
```
    - m_enumClassName
```
java.lang.String m_enumClassName
```
    - m_useOrdinalValues
```
boolean m_useOrdinalValues
```
- Class org.eclipse.persistence.mappings.converters.ObjectTypeConverter extends java.lang.Object implements Serializable
  - Serialized Fields
    - converterName
```
java.lang.String converterName
```
    - dataType
```
java.lang.Class<T> dataType
```
    - dataTypeName
```
java.lang.String dataTypeName
```
    - objectType
```
java.lang.Class<T> objectType
```
    - objectTypeName
```
java.lang.String objectTypeName
```
    - conversionValueStrings
```
java.util.Map<K,V> conversionValueStrings
```
    - addToAttributeOnlyConversionValueStrings
```
java.util.Map<K,V> addToAttributeOnlyConversionValueStrings
```
    - mapping
```
DatabaseMapping mapping
```
    - attributeToFieldValues
```
java.util.Map<K,V> attributeToFieldValues
```
    - defaultAttributeValueString
```
java.lang.String defaultAttributeValueString
```
- Class org.eclipse.persistence.mappings.converters.SerializedObjectConverter extends java.lang.Object implements Serializable
  - Serialized Fields
    - mapping
```
DatabaseMapping mapping
```
    - serializer
```
Serializer serializer
```
    - serializerClassName
```
java.lang.String serializerClassName
```
    - serializerPackage
```
java.lang.String serializerPackage
```
- Class org.eclipse.persistence.mappings.converters.TypeConversionConverter extends java.lang.Object implements Serializable
  - Serialized Fields
    - mapping
```
DatabaseMapping mapping
```
    - dataClass
```
java.lang.Class<T> dataClass
```
      Field type
    - dataClassName
```
java.lang.String dataClassName
```
    - objectClass
```
java.lang.Class<T> objectClass
```
      Object type
    - objectClassName
```
java.lang.String objectClassName
```
Package org.eclipse.persistence.mappings.foundation
- Class org.eclipse.persistence.mappings.foundation.AbstractColumnMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
      DatabaseField which this mapping represents.
    - converter
```
Converter converter
```
      Allows user defined conversion between the object attribute value and the database value.
    - converterClassName
```
java.lang.String converterClassName
```
    - isInsertable
```
boolean isInsertable
```
      Flag to support insertable JPA setting
    - isUpdatable
```
boolean isUpdatable
```
      Flag to support updatable JPA setting
- Class org.eclipse.persistence.mappings.foundation.AbstractCompositeCollectionMapping extends AggregateMapping implements Serializable
  - Serialized Fields
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
      The aggregate objects are stored in a single field.
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
      This determines the type of container used to hold the aggregate objects.
    - converter
```
Converter converter
```
      Allows user defined conversion between the object attribute value and the database value.
- Class org.eclipse.persistence.mappings.foundation.AbstractCompositeDirectCollectionMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
      This is the field holding the nested collection.
    - elementDataTypeName
```
java.lang.String elementDataTypeName
```
      This is the "data type" associated with each element in the nested collection. Depending on the data store, this could be optional.
    - valueConverter
```
Converter valueConverter
```
      Allows user defined conversion between the object value and the database value.
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
      This determines the type of container used to hold the nested collection in the object.
- Class org.eclipse.persistence.mappings.foundation.AbstractCompositeObjectMapping extends AggregateMapping implements Serializable
  - Serialized Fields
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
      The aggregate object is stored in a single field.
    - converter
```
Converter converter
```
      Allows user defined conversion between the object attribute value and the database value.
- Class org.eclipse.persistence.mappings.foundation.AbstractDirectMapping extends AbstractColumnMapping implements Serializable
  - Serialized Fields
    - attributeClassificationName
```
java.lang.String attributeClassificationName
```
    - keyTableForMapKey
```
org.eclipse.persistence.internal.helper.DatabaseTable keyTableForMapKey
```
    - fieldClassificationClassName
```
java.lang.String fieldClassificationClassName
```
    - bypassDefaultNullValueCheck
```
boolean bypassDefaultNullValueCheck
```
      PERF: Avoid default null value conversion check if not default null value set in conversion manager.
    - isMutable
```
java.lang.Boolean isMutable
```
      PERF: Indicates if this mapping's attribute is a simple atomic value and cannot be modified, only replaced. This is a tri-state to allow user to set to true or false, as default is false but some data-types such as Calendar or byte[] or converter types may be desired to be used as mutable.
- Class org.eclipse.persistence.mappings.foundation.AbstractTransformationMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - attributeTransformerClassName
```
java.lang.String attributeTransformerClassName
```
      Name of the class which implements AttributeTransformer to be used to retrieve the attribute value
    - attributeTransformer
```
AttributeTransformer attributeTransformer
```
      attributeTransformerClassName is converter to an instance of AttributeTransformer
    - fieldTransformations
```
java.util.List<E> fieldTransformations
```
      Stores field name and the class name of a FieldTransformer in a vector to preserve order
    - fieldToTransformers
```
java.util.List<E> fieldToTransformers
```
      The TransformerClassNames are converted into instances of FieldTransformer
    - isMutable
```
boolean isMutable
```
      PERF: Indicates if this mapping's attribute is a simple value which cannot be modified only replaced.
    - indirectionPolicy
```
org.eclipse.persistence.internal.indirection.IndirectionPolicy indirectionPolicy
```
      Implements indirection behaviour
Package org.eclipse.persistence.mappings.querykeys
- Class org.eclipse.persistence.mappings.querykeys.DirectCollectionQueryKey extends ForeignReferenceQueryKey implements Serializable
- Class org.eclipse.persistence.mappings.querykeys.DirectQueryKey extends QueryKey implements Serializable
  - Serialized Fields
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
- Class org.eclipse.persistence.mappings.querykeys.ForeignReferenceQueryKey extends QueryKey implements Serializable
  - Serialized Fields
    - referenceClass
```
java.lang.Class<T> referenceClass
```
    - referenceClassName
```
java.lang.String referenceClassName
```
    - joinCriteria
```
Expression joinCriteria
```
- Class org.eclipse.persistence.mappings.querykeys.ManyToManyQueryKey extends ForeignReferenceQueryKey implements Serializable
- Class org.eclipse.persistence.mappings.querykeys.OneToManyQueryKey extends ForeignReferenceQueryKey implements Serializable
- Class org.eclipse.persistence.mappings.querykeys.OneToOneQueryKey extends ForeignReferenceQueryKey implements Serializable
- Class org.eclipse.persistence.mappings.querykeys.QueryKey extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
    - descriptor
```
ClassDescriptor descriptor
```
Package org.eclipse.persistence.mappings.structures
- Class org.eclipse.persistence.mappings.structures.ArrayMapping extends AbstractCompositeDirectCollectionMapping implements Serializable
- Class org.eclipse.persistence.mappings.structures.NestedTableMapping extends CollectionMapping implements Serializable
  - Serialized Fields
    - nestedMapping
```
DatabaseMapping nestedMapping
```
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
      A ref is always stored in a single field.
    - structureName
```
java.lang.String structureName
```
      Arrays require a structure name, this is the ADT defined for the VARRAY.
- Class org.eclipse.persistence.mappings.structures.ObjectArrayMapping extends AbstractCompositeCollectionMapping implements Serializable
  - Serialized Fields
    - structureName
```
java.lang.String structureName
```
      Arrays require a structure name, this is the ADT defined for the VARRAY.
- Class org.eclipse.persistence.mappings.structures.ObjectRelationalDatabaseField extends org.eclipse.persistence.internal.helper.DatabaseField implements Serializable
  - Serialized Fields
    - sqlTypeName
```
java.lang.String sqlTypeName
```
    - nestedTypeField
```
org.eclipse.persistence.internal.helper.DatabaseField nestedTypeField
```
- Class org.eclipse.persistence.mappings.structures.ObjectRelationalDataTypeDescriptor extends RelationalDescriptor implements Serializable
  - Serialized Fields
    - structureName
```
java.lang.String structureName
```
    - orderedFields
```
java.util.Vector<E> orderedFields
```
    - allOrderedFields
```
java.util.Vector<E> allOrderedFields
```
- Class org.eclipse.persistence.mappings.structures.ReferenceMapping extends ObjectReferenceMapping implements Serializable
  - Serialized Fields
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
      A ref is always stored in a single field.
- Class org.eclipse.persistence.mappings.structures.StructureMapping extends AbstractCompositeObjectMapping implements Serializable
Package org.eclipse.persistence.mappings.transformers
- Class org.eclipse.persistence.mappings.transformers.AttributeTransformerAdapter extends java.lang.Object implements Serializable
- Class org.eclipse.persistence.mappings.transformers.ConstantTransformer extends FieldTransformerAdapter implements Serializable
  - Serialized Fields
    - value
```
java.lang.Object value
```
- Class org.eclipse.persistence.mappings.transformers.FieldTransformerAdapter extends java.lang.Object implements Serializable
- Class org.eclipse.persistence.mappings.transformers.MethodBasedAttributeTransformer extends java.lang.Object implements Serializable
  - Serialized Fields
    - mapping
```
AbstractTransformationMapping mapping
```
    - methodName
```
java.lang.String methodName
```
- Class org.eclipse.persistence.mappings.transformers.MethodBasedFieldTransformer extends java.lang.Object implements Serializable
  - Serialized Fields
    - methodName
```
java.lang.String methodName
```
    - mapping
```
AbstractTransformationMapping mapping
```
Package org.eclipse.persistence.mappings.xdb
- Class org.eclipse.persistence.mappings.xdb.DirectToXMLTypeMapping extends DirectToFieldMapping implements Serializable
  - Serialized Fields
    - shouldReadWholeDocument
```
boolean shouldReadWholeDocument
```
      Indicates if we should initialize the whole DOM on a read. This is only used if the user is mapping from an Oracle Document implementation.
    - xmlTransformer
```
XMLTransformer xmlTransformer
```
      Used to convert the DOM to a String.
    - xmlComparer
```
XMLComparer xmlComparer
```
      Used to determine if the XML document has been modified.
    - xmlParser
```
XMLParser xmlParser
```
      Used to convert the String to a DOM
Package org.eclipse.persistence.oxm
- Class org.eclipse.persistence.oxm.XMLDescriptor extends ClassDescriptor implements Serializable
  - Serialized Fields
    - namespaceResolver
```
NamespaceResolver namespaceResolver
```
    - schemaReference
```
XMLSchemaReference schemaReference
```
    - shouldPreserveDocument
```
boolean shouldPreserveDocument
```
    - defaultRootElementField
```
XMLField defaultRootElementField
```
    - sequencedObject
```
boolean sequencedObject
```
    - isWrapper
```
boolean isWrapper
```
    - resultAlwaysXMLRoot
```
boolean resultAlwaysXMLRoot
```
    - lazilyInitialized
```
boolean lazilyInitialized
```
    - locationAccessor
```
AttributeAccessor locationAccessor
```
    - hasReferenceMappings
```
boolean hasReferenceMappings
```
- Class org.eclipse.persistence.oxm.XMLField extends org.eclipse.persistence.internal.helper.DatabaseField implements Serializable
  - Serialized Fields
    - namespaceResolver
```
NamespaceResolver namespaceResolver
```
    - schemaType
```
javax.xml.namespace.QName schemaType
```
    - xPathFragment
```
org.eclipse.persistence.internal.oxm.XPathFragment<XML_FIELD extends org.eclipse.persistence.internal.oxm.mappings.Field> xPathFragment
```
    - lastXPathFragment
```
org.eclipse.persistence.internal.oxm.XPathFragment<XML_FIELD extends org.eclipse.persistence.internal.oxm.mappings.Field> lastXPathFragment
```
    - isCDATA
```
boolean isCDATA
```
    - isRequired
```
boolean isRequired
```
    - isInitialized
```
boolean isInitialized
```
    - usesSingleNode
```
boolean usesSingleNode
```
      Makes this maintain the collection of items in a single attribute or element instead of having one element per item in the collection. Default is false
    - userXMLTypes
```
java.util.HashMap<K,V> userXMLTypes
```
    - userJavaTypes
```
java.util.HashMap<K,V> userJavaTypes
```
    - isTypedTextField
```
boolean isTypedTextField
```
    - leafElementType
```
javax.xml.namespace.QName leafElementType
```
- Class org.eclipse.persistence.oxm.XMLLogin extends DatasourceLogin implements Serializable
  - Serialized Fields
    - equalNamespaceResolvers
```
boolean equalNamespaceResolvers
```
    - documentPreservationPolicy
```
DocumentPreservationPolicy documentPreservationPolicy
```
- Class org.eclipse.persistence.oxm.XMLUnionField extends XMLField implements Serializable
  - Serialized Fields
    - schemaTypes
```
java.util.ArrayList<E> schemaTypes
```
Package org.eclipse.persistence.oxm.mappings
- Class org.eclipse.persistence.oxm.mappings.XMLAbstractAnyMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - keepAsElementPolicy
```
UnmarshalKeepAsElementPolicy keepAsElementPolicy
```
    - isWriteOnly
```
boolean isWriteOnly
```
- Class org.eclipse.persistence.oxm.mappings.XMLAnyAttributeMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - wrapperNullPolicy
```
AbstractNullPolicy wrapperNullPolicy
```
    - field
```
XMLField field
```
    - containerPolicy
```
org.eclipse.persistence.internal.queries.MappedKeyMapContainerPolicy containerPolicy
```
    - isDefaultEmptyContainer
```
boolean isDefaultEmptyContainer
```
    - isNamespaceDeclarationIncluded
```
boolean isNamespaceDeclarationIncluded
```
    - isSchemaInstanceIncluded
```
boolean isSchemaInstanceIncluded
```
    - isWriteOnly
```
boolean isWriteOnly
```
    - reuseContainer
```
boolean reuseContainer
```
- Class org.eclipse.persistence.oxm.mappings.XMLAnyCollectionMapping extends XMLAbstractAnyMapping implements Serializable
  - Serialized Fields
    - field
```
XMLField field
```
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
    - defaultEmptyContainer
```
boolean defaultEmptyContainer
```
    - useXMLRoot
```
boolean useXMLRoot
```
    - mixedContent
```
boolean mixedContent
```
    - isWhitespacePreservedForMixedContent
```
boolean isWhitespacePreservedForMixedContent
```
    - areOtherMappingInThisContext
```
boolean areOtherMappingInThisContext
```
    - valueConverter
```
XMLConverter valueConverter
```
    - reuseContainer
```
boolean reuseContainer
```
    - wrapperNullPolicy
```
AbstractNullPolicy wrapperNullPolicy
```
- Class org.eclipse.persistence.oxm.mappings.XMLAnyObjectMapping extends XMLAbstractAnyMapping implements Serializable
  - Serialized Fields
    - field
```
XMLField field
```
    - useXMLRoot
```
boolean useXMLRoot
```
    - areOtherMappingInThisContext
```
boolean areOtherMappingInThisContext
```
    - converter
```
XMLConverter converter
```
    - isMixedContent
```
boolean isMixedContent
```
- Class org.eclipse.persistence.oxm.mappings.XMLBinaryDataCollectionMapping extends XMLCompositeDirectCollectionMapping implements Serializable
  - Serialized Fields
    - shouldInlineBinaryData
```
boolean shouldInlineBinaryData
```
    - mimeTypePolicy
```
MimeTypePolicy mimeTypePolicy
```
    - isSwaRef
```
boolean isSwaRef
```
    - collectionContentType
```
java.lang.Class<T> collectionContentType
```
- Class org.eclipse.persistence.oxm.mappings.XMLBinaryDataMapping extends XMLDirectMapping implements Serializable
  - Serialized Fields
    - shouldInlineBinaryData
```
boolean shouldInlineBinaryData
```
    - mimeTypePolicy
```
MimeTypePolicy mimeTypePolicy
```
    - isSwaRef
```
boolean isSwaRef
```
- Class org.eclipse.persistence.oxm.mappings.XMLChoiceCollectionMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - fieldToClassMappings
```
java.util.Map<K,V> fieldToClassMappings
```
    - classToFieldMappings
```
java.util.Map<K,V> classToFieldMappings
```
    - classToSourceFieldsMappings
```
java.util.Map<K,V> classToSourceFieldsMappings
```
    - classNameToSourceFieldsMappings
```
java.util.Map<K,V> classNameToSourceFieldsMappings
```
    - choiceElementMappings
```
java.util.Map<K,V> choiceElementMappings
```
    - choiceElementMappingsByClassName
```
java.util.Map<K,V> choiceElementMappingsByClassName
```
    - choiceElementMappingsByClass
```
java.util.Map<K,V> choiceElementMappingsByClass
```
    - fieldToClassNameMappings
```
java.util.Map<K,V> fieldToClassNameMappings
```
    - classNameToFieldMappings
```
java.util.Map<K,V> classNameToFieldMappings
```
    - fieldsToConverters
```
java.util.Map<K,V> fieldsToConverters
```
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
    - isDefaultEmptyContainer
```
boolean isDefaultEmptyContainer
```
    - isMixedContent
```
boolean isMixedContent
```
    - mixedGroupingElement
```
java.lang.String mixedGroupingElement
```
    - wrapperNullPolicy
```
AbstractNullPolicy wrapperNullPolicy
```
    - isAny
```
boolean isAny
```
    - isWriteOnly
```
boolean isWriteOnly
```
    - reuseContainer
```
boolean reuseContainer
```
    - converter
```
Converter converter
```
    - mixedContentMapping
```
XMLCompositeDirectCollectionMapping mixedContentMapping
```
    - anyMapping
```
XMLAnyCollectionMapping anyMapping
```
- Class org.eclipse.persistence.oxm.mappings.XMLChoiceObjectMapping extends DatabaseMapping implements Serializable
  - Serialized Fields
    - fieldToClassMappings
```
java.util.Map<K,V> fieldToClassMappings
```
    - classToFieldMappings
```
java.util.Map<K,V> classToFieldMappings
```
    - classNameToFieldMappings
```
java.util.Map<K,V> classNameToFieldMappings
```
    - classToSourceFieldsMappings
```
java.util.Map<K,V> classToSourceFieldsMappings
```
    - classNameToSourceFieldsMappings
```
java.util.Map<K,V> classNameToSourceFieldsMappings
```
    - fieldToClassNameMappings
```
java.util.Map<K,V> fieldToClassNameMappings
```
    - choiceElementMappings
```
java.util.Map<K,V> choiceElementMappings
```
    - choiceElementMappingsByClass
```
java.util.Map<K,V> choiceElementMappingsByClass
```
    - choiceElementMappingsByClassName
```
java.util.Map<K,V> choiceElementMappingsByClassName
```
    - fieldsToConverters
```
java.util.Map<K,V> fieldsToConverters
```
    - classNameToConverter
```
java.util.Map<K,V> classNameToConverter
```
    - classToConverter
```
java.util.Map<K,V> classToConverter
```
    - converter
```
Converter converter
```
    - isWriteOnly
```
boolean isWriteOnly
```
- Class org.eclipse.persistence.oxm.mappings.XMLCollectionReferenceMapping extends XMLObjectReferenceMapping implements Serializable
  - Serialized Fields
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
    - defaultEmptyContainer
```
boolean defaultEmptyContainer
```
    - usesSingleNode
```
boolean usesSingleNode
```
    - reuseContainer
```
boolean reuseContainer
```
    - wrapperNullPolicy
```
AbstractNullPolicy wrapperNullPolicy
```
- Class org.eclipse.persistence.oxm.mappings.XMLCompositeCollectionMapping extends AbstractCompositeCollectionMapping implements Serializable
  - Serialized Fields
    - nullPolicy
```
AbstractNullPolicy nullPolicy
```
    - wrapperNullPolicy
```
AbstractNullPolicy wrapperNullPolicy
```
    - keepAsElementPolicy
```
UnmarshalKeepAsElementPolicy keepAsElementPolicy
```
    - inverseReferenceMapping
```
XMLInverseReferenceMapping inverseReferenceMapping
```
    - defaultEmptyContainer
```
boolean defaultEmptyContainer
```
    - isWriteOnly
```
boolean isWriteOnly
```
    - reuseContainer
```
boolean reuseContainer
```
- Class org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping extends AbstractCompositeDirectCollectionMapping implements Serializable
  - Serialized Fields
    - isCDATA
```
boolean isCDATA
```
    - isDefaultEmptyContainer
```
boolean isDefaultEmptyContainer
```
    - isWriteOnly
```
boolean isWriteOnly
```
    - nullPolicy
```
AbstractNullPolicy nullPolicy
```
    - reuseContainer
```
boolean reuseContainer
```
    - isCollapsingStringValues
```
boolean isCollapsingStringValues
```
    - isNormalizingStringValues
```
boolean isNormalizingStringValues
```
    - wrapperNullPolicy
```
AbstractNullPolicy wrapperNullPolicy
```
- Class org.eclipse.persistence.oxm.mappings.XMLCompositeObjectMapping extends AbstractCompositeObjectMapping implements Serializable
  - Serialized Fields
    - nullPolicy
```
AbstractNullPolicy nullPolicy
```
    - inverseReferenceMapping
```
XMLInverseReferenceMapping inverseReferenceMapping
```
    - keepAsElementPolicy
```
UnmarshalKeepAsElementPolicy keepAsElementPolicy
```
    - isWriteOnly
```
boolean isWriteOnly
```
- Class org.eclipse.persistence.oxm.mappings.XMLDirectMapping extends AbstractDirectMapping implements Serializable
  - Serialized Fields
    - nullPolicy
```
AbstractNullPolicy nullPolicy
```
    - isCDATA
```
boolean isCDATA
```
    - isWriteOnly
```
boolean isWriteOnly
```
    - isCollapsingStringValues
```
boolean isCollapsingStringValues
```
    - isNormalizingStringValues
```
boolean isNormalizingStringValues
```
    - isNullValueMarshalled
```
boolean isNullValueMarshalled
```
- Class org.eclipse.persistence.oxm.mappings.XMLFragmentCollectionMapping extends AbstractCompositeDirectCollectionMapping implements Serializable
  - Serialized Fields
    - defaultEmptyContainer
```
boolean defaultEmptyContainer
```
    - isWriteOnly
```
boolean isWriteOnly
```
    - reuseContainer
```
boolean reuseContainer
```
    - wrapperNullPolicy
```
AbstractNullPolicy wrapperNullPolicy
```
- Class org.eclipse.persistence.oxm.mappings.XMLFragmentMapping extends XMLDirectMapping implements Serializable
- Class org.eclipse.persistence.oxm.mappings.XMLInverseReferenceMapping extends AggregateMapping implements Serializable
  - Serialized Fields
    - mappedBy
```
java.lang.String mappedBy
```
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
    - inlineMapping
```
DatabaseMapping inlineMapping
```
- Class org.eclipse.persistence.oxm.mappings.XMLObjectReferenceMapping extends AggregateMapping implements Serializable
  - Serialized Fields
    - sourceToTargetKeyFieldAssociations
```
java.util.HashMap<K,V> sourceToTargetKeyFieldAssociations
```
    - sourceToTargetKeys
```
java.util.Vector<E> sourceToTargetKeys
```
    - isWriteOnly
```
boolean isWriteOnly
```
    - inverseReferenceMapping
```
XMLInverseReferenceMapping inverseReferenceMapping
```
- Class org.eclipse.persistence.oxm.mappings.XMLTransformationMapping extends AbstractTransformationMapping implements Serializable
- Class org.eclipse.persistence.oxm.mappings.XMLVariableXPathCollectionMapping extends XMLCompositeCollectionMapping implements Serializable
  - Serialized Fields
    - variableAttributeName
```
java.lang.String variableAttributeName
```
    - variableGetMethodName
```
java.lang.String variableGetMethodName
```
    - variableSetMethodName
```
java.lang.String variableSetMethodName
```
    - variableAttributeAccessor
```
AttributeAccessor variableAttributeAccessor
```
    - isAttribute
```
boolean isAttribute
```
- Class org.eclipse.persistence.oxm.mappings.XMLVariableXPathObjectMapping extends XMLCompositeObjectMapping implements Serializable
  - Serialized Fields
    - variableAttributeName
```
java.lang.String variableAttributeName
```
    - variableGetMethodName
```
java.lang.String variableGetMethodName
```
    - variableSetMethodName
```
java.lang.String variableSetMethodName
```
    - variableAttributeAccessor
```
AttributeAccessor variableAttributeAccessor
```
    - isAttribute
```
boolean isAttribute
```
Package org.eclipse.persistence.oxm.mappings.converters
- Class org.eclipse.persistence.oxm.mappings.converters.XMLConverterAdapter extends java.lang.Object implements Serializable
- Class org.eclipse.persistence.oxm.mappings.converters.XMLListConverter extends java.lang.Object implements Serializable
  - Serialized Fields
    - conversionManager
```
org.eclipse.persistence.internal.oxm.XMLConversionManager conversionManager
```
    - mapping
```
XMLCompositeDirectCollectionMapping mapping
```
    - objectClass
```
java.lang.Class<T> objectClass
```
    - objectClassName
```
java.lang.String objectClassName
```
- Class org.eclipse.persistence.oxm.mappings.converters.XMLRootConverter extends java.lang.Object implements Serializable
  - Serialized Fields
    - rootFragment
```
org.eclipse.persistence.internal.oxm.XPathFragment<XML_FIELD extends org.eclipse.persistence.internal.oxm.mappings.Field> rootFragment
```
    - associatedField
```
XMLField associatedField
```
    - mapping
```
DatabaseMapping mapping
```
Package org.eclipse.persistence.oxm.platform
- Class org.eclipse.persistence.oxm.platform.DOMPlatform extends XMLPlatform<XMLUnmarshaller> implements Serializable
- Class org.eclipse.persistence.oxm.platform.SAXPlatform extends XMLPlatform<org.eclipse.persistence.internal.oxm.XMLUnmarshaller> implements Serializable
- Class org.eclipse.persistence.oxm.platform.XMLPlatform extends org.eclipse.persistence.internal.databaseaccess.DatasourcePlatform implements Serializable

Package org.eclipse.persistence.oxm.record

Class org.eclipse.persistence.oxm.record.DOMRecord extends XMLRecord implements Serializable
- Serialized Fields
  - dom
```
org.w3c.dom.Node dom
```
  - currentNode
```
org.w3c.dom.Node currentNode
```
  - lastUpdatedField
```
XMLField lastUpdatedField
```
  - referenceResolver
```
org.eclipse.persistence.internal.oxm.ReferenceResolver referenceResolver
```

Class org.eclipse.persistence.oxm.record.UnmarshalRecord extends XMLRecord implements Serializable

Serialized Fields

unmarshalRecord

org.eclipse.persistence.internal.oxm.record.UnmarshalRecord<ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField,ID_RESOLVER extends org.eclipse.persistence.internal.oxm.IDResolver,OBJECT_BUILDER extends org.eclipse.persistence.internal.oxm.ObjectBuilder,TRANSFORMATION_RECORD extends org.eclipse.persistence.internal.oxm.record.TransformationRecord,UNMARSHALLER extends org.eclipse.persistence.internal.oxm.Unmarshaller> unmarshalRecord

Class org.eclipse.persistence.oxm.record.ValidatingMarshalRecord.MarshalSAXParseException extends org.xml.sax.SAXParseException implements Serializable
- Serialized Fields
  - object
```
java.lang.Object object
```

Class org.eclipse.persistence.oxm.record.XMLRecord extends org.eclipse.persistence.internal.sessions.AbstractRecord implements Serializable

Serialized Fields

unmarshaller
```
XMLUnmarshaller unmarshaller
```

docPresPolicy

DocumentPreservationPolicy docPresPolicy

currentObject
```
java.lang.Object currentObject
```

session

org.eclipse.persistence.internal.sessions.AbstractSession session

hasCustomNamespaceMapper
```
boolean hasCustomNamespaceMapper
```
equalNamespaceResolvers
```
boolean equalNamespaceResolvers
```

abstractMarshalRecord

org.eclipse.persistence.internal.oxm.record.AbstractMarshalRecord<ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField,MARSHALLER extends org.eclipse.persistence.internal.oxm.Marshaller,NAMESPACE_RESOLVER extends org.eclipse.persistence.internal.oxm.NamespaceResolver> abstractMarshalRecord

Package org.eclipse.persistence.platform.database
- Class org.eclipse.persistence.platform.database.AccessPlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.AttunityPlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.CloudscapePlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.DatabasePlatform extends org.eclipse.persistence.internal.databaseaccess.DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.DB2MainframePlatform extends DB2Platform implements Serializable
- Class org.eclipse.persistence.platform.database.DB2Platform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.DB2ZPlatform extends DB2Platform implements Serializable
- Class org.eclipse.persistence.platform.database.DBasePlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.DerbyPlatform extends DB2Platform implements Serializable
  - Serialized Fields
    - isSequenceSupported
```
boolean isSequenceSupported
```
      Allow sequence support to be disabled for Derby < 10.6.1.
    - isOffsetFetchParameterSupported
```
boolean isOffsetFetchParameterSupported
```
      < = 10.6.1.0 supports parameters with OFFSET/FETCH - DERBY-4208
    - isConnectionDataInitialized
```
boolean isConnectionDataInitialized
```
- Class org.eclipse.persistence.platform.database.FirebirdPlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.H2Platform extends DatabasePlatform implements Serializable
  
  serialVersionUID:
  
  -2935483687958482934L
- Class org.eclipse.persistence.platform.database.HANAPlatform extends DatabasePlatform implements Serializable
  
  serialVersionUID:
  
  1L
- Class org.eclipse.persistence.platform.database.HSQLPlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.Informix11Platform extends InformixPlatform implements Serializable
  
  serialVersionUID:
  
  1L
- Class org.eclipse.persistence.platform.database.InformixPlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.JavaDBPlatform extends DerbyPlatform implements Serializable
- Class org.eclipse.persistence.platform.database.MaxDBPlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.MySQLPlatform extends DatabasePlatform implements Serializable
  - Serialized Fields
    - isFractionalTimeSupported
```
boolean isFractionalTimeSupported
```
      Support fractional seconds in time values since MySQL v. 5.6.4.
    - isConnectionDataInitialized
```
boolean isConnectionDataInitialized
```
- Class org.eclipse.persistence.platform.database.OraclePlatform extends DatabasePlatform implements Serializable
  - Serialized Fields
    - supportsIdentity
```
boolean supportsIdentity
```
      Advanced attribute indicating whether identity is supported, see comment to setSupportsIdentity method.
    - SELECT
```
java.lang.String SELECT
```
    - HINT_START
```
java.lang.String HINT_START
```
    - HINT_END
```
java.lang.String HINT_END
```
    - FROM
```
java.lang.String FROM
```
    - END_FROM
```
java.lang.String END_FROM
```
    - MAX_ROW
```
java.lang.String MAX_ROW
```
    - MIN_ROW
```
java.lang.String MIN_ROW
```
- Class org.eclipse.persistence.platform.database.PervasivePlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.PointBasePlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.PostgreSQLPlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.SQLAnywherePlatform extends SybasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.SQLServerPlatform extends DatabasePlatform implements Serializable
  - Serialized Fields
    - supportsSequenceObjects
```
boolean supportsSequenceObjects
```
      Support for sequence objects added in SQL Server 2012
    - isConnectionDataInitialized
```
boolean isConnectionDataInitialized
```
- Class org.eclipse.persistence.platform.database.SybasePlatform extends DatabasePlatform implements Serializable
  - Serialized Fields
    - typeStrings
```
java.util.Map<K,V> typeStrings
```
- Class org.eclipse.persistence.platform.database.SymfowarePlatform extends DatabasePlatform implements Serializable
- Class org.eclipse.persistence.platform.database.TimesTen7Platform extends TimesTenPlatform implements Serializable
- Class org.eclipse.persistence.platform.database.TimesTenPlatform extends DatabasePlatform implements Serializable
  - Serialized Fields
    - supportsForeignKeyConstraints
```
boolean supportsForeignKeyConstraints
```
Package org.eclipse.persistence.platform.database.oracle.plsql
- Class org.eclipse.persistence.platform.database.oracle.plsql.PLSQLStoredFunctionCall extends PLSQLStoredProcedureCall implements Serializable
- Class org.eclipse.persistence.platform.database.oracle.plsql.PLSQLStoredProcedureCall extends StoredProcedureCall implements Serializable
  - Serialized Fields
    - arguments
```
java.util.List<E> arguments
```
      List of procedure IN/OUT/INOUT arguments.
    - originalIndex
```
int originalIndex
```
      Keeps track of the next procedure argument index.
    - translationRow
```
org.eclipse.persistence.internal.sessions.AbstractRecord translationRow
```
      Translation row stored after translation on the call clone, used only for logging.
    - typesInfo
```
java.util.Map<K,V> typesInfo
```
      Map of conversion function routines for converting complex PLSQL types.
    - functionId
```
int functionId
```
      Id used to generate unique local functions.
Package org.eclipse.persistence.platform.xml
- Class org.eclipse.persistence.platform.xml.XMLPlatformException extends EclipseLinkException implements Serializable
Package org.eclipse.persistence.queries
- Class org.eclipse.persistence.queries.AttributeGroup extends CoreAttributeGroup<org.eclipse.persistence.internal.queries.AttributeItem,ClassDescriptor> implements Serializable
- Class org.eclipse.persistence.queries.BatchFetchPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - type
```
BatchFetchType type
```
      Define the type of batch fetching to use.
    - size
```
int size
```
      Define the batch size for IN style batch fetching.
    - attributeExpressions
```
java.util.List<E> attributeExpressions
```
      Define the attributes to be batch fetched.
    - batchedMappings
```
java.util.List<E> batchedMappings
```
      Define the mapping to be batch fetched (from mapping settings).
    - attributes
```
java.util.List<E> attributes
```
      PERF: Cache the local batch read attribute names.
- Class org.eclipse.persistence.queries.ColumnResult extends SQLResult implements Serializable
  - Serialized Fields
    - column
```
org.eclipse.persistence.internal.helper.DatabaseField column
```
      Stores the Columns name from the result set
- Class org.eclipse.persistence.queries.ConstructorReportItem extends org.eclipse.persistence.internal.queries.ReportItem implements Serializable
  - Serialized Fields
    - constructorArgTypes
```
java.lang.Class<T>[] constructorArgTypes
```
    - constructorMappings
```
java.util.List<E> constructorMappings
```
    - reportItems
```
java.util.List<E> reportItems
```
    - constructor
```
java.lang.reflect.Constructor<T> constructor
```
- Class org.eclipse.persistence.queries.ConstructorResult extends SQLResult implements Serializable
  - Serialized Fields
    - targetClassName
```
java.lang.String targetClassName
```
      Stores the class of result
    - columnResults
```
java.util.List<E> columnResults
```
      Stored the column results of this constructor result
    - constructor
```
java.lang.reflect.Constructor<T> constructor
```
    - constructorArgTypes
```
java.lang.Class<T>[] constructorArgTypes
```
- Class org.eclipse.persistence.queries.Cursor extends java.lang.Object implements Serializable
  - Serialized Fields
    - size
```
int size
```
      Cached size of the stream.
    - objectCollection
```
java.util.List<E> objectCollection
```
      Internal collection of objects.
    - initiallyConformingIndex
```
java.util.Map<K,V> initiallyConformingIndex
```
      Conforming instances found in memory when building the result.
    - selectionCriteriaClone
```
Expression selectionCriteriaClone
```
      SelectionCriteria & translation row ready for incremental conforming.
    - translationRow
```
org.eclipse.persistence.internal.sessions.AbstractRecord translationRow
```
    - nextRow
```
org.eclipse.persistence.internal.sessions.AbstractRecord nextRow
```
      Store the next row, for 1-m joining.
    - position
```
int position
```
      Current position in the objectCollection of the stream.
- Class org.eclipse.persistence.queries.CursoredStream extends Cursor implements Serializable
  - Serialized Fields
    - marker
```
int marker
```
      Marker for backing up.
- Class org.eclipse.persistence.queries.CursoredStreamPolicy extends CursorPolicy implements Serializable
  - Serialized Fields
    - initialReadSize
```
int initialReadSize
```
    - sizeQuery
```
ValueReadQuery sizeQuery
```
- Class org.eclipse.persistence.queries.CursorPolicy extends org.eclipse.persistence.internal.queries.ContainerPolicy implements Serializable
  - Serialized Fields
    - pageSize
```
int pageSize
```
    - query
```
ReadQuery query
```
- Class org.eclipse.persistence.queries.DatabaseQuery extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
      Queries can be given a name and registered with a descriptor to allow common queries to be reused.
    - arguments
```
java.util.List<E> arguments
```
      Arguments can be given and specified to predefined queries to allow reuse.
    - argumentFields
```
java.util.List<E> argumentFields
```
      PERF: Argument fields are cached in prepare to avoid rebuilding on each execution.
    - argumentValues
```
java.util.List<E> argumentValues
```
      Arguments values can be given and specified to predefined queries to allow reuse.
    - argumentTypes
```
java.util.List<E> argumentTypes
```
      Needed to differentiate queries with the same name.
    - argumentTypeNames
```
java.util.List<E> argumentTypeNames
```
      Used to build a list of argumentTypes by name pre-initialization
    - argumentParameterTypes
```
java.util.List<E> argumentParameterTypes
```
    - descriptors
```
java.util.List<E> descriptors
```
      The list of descriptors this query deals with. Set via JPA processing for table per tenant queries
    - queryMechanism
```
org.eclipse.persistence.internal.queries.DatabaseQueryMechanism queryMechanism
```
      The query mechanism determines the mechanism on how the database will be accessed.
    - redirector
```
QueryRedirector redirector
```
      A redirector allows for a queries execution to be the execution of a piece of code.
    - doNotRedirect
```
boolean doNotRedirect
```
      Can be set to true in the case there is a redirector or a default redirector but the user does not want the query redirected.
    - shouldMaintainCache
```
boolean shouldMaintainCache
```
      Flag used for a query to bypass the identitymap and unit of work.
    - shouldRetrieveBypassCache
```
boolean shouldRetrieveBypassCache
```
      JPA flags to control the shared cache
    - shouldStoreBypassCache
```
boolean shouldStoreBypassCache
```
    - allowNativeSQLQuery
```
java.lang.Boolean allowNativeSQLQuery
```
      Property used to override a persistence unit level that disallows native SQL queries.
      
      See Also:
      Project.setAllowNativeSQLQueries(boolean)
    - properties
```
java.util.Map<K,V> properties
```
      Internally used by the mappings as a temporary store.
    - translationRow
```
org.eclipse.persistence.internal.sessions.AbstractRecord translationRow
```
      Mappings and the descriptor use parameterized mechanisms that will be translated with the data from the row.
    - isUserDefined
```
boolean isUserDefined
```
      Internal flag used to bypass user define queries when executing one for custom sql/query support.
    - isUserDefinedSQLCall
```
boolean isUserDefinedSQLCall
```
      Internal flag used to bypass user define queries when executing one for custom sql/query support.
    - cascadePolicy
```
int cascadePolicy
```
      Policy that determines how the query will cascade to its object's parts.
    - sessionName
```
java.lang.String sessionName
```
      Used to override the default session in the session broker.
    - isPrepared
```
boolean isPrepared
```
      Queries prepare common stated in themselves.
    - shouldCloneCall
```
boolean shouldCloneCall
```
      Used to indicate whether or not the call needs to be cloned.
    - shouldPrepare
```
boolean shouldPrepare
```
      Allow for the prepare of queries to be turned off, this allow for dynamic non-pre SQL generated queries.
    - nullableArguments
```
java.util.List<E> nullableArguments
```
      List of arguments to check for null. If any are null, the query needs to be re-prepared.
    - shouldBindAllParameters
```
java.lang.Boolean shouldBindAllParameters
```
      Bind all arguments to the SQL statement.
    - shouldCacheStatement
```
java.lang.Boolean shouldCacheStatement
```
      Cache the prepared statement, this requires full parameter binding as well.
    - shouldUseWrapperPolicy
```
boolean shouldUseWrapperPolicy
```
      Use the WrapperPolicy for the objects returned by the query
    - sourceMapping
```
DatabaseMapping sourceMapping
```
      Table per class requires multiple query executions. Internally we prepare those queries and cache them against the source mapping's selection query. When queries are executed they are cloned so we need a mechanism to keep a reference back to the actual selection query so that we can successfully look up and chain query executions within a table per class inheritance hierarchy.
    - queryTimeout
```
int queryTimeout
```
      queryTimeout has three possible settings: DefaultTimeout, NoTimeout, and 1..N This applies to both DatabaseQuery.queryTimeout and DescriptorQueryManager.queryTimeout DatabaseQuery.queryTimeout: - DefaultTimeout: get queryTimeout from DescriptorQueryManager - NoTimeout, 1..N: overrides queryTimeout in DescriptorQueryManager DescriptorQueryManager.queryTimeout: - DefaultTimeout: get queryTimeout from parent DescriptorQueryManager. If there is no parent, default to NoTimeout - NoTimeout, 1..N: overrides parent queryTimeout
    - hintString
```
java.lang.String hintString
```
      Used for adding hints to the query string in oracle
    - flushOnExecute
```
java.lang.Boolean flushOnExecute
```
    - isExecutionClone
```
boolean isExecutionClone
```
      PERF: Determines if the query has already been cloned for execution, to avoid duplicate cloning.
    - isCustomQueryUsed
```
java.lang.Boolean isCustomQueryUsed
```
      PERF: Store if this query will use the descriptor custom query.
    - isNativeConnectionRequired
```
boolean isNativeConnectionRequired
```
      Allow connection unwrapping to be configured.
    - shouldValidateUpdateCallCacheUse
```
boolean shouldValidateUpdateCallCacheUse
```
      Allow additional validation to be performed before using the update call cache
    - partitioningPolicy
```
PartitioningPolicy partitioningPolicy
```
      Allow queries to be targeted at specific connection pools.
    - parameterDelimiter
```
java.lang.String parameterDelimiter
```
      Allow the reserved pound char used to delimit bind parameters to be overridden
- Class org.eclipse.persistence.queries.DataModifyQuery extends ModifyQuery implements Serializable
  - Serialized Fields
    - hasModifyRow
```
boolean hasModifyRow
```
      Used to distinguish query that have a different modify row than translation row.
- Class org.eclipse.persistence.queries.DataReadQuery extends ReadQuery implements Serializable
  - Serialized Fields
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
    - resultType
```
int resultType
```
      Allow return type to be configured, MAP, ARRAY, VALUE, ATTRIBUTE (MAP is the default, i.e. DatabaseRecord).
- Class org.eclipse.persistence.queries.DeleteAllQuery extends ModifyAllQuery implements Serializable
  - Serialized Fields
    - objects
```
java.util.List<E> objects
```
      List containing objects to be deleted, these should be removed from the identity map after deletion.
    - isInMemoryOnly
```
boolean isInMemoryOnly
```
      Defines if objects should be remove from the persistence context only (no database). This is used if delete was already cascaded by the database.
- Class org.eclipse.persistence.queries.DeleteObjectQuery extends ObjectLevelModifyQuery implements Serializable
  - Serialized Fields
    - isFullRowRequired
```
boolean isFullRowRequired
```
      PERF: By default only the translation row is used for deletes, the full row can be requested for custom deletes.
    - usesOptimisticLocking
```
boolean usesOptimisticLocking
```
      Indicates whether the query should use optimistic locking.
- Class org.eclipse.persistence.queries.DirectReadQuery extends DataReadQuery implements Serializable
  - Serialized Fields
    - valueConverter
```
Converter valueConverter
```
      Allows user defined conversion between the result value and the database value.
- Class org.eclipse.persistence.queries.DoesExistQuery extends DatabaseQuery implements Serializable
  - Serialized Fields
    - primaryKey
```
java.lang.Object primaryKey
```
      Query that is performing the does exist check.
    - object
```
java.lang.Object object
```
    - existencePolicy
```
int existencePolicy
```
      Flag to determine existence check policy.
    - checkDatabaseIfInvalid
```
boolean checkDatabaseIfInvalid
```
      Flag to determine cache invalidation policy support. This overrides the CheckCache existence setting if the object is invalid or if the cache cannot be trusted because a flush or DML has occurred. The default is true.
    - checkCacheFirst
```
boolean checkCacheFirst
```
      Flag to determine if the cache should be check first in addition to another option. The default is true;
- Class org.eclipse.persistence.queries.EntityResult extends SQLResult implements Serializable
  - Serialized Fields
    - entityClassName
```
java.lang.String entityClassName
```
      Stores the class name of result
    - fieldResults
```
java.util.Map<K,V> fieldResults
```
      Stores the list of FieldResult
    - discriminatorColumn
```
org.eclipse.persistence.internal.helper.DatabaseField discriminatorColumn
```
      Stores the column that will contain the value to determine the correct subclass to create if applicable.
- Class org.eclipse.persistence.queries.FetchGroup extends AttributeGroup implements Serializable
  - Serialized Fields
    - shouldLoad
```
boolean shouldLoad
```
      Indicates whether this group should be also used as a LoadGroup when processing the query result.
    - entityFetchGroup
```
org.eclipse.persistence.internal.queries.EntityFetchGroup entityFetchGroup
```
      Caches the EntityFetch group for this FetchGroup
    - rootEntity
```
FetchGroupTracker rootEntity
```
      Stores a reference to the root entity for an Aggregate Object relationship. This ensures that partially loaded aggregates can be triggered.
- Class org.eclipse.persistence.queries.FieldResult extends java.lang.Object implements Serializable
  - Serialized Fields
    - attributeName
```
java.lang.String attributeName
```
      Stores the name of the bean attribute
    - multipleFieldIdentifiers
```
java.lang.String[] multipleFieldIdentifiers
```
      Stores passed in field name split on the '.' character
    - fieldResults
```
java.util.Vector<E> fieldResults
```
      FieldResult now can contain multiple FieldResults in a collection if an attribute has multiple fields
    - column
```
org.eclipse.persistence.internal.helper.DatabaseField column
```
      Stores the Columns name from the result set that contains the attribute value
- Class org.eclipse.persistence.queries.InMemoryQueryIndirectionPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - policy
```
int policy
```
    - query
```
ObjectLevelReadQuery query
```
      Used to set the policy state in the query.
- Class org.eclipse.persistence.queries.InsertObjectQuery extends WriteObjectQuery implements Serializable
- Class org.eclipse.persistence.queries.JPQLCall extends java.lang.Object implements Serializable
  - Serialized Fields
    - jpqlString
```
java.lang.String jpqlString
```
    - isParsed
```
boolean isParsed
```
- Class org.eclipse.persistence.queries.LoadGroup extends AttributeGroup implements Serializable
  - Serialized Fields
    - isConcurrent
```
java.lang.Boolean isConcurrent
```
- Class org.eclipse.persistence.queries.MethodBaseQueryRedirector extends java.lang.Object implements Serializable
  - Serialized Fields
    - methodClass
```
java.lang.Class<T> methodClass
```
    - methodClassName
```
java.lang.String methodClassName
```
    - methodName
```
java.lang.String methodName
```
- Class org.eclipse.persistence.queries.ModifyAllQuery extends ModifyQuery implements Serializable
  - Serialized Fields
    - m_cacheUsage
```
int m_cacheUsage
```
    - referenceClass
```
java.lang.Class<T> referenceClass
```
    - referenceClassName
```
java.lang.String referenceClassName
```
    - shouldDeferExecutionInUOW
```
boolean shouldDeferExecutionInUOW
```
      Indicates whether execution should be deferred in UOW
    - defaultBuilder
```
ExpressionBuilder defaultBuilder
```
      Provide a default builder so that it's easier to be consistent
    - isPreparedUsingTempStorage
```
boolean isPreparedUsingTempStorage
```
      Indicates whether the query was prepared so that it will execute using temp storage
- Class org.eclipse.persistence.queries.ModifyQuery extends DatabaseQuery implements Serializable
  - Serialized Fields
    - modifyRow
```
org.eclipse.persistence.internal.sessions.AbstractRecord modifyRow
```
    - forceBatchStatementExecution
```
boolean forceBatchStatementExecution
```
    - isBatchExecutionSupported
```
boolean isBatchExecutionSupported
```
      Define if this query is compatible with batch writing. Some queries, such as DDL are not compatible.
- Class org.eclipse.persistence.queries.ObjectBuildingQuery extends ReadQuery implements Serializable
  - Serialized Fields
    - referenceClass
```
java.lang.Class<T> referenceClass
```
      The class of the target objects to be read from the database.
    - referenceClassName
```
java.lang.String referenceClassName
```
    - shouldRefreshIdentityMapResult
```
boolean shouldRefreshIdentityMapResult
```
      Allows for the resulting objects to be refresh with the data from the database.
    - shouldRefreshRemoteIdentityMapResult
```
boolean shouldRefreshRemoteIdentityMapResult
```
    - shouldRegisterResultsInUnitOfWork
```
boolean shouldRegisterResultsInUnitOfWork
```
      INTERNAL: for bug 2612601 allow ability not to register results in UOW.
    - lockingClause
```
org.eclipse.persistence.internal.expressions.ForUpdateClause lockingClause
```
      Used for pessimistic locking.
    - executionTime
```
long executionTime
```
      Used to set the read time on objects that use this query. Should be set to the time the query returned from the database.
    - shouldUseExclusiveConnection
```
boolean shouldUseExclusiveConnection
```
      Added for Exclusive Connection (VPD) support see accessor for information
    - wasDefaultLockMode
```
boolean wasDefaultLockMode
```
      PERF: Store if the query originally used the default lock mode.
    - shouldBuildNullForNullPk
```
boolean shouldBuildNullForNullPk
```
      INTERNAL: If primary key is null ObjectBuilder.buildObject returns null in case this flag is set to true (instead of throwing exception).
    - requiresDeferredLocks
```
java.lang.Boolean requiresDeferredLocks
```
      When reading across relationships, queries may be set to acquire deferred locks This is used to ensure any Eagerly fetched object that is the target of a relationship with an object the acquires deferred locks behaves the same as its owner
    - isCacheCheckComplete
```
boolean isCacheCheckComplete
```
      was a check early return completed
    - prefetchedCacheKeys
```
java.util.Map<K,V> prefetchedCacheKeys
```
- Class org.eclipse.persistence.queries.ObjectLevelModifyQuery extends ModifyQuery implements Serializable
  - Serialized Fields
    - primaryKey
```
java.lang.Object primaryKey
```
    - object
```
java.lang.Object object
```
    - objectChangeSet
```
org.eclipse.persistence.internal.sessions.ObjectChangeSet objectChangeSet
```
    - backupClone
```
java.lang.Object backupClone
```
- Class org.eclipse.persistence.queries.ObjectLevelReadQuery extends ObjectBuildingQuery implements Serializable
  - Serialized Fields
    - defaultBuilder
```
ExpressionBuilder defaultBuilder
```
      Provide a default builder so that it's easier to be consistent
    - cacheUsage
```
int cacheUsage
```
      Allow for the cache usage to be specified to enable in-memory querying.
    - additionalFields
```
java.util.List<E> additionalFields
```
      Allow for additional fields to be selected, used for m-m batch reading. Can contain DatabaseField or Expression.
    - shouldIncludeData
```
boolean shouldIncludeData
```
      Allow for a complex result to be return including the rows and objects, used for m-m batch reading.
    - isPrePrepared
```
boolean isPrePrepared
```
      Allow a prePrepare stage to build the expression for EJBQL and QBE and resolve joining.
    - distinctState
```
short distinctState
```
      Indicates if distinct should be used or not.
    - inMemoryQueryIndirectionPolicy
```
int inMemoryQueryIndirectionPolicy
```
      Used to determine behavior of indirection in in-memory querying and conforming.
    - fetchGroup
```
FetchGroup fetchGroup
```
      FetchGroup specified on this query. When set this FetchGroup will override the ObjectLevelReadQuery.fetchGroupName and the use of the descriptor's FetchGroupManager.getDefaultFetchGroup()
    - fetchGroupName
```
java.lang.String fetchGroupName
```
      Name of FetchGroup stored in the FetchGroupManager of the reference class' descriptor or any of its parent descriptors.
    - shouldUseDefaultFetchGroup
```
boolean shouldUseDefaultFetchGroup
```
      Flag to turn on/off the use of the default fetch group.
    - loadGroup
```
LoadGroup loadGroup
```
      Specifies indirection that should be instantiated before returning result
    - nonFetchJoinAttributeExpressions
```
java.util.List<E> nonFetchJoinAttributeExpressions
```
      Stores the non fetchjoin attributes, these are joins that will be represented in the where clause but not in the select.
    - partialAttributeExpressions
```
java.util.List<E> partialAttributeExpressions
```
      Stores the partial attributes that have been added to this query
    - joinedAttributeManager
```
org.eclipse.persistence.internal.queries.JoinedAttributeManager joinedAttributeManager
```
      Stores the helper object for dealing with joined attributes
    - batchFetchPolicy
```
BatchFetchPolicy batchFetchPolicy
```
      Defines batch fetching configuration.
    - isReferenceClassLocked
```
java.lang.Boolean isReferenceClassLocked
```
      PERF: Caches locking policy isReferenceClassLocked setting.
    - isResultSetOptimizedQuery
```
boolean isResultSetOptimizedQuery
```
      PERF: Allow queries to build directly from the database result-set.
    - isResultSetAccessOptimizedQuery
```
java.lang.Boolean isResultSetAccessOptimizedQuery
```
      PERF: Allow queries to build while accessing the database result-set. Skips accessing result set non-pk fields in case the cached object is found. If ResultSet optimization is used (isResultSetOptimizedQuery is set to true) then ResultSet Access optimization is ignored.
    - isReadOnly
```
boolean isReadOnly
```
      PERF: Allow queries to be defined as read-only in unit of work execution.
    - shouldOuterJoinSubclasses
```
java.lang.Boolean shouldOuterJoinSubclasses
```
      Define if an outer join should be used to read subclasses.
    - concreteSubclassCalls
```
java.util.Map<K,V> concreteSubclassCalls
```
      Allow concrete subclasses calls to be prepared and cached for inheritance queries.
    - concreteSubclassQueries
```
java.util.Map<K,V> concreteSubclassQueries
```
      Allow concrete subclasses queries to be prepared and cached for inheritance queries.
    - aggregateQueries
```
java.util.Map<K,V> aggregateQueries
```
      Allow aggregate queries to be prepared and cached.
    - concreteSubclassJoinedMappingIndexes
```
java.util.Map<K,V> concreteSubclassJoinedMappingIndexes
```
      Allow concrete subclasses joined mapping indexes to be prepared and cached for inheritance queries.
    - lockModeType
```
java.lang.String lockModeType
```
      Used when specifying a lock mode for the query
    - waitTimeout
```
java.lang.Integer waitTimeout
```
      waitTimeout has three possible setting: null, 0 and 1..N null: use the session.getPessimisticLockTimeoutDefault() if available. 0: issue a LOCK_NOWAIT 1..N: use this value to set the WAIT clause.
    - orderByExpressions
```
java.util.List<E> orderByExpressions
```
      Used for ordering support.
    - shouldExtendPessimisticLockScope
```
boolean shouldExtendPessimisticLockScope
```
      Indicates whether pessimistic lock should also be applied to relation tables (ManyToMany and OneToOne mappings), reference tables (DirectCollection and AggregateCollection mapping).
    - unionExpressions
```
java.util.List<E> unionExpressions
```
      Allow a query's results to be unioned (UNION, INTERSECT, EXCEPT) with another query results.
    - isCachedExpressionQuery
```
boolean isCachedExpressionQuery
```
      Indicates whether the query is cached as an expression query in descriptor's query manager.
    - shouldUseSerializedObjectPolicy
```
boolean shouldUseSerializedObjectPolicy
```
      Indicates whether the query should use SerializedObjectPolicy if descriptor has it.
- Class org.eclipse.persistence.queries.QueryByExamplePolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - valuesToExclude
```
java.util.Map<K,V> valuesToExclude
```
    - attributesToAlwaysInclude
```
java.util.Map<K,V> attributesToAlwaysInclude
```
    - specialOperations
```
java.util.Map<K,V> specialOperations
```
    - shouldUseEqualityForNulls
```
boolean shouldUseEqualityForNulls
```
    - validateExample
```
boolean validateExample
```
- Class org.eclipse.persistence.queries.QueryResultsCachePolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - invalidationPolicy
```
CacheInvalidationPolicy invalidationPolicy
```
      Allows invalidation to be specified.
    - maximumResultSets
```
int maximumResultSets
```
      Specifies the cache size.
    - cacheType
```
java.lang.Class<T> cacheType
```
      Allows the identity map class type to be set.
    - isNullIgnored
```
boolean isNullIgnored
```
      Allows the caching of null to be configured.
    - invalidateOnChange
```
boolean invalidateOnChange
```
      Allows the query cache to be invalidated when any object of any of the query classes is modified.
    - invalidationClasses
```
java.util.Set<E> invalidationClasses
```
      Stores the set of classes that should trigger the query cached results to be invalidated.
- Class org.eclipse.persistence.queries.ReadAllQuery extends ObjectLevelReadQuery implements Serializable
  - Serialized Fields
    - containerPolicy
```
org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy
```
      Used for collection and stream support.
    - startWithExpression
```
Expression startWithExpression
```
      Used for Oracle HierarchicalQuery support
    - connectByExpression
```
Expression connectByExpression
```
    - orderSiblingsByExpressions
```
java.util.List<E> orderSiblingsByExpressions
```
    - direction
```
ReadAllQuery.Direction direction
```
- Class org.eclipse.persistence.queries.ReadObjectQuery extends ObjectLevelReadQuery implements Serializable
  - Serialized Fields
    - selectionId
```
java.lang.Object selectionId
```
      Key that can be used in place of a selection criteria.
    - shouldLoadResultIntoSelectionObject
```
boolean shouldLoadResultIntoSelectionObject
```
      Can be used to refresh a specific non-cached instance from the database.
- Class org.eclipse.persistence.queries.ReadQuery extends DatabaseQuery implements Serializable
  - Serialized Fields
    - maxRows
```
int maxRows
```
      Used for retrieve limited rows through the query.
    - firstResult
```
int firstResult
```
      Used to start query results at a specific result
    - queryId
```
long queryId
```
    - fetchSize
```
int fetchSize
```
      Used to set statement fetch size
    - queryResultCachingPolicy
```
QueryResultsCachePolicy queryResultCachingPolicy
```
      Used to specify how query results are cached
    - maxResults
```
int maxResults
```
      Stores the JPA maxResult settings for a NamedQuery
- Class org.eclipse.persistence.queries.ReportQuery extends ReadAllQuery implements Serializable
  - Serialized Fields
    - shouldRetrievePrimaryKeys
```
int shouldRetrievePrimaryKeys
```
      Flag indicating whether the primary key values should also be retrieved for the reference class.
    - names
```
java.util.List<E> names
```
      Collection of names for use by results.
    - items
```
java.util.List<E> items
```
      Items to be selected, these could be attributes or aggregate functions.
    - groupByExpressions
```
java.util.List<E> groupByExpressions
```
      Expressions representing fields to be used in the GROUP BY clause.
    - havingExpression
```
Expression havingExpression
```
      Expression representing the HAVING clause.
    - returnChoice
```
int returnChoice
```
      Can be one of (ShouldReturnSingleResult, ShouldReturnSingleValue, ShouldReturnSingleAttribute) Simplifies the result by only returning the first result, first value, or all attribute values
    - addToConstructorItem
```
boolean addToConstructorItem
```
      flag to allow items to be added to the last ConstructorReportItem
    - returnedKeys
```
java.util.Set<E> returnedKeys
```
- Class org.eclipse.persistence.queries.ReportQueryResult extends java.lang.Object implements Serializable
  - Serialization Methods
    - readObject
```
public java.lang.Object readObject(java.lang.Class javaClass,
                          Session session)
```
      PUBLIC: If the PKs were retrieved with the attributes then this method can be used to read the real object from the database.
  - Serialized Fields
    - names
```
java.util.List<E> names
```
      Item names to lookup result values
    - results
```
java.util.List<E> results
```
      Actual converted attribute values
    - primaryKey
```
java.lang.Object primaryKey
```
      Id value if the retrievPKs flag was set on the ReportQuery. These can be used to get the actual object
    - key
```
java.lang.StringBuffer key
```
      If an objectLevel distinct is used then generate unique key for this result
- Class org.eclipse.persistence.queries.ResultSetMappingQuery extends ObjectBuildingQuery implements Serializable
  - Serialized Fields
    - isExecuteCall
```
boolean isExecuteCall
```
    - returnNameValuePairs
```
boolean returnNameValuePairs
```
    - resultRows
```
java.util.Vector<E> resultRows
```
    - resultSetMappingNames
```
java.util.List<E> resultSetMappingNames
```
    - resultSetMappings
```
java.util.List<E> resultSetMappings
```
- Class org.eclipse.persistence.queries.ScrollableCursor extends Cursor implements Serializable
  - Serialized Fields
    - previousRow
```
org.eclipse.persistence.internal.sessions.AbstractRecord previousRow
```
      Store the previous row, for 1-m joining.
    - atEndOfCursor
```
boolean atEndOfCursor
```
      Internal flag indicating if the end of the cursor has been reached
- Class org.eclipse.persistence.queries.ScrollableCursorPolicy extends CursorPolicy implements Serializable
  - Serialized Fields
    - resultSetType
```
int resultSetType
```
    - resultSetConcurrency
```
int resultSetConcurrency
```
- Class org.eclipse.persistence.queries.SQLCall extends org.eclipse.persistence.internal.databaseaccess.DatabaseCall implements Serializable
  - Serialized Fields
    - hasCustomSQLArguments
```
boolean hasCustomSQLArguments
```
- Class org.eclipse.persistence.queries.SQLResult extends java.lang.Object implements Serializable
  - Serialized Fields
    - sqlResultSetMapping
```
SQLResultSetMapping sqlResultSetMapping
```
- Class org.eclipse.persistence.queries.SQLResultSetMapping extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
      Stores the name of this SQLResultSetMapping. This name is unique within The project.
    - results
```
java.util.List<E> results
```
      Stores the list of SQLResult in the order they were added to the Mapping
- Class org.eclipse.persistence.queries.StoredFunctionCall extends StoredProcedureCall implements Serializable
- Class org.eclipse.persistence.queries.StoredProcedureCall extends org.eclipse.persistence.internal.databaseaccess.DatabaseCall implements Serializable
  - Serialized Fields
    - procedureName
```
java.lang.String procedureName
```
    - procedureArgumentNames
```
java.util.List<E> procedureArgumentNames
```
    - optionalArguments
```
java.util.List<E> optionalArguments
```
    - cursorOrdinalPositions
```
java.util.Map<K,V> cursorOrdinalPositions
```
- Class org.eclipse.persistence.queries.UpdateAllQuery extends ModifyAllQuery implements Serializable
  - Serialized Fields
    - m_updateClauses
```
java.util.HashMap<K,V> m_updateClauses
```
- Class org.eclipse.persistence.queries.UpdateObjectQuery extends WriteObjectQuery implements Serializable
- Class org.eclipse.persistence.queries.ValueReadQuery extends DirectReadQuery implements Serializable
- Class org.eclipse.persistence.queries.WriteObjectQuery extends ObjectLevelModifyQuery implements Serializable
Package org.eclipse.persistence.sequencing
- Class org.eclipse.persistence.sequencing.DefaultSequence extends Sequence implements Serializable
  - Serialized Fields
    - defaultSequence
```
Sequence defaultSequence
```
- Class org.eclipse.persistence.sequencing.NativeSequence extends QuerySequence implements Serializable
  - Serialized Fields
    - shouldUseIdentityIfPlatformSupports
```
boolean shouldUseIdentityIfPlatformSupports
```
      true indicates that identity should be used - if the platform supports identity. false indicates that sequence objects should be used - if the platform supports sequence objects.
    - delegateSequence
```
QuerySequence delegateSequence
```
      Allow sequencing to be delegated to another sequence if native sequencing is not supported.
- Class org.eclipse.persistence.sequencing.QuerySequence extends StandardSequence implements Serializable
  - Serialized Fields
    - selectQuery
```
ValueReadQuery selectQuery
```
    - updateQuery
```
DataModifyQuery updateQuery
```
    - shouldAcquireValueAfterInsert
```
boolean shouldAcquireValueAfterInsert
```
    - shouldUseTransaction
```
boolean shouldUseTransaction
```
    - shouldSkipUpdate
```
boolean shouldSkipUpdate
```
    - shouldSelectBeforeUpdate
```
boolean shouldSelectBeforeUpdate
```
    - wasSelectQueryCreated
```
boolean wasSelectQueryCreated
```
    - wasUpdateQueryCreated
```
boolean wasUpdateQueryCreated
```
- Class org.eclipse.persistence.sequencing.Sequence extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
    - size
```
int size
```
    - platform
```
org.eclipse.persistence.internal.databaseaccess.Platform platform
```
    - initialValue
```
int initialValue
```
    - depth
```
int depth
```
    - qualifier
```
java.lang.String qualifier
```
    - isCustomQualifier
```
boolean isCustomQualifier
```
    - shouldAlwaysOverrideExistingValue
```
boolean shouldAlwaysOverrideExistingValue
```
- Class org.eclipse.persistence.sequencing.StandardSequence extends Sequence implements Serializable
- Class org.eclipse.persistence.sequencing.TableSequence extends QuerySequence implements Serializable
  - Serialized Fields
    - table
```
org.eclipse.persistence.internal.helper.DatabaseTable table
```
      Hold the database table
    - counterFieldName
```
java.lang.String counterFieldName
```
      Hold the name of the column in the sequence table which specifies the sequence numeric value
    - nameFieldName
```
java.lang.String nameFieldName
```
      Hold the name of the column in the sequence table which specifies the sequence name
- Class org.eclipse.persistence.sequencing.UnaryTableSequence extends QuerySequence implements Serializable
  - Serialized Fields
    - counterFieldName
```
java.lang.String counterFieldName
```
      Hold the name of the only column in multiple single-column tables
    - updateString1
```
java.lang.String updateString1
```
    - updateString2
```
java.lang.String updateString2
```
    - selectString1
```
java.lang.String selectString1
```
    - selectString2
```
java.lang.String selectString2
```
    - updateStringBufferSize
```
int updateStringBufferSize
```
    - selectStringBufferSize
```
int selectStringBufferSize
```
- Class org.eclipse.persistence.sequencing.UUIDSequence extends Sequence implements Serializable
Package org.eclipse.persistence.sessions
- Class org.eclipse.persistence.sessions.CopyGroup extends AttributeGroup implements Serializable
  - Serialized Fields
    - shouldResetPrimaryKey
```
boolean shouldResetPrimaryKey
```
    - shouldResetVersion
```
boolean shouldResetVersion
```
    - copies
```
java.util.Map<K,V> copies
```
    - depth
```
int depth
```
      Policy depth that determines how the copy will cascade to the object's related parts
- Class org.eclipse.persistence.sessions.DatabaseLogin extends DatasourceLogin implements Serializable
  - Serialized Fields
    - queryRetryAttemptCount
```
int queryRetryAttemptCount
```
      Stores the value for the number of time EclipseLink will attempt to reconnect the connection on a comm failure in the case EclipseLink is attempting to retry a query. EclipseLink will retry a read query outside of a transaction if EclipseLink can determine that a communication error occurred with the database.
    - delayBetweenConnectionAttempts
```
int delayBetweenConnectionAttempts
```
      Stores the number of milliseconds that EclipseLink will wait between attempts to reconnect a DatabaseConnection in the case EclipseLink is attempting to retry a query. EclipseLink will retry a read query outside of a transaction if EclipseLink can determine that a communication error occurred with the database.
    - connectionHealthValidatedOnError
```
java.lang.Boolean connectionHealthValidatedOnError
```
      On an SQL Exception EclipseLink will ping the database to determine if the connection used can continue to be used for queries. This should have no impact on applications unless the user is using pessimistic locking queries with 'no wait' or are using a query timeout feature. If that is the case and the application is experiencing a performance impact from the health check then this feature can be turned off. Turning this feature off will prevent EclipseLink from being able to retry queries in the case of database failure. By default (null) connection health is validate if the query does not have a timeout, and there is a ping string. Setting to true or false overrides this.
- Class org.eclipse.persistence.sessions.DatabaseRecord extends org.eclipse.persistence.internal.sessions.AbstractRecord implements Serializable
- Class org.eclipse.persistence.sessions.DatasourceLogin extends java.lang.Object implements Serializable
  - Serialized Fields
    - properties
```
java.util.Properties properties
```
      Connection properties (e.g. user, password, and driver-specific settings)
    - platform
```
org.eclipse.persistence.internal.databaseaccess.Platform platform
```
      Implementation of platform-specific behaviors.
    - isEncryptedPasswordSet
```
boolean isEncryptedPasswordSet
```
      The securable object holder and flag
    - connector
```
Connector connector
```
      Provide a little flexibility for connecting to a database
    - usesExternalConnectionPooling
```
boolean usesExternalConnectionPooling
```
      True if we use an external connection pool such as WebLogic's JTS driver
    - usesExternalTransactionController
```
boolean usesExternalTransactionController
```
      True if we should use some external transaction service such as JTS.
    - cacheTransactionIsolation
```
int cacheTransactionIsolation
```
      By default concurrency is optimized and the cache is not locked during reads or writes, This allows for concurrent reading and writing and should never cause any problems. If the application uses no form of locking the last unit of work to merge changes will win, with no locking it is possible only under this scenario for two unit of works to merge changes different than the database although highly unlikely and if occurred is the entire purpose of locking. This property allows for the isolation level of changes to the cache to be configured for sever situation and it is not suggest that this be changed.
- Class org.eclipse.persistence.sessions.DefaultConnector extends java.lang.Object implements Serializable
  - Serialized Fields
    - driverClassName
```
java.lang.String driverClassName
```
    - driverURLHeader
```
java.lang.String driverURLHeader
```
    - databaseURL
```
java.lang.String databaseURL
```
    - driverClass
```
java.lang.Class<T> driverClass
```
      cache up the driver class to speed up reconnects
    - driver
```
java.sql.Driver driver
```
      cache up the instantiated Driver to speed up reconnects
    - connectDirectly
```
boolean connectDirectly
```
      Save whether we have switched to direct connect (sql.Driver.connect()) mode
- Class org.eclipse.persistence.sessions.DirectConnector extends DefaultConnector implements Serializable
- Class org.eclipse.persistence.sessions.JNDIConnector extends java.lang.Object implements Serializable
  - Serialized Fields
    - dataSource
```
javax.sql.DataSource dataSource
```
    - context
```
javax.naming.Context context
```
    - name
```
java.lang.String name
```
    - isCallbackRegistered
```
boolean isCallbackRegistered
```
    - lookupType
```
int lookupType
```
      Deprecated.
- Class org.eclipse.persistence.sessions.ObjectCopyingPolicy extends CopyGroup implements Serializable
- Class org.eclipse.persistence.sessions.Project extends CoreProject<ClassDescriptor,Login,DatabaseSession> implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
    - datasourceLogin
```
Login datasourceLogin
```
    - descriptors
```
java.util.Map<K,V> descriptors
```
    - orderedDescriptors
```
java.util.List<E> orderedDescriptors
```
    - multitenantPolicy
```
MultitenantPolicy multitenantPolicy
```
    - defaultReadOnlyClasses
```
java.util.Vector<E> defaultReadOnlyClasses
```
      Holds the default set of read-only classes that apply to each UnitOfWork.
    - aliasDescriptors
```
java.util.Map<K,V> aliasDescriptors
```
      Cache the EJBQL descriptor aliases.
    - hasIsolatedClasses
```
boolean hasIsolatedClasses
```
      Cache if any descriptor is isolated. (set during initialization)
    - hasNonIsolatedUOWClasses
```
boolean hasNonIsolatedUOWClasses
```
      Cache if all descriptors are isolated in the unit of work. (set during initialization)
    - hasGenericHistorySupport
```
boolean hasGenericHistorySupport
```
      Cache if any descriptor has history. (set during initialization)
    - hasProxyIndirection
```
boolean hasProxyIndirection
```
      Cache if any descriptor is using ProxyIndirection. (set during initialization
    - sqlResultSetMappings
```
java.util.Map<K,V> sqlResultSetMappings
```
      This a collection of 'maps' that allow users to map custom SQL to query results
    - defaultTemporalMutable
```
boolean defaultTemporalMutable
```
      Define the default setting for configuring if dates and calendars are mutable.
    - defaultIdentityMapClass
```
java.lang.Class<T> defaultIdentityMapClass
```
      Default value for ClassDescriptor.identityMapClass.
    - defaultIdentityMapSize
```
int defaultIdentityMapSize
```
      Default value for ClassDescriptor.identityMapSize.
    - defaultCacheIsolation
```
CacheIsolationType defaultCacheIsolation
```
      Default value for ClassDescriptor.isIsolated.
    - defaultQueryResultsCachePolicy
```
QueryResultsCachePolicy defaultQueryResultsCachePolicy
```
      Default value for query caching options for all named queries.
    - defaultIdValidation
```
IdValidation defaultIdValidation
```
      Default value for ClassDescriptor.idValidation.
    - queries
```
java.util.List<E> queries
```
      List of queries - once Project is initialized, these are copied to the Session.
    - attributeGroups
```
java.util.Map<K,V> attributeGroups
```
      List of named AttributeGroups - once Project is initialized, these are copied to the Session.
    - jpaQueries
```
java.util.List<E> jpaQueries
```
      List of queries from JPA that need special processing before execution.
    - jpaTablePerTenantQueries
```
java.util.List<E> jpaTablePerTenantQueries
```
      List of queries from JPA that may special processing and handling before execution.
    - allowNativeSQLQueries
```
boolean allowNativeSQLQueries
```
      Flag that allows native queries or not
    - allowTablePerMultitenantDDLGeneration
```
boolean allowTablePerMultitenantDDLGeneration
```
      Flag that allows DDL generation of table per tenant multitenant descriptors
    - mappedSuperclassDescriptors
```
java.util.Map<K,V> mappedSuperclassDescriptors
```
      Mapped Superclasses (JPA 2) collection of parent non-relational descriptors keyed on MetadataClass without creating a compile time dependency on JPA. The descriptor values of this map must not be replaced by a put() so that the mappings on the initial descriptor are not overwritten.
      These descriptors are only to be used by Metamodel generation.
      
      Since:
      
      EclipseLink 1.2 for the JPA 2.0 Reference Implementation
    - metamodelIdClassMap
```
java.util.Map<K,V> metamodelIdClassMap
```
      Store the IdClass Id attributes for exclusive use by the Metamodel API Keyed on the fully qualified accessible object owner class name. Value is a List of the fully qualified id class name or id attribute name.
      
      Since:
      
      EclipseLink 1.2 for the JPA 2.0 Reference Implementation
    - partitioningPolicies
```
java.util.Map<K,V> partitioningPolicies
```
      Map of named partitioning policies, keyed by their name.
    - descriptorsLock
```
java.lang.Object descriptorsLock
```
      Ensures that only one thread at a time can add/remove descriptors
    - vpdIdentifier
```
java.lang.String vpdIdentifier
```
      VPD connection settings
    - vpdLastIdentifierClassName
```
java.lang.String vpdLastIdentifierClassName
```
    - classNamesForWeaving
```
java.util.Collection<E> classNamesForWeaving
```
      used for Caching JPA projects
    - structConverters
```
java.util.Collection<E> structConverters
```
- Class org.eclipse.persistence.sessions.SessionEvent extends java.util.EventObject implements Serializable
  - Serialized Fields
    - query
```
DatabaseQuery query
```
      Some events may have a query associated with them (pre/postExecuteQuery).
    - result
```
java.lang.Object result
```
      Some events may have a result associated with them (pre/postExecuteQuery).
    - session
```
Session session
```
      The session or unit of work raising the event.
    - eventCode
```
int eventCode
```
      The code of the event being raised. This is an integer constant value as defined below.
    - properties
```
java.util.Hashtable<K,V> properties
```
      Additional properties may be added.
- Class org.eclipse.persistence.sessions.SessionEventManager extends CoreSessionEventManager<SessionEventListener> implements Serializable
  - Serialized Fields
    - listeners
```
java.util.List<E> listeners
```
    - session
```
Session session
```
Package org.eclipse.persistence.sessions.broker
- Class org.eclipse.persistence.sessions.broker.SessionBroker extends org.eclipse.persistence.internal.sessions.DatabaseSessionImpl implements Serializable
  - Serialized Fields
    - parent
```
SessionBroker parent
```
    - sessionNamesByClass
```
java.util.Map<K,V> sessionNamesByClass
```
    - sessionsByName
```
java.util.Map<K,V> sessionsByName
```
    - sequencing
```
org.eclipse.persistence.internal.sequencing.Sequencing sequencing
```
    - shouldUseDescriptorAliases
```
boolean shouldUseDescriptorAliases
```
Package org.eclipse.persistence.sessions.coordination
- Class org.eclipse.persistence.sessions.coordination.Command extends java.lang.Object implements Serializable
  - Serialized Fields
    - serviceId
```
ServiceId serviceId
```
      The unique calling card of the service that initiated the command
- Class org.eclipse.persistence.sessions.coordination.MergeChangeSetCommand extends Command implements Serializable
  - Serialized Fields
    - changeSet
```
org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet changeSet
```
      The changes to be applied remotely
- Class org.eclipse.persistence.sessions.coordination.ServiceId extends java.lang.Object implements Serializable
  - Serialized Fields
    - id
```
java.lang.String id
```
      Generated unique id to distinguish the service instance from all others
    - channel
```
java.lang.String channel
```
      The logical channel that the service instance subscribes to
    - url
```
java.lang.String url
```
      Url of the service instance
Package org.eclipse.persistence.sessions.interceptors
- Class org.eclipse.persistence.sessions.interceptors.CacheKeyInterceptor extends org.eclipse.persistence.internal.identitymaps.CacheKey implements Serializable
  - Serialized Fields
    - wrappedKey
```
org.eclipse.persistence.internal.identitymaps.CacheKey wrappedKey
```
Package org.eclipse.persistence.sessions.remote
- Class org.eclipse.persistence.sessions.remote.DistributedSession extends org.eclipse.persistence.internal.sessions.DatabaseSessionImpl implements Serializable
  - Serialized Fields
    - hasDefaultReadOnlyClasses
```
boolean hasDefaultReadOnlyClasses
```
      Cache if default classes have been read from server.
    - isMetadataRemote
```
boolean isMetadataRemote
```
      Define if meta-data is initialized locally, or serialized from the server.
- Class org.eclipse.persistence.sessions.remote.RemoteSession extends DistributedSession implements Serializable
  - Serialized Fields
    - sequencing
```
org.eclipse.persistence.internal.sequencing.Sequencing sequencing
```
    - shouldEnableDistributedIndirectionGarbageCollection
```
boolean shouldEnableDistributedIndirectionGarbageCollection
```
Package org.eclipse.persistence.sessions.remote.corba.sun
- Class org.eclipse.persistence.sessions.remote.corba.sun._CORBARemoteSessionControllerImplBase extends org.omg.CORBA.portable.ObjectImpl implements Serializable
- Class org.eclipse.persistence.sessions.remote.corba.sun._CORBARemoteSessionControllerStub extends org.omg.CORBA.portable.ObjectImpl implements Serializable
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream s)
```
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream s)
```
- Class org.eclipse.persistence.sessions.remote.corba.sun.CORBAConnection extends org.eclipse.persistence.internal.sessions.remote.RemoteConnection implements Serializable
  - Serialized Fields
    - remoteSessionController
```
CORBARemoteSessionController remoteSessionController
```
- Class org.eclipse.persistence.sessions.remote.corba.sun.CORBARemoteSessionControllerDispatcher extends _CORBARemoteSessionControllerImplBase implements Serializable
  - Serialized Fields
    - controller
```
org.eclipse.persistence.internal.sessions.remote.RemoteSessionController controller
```
      Store the real controller.
Package org.eclipse.persistence.sessions.remote.rmi
- Class org.eclipse.persistence.sessions.remote.rmi.RMIConnection extends org.eclipse.persistence.internal.sessions.remote.RemoteConnection implements Serializable
  - Serialized Fields
    - remoteSessionController
```
RMIRemoteSessionController remoteSessionController
```
- Class org.eclipse.persistence.sessions.remote.rmi.RMIRemoteSessionControllerDispatcher extends java.rmi.server.UnicastRemoteObject implements Serializable
  - Serialized Fields
    - controller
```
org.eclipse.persistence.internal.sessions.remote.RemoteSessionController controller
```
      Store the real controller.
- Class org.eclipse.persistence.sessions.remote.rmi.RMIServerSessionManagerDispatcher extends java.rmi.server.UnicastRemoteObject implements Serializable
  - Serialized Fields
    - session
```
Session session
```
    - controllerClassName
```
java.lang.String controllerClassName
```
Package org.eclipse.persistence.sessions.remote.rmi.iiop
- Class org.eclipse.persistence.sessions.remote.rmi.iiop._RMIRemoteSessionController_Stub extends javax.rmi.CORBA.Stub implements Serializable
- Class org.eclipse.persistence.sessions.remote.rmi.iiop.RMIConnection extends org.eclipse.persistence.internal.sessions.remote.RemoteConnection implements Serializable
  - Serialized Fields
    - remoteSessionController
```
RMIRemoteSessionController remoteSessionController
```
Package org.eclipse.persistence.sessions.serializers
- Class org.eclipse.persistence.sessions.serializers.AbstractSerializer extends java.lang.Object implements Serializable
- Class org.eclipse.persistence.sessions.serializers.JavaSerializer extends AbstractSerializer implements Serializable
- Class org.eclipse.persistence.sessions.serializers.JSONSerializer extends XMLSerializer implements Serializable
- Class org.eclipse.persistence.sessions.serializers.XMLSerializer extends AbstractSerializer implements Serializable
  - Serialized Fields
    - context
```
JAXBContext context
```
Package org.eclipse.persistence.sessions.server
- Class org.eclipse.persistence.sessions.server.ClientSession extends org.eclipse.persistence.internal.sessions.AbstractSession implements Serializable
  - Serialized Fields
    - parent
```
ServerSession parent
```
    - connectionPolicy
```
ConnectionPolicy connectionPolicy
```
    - writeConnections
```
java.util.Map<K,V> writeConnections
```
    - isActive
```
boolean isActive
```
    - sequencing
```
org.eclipse.persistence.internal.sequencing.Sequencing sequencing
```
- Class org.eclipse.persistence.sessions.server.ConnectionPolicy extends java.lang.Object implements Serializable
  - Serialized Fields
    - login
```
Login login
```
      The login information used to create a JDBC connection or acquire one from an external pool/data-source. Typically this is constant within a single persistence unit but in some advanced usages users can customize connections for each client session.
    - poolName
```
java.lang.String poolName
```
      Name of the pool to be used. If neither pool name nor login provided then default pool will be used. If no pool name is provided but there's a login then the login is used to create connection which the ClientSession will use.
    - isLazy
```
boolean isLazy
```
      Determines if the write/exclusive connection is acquired only when first requested (lazy, this is the default) or immediately when the client session is acquired. After write/exclusive connection is acquired if isLazy is true and exclusiveMode is Transactional then it's held until transaction is committed or rolled back, otherwise until the client session is released.
    - exclusiveMode
```
ConnectionPolicy.ExclusiveMode exclusiveMode
```
      This attribute is used by the ServerSession to determine if a client session with an exclusive connection should be built and how the exclusive connection should be used.
    - properties
```
java.util.Map<K,V> properties
```
      This attribute will provide a mechanism by which customers will be able to pass connection information to events to enable further customization.
- Class org.eclipse.persistence.sessions.server.ServerSession extends org.eclipse.persistence.internal.sessions.DatabaseSessionImpl implements Serializable
  - Serialized Fields
    - readConnectionPool
```
ConnectionPool readConnectionPool
```
    - connectionPools
```
java.util.Map<K,V> connectionPools
```
    - defaultConnectionPolicy
```
ConnectionPolicy defaultConnectionPolicy
```
    - numberOfNonPooledConnectionsUsed
```
int numberOfNonPooledConnectionsUsed
```
    - maxNumberOfNonPooledConnections
```
int maxNumberOfNonPooledConnections
```
Package org.eclipse.persistence.tools
- Class org.eclipse.persistence.tools.PackageRenamer.PackageRenamerException extends java.lang.RuntimeException implements Serializable
Package org.eclipse.persistence.tools.profiler
- Class org.eclipse.persistence.tools.profiler.PerformanceMonitor extends java.lang.Object implements Serializable
  - Serialized Fields
    - operationTimings
```
java.util.Map<K,V> operationTimings
```
    - operationStartTimesByThread
```
java.util.Map<K,V> operationStartTimesByThread
```
    - lastDumpTime
```
long lastDumpTime
```
    - dumpTime
```
long dumpTime
```
    - profileWeight
```
int profileWeight
```
- Class org.eclipse.persistence.tools.profiler.PerformanceProfiler extends SessionProfilerAdapter implements Serializable
  - Serialized Fields
    - profiles
```
java.util.List<E> profiles
```
    - shouldLogProfile
```
boolean shouldLogProfile
```
    - nestLevel
```
int nestLevel
```
    - nestTime
```
long nestTime
```
    - profileTime
```
long profileTime
```
    - operationTimingsByThread
```
java.util.Map<K,V> operationTimingsByThread
```
    - operationStartTimesByThread
```
java.util.Map<K,V> operationStartTimesByThread
```
- Class org.eclipse.persistence.tools.profiler.Profile extends java.lang.Object implements Serializable
  - Serialized Fields
    - queryClass
```
java.lang.Class<T> queryClass
```
    - domainClass
```
java.lang.Class<T> domainClass
```
    - numberOfInstancesEffected
```
long numberOfInstancesEffected
```
    - operationTimings
```
java.util.Hashtable<K,V> operationTimings
```
    - localTime
```
long localTime
```
    - profileTime
```
long profileTime
```
    - totalTime
```
long totalTime
```
    - shortestTime
```
long shortestTime
```
    - longestTime
```
long longestTime
```
Package org.eclipse.persistence.tools.schemaframework
- Class org.eclipse.persistence.tools.schemaframework.DatabaseObjectDefinition extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
    - qualifier
```
java.lang.String qualifier
```
- Class org.eclipse.persistence.tools.schemaframework.FieldDefinition extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
    - type
```
java.lang.Class<T> type
```
      Java type class for the field. Particular database type is generated based on platform from this.
    - typeName
```
java.lang.String typeName
```
      Generic database type name for the field, which can be used instead of the Java class 'type'. This is translated to a particular database type based on platform.
    - field
```
org.eclipse.persistence.internal.helper.DatabaseField field
```
      DatabaseField stores the field name with case and delimiting information. Used if the field needs to be found in the table metadata, for extending tables. if null, name is used for comparison to determine if this field already exists.
    - typeDefinition
```
java.lang.String typeDefinition
```
      Database-specific complete type definition like "VARCHAR2(50) UNIQUE NOT NULL". If this is given, other additional type constraint fields(size, unique, null) are meaningless.
    - size
```
int size
```
    - subSize
```
int subSize
```
    - shouldAllowNull
```
boolean shouldAllowNull
```
    - isIdentity
```
boolean isIdentity
```
    - isPrimaryKey
```
boolean isPrimaryKey
```
    - isUnique
```
boolean isUnique
```
    - additional
```
java.lang.String additional
```
    - constraint
```
java.lang.String constraint
```
    - foreignKeyFieldName
```
java.lang.String foreignKeyFieldName
```
- Class org.eclipse.persistence.tools.schemaframework.ForeignKeyConstraint extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
    - sourceFields
```
java.util.List<E> sourceFields
```
    - targetFields
```
java.util.List<E> targetFields
```
    - targetTable
```
java.lang.String targetTable
```
    - shouldCascadeOnDelete
```
boolean shouldCascadeOnDelete
```
    - foreignKeyDefinition
```
java.lang.String foreignKeyDefinition
```
    - disableForeignKey
```
boolean disableForeignKey
```
- Class org.eclipse.persistence.tools.schemaframework.IndexDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - targetTable
```
java.lang.String targetTable
```
    - fields
```
java.util.List<E> fields
```
    - isUnique
```
boolean isUnique
```
- Class org.eclipse.persistence.tools.schemaframework.NestedTableDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - typeSize
```
int typeSize
```
    - type
```
java.lang.Class<T> type
```
    - typeName
```
java.lang.String typeName
```
- Class org.eclipse.persistence.tools.schemaframework.ObjectVarrayDefinition extends VarrayDefinition implements Serializable
  - Serialized Fields
    - isNullAllowed
```
boolean isNullAllowed
```
- Class org.eclipse.persistence.tools.schemaframework.PackageDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - statements
```
java.util.Vector<E> statements
```
    - procedures
```
java.util.Vector<E> procedures
```
- Class org.eclipse.persistence.tools.schemaframework.SequenceDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - sequence
```
Sequence sequence
```
- Class org.eclipse.persistence.tools.schemaframework.SequenceObjectDefinition extends SequenceDefinition implements Serializable
- Class org.eclipse.persistence.tools.schemaframework.StoredFunctionDefinition extends StoredProcedureDefinition implements Serializable
- Class org.eclipse.persistence.tools.schemaframework.StoredProcedureDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - variables
```
java.util.Vector<E> variables
```
    - statements
```
java.util.Vector<E> statements
```
    - arguments
```
java.util.Vector<E> arguments
```
    - argumentTypes
```
java.util.Vector<E> argumentTypes
```
- Class org.eclipse.persistence.tools.schemaframework.TableDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - fields
```
java.util.List<E> fields
```
    - foreignKeyMap
```
java.util.Map<K,V> foreignKeyMap
```
    - uniqueKeys
```
java.util.List<E> uniqueKeys
```
    - indexes
```
java.util.List<E> indexes
```
    - creationPrefix
```
java.lang.String creationPrefix
```
    - creationSuffix
```
java.lang.String creationSuffix
```
    - createSQLFiles
```
boolean createSQLFiles
```
    - createVPDCalls
```
boolean createVPDCalls
```
    - tenantFieldName
```
java.lang.String tenantFieldName
```
    - table
```
org.eclipse.persistence.internal.helper.DatabaseTable table
```
    - hasUserDefinedForeignKeyConstraints
```
boolean hasUserDefinedForeignKeyConstraints
```
- Class org.eclipse.persistence.tools.schemaframework.TableSequenceDefinition extends SequenceDefinition implements Serializable
  - Serialized Fields
    - tableDefinition
```
TableDefinition tableDefinition
```
    - deleteSchema
```
boolean deleteSchema
```
- Class org.eclipse.persistence.tools.schemaframework.TypeDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - fields
```
java.util.Vector<E> fields
```
- Class org.eclipse.persistence.tools.schemaframework.TypeTableDefinition extends TableDefinition implements Serializable
  - Serialized Fields
    - typeName
```
java.lang.String typeName
```
      The name of the type that this table is of.
    - additional
```
java.lang.String additional
```
- Class org.eclipse.persistence.tools.schemaframework.UnaryTableSequenceDefinition extends TableSequenceDefinition implements Serializable
- Class org.eclipse.persistence.tools.schemaframework.UniqueKeyConstraint extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
    - sourceFields
```
java.util.Vector<E> sourceFields
```
- Class org.eclipse.persistence.tools.schemaframework.VarrayDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - typeSize
```
int typeSize
```
    - size
```
int size
```
    - type
```
java.lang.Class<T> type
```
    - typeName
```
java.lang.String typeName
```
- Class org.eclipse.persistence.tools.schemaframework.ViewDefinition extends DatabaseObjectDefinition implements Serializable
  - Serialized Fields
    - selectClause
```
java.lang.String selectClause
```

Serialized Form

Package javax.persistence

Class javax.persistence.EntityExistsException extends PersistenceException implements Serializable

Class javax.persistence.EntityNotFoundException extends PersistenceException implements Serializable

Class javax.persistence.LockTimeoutException extends PersistenceException implements Serializable

Serialized Fields

entity

Class javax.persistence.NonUniqueResultException extends PersistenceException implements Serializable

Class javax.persistence.NoResultException extends PersistenceException implements Serializable

Class javax.persistence.OptimisticLockException extends PersistenceException implements Serializable

Serialized Fields

entity

Class javax.persistence.PersistenceException extends java.lang.RuntimeException implements Serializable

Class javax.persistence.PessimisticLockException extends PersistenceException implements Serializable

Serialized Fields

entity

Class javax.persistence.QueryTimeoutException extends PersistenceException implements Serializable

Serialized Fields

query

Class javax.persistence.RollbackException extends PersistenceException implements Serializable

Class javax.persistence.TransactionRequiredException extends PersistenceException implements Serializable

Package javax.xml.bind

Class javax.xml.bind.DataBindingException extends java.lang.RuntimeException implements Serializable

Class javax.xml.bind.JAXBElement extends java.lang.Object implements Serializable

Serialized Fields

name

declaredType

scope

value

nil

Class javax.xml.bind.JAXBException extends java.lang.Exception implements Serializable

Serialized Fields

errorCode

linkedException

Class javax.xml.bind.JAXBPermission extends java.security.BasicPermission implements Serializable

Class javax.xml.bind.MarshalException extends JAXBException implements Serializable

Class javax.xml.bind.PropertyException extends JAXBException implements Serializable

Class javax.xml.bind.TypeConstraintException extends java.lang.RuntimeException implements Serializable

Serialized Fields

errorCode

linkedException

Class javax.xml.bind.UnmarshalException extends JAXBException implements Serializable

Class javax.xml.bind.ValidationException extends JAXBException implements Serializable

Package org.eclipse.persistence.core.descriptors

Class org.eclipse.persistence.core.descriptors.CoreDescriptor extends java.lang.Object implements Serializable

Serialized Fields

eventManager

field

instantiationPolicy

inheritancePolicy

objectBuilder

attributeGroups

Package org.eclipse.persistence.core.mappings.transformers

Package org.eclipse.persistence.core.queries

Class org.eclipse.persistence.core.queries.CoreAttributeGroup extends java.lang.Object implements Serializable

Serialized Fields

name

typeName

type

superClassGroup

allsubclasses

items

isValidated

Class org.eclipse.persistence.core.queries.CoreAttributeItem extends java.lang.Object implements Serializable

Serialized Fields

attributeName

parent

group

keyGroup

subGroups

keyGroups

Package org.eclipse.persistence.core.sessions

Class org.eclipse.persistence.core.sessions.CoreProject extends java.lang.Object implements Serializable

Package org.eclipse.persistence.dbws

Class org.eclipse.persistence.dbws.DBWSModelProject extends Project implements Serializable

Serialized Fields

ns

Package org.eclipse.persistence.descriptors

Class org.eclipse.persistence.descriptors.AllFieldsLockingPolicy extends FieldsLockingPolicy implements Serializable

Class org.eclipse.persistence.descriptors.CacheIndex extends java.lang.Object implements Serializable