EntityPersister (Red Hat JBoss Enterprise Application Platform 7.4.0.GA public API)

All Superinterfaces:

AttributeSource, EntityDefinition

All Known Subinterfaces:

Loadable, Lockable, OuterJoinLoadable, PostInsertIdentityPersister, Queryable, SQLLoadable, UniqueKeyLoadable

All Known Implementing Classes:

AbstractEntityPersister, JoinedSubclassEntityPersister, SingleTableEntityPersister, UnionSubclassEntityPersister
```
public interface EntityPersister
extends EntityDefinition
```
Contract describing mapping information and persistence logic for a particular strategy of entity mapping. A given persister instance corresponds to a given mapped entity class.
Implementations must be thread-safe (preferably immutable).
Unless a custom PersisterFactory is used, it is expected that implementations of EntityPersister define a constructor accepting the following arguments:
1. PersistentClass - describes the metadata about the entity to be handled by the persister
2. EntityDataAccess - the second level caching strategy for this entity
3. NaturalIdDataAccess - the second level caching strategy for the natural-id defined for this entity, if one
4. PersisterCreationContext - access to additional information useful while constructing the persister.
Author:

Gavin King, Steve Ebersole

See Also:

PersisterFactory, PersisterClassResolver

Field Summary

Fields
Modifier and Type Field and Description

static String ENTITY_ID
The property name of the "special" identifier property in HQL

Fields
Modifier and Type	Field and Description
`static String`	`ENTITY_ID` The property name of the "special" identifier property in HQL

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`afterInitialize(Object entity, SharedSessionContractImplementor session)` Called just after the entities properties have been initialized
`void`	`afterReassociate(Object entity, SharedSessionContractImplementor session)` Called just after the entity has been reassociated with the session
`CacheEntry`	`buildCacheEntry(Object entity, Object[] state, Object version, SharedSessionContractImplementor session)`
`boolean`	`canExtractIdOutOfEntity()` Determine whether detached instances of this entity carry their own identifier value.
`boolean`	`canReadFromCache()`
`boolean`	`canUseReferenceCacheEntries()`
`boolean`	`canWriteToCache()`
`Object`	`createProxy(Serializable id, SharedSessionContractImplementor session)` Create a new proxy instance
`void`	`delete(Serializable id, Object version, Object object, SharedSessionContractImplementor session)` Delete a persistent instance
`int[]`	`findDirty(Object[] currentState, Object[] previousState, Object owner, SharedSessionContractImplementor session)` Compare the two snapshots to determine if they represent dirty state.
`int[]`	`findModified(Object[] old, Object[] current, Object object, SharedSessionContractImplementor session)` Compare the two snapshots to determine if they represent modified state.
`Object`	`forceVersionIncrement(Serializable id, Object currentVersion, SharedSessionContractImplementor session)`
`void`	`generateEntityDefinition()` Generate the entity definition for this object.
`default BytecodeEnhancementMetadata`	`getBytecodeEnhancementMetadata()`
`EntityDataAccess`	`getCacheAccessStrategy()` Get the cache (optional operation)
`CacheEntryStructure`	`getCacheEntryStructure()` Get the cache structure
`ClassMetadata`	`getClassMetadata()` Get the user-visible metadata for the class (optional operation)
`Class`	`getConcreteProxyClass()` Get the proxy interface that instances of this concrete class will be cast to (optional operation).
`Object`	`getCurrentVersion(Serializable id, SharedSessionContractImplementor session)` Get the current version of the object, or return null if there is no row for the given identifier.
`Object[]`	`getDatabaseSnapshot(Serializable id, SharedSessionContractImplementor session)` Get the current database state of the object, in a "hydrated" form, without resolving identifiers
`EntityEntryFactory`	`getEntityEntryFactory()` Get the EntityEntryFactory indicated for the entity mapped by this persister.
`EntityMetamodel`	`getEntityMetamodel()` Retrieve the underlying entity metamodel instance...
`EntityMode`	`getEntityMode()`
`String`	`getEntityName()` The entity name which this persister maps.
`EntityTuplizer`	`getEntityTuplizer()`
`SessionFactoryImplementor`	`getFactory()` Return the SessionFactory to which this persister "belongs".
`FilterAliasGenerator`	`getFilterAliasGenerator(String rootAlias)`
`Serializable`	`getIdByUniqueKey(Serializable key, String uniquePropertyName, SharedSessionContractImplementor session)`
`Serializable`	`getIdentifier(Object object)` Deprecated. Use `getIdentifier(Object,SharedSessionContractImplementor)` instead
`Serializable`	`getIdentifier(Object entity, SharedSessionContractImplementor session)` Get the identifier of an instance (throw an exception if no identifier property)
`IdentifierGenerator`	`getIdentifierGenerator()` Determine which identifier generation strategy is used for this entity.
`String`	`getIdentifierPropertyName()` Get the name of the identifier property (or return null) - need not return the name of an actual Java property
`Type`	`getIdentifierType()` Get the identifier type
`BytecodeEnhancementMetadata`	`getInstrumentationMetadata()`
`Class`	`getMappedClass()` The persistent class, or null
`NaturalIdDataAccess`	`getNaturalIdCacheAccessStrategy()` Get the NaturalId cache (optional operation)
`int[]`	`getNaturalIdentifierProperties()` If the entity defines a natural id (`hasNaturalIdentifier()`), which properties make up the natural id.
`Object[]`	`getNaturalIdentifierSnapshot(Serializable id, SharedSessionContractImplementor session)` Retrieve the current state of the natural-id properties from the database.
`NavigableRole`	`getNavigableRole()`
`CascadeStyle[]`	`getPropertyCascadeStyles()` Get the cascade styles of the properties (optional operation)
`boolean[]`	`getPropertyCheckability()` Get the "checkability" of the properties of this class (is the property dirty checked, does the cache need to be updated)
`boolean[]`	`getPropertyInsertability()` Get the "insertability" of the properties of this class (does the property appear in an SQL INSERT)
`ValueInclusion[]`	`getPropertyInsertGenerationInclusions()` Deprecated. Replaced internally with InMemoryValueGenerationStrategy / InDatabaseValueGenerationStrategy
`boolean[]`	`getPropertyLaziness()`
`String[]`	`getPropertyNames()` Get the names of the class properties - doesn't have to be the names of the actual Java properties (used for XML generation only)
`boolean[]`	`getPropertyNullability()` Get the nullability of the properties of this class
`Serializable[]`	`getPropertySpaces()` Returns an array of objects that identify spaces in which properties of this entity are persisted, for instances of this class only.
`Type`	`getPropertyType(String propertyName)` Get the type of a particular property by name.
`Type[]`	`getPropertyTypes()` Get the Hibernate types of the class properties
`boolean[]`	`getPropertyUpdateability()` Get the "updateability" of the properties of this class (does the property appear in an SQL UPDATE)
`ValueInclusion[]`	`getPropertyUpdateGenerationInclusions()` Deprecated. Replaced internally with InMemoryValueGenerationStrategy / InDatabaseValueGenerationStrategy
`Object`	`getPropertyValue(Object object, int i)` Get the value of a particular property
`Object`	`getPropertyValue(Object object, String propertyName)` Get the value of a particular property
`Object[]`	`getPropertyValues(Object object)` Return the (loaded) values of the mapped properties of the object (not including backrefs)
`Object[]`	`getPropertyValuesToInsert(Object object, Map mergeMap, SharedSessionContractImplementor session)` Return the values of the insertable properties of the object (including backrefs)
`boolean[]`	`getPropertyVersionability()` Get the "versionability" of the properties of this class (is the property optimistic-locked)
`Serializable[]`	`getQuerySpaces()` Returns an array of objects that identify spaces in which properties of this entity are persisted, for instances of this class and its subclasses.
`String`	`getRootEntityName()` Returns an object that identifies the space in which identifiers of this entity hierarchy are unique.
`EntityPersister`	`getSubclassEntityPersister(Object instance, SessionFactoryImplementor factory)` A request has already identified the entity-name of this persister as the mapping for the given instance.
`Object`	`getVersion(Object object)` Get the version number (or timestamp) from the object's version property (or return null if not versioned)
`int`	`getVersionProperty()` If `isVersioned()`, then what is the index of the property holding the locking value.
`VersionType`	`getVersionType()` If `isVersioned()`, then what is the type of the property holding the locking value.
`boolean`	`hasCache()` Deprecated. Use `canReadFromCache()` and/or `canWriteToCache()` depending on need
`boolean`	`hasCascades()` Determine whether this entity has any non-none cascading.
`boolean`	`hasCollections()` Determine whether this entity contains references to persistent collections.
`boolean`	`hasIdentifierProperty()` Determine whether the entity has a particular property holding the identifier value.
`boolean`	`hasInsertGeneratedProperties()` Does this entity define any properties as being database generated on insert?
`boolean`	`hasLazyProperties()` Determine whether this entity defines any lazy properties (ala bytecode instrumentation).
`boolean`	`hasMutableProperties()` Determine whether any properties of this entity are considered mutable.
`boolean`	`hasNaturalIdCache()` Does this class have a natural id cache
`boolean`	`hasNaturalIdentifier()` Determine whether this entity defines a natural identifier.
`boolean`	`hasProxy()` Determine whether this entity supports dynamic proxies.
`boolean`	`hasSubselectLoadableCollections()` Determine whether this entity contains references to persistent collections which are fetchable by subselect?
`boolean`	`hasUninitializedLazyProperties(Object object)` Does the given instance have any uninitialized lazy properties?
`boolean`	`hasUpdateGeneratedProperties()` Does this entity define any properties as being database generated on update?
`boolean`	`implementsLifecycle()` Does the class implement the `Lifecycle` interface.
`default Object`	`initializeEnhancedEntityUsedAsProxy(Object entity, String nameOfAttributeBeingAccessed, SharedSessionContractImplementor session)` Called from `EnhancementAsProxyLazinessInterceptor` to trigger load of the entity's non-lazy state as well as the named attribute we are accessing if it is still uninitialized after fetching non-lazy state
`Serializable`	`insert(Object[] fields, Object object, SharedSessionContractImplementor session)` Persist an instance, using a natively generated identifier (optional operation)
`void`	`insert(Serializable id, Object[] fields, Object object, SharedSessionContractImplementor session)` Persist an instance
`Object`	`instantiate(Serializable id, SharedSessionContractImplementor session)` Create a class instance initialized with the given identifier
`boolean`	`isBatchLoadable()` Is batch loading enabled?
`boolean`	`isCacheInvalidationRequired()` Should we always invalidate the cache instead of recaching updated state
`boolean`	`isIdentifierAssignedByInsert()` Are identifiers of this entity assigned known before the insert execution? Or, are they generated (in the database) by the insert execution.
`boolean`	`isInherited()` Determine whether the entity is inherited one or more other entities.
`boolean`	`isInstance(Object object)` Is the given object an instance of this entity?
`boolean`	`isInstrumented()` Has the class actually been bytecode instrumented?
`boolean`	`isLazyPropertiesCacheable()` Should lazy properties of this entity be cached?
`boolean`	`isMutable()` Determine whether instances of this entity are considered mutable.
`boolean`	`isSelectBeforeUpdateRequired()` Is select snapshot before update enabled?
`boolean`	`isSubclassEntityName(String entityName)` Determine whether the given name represents a subclass entity (or this entity itself) of the entity mapped by this persister.
`Boolean`	`isTransient(Object object, SharedSessionContractImplementor session)` Is this a new transient instance?
`boolean`	`isVersioned()` Determine whether optimistic locking by column is enabled for this entity.
`boolean`	`isVersionPropertyGenerated()` Does this entity contain a version property that is defined to be database generated?
`Object`	`load(Serializable id, Object optionalObject, LockMode lockMode, SharedSessionContractImplementor session)` Load an instance of the persistent class.
`Object`	`load(Serializable id, Object optionalObject, LockOptions lockOptions, SharedSessionContractImplementor session)` Load an instance of the persistent class.
`Serializable`	`loadEntityIdByNaturalId(Object[] naturalIdValues, LockOptions lockOptions, SharedSessionContractImplementor session)` Load the id for the entity based on the natural id.
`void`	`lock(Serializable id, Object version, Object object, LockMode lockMode, SharedSessionContractImplementor session)` Do a version check (optional operation)
`void`	`lock(Serializable id, Object version, Object object, LockOptions lockOptions, SharedSessionContractImplementor session)` Do a version check (optional operation)
`List`	`multiLoad(Serializable[] ids, SharedSessionContractImplementor session, MultiLoadOptions loadOptions)` Performs a load of multiple entities (of this type) by identifier simultaneously.
`void`	`postInstantiate()` Finish the initialization of this object.
`void`	`processInsertGeneratedProperties(Serializable id, Object entity, Object[] state, SharedSessionContractImplementor session)` Perform a select to retrieve the values of any generated properties back from the database, injecting these generated values into the given entity as well as writing this state to the `PersistenceContext`.
`void`	`processUpdateGeneratedProperties(Serializable id, Object entity, Object[] state, SharedSessionContractImplementor session)` Perform a select to retrieve the values of any generated properties back from the database, injecting these generated values into the given entity as well as writing this state to the `PersistenceContext`.
`void`	`resetIdentifier(Object entity, Serializable currentId, Object currentVersion, SharedSessionContractImplementor session)` Set the identifier and version of the given instance back to its "unsaved" value.
`int[]`	`resolveAttributeIndexes(String[] attributeNames)` Converts an array of attribute names to a set of indexes, according to the entity metamodel
`void`	`setIdentifier(Object entity, Serializable id, SharedSessionContractImplementor session)` Inject the identifier value into the given entity.
`void`	`setPropertyValue(Object object, int i, Object value)` Set the value of a particular property
`void`	`setPropertyValues(Object object, Object[] values)` Set the given values to the mapped properties of the given object
`void`	`update(Serializable id, Object[] fields, int[] dirtyFields, boolean hasDirtyCollection, Object[] oldFields, Object oldVersion, Object object, Object rowId, SharedSessionContractImplementor session)` Update a persistent instance

Methods inherited from interface org.hibernate.persister.walking.spi.EntityDefinition
getEntityKeyDefinition, getEntityPersister

Methods inherited from interface org.hibernate.persister.walking.spi.AttributeSource
getAttributes

- Field Detail
  - ENTITY_ID
```
static final String ENTITY_ID
```
    The property name of the "special" identifier property in HQL
    
    See Also:
    
    Constant Field Values
- Method Detail
  - generateEntityDefinition
```
void generateEntityDefinition()
```
    Generate the entity definition for this object. This must be done for all entity persisters before calling postInstantiate().
  - postInstantiate
```
void postInstantiate()
              throws MappingException
```
    Finish the initialization of this object. generateEntityDefinition() must be called for all entity persisters before calling this method.
    Called only once per SessionFactory lifecycle, after all entity persisters have been instantiated.
    
    Throws:
    
    MappingException - Indicates an issue in the metadata.
  - getFactory
```
SessionFactoryImplementor getFactory()
```
    Return the SessionFactory to which this persister "belongs".
    
    Returns:
    
    The owning SessionFactory.
  - getNavigableRole
```
NavigableRole getNavigableRole()
```
  - getEntityEntryFactory
```
EntityEntryFactory getEntityEntryFactory()
```
    Get the EntityEntryFactory indicated for the entity mapped by this persister.
    
    Returns:
    
    The proper EntityEntryFactory.
  - getRootEntityName
```
String getRootEntityName()
```
    Returns an object that identifies the space in which identifiers of this entity hierarchy are unique. Might be a table name, a JNDI URL, etc.
    
    Returns:
    
    The root entity name.
  - getEntityName
```
String getEntityName()
```
    The entity name which this persister maps.
    
    Returns:
    
    The name of the entity which this persister maps.
  - getEntityMetamodel
```
EntityMetamodel getEntityMetamodel()
```
    Retrieve the underlying entity metamodel instance...
    
    Returns:
    
    The metamodel
  - initializeEnhancedEntityUsedAsProxy
```
default Object initializeEnhancedEntityUsedAsProxy(Object entity,
                                                   String nameOfAttributeBeingAccessed,
                                                   SharedSessionContractImplementor session)
```
    Called from EnhancementAsProxyLazinessInterceptor to trigger load of the entity's non-lazy state as well as the named attribute we are accessing if it is still uninitialized after fetching non-lazy state
  - isSubclassEntityName
```
boolean isSubclassEntityName(String entityName)
```
    Determine whether the given name represents a subclass entity (or this entity itself) of the entity mapped by this persister.
    
    Parameters:
    
    entityName - The entity name to be checked.
    
    Returns:
    
    True if the given entity name represents either the entity mapped by this persister or one of its subclass entities; false otherwise.
  - getPropertySpaces
```
Serializable[] getPropertySpaces()
```
    Returns an array of objects that identify spaces in which properties of this entity are persisted, for instances of this class only.
    For most implementations, this returns the complete set of table names to which instances of the mapped entity are persisted (not accounting for superclass entity mappings).
    
    Returns:
    
    The property spaces.
  - getQuerySpaces
```
Serializable[] getQuerySpaces()
```
    Returns an array of objects that identify spaces in which properties of this entity are persisted, for instances of this class and its subclasses.
    Much like getPropertySpaces(), except that here we include subclass entity spaces.
    
    Returns:
    
    The query spaces.
  - hasProxy
```
boolean hasProxy()
```
    Determine whether this entity supports dynamic proxies.
    
    Returns:
    
    True if the entity has dynamic proxy support; false otherwise.
  - hasCollections
```
boolean hasCollections()
```
    Determine whether this entity contains references to persistent collections.
    
    Returns:
    
    True if the entity does contain persistent collections; false otherwise.
  - hasMutableProperties
```
boolean hasMutableProperties()
```
    Determine whether any properties of this entity are considered mutable.
    
    Returns:
    
    True if any properties of the entity are mutable; false otherwise (meaning none are).
  - hasSubselectLoadableCollections
```
boolean hasSubselectLoadableCollections()
```
    Determine whether this entity contains references to persistent collections which are fetchable by subselect?
    
    Returns:
    
    True if the entity contains collections fetchable by subselect; false otherwise.
  - hasCascades
```
boolean hasCascades()
```
    Determine whether this entity has any non-none cascading.
    
    Returns:
    
    True if the entity has any properties with a cascade other than NONE; false otherwise (aka, no cascading).
  - isMutable
```
boolean isMutable()
```
    Determine whether instances of this entity are considered mutable.
    
    Returns:
    
    True if the entity is considered mutable; false otherwise.
  - isInherited
```
boolean isInherited()
```
    Determine whether the entity is inherited one or more other entities. In other words, is this entity a subclass of other entities.
    
    Returns:
    
    True if other entities extend this entity; false otherwise.
  - isIdentifierAssignedByInsert
```
boolean isIdentifierAssignedByInsert()
```
    Are identifiers of this entity assigned known before the insert execution? Or, are they generated (in the database) by the insert execution.
    
    Returns:
    
    True if identifiers for this entity are generated by the insert execution.
  - getPropertyType
```
Type getPropertyType(String propertyName)
              throws MappingException
```
    Get the type of a particular property by name.
    
    Parameters:
    
    propertyName - The name of the property for which to retrieve the type.
    
    Returns:
    
    The type.
    
    Throws:
    
    MappingException - Typically indicates an unknown property name.
  - findDirty
```
int[] findDirty(Object[] currentState,
                Object[] previousState,
                Object owner,
                SharedSessionContractImplementor session)
```
    Compare the two snapshots to determine if they represent dirty state.
    
    Parameters:
    
    currentState - The current snapshot
    
    previousState - The baseline snapshot
    
    owner - The entity containing the state
    
    session - The originating session
    
    Returns:
    
    The indices of all dirty properties, or null if no properties were dirty.
  - findModified
```
int[] findModified(Object[] old,
                   Object[] current,
                   Object object,
                   SharedSessionContractImplementor session)
```
    Compare the two snapshots to determine if they represent modified state.
    
    Parameters:
    
    old - The baseline snapshot
    
    current - The current snapshot
    
    object - The entity containing the state
    
    session - The originating session
    
    Returns:
    
    The indices of all modified properties, or null if no properties were modified.
  - hasIdentifierProperty
```
boolean hasIdentifierProperty()
```
    Determine whether the entity has a particular property holding the identifier value.
    
    Returns:
    
    True if the entity has a specific property holding identifier value.
  - canExtractIdOutOfEntity
```
boolean canExtractIdOutOfEntity()
```
    Determine whether detached instances of this entity carry their own identifier value.
    The other option is the deprecated feature where users could supply the id during session calls.
    
    Returns:
    
    True if either (1) hasIdentifierProperty() or (2) the identifier is an embedded composite identifier; false otherwise.
  - isVersioned
```
boolean isVersioned()
```
    Determine whether optimistic locking by column is enabled for this entity.
    
    Returns:
    
    True if optimistic locking by column (i.e., or ) is enabled; false otherwise.
  - getVersionType
```
VersionType getVersionType()
```
    If isVersioned(), then what is the type of the property holding the locking value.
    
    Returns:
    
    The type of the version property; or null, if not versioned.
  - getVersionProperty
```
int getVersionProperty()
```
    If isVersioned(), then what is the index of the property holding the locking value.
    
    Returns:
    
    The type of the version property; or -66, if not versioned.
  - hasNaturalIdentifier
```
boolean hasNaturalIdentifier()
```
    Determine whether this entity defines a natural identifier.
    
    Returns:
    
    True if the entity defines a natural id; false otherwise.
  - getNaturalIdentifierProperties
```
int[] getNaturalIdentifierProperties()
```
    If the entity defines a natural id (hasNaturalIdentifier()), which properties make up the natural id.
    
    Returns:
    
    The indices of the properties making of the natural id; or null, if no natural id is defined.
  - getNaturalIdentifierSnapshot
```
Object[] getNaturalIdentifierSnapshot(Serializable id,
                                      SharedSessionContractImplementor session)
```
    Retrieve the current state of the natural-id properties from the database.
    
    Parameters:
    
    id - The identifier of the entity for which to retrieve the natural-id values.
    
    session - The session from which the request originated.
    
    Returns:
    
    The natural-id snapshot.
  - getIdentifierGenerator
```
IdentifierGenerator getIdentifierGenerator()
```
    Determine which identifier generation strategy is used for this entity.
    
    Returns:
    
    The identifier generation strategy.
  - hasLazyProperties
```
boolean hasLazyProperties()
```
    Determine whether this entity defines any lazy properties (ala bytecode instrumentation).
    
    Returns:
    
    True if the entity has properties mapped as lazy; false otherwise.
  - loadEntityIdByNaturalId
```
Serializable loadEntityIdByNaturalId(Object[] naturalIdValues,
                                     LockOptions lockOptions,
                                     SharedSessionContractImplementor session)
```
    Load the id for the entity based on the natural id.
  - load
```
Object load(Serializable id,
            Object optionalObject,
            LockMode lockMode,
            SharedSessionContractImplementor session)
     throws HibernateException
```
    Load an instance of the persistent class.
    
    Throws:
    
    HibernateException
  - load
```
Object load(Serializable id,
            Object optionalObject,
            LockOptions lockOptions,
            SharedSessionContractImplementor session)
     throws HibernateException
```
    Load an instance of the persistent class.
    
    Throws:
    
    HibernateException
  - multiLoad
```
List multiLoad(Serializable[] ids,
               SharedSessionContractImplementor session,
               MultiLoadOptions loadOptions)
```
    Performs a load of multiple entities (of this type) by identifier simultaneously.
    
    Parameters:
    
    ids - The identifiers to load
    
    session - The originating Sesison
    
    loadOptions - The options for loading
    
    Returns:
    
    The loaded, matching entities
  - lock
```
void lock(Serializable id,
          Object version,
          Object object,
          LockMode lockMode,
          SharedSessionContractImplementor session)
   throws HibernateException
```
    Do a version check (optional operation)
    
    Throws:
    
    HibernateException
  - lock
```
void lock(Serializable id,
          Object version,
          Object object,
          LockOptions lockOptions,
          SharedSessionContractImplementor session)
   throws HibernateException
```
    Do a version check (optional operation)
    
    Throws:
    
    HibernateException
  - insert
```
void insert(Serializable id,
            Object[] fields,
            Object object,
            SharedSessionContractImplementor session)
     throws HibernateException
```
    Persist an instance
    
    Throws:
    
    HibernateException
  - insert
```
Serializable insert(Object[] fields,
                    Object object,
                    SharedSessionContractImplementor session)
             throws HibernateException
```
    Persist an instance, using a natively generated identifier (optional operation)
    
    Throws:
    
    HibernateException
  - delete
```
void delete(Serializable id,
            Object version,
            Object object,
            SharedSessionContractImplementor session)
     throws HibernateException
```
    Delete a persistent instance
    
    Throws:
    
    HibernateException
  - update
```
void update(Serializable id,
            Object[] fields,
            int[] dirtyFields,
            boolean hasDirtyCollection,
            Object[] oldFields,
            Object oldVersion,
            Object object,
            Object rowId,
            SharedSessionContractImplementor session)
     throws HibernateException
```
    Update a persistent instance
    
    Throws:
    
    HibernateException
  - getPropertyTypes
```
Type[] getPropertyTypes()
```
    Get the Hibernate types of the class properties
  - getPropertyNames
```
String[] getPropertyNames()
```
    Get the names of the class properties - doesn't have to be the names of the actual Java properties (used for XML generation only)
  - getPropertyInsertability
```
boolean[] getPropertyInsertability()
```
    Get the "insertability" of the properties of this class (does the property appear in an SQL INSERT)
  - getPropertyInsertGenerationInclusions
```
@Deprecated
ValueInclusion[] getPropertyInsertGenerationInclusions()
```
    Deprecated. Replaced internally with InMemoryValueGenerationStrategy / InDatabaseValueGenerationStrategy
    
    Which of the properties of this class are database generated values on insert?
  - getPropertyUpdateGenerationInclusions
```
@Deprecated
ValueInclusion[] getPropertyUpdateGenerationInclusions()
```
    Deprecated. Replaced internally with InMemoryValueGenerationStrategy / InDatabaseValueGenerationStrategy
    
    Which of the properties of this class are database generated values on update?
  - getPropertyUpdateability
```
boolean[] getPropertyUpdateability()
```
    Get the "updateability" of the properties of this class (does the property appear in an SQL UPDATE)
  - getPropertyCheckability
```
boolean[] getPropertyCheckability()
```
    Get the "checkability" of the properties of this class (is the property dirty checked, does the cache need to be updated)
  - getPropertyNullability
```
boolean[] getPropertyNullability()
```
    Get the nullability of the properties of this class
  - getPropertyVersionability
```
boolean[] getPropertyVersionability()
```
    Get the "versionability" of the properties of this class (is the property optimistic-locked)
  - getPropertyLaziness
```
boolean[] getPropertyLaziness()
```
  - getPropertyCascadeStyles
```
CascadeStyle[] getPropertyCascadeStyles()
```
    Get the cascade styles of the properties (optional operation)
  - getIdentifierType
```
Type getIdentifierType()
```
    Get the identifier type
  - getIdentifierPropertyName
```
String getIdentifierPropertyName()
```
    Get the name of the identifier property (or return null) - need not return the name of an actual Java property
  - isCacheInvalidationRequired
```
boolean isCacheInvalidationRequired()
```
    Should we always invalidate the cache instead of recaching updated state
  - isLazyPropertiesCacheable
```
boolean isLazyPropertiesCacheable()
```
    Should lazy properties of this entity be cached?
  - canReadFromCache
```
boolean canReadFromCache()
```
  - canWriteToCache
```
boolean canWriteToCache()
```
  - hasCache
```
@Deprecated
boolean hasCache()
```
    Deprecated. Use canReadFromCache() and/or canWriteToCache() depending on need
    
    Does this class have a cache.
  - getCacheAccessStrategy
```
EntityDataAccess getCacheAccessStrategy()
```
    Get the cache (optional operation)
  - getCacheEntryStructure
```
CacheEntryStructure getCacheEntryStructure()
```
    Get the cache structure
  - buildCacheEntry
```
CacheEntry buildCacheEntry(Object entity,
                           Object[] state,
                           Object version,
                           SharedSessionContractImplementor session)
```
  - hasNaturalIdCache
```
boolean hasNaturalIdCache()
```
    Does this class have a natural id cache
  - getNaturalIdCacheAccessStrategy
```
NaturalIdDataAccess getNaturalIdCacheAccessStrategy()
```
    Get the NaturalId cache (optional operation)
  - getClassMetadata
```
ClassMetadata getClassMetadata()
```
    Get the user-visible metadata for the class (optional operation)
  - isBatchLoadable
```
boolean isBatchLoadable()
```
    Is batch loading enabled?
  - isSelectBeforeUpdateRequired
```
boolean isSelectBeforeUpdateRequired()
```
    Is select snapshot before update enabled?
  - getDatabaseSnapshot
```
Object[] getDatabaseSnapshot(Serializable id,
                             SharedSessionContractImplementor session)
                      throws HibernateException
```
    Get the current database state of the object, in a "hydrated" form, without resolving identifiers
    
    Returns:
    
    null if there is no row in the database
    
    Throws:
    
    HibernateException
  - getIdByUniqueKey
```
Serializable getIdByUniqueKey(Serializable key,
                              String uniquePropertyName,
                              SharedSessionContractImplementor session)
```
  - getCurrentVersion
```
Object getCurrentVersion(Serializable id,
                         SharedSessionContractImplementor session)
                  throws HibernateException
```
    Get the current version of the object, or return null if there is no row for the given identifier. In the case of unversioned data, return any object if the row exists.
    
    Throws:
    
    HibernateException
  - forceVersionIncrement
```
Object forceVersionIncrement(Serializable id,
                             Object currentVersion,
                             SharedSessionContractImplementor session)
                      throws HibernateException
```
    Throws:
    
    HibernateException
  - isInstrumented
```
boolean isInstrumented()
```
    Has the class actually been bytecode instrumented?
  - hasInsertGeneratedProperties
```
boolean hasInsertGeneratedProperties()
```
    Does this entity define any properties as being database generated on insert?
    
    Returns:
    
    True if this entity contains at least one property defined as generated (including version property, but not identifier).
  - hasUpdateGeneratedProperties
```
boolean hasUpdateGeneratedProperties()
```
    Does this entity define any properties as being database generated on update?
    
    Returns:
    
    True if this entity contains at least one property defined as generated (including version property, but not identifier).
  - isVersionPropertyGenerated
```
boolean isVersionPropertyGenerated()
```
    Does this entity contain a version property that is defined to be database generated?
    
    Returns:
    
    true if this entity contains a version property and that property has been marked as generated.
  - afterInitialize
```
void afterInitialize(Object entity,
                     SharedSessionContractImplementor session)
```
    Called just after the entities properties have been initialized
  - afterReassociate
```
void afterReassociate(Object entity,
                      SharedSessionContractImplementor session)
```
    Called just after the entity has been reassociated with the session
  - createProxy
```
Object createProxy(Serializable id,
                   SharedSessionContractImplementor session)
            throws HibernateException
```
    Create a new proxy instance
    
    Throws:
    
    HibernateException
  - isTransient
```
Boolean isTransient(Object object,
                    SharedSessionContractImplementor session)
             throws HibernateException
```
    Is this a new transient instance?
    
    Throws:
    
    HibernateException
  - getPropertyValuesToInsert
```
Object[] getPropertyValuesToInsert(Object object,
                                   Map mergeMap,
                                   SharedSessionContractImplementor session)
                            throws HibernateException
```
    Return the values of the insertable properties of the object (including backrefs)
    
    Throws:
    
    HibernateException
  - processInsertGeneratedProperties
```
void processInsertGeneratedProperties(Serializable id,
                                      Object entity,
                                      Object[] state,
                                      SharedSessionContractImplementor session)
```
    Perform a select to retrieve the values of any generated properties back from the database, injecting these generated values into the given entity as well as writing this state to the PersistenceContext.
    Note, that because we update the PersistenceContext here, callers need to take care that they have already written the initial snapshot to the PersistenceContext before calling this method.
    
    Parameters:
    
    id - The entity's id value.
    
    entity - The entity for which to get the state.
    
    state -
    
    session - The session
  - processUpdateGeneratedProperties
```
void processUpdateGeneratedProperties(Serializable id,
                                      Object entity,
                                      Object[] state,
                                      SharedSessionContractImplementor session)
```
    Perform a select to retrieve the values of any generated properties back from the database, injecting these generated values into the given entity as well as writing this state to the PersistenceContext.
    Note, that because we update the PersistenceContext here, callers need to take care that they have already written the initial snapshot to the PersistenceContext before calling this method.
    
    Parameters:
    
    id - The entity's id value.
    
    entity - The entity for which to get the state.
    
    state -
    
    session - The session
  - getMappedClass
```
Class getMappedClass()
```
    The persistent class, or null
  - implementsLifecycle
```
boolean implementsLifecycle()
```
    Does the class implement the Lifecycle interface.
  - getConcreteProxyClass
```
Class getConcreteProxyClass()
```
    Get the proxy interface that instances of this concrete class will be cast to (optional operation).
  - setPropertyValues
```
void setPropertyValues(Object object,
                       Object[] values)
```
    Set the given values to the mapped properties of the given object
  - setPropertyValue
```
void setPropertyValue(Object object,
                      int i,
                      Object value)
```
    Set the value of a particular property
  - getPropertyValues
```
Object[] getPropertyValues(Object object)
```
    Return the (loaded) values of the mapped properties of the object (not including backrefs)
  - getPropertyValue
```
Object getPropertyValue(Object object,
                        int i)
                 throws HibernateException
```
    Get the value of a particular property
    
    Throws:
    
    HibernateException
  - getPropertyValue
```
Object getPropertyValue(Object object,
                        String propertyName)
```
    Get the value of a particular property
  - getIdentifier
```
@Deprecated
Serializable getIdentifier(Object object)
                                throws HibernateException
```
    Deprecated. Use getIdentifier(Object,SharedSessionContractImplementor) instead
    
    Get the identifier of an instance (throw an exception if no identifier property)
    
    Throws:
    
    HibernateException
  - getIdentifier
```
Serializable getIdentifier(Object entity,
                           SharedSessionContractImplementor session)
```
    Get the identifier of an instance (throw an exception if no identifier property)
    
    Parameters:
    
    entity - The entity for which to get the identifier
    
    session - The session from which the request originated
    
    Returns:
    
    The identifier
  - setIdentifier
```
void setIdentifier(Object entity,
                   Serializable id,
                   SharedSessionContractImplementor session)
```
    Inject the identifier value into the given entity.
    
    Parameters:
    
    entity - The entity to inject with the identifier value.
    
    id - The value to be injected as the identifier.
    
    session - The session from which is requests originates
  - getVersion
```
Object getVersion(Object object)
           throws HibernateException
```
    Get the version number (or timestamp) from the object's version property (or return null if not versioned)
    
    Throws:
    
    HibernateException
  - instantiate
```
Object instantiate(Serializable id,
                   SharedSessionContractImplementor session)
```
    Create a class instance initialized with the given identifier
    
    Parameters:
    
    id - The identifier value to use (may be null to represent no value)
    
    session - The session from which the request originated.
    
    Returns:
    
    The instantiated entity.
  - isInstance
```
boolean isInstance(Object object)
```
    Is the given object an instance of this entity?
  - hasUninitializedLazyProperties
```
boolean hasUninitializedLazyProperties(Object object)
```
    Does the given instance have any uninitialized lazy properties?
  - resetIdentifier
```
void resetIdentifier(Object entity,
                     Serializable currentId,
                     Object currentVersion,
                     SharedSessionContractImplementor session)
```
    Set the identifier and version of the given instance back to its "unsaved" value.
    
    Parameters:
    
    entity - The entity instance
    
    currentId - The currently assigned identifier value.
    
    currentVersion - The currently assigned version value.
    
    session - The session from which the request originated.
  - getSubclassEntityPersister
```
EntityPersister getSubclassEntityPersister(Object instance,
                                           SessionFactoryImplementor factory)
```
    A request has already identified the entity-name of this persister as the mapping for the given instance. However, we still need to account for possible subclassing and potentially re-route to the more appropriate persister.
    For example, a request names Animal as the entity-name which gets resolved to this persister. But the actual instance is really an instance of Cat which is a subclass of Animal. So, here the Animal persister is being asked to return the persister specific to Cat.
    It is also possible that the instance is actually an Animal instance in the above example in which case we would return this from this method.
    
    Parameters:
    
    instance - The entity instance
    
    factory - Reference to the SessionFactory
    
    Returns:
    
    The appropriate persister
    
    Throws:
    
    HibernateException - Indicates that instance was deemed to not be a subclass of the entity mapped by this persister.
  - getEntityMode
```
EntityMode getEntityMode()
```
  - getEntityTuplizer
```
EntityTuplizer getEntityTuplizer()
```
  - getInstrumentationMetadata
```
BytecodeEnhancementMetadata getInstrumentationMetadata()
```
  - getBytecodeEnhancementMetadata
```
default BytecodeEnhancementMetadata getBytecodeEnhancementMetadata()
```
  - getFilterAliasGenerator
```
FilterAliasGenerator getFilterAliasGenerator(String rootAlias)
```
  - resolveAttributeIndexes
```
int[] resolveAttributeIndexes(String[] attributeNames)
```
    Converts an array of attribute names to a set of indexes, according to the entity metamodel
    
    Parameters:
    
    attributeNames - Array of names to be resolved
    
    Returns:
    
    A set of unique indexes of the attribute names found in the metamodel
  - canUseReferenceCacheEntries
```
boolean canUseReferenceCacheEntries()
```

Interface EntityPersister

Field Summary

Method Summary

Methods inherited from interface org.hibernate.persister.walking.spi.EntityDefinition

Methods inherited from interface org.hibernate.persister.walking.spi.AttributeSource

Field Detail

ENTITY_ID

Method Detail

generateEntityDefinition

postInstantiate

getFactory

getNavigableRole

getEntityEntryFactory

getRootEntityName

getEntityName

getEntityMetamodel

initializeEnhancedEntityUsedAsProxy

isSubclassEntityName

getPropertySpaces

getQuerySpaces

hasProxy

hasCollections

hasMutableProperties

hasSubselectLoadableCollections

hasCascades

isMutable

isInherited

isIdentifierAssignedByInsert

getPropertyType

findDirty

findModified

hasIdentifierProperty

canExtractIdOutOfEntity

isVersioned

getVersionType

getVersionProperty

hasNaturalIdentifier

getNaturalIdentifierProperties

getNaturalIdentifierSnapshot

getIdentifierGenerator

hasLazyProperties

loadEntityIdByNaturalId

load

load

multiLoad

lock

lock

insert

insert

delete

update

getPropertyTypes

getPropertyNames

getPropertyInsertability

getPropertyInsertGenerationInclusions

getPropertyUpdateGenerationInclusions

getPropertyUpdateability

getPropertyCheckability

getPropertyNullability

getPropertyVersionability

getPropertyLaziness

getPropertyCascadeStyles

getIdentifierType

getIdentifierPropertyName

isCacheInvalidationRequired

isLazyPropertiesCacheable

canReadFromCache

canWriteToCache

hasCache

getCacheAccessStrategy

getCacheEntryStructure

buildCacheEntry

hasNaturalIdCache

getNaturalIdCacheAccessStrategy

getClassMetadata

isBatchLoadable

isSelectBeforeUpdateRequired

getDatabaseSnapshot

getIdByUniqueKey

getCurrentVersion