java.lang.Object
- org.hibernate.persister.entity.AbstractEntityPersister

All Implemented Interfaces:

LazyPropertyInitializer, FetchProfileAffectee, PostInsertIdentityPersister, Loadable, ClassMetadata, Bindable, Discriminable, EntityMappingType, EntityValuedModelPart, FilterRestrictable, InFlightEntityMappingType, JdbcMappingContainer, ManagedMappingType, MappingModelExpressible, MappingType, ModelPart, ModelPartContainer, Restrictable, SoftDeletableModelPart, WhereRestrictable, DeprecatedEntityStuff, EntityPersister, Joinable, Loadable, Lockable, EntityMutationTarget, OuterJoinLoadable, PropertyMapping, Queryable, SQLLoadable, UniqueKeyLoadable, AttributeSource, RootTableGroupProducer, TableGroupProducer, MutationTarget<EntityTableMapping>, FetchableContainer

Direct Known Subclasses:

JoinedSubclassEntityPersister, SingleTableEntityPersister, UnionSubclassEntityPersister
```
@Internal
public abstract class AbstractEntityPersister
extends Object
implements InFlightEntityMappingType, EntityMutationTarget, LazyPropertyInitializer, PostInsertIdentityPersister, FetchProfileAffectee, DeprecatedEntityStuff
```
Basic functionality for persisting an entity via JDBC, using either generated or custom SQL.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static interface AbstractEntityPersister.CacheEntryHelper
Consolidated these onto a single helper because the 2 pieces work in tandem.
- Nested classes/interfaces inherited from interface org.hibernate.metamodel.mapping.Bindable
  Bindable.JdbcValuesBiConsumer<X,Y>, Bindable.JdbcValuesConsumer
- Nested classes/interfaces inherited from interface org.hibernate.metamodel.mapping.EntityMappingType
  EntityMappingType.ConstraintOrderedTableConsumer
- Nested classes/interfaces inherited from interface org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer
  LazyPropertyInitializer.InterceptorImplementor
- Nested classes/interfaces inherited from interface org.hibernate.metamodel.mapping.ModelPart
  ModelPart.JdbcValueBiConsumer<X,Y>, ModelPart.JdbcValueConsumer
- Nested classes/interfaces inherited from interface org.hibernate.persister.entity.Queryable
  Queryable.Declarer

Field Summary

Fields
Modifier and Type	Field	Description
`protected ReflectionOptimizer.AccessOptimizer`	`accessOptimizer`
`protected int`	`batchSize`
`protected String[]`	`customSQLDelete`	Deprecated.
`protected String[]`	`customSQLInsert`	Deprecated.
`protected String[]`	`customSQLUpdate`	Deprecated.
`protected AttributeMappingsMap`	`declaredAttributeMappings`
`protected boolean[]`	`deleteCallable`	Deprecated.
`protected Expectation[]`	`deleteExpectations`	Deprecated.
`static String`	`ENTITY_CLASS`
`protected String[]`	`fullDiscriminatorSQLValues`
`protected boolean[]`	`insertCallable`	Deprecated.
`protected Expectation[]`	`insertExpectations`	Deprecated.
`protected BasicEntityPropertyMapping`	`propertyMapping`	Warning: When there are duplicated property names in the subclasses then propertyMapping will only contain one of those properties.
`protected String`	`rowIdName`
`protected AttributeMappingsList`	`staticFetchableList`
`protected boolean[]`	`updateCallable`	Deprecated.
`protected Expectation[]`	`updateExpectations`	Deprecated.
`static String`	`VERSION_COLUMN_ALIAS`

Fields inherited from interface org.hibernate.persister.entity.EntityPersister
ENTITY_ID

Fields inherited from interface org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer
UNFETCHED_PROPERTY

Fields inherited from interface org.hibernate.persister.entity.Loadable
ROWID_ALIAS

Constructor Summary

Constructors
Constructor	Description
`AbstractEntityPersister(PersistentClass persistentClass, EntityDataAccess cacheAccessStrategy, NaturalIdDataAccess naturalIdRegionAccessStrategy, RuntimeModelCreationContext creationContext)`
`AbstractEntityPersister(PersistentClass persistentClass, EntityDataAccess cacheAccessStrategy, NaturalIdDataAccess naturalIdRegionAccessStrategy, PersisterCreationContext creationContext)`	Deprecated.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`void`	`addDiscriminatorToInsertGroup(MutationGroupBuilder insertGroupBuilder)`
`void`	`addSoftDeleteToInsertGroup(MutationGroupBuilder insertGroupBuilder)`
`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
`void`	`applyBaseRestrictions(Consumer<Predicate> predicateConsumer, TableGroup tableGroup, boolean useQualifier, Map<String,Filter> enabledFilters, Set<String> treatAsDeclarations, SqlAstCreationState creationState)`	Applies the base set of restrictions.
`void`	`applyDiscriminator(Consumer<Predicate> predicateConsumer, String alias, TableGroup tableGroup, SqlAstCreationState creationState)`	Apply the discriminator as a predicate via the `predicateConsumer`
`void`	`applyFilterRestrictions(Consumer<Predicate> predicateConsumer, TableGroup tableGroup, boolean useQualifier, Map<String,Filter> enabledFilters, SqlAstCreationState creationState)`	Applies just the `Filter` values enabled for the associated entity
`void`	`applySqlSelections(NavigablePath navigablePath, TableGroup tableGroup, DomainResultCreationState creationState)`	Apply SQL selections for a specific reference to this ModelPart outside the domain query's root select clause.
`void`	`applySqlSelections(NavigablePath navigablePath, TableGroup tableGroup, DomainResultCreationState creationState, BiConsumer<SqlSelection,JdbcMapping> selectionConsumer)`	Apply SQL selections for a specific reference to this ModelPart outside the domain query's root select clause.
`void`	`applyWhereRestrictions(Consumer<Predicate> predicateConsumer, TableGroup tableGroup, boolean useQualifier, SqlAstCreationState creationState)`	Apply the `Where` restrictions
`CacheEntry`	`buildCacheEntry(Object entity, Object[] state, Object version, SharedSessionContractImplementor session)`
`protected AbstractEntityPersister.CacheEntryHelper`	`buildCacheEntryHelper(SessionFactoryOptions options)`
`protected DeleteCoordinator`	`buildDeleteCoordinator()`
`protected EmbeddedAttributeMapping`	`buildEmbeddedAttributeMapping(String attrName, int stateArrayPosition, int fetchableIndex, Property bootProperty, DependantValue dependantValue, int dependantColumnIndex, ManagedMappingType declaringType, CompositeType attrType, String tableExpression, String[] rootTableKeyColumnNames, PropertyAccess propertyAccess, CascadeStyle cascadeStyle, MappingModelCreationProcess creationProcess)`	For Hibernate Reactive
`protected InsertCoordinator`	`buildInsertCoordinator()`
`protected UpdateCoordinator`	`buildMergeCoordinator()`
`protected MultiIdEntityLoader<Object>`	`buildMultiIdLoader()`
`protected AttributeMapping`	`buildPluralAttributeMapping(String attrName, int stateArrayPosition, int fetchableIndex, Property bootProperty, ManagedMappingType declaringType, PropertyAccess propertyAccess, CascadeStyle cascadeStyle, FetchMode fetchMode, MappingModelCreationProcess creationProcess)`	For Hibernate Reactive
`protected SingleIdEntityLoader<?>`	`buildSingleIdEntityLoader()`	For Hibernate Reactive
`protected AttributeMapping`	`buildSingularAssociationAttributeMapping(String attrName, NavigableRole navigableRole, int stateArrayPosition, int fetchableIndex, Property bootProperty, ManagedMappingType declaringType, EntityPersister declaringEntityPersister, EntityType attrType, PropertyAccess propertyAccess, CascadeStyle cascadeStyle, MappingModelCreationProcess creationProcess)`	For Hibernate Reactive
`protected EntityTableMapping[]`	`buildTableMappings()`	Builds the EntityTableMapping descriptors for the tables mapped by this entity.
`protected UpdateCoordinator`	`buildUpdateCoordinator()`
`boolean`	`canReadFromCache()`
`boolean`	`canUseReferenceCacheEntries()`
`boolean`	`canWriteToCache()`
`protected boolean`	`check(int rows, Object id, int tableNumber, Expectation expectation, PreparedStatement statement, String statementSQL)`
`boolean`	`checkVersion(boolean[] includeProperty)`
`boolean`	`consumesCollectionAlias()`	Very, very, very ugly...
`boolean`	`consumesEntityAlias()`	Very, very, very ugly...
`boolean`	`containsTableReference(String tableExpression)`
`int`	`countSubclassProperties()`	How many properties are there, for this class and all subclasses?
`<T> DomainResult<T>`	`createDomainResult(NavigablePath navigablePath, TableGroup tableGroup, String resultVariable, DomainResultCreationState creationState)`	Create a DomainResult for a specific reference to this ModelPart.
`TableReference`	`createPrimaryTableReference(SqlAliasBase sqlAliasBase, SqlAstCreationState sqlAstCreationState)`
`Object`	`createProxy(Object id, SharedSessionContractImplementor session)`	Create a new proxy instance
`TableGroup`	`createRootTableGroup(boolean canUseInnerJoins, NavigablePath navigablePath, String explicitSourceAlias, SqlAliasBase explicitSqlAliasBase, Supplier<Consumer<Predicate>> additionalPredicateCollectorAccess, SqlAstCreationState creationState)`	Create a root TableGroup as defined by this producer
`TableReferenceJoin`	`createTableReferenceJoin(String joinTableExpression, SqlAliasBase sqlAliasBase, TableReference lhs, SqlAstCreationState creationState)`
`@org.hibernate.Remove int`	`dehydrate(Object id, Object[] fields, Object rowId, boolean[] includeProperty, boolean[][] includeColumns, int j, PreparedStatement ps, SharedSessionContractImplementor session, int index, boolean isUpdate)`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used.
`void`	`delete(Object id, Object version, Object object, SharedSessionContractImplementor session)`	Delete an object
`protected SingleIdEntityLoader<?>`	`determineLoaderToUse(SharedSessionContractImplementor session)`
`protected String`	`determineTableName(Table table)`
`int`	`determineTableNumberForColumn(String columnName)`
`Object`	`disassemble(Object value, SharedSessionContractImplementor session)`	Breaks down a value of `J` into its simple pieces.
`AttributeMapping`	`findAttributeMapping(String name)`	Find an attribute by name.
`AttributeMapping`	`findDeclaredAttributeMapping(String name)`	Find an attribute-mapping, declared on this entity mapping (not super or subs), by name
`int[]`	`findDirty(Object[] currentState, Object[] previousState, Object entity, SharedSessionContractImplementor session)`	Locate the property-indices of all properties considered to be dirty.
`int[]`	`findModified(Object[] old, Object[] current, Object entity, SharedSessionContractImplementor session)`	Locate the property-indices of all properties considered to be dirty.
`ModelPart`	`findSubPart(String name, EntityMappingType treatTargetType)`
`ModelPart`	`findSubTypesSubPart(String name, EntityMappingType treatTargetType)`
`Object`	`forceVersionIncrement(Object id, Object currentVersion, boolean batching, SharedSessionContractImplementor session)`
`Object`	`forceVersionIncrement(Object id, Object currentVersion, SharedSessionContractImplementor session)`
`void`	`forEachAttributeMapping(Consumer<? super AttributeMapping> action)`	Visit each attribute mapping
`void`	`forEachAttributeMapping(IndexedConsumer<? super AttributeMapping> consumer)`	Visit attributes defined on this class and any supers
`<X,Y> int`	`forEachDisassembledJdbcValue(Object value, int offset, X x, Y y, Bindable.JdbcValuesBiConsumer<X,Y> valuesConsumer, SharedSessionContractImplementor session)`	Like `Bindable.forEachDisassembledJdbcValue(Object, Object, Object, JdbcValuesBiConsumer, SharedSessionContractImplementor)`, but additionally receives an offset by which the selectionIndex is incremented when calling `Bindable.JdbcValuesBiConsumer.consume(int, Object, Object, Object, JdbcMapping)`.
`int`	`forEachJdbcType(int offset, IndexedConsumer<JdbcMapping> action)`	Visit each JdbcMapping starting from the given offset
`<X,Y> int`	`forEachJdbcValue(Object value, int offset, X x, Y y, Bindable.JdbcValuesBiConsumer<X,Y> consumer, SharedSessionContractImplementor session)`	Visit each constituent JDBC value extracted from the entity instance itself.
`void`	`forEachMutableTable(Consumer<EntityTableMapping> consumer)`	Visit each table.
`void`	`forEachMutableTableReverse(Consumer<EntityTableMapping> consumer)`	Same as `MutationTarget.forEachMutableTable(java.util.function.Consumer<T>)` except that here the tables are visited in reverse order
`int`	`forEachSelectable(int offset, SelectableConsumer selectableConsumer)`	Visits each selectable mapping with the selectable index offset by the given value.
`@Remove String`	`generateDeleteString(int j)`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used.
`protected EntityDiscriminatorMapping`	`generateDiscriminatorMapping(PersistentClass bootEntityDescriptor, MappingModelCreationProcess modelCreationProcess)`
`String`	`generateFilterConditionAlias(String rootAlias)`	The alias used for any filter conditions (mapped where-fragments or enabled-filters).
`protected EntityIdentifierMapping`	`generateIdentifierMapping(Supplier<?> templateInstanceCreator, PersistentClass bootEntityDescriptor, MappingModelCreationProcess creationProcess)`
`protected Predicate`	`generateJoinPredicate(TableReference rootTableReference, TableReference joinedTableReference, String[] pkColumnNames, String[] fkColumnNames, SqlAstCreationState creationState)`
`protected LockingStrategy`	`generateLocker(LockMode lockMode)`
`protected NaturalIdMapping`	`generateNaturalIdMapping(MappingModelCreationProcess creationProcess, PersistentClass bootEntityDescriptor)`
`protected EntityIdentifierMapping`	`generateNonEncapsulatedCompositeIdentifierMapping(MappingModelCreationProcess creationProcess, PersistentClass bootEntityDescriptor)`
`protected AttributeMapping`	`generateNonIdAttributeMapping(NonIdentifierAttribute tupleAttrDefinition, Property bootProperty, int stateArrayPosition, int fetchableIndex, MappingModelCreationProcess creationProcess)`
`String`	`generateSelectVersionString()`	Generate the SQL that selects the version number by id
`protected @Remove String[]`	`generateSQLDeleteStrings(Object[] loadedState)`	Deprecated, for removal: This API element is subject to removal in a future version.
`static String`	`generateTableAlias(String rootAlias, int tableNumber)`
`protected TableReferenceJoin`	`generateTableReferenceJoin(TableReference lhs, String joinTableExpression, SqlAliasBase sqlAliasBase, boolean innerJoin, String[] targetColumns, SqlAstCreationState creationState)`
`protected EntityVersionMapping`	`generateVersionMapping(Supplier<?> templateInstanceCreator, PersistentClass bootEntityDescriptor, MappingModelCreationProcess creationProcess)`
`protected static EntityVersionMapping`	`generateVersionMapping(AbstractEntityPersister entityPersister, Supplier<?> templateInstanceCreator, PersistentClass bootModelRootEntityDescriptor, MappingModelCreationProcess creationProcess)`
`AttributeMapping`	`getAttributeMapping(int position)`	Retrieve an attribute mapping by position, relative to all attributes
`AttributeMappingsList`	`getAttributeMappings()`	The attributes mapping for this entity, including those declared on supertype mappings
`int`	`getBatchSize()`	The batch size for batch loading.
`BytecodeEnhancementMetadata`	`getBytecodeEnhancementMetadata()`
`EntityDataAccess`	`getCacheAccessStrategy()`	Get the cache (optional operation)
`CacheEntryStructure`	`getCacheEntryStructure()`	Get the cache structure
`CascadeStyle`	`getCascadeStyle(int i)`	Get the cascade style of this (subclass closure) property
`ClassMetadata`	`getClassMetadata()`	Deprecated.
`Object`	`getCollectionKey(CollectionPersister persister, Object owner, EntityEntry ownerEntry, SharedSessionContractImplementor session)`
`Class<?>`	`getConcreteProxyClass()`	Get the proxy interface that instances of this concrete class will be cast to (optional operation).
`Object`	`getCurrentVersion(Object id, SharedSessionContractImplementor session)`	Retrieve the version number
`Object[]`	`getDatabaseSnapshot(Object id, SharedSessionContractImplementor session)`	Get the current database state of the object, in a "hydrated" form, without resolving identifiers.
`AttributeMappingsMap`	`getDeclaredAttributeMappings()`	Get access to the attributes defined on this class - do not access attributes defined on the super
`DeleteCoordinator`	`getDeleteCoordinator()`
`String`	`getDiscriminatorAlias()`	Deprecated. Hibernate no longer uses aliases to read from result sets
`String`	`getDiscriminatorAlias(String suffix)`	Get the result set aliases used for the identifier columns, given a suffix
`String`	`getDiscriminatorColumnName()`
`String`	`getDiscriminatorColumnReaders()`
`String`	`getDiscriminatorColumnReaderTemplate()`
`String`	`getDiscriminatorFormulaTemplate()`
`EntityDiscriminatorMapping`	`getDiscriminatorMapping()`	Mapping details for the entity's discriminator.
`abstract BasicType<?>`	`getDiscriminatorType()`	Get the discriminator type
`EntityMappingType`	`getElementTypeDescriptor()`	Deprecated, for removal: This API element is subject to removal in a future version. With no replacement.
`EntityEntryFactory`	`getEntityEntryFactory()`	Get the EntityEntryFactory indicated for the entity mapped by this persister.
`EntityMetamodel`	`getEntityMetamodel()`	Retrieve the underlying entity metamodel instance.
`String`	`getEntityName()`	The entity name.
`static Map<String,String>`	`getEntityNameByTableNameMap(PersistentClass persistentClass, SqlStringGenerationContext stringGenerationContext)`
`EntityPersister`	`getEntityPersister()`	Safety-net.
`EntityType`	`getEntityType()`
`SessionFactoryImplementor`	`getFactory()`	Return the `SessionFactory` to which this persister belongs.
`Fetchable`	`getFetchable(int position)`
`FetchMode`	`getFetchMode(int i)`	May this (subclass closure) property be fetched using an SQL outerjoin?
`Generator`	`getGenerator()`
`Object`	`getIdByUniqueKey(Object key, String uniquePropertyName, SharedSessionContractImplementor session)`
`Object`	`getIdentifier(Object entity, SharedSessionContractImplementor session)`	Get the identifier of an instance from the object's identifier property.
`String[]`	`getIdentifierAliases()`
`String[]`	`getIdentifierAliases(String suffix)`	Get the result set aliases used for the identifier columns, given a suffix
`String[]`	`getIdentifierColumnNames()`	Get the names of columns used to persist the identifier
`String[]`	`getIdentifierColumnReaders()`
`String[]`	`getIdentifierColumnReaderTemplates()`
`int`	`getIdentifierColumnSpan()`
`ModelPart`	`getIdentifierDescriptor()`	The ModelPart describing the identifier/key for this target
`IdentifierGenerator`	`getIdentifierGenerator()`	Deprecated.
`EntityIdentifierMapping`	`getIdentifierMapping()`	Mapping details for the entity's identifier.
`String`	`getIdentifierPropertyName()`	Get the name of the identifier property (or return null) - need not return the name of an actual Java property
`EntityTableMapping`	`getIdentifierTableMapping()`	The descriptor for the table containing the identifier for the target
`String`	`getIdentifierTableName()`	The name of the table defining the identifier for this target
`Type`	`getIdentifierType()`	Get the identifier type
`InsertGeneratedIdentifierDelegate`	`getIdentityInsertDelegate()`	The delegate for executing inserts against the root table for targets defined using post-insert id generation
`String`	`getIdentitySelectString()`	Get the database-specific SQL command to retrieve the last generated IDENTITY value.
`InsertCoordinator`	`getInsertCoordinator()`
`GeneratedValuesProcessor`	`getInsertGeneratedValuesProcessor()`
`BytecodeEnhancementMetadata`	`getInstrumentationMetadata()`
`JdbcMapping`	`getJdbcMapping(int index)`
`int`	`getJdbcTypeCount()`	The number of JDBC mappings
`String[]`	`getKeyColumnNames()`	The columns to join on
`abstract String[]`	`getKeyColumns(int j)`
`Fetchable`	`getKeyFetchable(int position)`
`protected Map<String,SingleIdArrayLoadPlan>`	`getLazyLoadPlanByFetchGroup()`
`protected String[][]`	`getLazyPropertyColumnAliases()`	Deprecated. Hibernate no longer uses aliases to read from result sets
`Class<?>`	`getMappedClass()`	The persistent class, or null
`JavaType<?>`	`getMappedJavaType()`	The descriptor descriptor for the mapped Java type
`String`	`getMappedSuperclass()`	Get the name of the entity that is the "super class" for this entity
`UpdateCoordinator`	`getMergeCoordinator()`
`MultiNaturalIdLoader<?>`	`getMultiNaturalIdLoader()`	Access to performing multi-value natural-id database selection.
`String`	`getName()`	An identifying name; a class name or collection role name.
`NaturalIdDataAccess`	`getNaturalIdCacheAccessStrategy()`	Get the NaturalId cache (optional operation)
`int[]`	`getNaturalIdentifierProperties()`	If the entity defines a natural id, that is, if `EntityPersister.hasNaturalIdentifier()` returns `true`, the indices of the properties which make up the natural id.
`Object`	`getNaturalIdentifierSnapshot(Object id, SharedSessionContractImplementor session)`	Retrieve the current state of the natural-id properties from the database.
`NaturalIdLoader<?>`	`getNaturalIdLoader()`	Access to performing natural-id database selection.
`NaturalIdMapping`	`getNaturalIdMapping()`	The mapping for the natural-id of the entity, if one is defined
`NavigableRole`	`getNavigableRole()`	The model role of this target
`boolean[]`	`getNonLazyPropertyUpdateability()`
`int`	`getNumberOfAttributeMappings()`	The total number of attributes for this entity, including those declared on supertype mappings
`int`	`getNumberOfDeclaredAttributeMappings()`	Get the number of attributes defined on this entity mapping - do not access attributes defined on the super
`int`	`getNumberOfFetchableKeys()`	The number of fetchables in the container
`int`	`getNumberOfFetchables()`	The number of fetchables in the container
`int`	`getNumberOfKeyFetchables()`	The number of key fetchables in the container
`String`	`getPartName()`	The local part name, which is generally the unqualified role name
`EntityTableMapping`	`getPhysicalTableMappingForMutation(SelectableMapping selectableMapping)`
`String[]`	`getPropertyAliases(String suffix, int i)`	Get the result set aliases used for the property columns, given a suffix (properties of this class, only).
`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[][]`	`getPropertyColumnInsertable()`	For Hibernate Reactive
`String[]`	`getPropertyColumnNames(int i)`	Get the result set column names mapped for this property (properties of this class, only).
`String[]`	`getPropertyColumnNames(String propertyName)`	Get the column names for the given property path
`int`	`getPropertyColumnSpan(int i)`
`boolean[][]`	`getPropertyColumnUpdateable()`	For Hibernate Reactive
`String[]`	`getPropertyColumnWriters(int i)`
`int`	`getPropertyIndex(String propertyName)`	Get the property number of the unique key property
`boolean[]`	`getPropertyInsertability()`	Get the "insertability" of the properties of this class (does the property appear in an SQL INSERT)
`boolean[]`	`getPropertyLaziness()`	Get the "laziness" of the properties of this class
`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
`int`	`getPropertySpan()`
`String`	`getPropertyTableName(String propertyName)`	Get the table name for the given property path
`protected abstract int[]`	`getPropertyTableNumbers()`
`Type`	`getPropertyType(String propertyName)`	Deprecated. by the supertypes
`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)
`boolean[]`	`getPropertyUpdateability(Object entity)`	Which properties appear in the SQL update? (Initialized, updateable ones!)
`Object`	`getPropertyValue(Object object, int i)`
`Object`	`getPropertyValue(Object object, String propertyName)`	Get the value of a particular property
`Object[]`	`getPropertyValues(Object object)`	Extract the property values from the given entity.
`Object[]`	`getPropertyValuesToInsert(Object entity, Map<Object,Object> 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)
`protected String`	`getPrunedDiscriminatorPredicate(Map<String,EntityNameUse> entityNameUses, MappingMetamodelImplementor mappingMetamodel, String alias)`
`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.
`EntityRepresentationStrategy`	`getRepresentationStrategy()`	Describes how the entity is represented in the application's domain model.
`String`	`getRootEntityName()`	Returns an object that identifies the space in which identifiers of this entity hierarchy are unique.
`String`	`getRootTableAlias(String drivingAlias)`	Get the SQL alias this persister would use for the root table given the passed driving alias.
`String[]`	`getRootTableIdentifierColumnNames()`	Get the names of columns on the root table used to persist the identifier.
`String[]`	`getRootTableKeyColumnNames()`	The names of the primary key columns in the root table.
`String`	`getRootTableName()`	Locks are always applied to the "root table".
`EntityRowIdMapping`	`getRowIdMapping()`	The mapping for the row-id of the entity, if one is defined.
`String`	`getSelectByUniqueKeyString(String propertyName)`	Get a SQL select string that performs a select based on a unique key determined by the given property name.
`String`	`getSelectByUniqueKeyString(String[] propertyNames)`	Get a SQL select string that performs a select based on a unique key determined by the given property names.
`SingleIdEntityLoader<?>`	`getSingleIdLoader()`
`SoftDeleteMapping`	`getSoftDeleteMapping()`	Mapping for soft-delete support, or `null` if soft-delete not defined
`TableDetails`	`getSoftDeleteTableDetails()`
`String`	`getSqlAliasStem()`	Get the "stem" used as the base for generating SQL table aliases for table references that are part of the TableGroup being generated
`@Remove String[]`	`getSQLDeleteStrings()`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used.
`@Remove String[]`	`getSQLUpdateStrings()`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used.
`protected String`	`getSqlWhereStringTableExpression()`
`SqmMultiTableInsertStrategy`	`getSqmMultiTableInsertStrategy()`
`SqmMultiTableMutationStrategy`	`getSqmMultiTableMutationStrategy()`	The strategy to use for SQM mutation statements where the target entity has multiple tables.
`protected int`	`getStateArrayInitialPosition(MappingModelCreationProcess creationProcess)`
`protected AttributeMappingsList`	`getStaticFetchableList()`
`abstract Map<Object,String>`	`getSubclassByDiscriminatorValue()`
`protected String[]`	`getSubclassColumnAliasClosure()`	Deprecated. Hibernate no longer uses aliases to read from result sets
`EntityPersister`	`getSubclassEntityPersister(Object instance, SessionFactoryImplementor factory)`	Obtain the `EntityPersister` for the concrete class of the given entity instance which participates in a mapped inheritance hierarchy with this persister.
`protected String[]`	`getSubclassFormulaAliasClosure()`	Deprecated. Hibernate no longer uses aliases to read from result sets
`String[]`	`getSubclassPropertyColumnAliases(String propertyName, String suffix)`	Deprecated. Hibernate no longer uses aliases to read from result sets
`protected String[][]`	`getSubclassPropertyColumnNameClosure()`
`String[]`	`getSubclassPropertyColumnNames(int i)`	Return the column names used to persist the numbered property of the class or a subclass.
`String[]`	`getSubclassPropertyColumnNames(String propertyName)`	Return the column names used to persist/query the named property of the class or a subclass (optional operation).
`String[][]`	`getSubclassPropertyColumnReaderClosure()`
`String[][]`	`getSubclassPropertyColumnReaderTemplateClosure()`
`Queryable.Declarer`	`getSubclassPropertyDeclarer(String propertyPath)`	Determine whether the given property is declared by our mapped class, our super class, or one of our subclasses...
`String[][]`	`getSubclassPropertyFormulaTemplateClosure()`
`String`	`getSubclassPropertyName(int i)`	Get the name of the numbered property of the class or a subclass.
`protected String[]`	`getSubclassPropertyNameClosure()`
`protected abstract int`	`getSubclassPropertyTableNumber(int i)`
`int`	`getSubclassPropertyTableNumber(String propertyPath)`	Warning: When there are duplicated property names in the subclasses of the class, this method may return the wrong table number for the duplicated subclass property (note that SingleTableEntityPersister defines an overloaded form which takes the entity name.
`Type`	`getSubclassPropertyType(int i)`	Get the type of the numbered property of the class or a subclass.
`protected Type[]`	`getSubclassPropertyTypeClosure()`
`protected abstract String[]`	`getSubclassTableKeyColumns(int j)`
`abstract String`	`getSubclassTableName(int j)`	Get the name of the table with the given index from the internal array.
`protected abstract String[]`	`getSubclassTableNames()`
`abstract int`	`getSubclassTableSpan()`
`Collection<EntityMappingType>`	`getSubMappingTypes()`	Retrieve mappings for all subtypes
`EntityMappingType`	`getSuperMappingType()`	The mapping for the entity which is the supertype for this entity mapping.
`String`	`getTableAliasForColumn(String columnName, String rootAlias)`	Given a column name and the root table alias in use for the entity hierarchy, determine the proper table alias for the table in that hierarchy that contains said column.
`protected boolean[]`	`getTableHasColumns()`
`static int`	`getTableId(String tableName, String[] tables)`
`EntityTableMapping`	`getTableMapping(int i)`
`protected EntityTableMapping[]`	`getTableMappings()`
`int`	`getTableMappingsCount()`	Deprecated, for removal: This API element is subject to removal in a future version. this method is no longer used
`abstract String`	`getTableName(int j)`	Deprecated. Only ever used from places where we really want to use `SelectStatement` (select generator) `InsertSelectStatement` `UpdateStatement` `DeleteStatement`
`String[]`	`getTableNames()`
`abstract int`	`getTableSpan()`
`@org.hibernate.Remove boolean[]`	`getTableUpdateNeeded(int[] dirtyProperties, boolean hasDirtyCollection)`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used.
`EntityMappingType`	`getTargetPart()`	The ModelPart describing the mutation target
`Type`	`getType()`	Get the type
`DiscriminatorMetadata`	`getTypeDiscriminatorMetadata()`	Retrieve the information needed to properly deal with this entity's discriminator in a query.
`protected SingleUniqueKeyEntityLoader<?>`	`getUniqueKeyLoader(String attributeName)`
`UpdateCoordinator`	`getUpdateCoordinator()`
`GeneratedValuesProcessor`	`getUpdateGeneratedValuesProcessor()`
`Object`	`getVersion(Object object)`	Get the version number (or timestamp) from the object's version property.
`String`	`getVersionColumnName()`	For versioned entities, get the name of the column (again, expected on the root table) used to store the version values.
`String`	`getVersionedTableName()`
`BeforeExecutionGenerator`	`getVersionGenerator()`
`EntityVersionMapping`	`getVersionMapping()`	Mapping details for the entity's version when using the version strategy.
`int`	`getVersionProperty()`	If `EntityPersister.isVersioned()`, then what is the index of the property holding the locking value.
`String`	`getVersionSelectString()`
`BasicType<?>`	`getVersionType()`	If `EntityPersister.isVersioned()`, then what is the type of the property holding the locking value.
`protected boolean`	`hasAnySkippableTables(boolean[] optionalTables, boolean[] inverseTables)`
`boolean`	`hasCache()`	Does this class have a cache.
`boolean`	`hasCascadeDelete()`	Determine whether this entity has any delete cascading.
`boolean`	`hasCascades()`	Determine whether this entity has any (non-none) cascading.
`boolean`	`hasCollectionNotReferencingPK()`	Determine whether this entity contains references to persistent collections not referencing the primary key.
`boolean`	`hasCollections()`	Determine whether this entity contains references to persistent collections.
`abstract boolean`	`hasDuplicateTables()`
`boolean`	`hasFormulaProperties()`
`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`	`hasLazyDirtyFields(int[] dirtyFields)`
`boolean`	`hasLazyProperties()`	Determine whether this entity defines any lazy properties (when bytecode instrumentation is enabled).
`protected boolean`	`hasMultipleTables()`
`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`	`hasOwnedCollections()`	Determine whether this entity has any owned collections.
`boolean`	`hasPartitionedSelectionMapping()`
`boolean`	`hasProxy()`	Determine whether this entity supports dynamic proxies.
`boolean`	`hasRowId()`	Does the result set contain rowids?
`boolean`	`hasSkippableTables()`	Whether this target defines any potentially skippable tables.
`boolean`	`hasSubclasses()`	Whether this entity mapping has any subtype mappings
`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`	`hasWhereRestrictions()`	Does this restrictable have a where restriction?
`boolean`	`implementsLifecycle()`	Does the class implement the `Lifecycle` interface?
`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.
`protected Object`	`initializeLazyPropertiesFromCache(String fieldName, Object entity, SharedSessionContractImplementor session, EntityEntry entry, CacheEntry cacheEntry)`
`protected Object`	`initializeLazyPropertiesFromDatastore(Object entity, Object id, EntityEntry entry, String fieldName, SharedSessionContractImplementor session)`
`protected boolean`	`initializeLazyProperty(String fieldName, Object entity, EntityEntry entry, int index, Object propValue)`	Called by Hibernate Reactive
`Object`	`initializeLazyProperty(String fieldName, Object entity, SharedSessionContractImplementor session)`	Initialize the property, and return its new value.
`protected void`	`initPropertyPaths(Metadata mapping)`
`protected void`	`initSubclassPropertyAliasesMap(PersistentClass model)`	Deprecated. Hibernate no longer uses aliases to read from result sets
`Object`	`insert(Object[] fields, Object object, SharedSessionContractImplementor session)`	Persist an instance, using a natively generated identifier (optional operation)
`void`	`insert(Object id, Object[] fields, Object object, SharedSessionContractImplementor session)`	Persist an instance
`Object`	`instantiate(Object id, SharedSessionContractImplementor session)`	Create a class instance initialized with the given identifier
`protected static SqmMultiTableInsertStrategy`	`interpretSqmMultiTableInsertStrategy(AbstractEntityPersister entityMappingDescriptor, MappingModelCreationProcess creationProcess)`
`protected static SqmMultiTableMutationStrategy`	`interpretSqmMultiTableStrategy(AbstractEntityPersister entityMappingDescriptor, MappingModelCreationProcess creationProcess)`
`boolean`	`isAbstract()`	Whether this entity is defined as abstract using the Java `abstract` keyword
`boolean`	`isAffectedByEnabledFetchProfiles(LoadQueryInfluencers loadQueryInfluencers)`	Whether any of the LoadQueryInfluencers.getEnabledFetchProfileNames() apply to this loadable
`boolean`	`isAffectedByEnabledFilters(LoadQueryInfluencers loadQueryInfluencers)`	Whether any of the "influencers" affect this loadable.
`boolean`	`isAffectedByEntityGraph(LoadQueryInfluencers loadQueryInfluencers)`	Whether the effective entity-graph applies to this loadable
`@org.hibernate.Remove boolean`	`isAllNull(Object[] array, int tableNumber)`	Deprecated, for removal: This API element is subject to removal in a future version.
`protected boolean`	`isAllOrDirtyOptLocking()`	Deprecated, for removal: This API element is subject to removal in a future version. this method is no longer used
`@org.hibernate.Remove boolean`	`isBatchable()`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used.
`boolean`	`isBatchLoadable()`	Is batch loading enabled?
`boolean`	`isCacheInvalidationRequired()`	We can't immediately add to the cache if we have formulas which must be evaluated, or if we have the possibility of two concurrent updates to the same item being merged on the database.
`protected boolean`	`isClassOrSuperclassJoin(int j)`
`protected abstract boolean`	`isClassOrSuperclassTable(int j)`
`boolean`	`isCollection()`	Is this instance actually a CollectionPersister?
`boolean`	`isDefinedOnSubclass(int i)`	Is this property defined on a subclass of the mapped class.
`boolean`	`isDeleteCallable(int j)`	Deprecated, for removal: This API element is subject to removal in a future version. With no replacement
`protected boolean`	`isDiscriminatorFormula()`
`boolean`	`isExplicitPolymorphism()`	Is this class explicit polymorphism only?
`boolean`	`isIdentifierAssignedByInsert()`	Are identifiers of this entity assigned known before the insert execution? Or, are they generated (in the database) by the insert execution.
`protected abstract boolean`	`isIdentifierTable(String tableExpression)`
`boolean`	`isInherited()`	Determine whether the entity is inherited one or more other entities.
`boolean`	`isInsertCallable(int j)`	Deprecated, for removal: This API element is subject to removal in a future version. With no replacement
`boolean`	`isInstance(Object object)`	Is the given object an instance of this entity?
`boolean`	`isInstrumented()`	Has the class actually been bytecode instrumented?
`protected @org.hibernate.Remove boolean`	`isInverseSubclassTable(int j)`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used
`boolean`	`isInverseTable(int j)`
`boolean`	`isLazyPropertiesCacheable()`	Should lazy properties of this entity be cached?
`boolean`	`isMultiTable()`	Deprecated.
`boolean`	`isMutable()`	Determine whether instances of this entity are considered mutable.
`protected boolean`	`isNullableSubclassTable(int j)`
`boolean`	`isNullableTable(int j)`
`protected boolean`	`isPhysicalDiscriminator()`
`boolean`	`isPolymorphic()`
`abstract boolean`	`isPropertyOfTable(int property, int j)`
`boolean`	`isPropertySelectable(int propertyNumber)`
`boolean`	`isSelectable(FetchParent fetchParent, Fetchable fetchable)`	Deprecated. use `Fetchable.isSelectable()` instead.
`boolean`	`isSelectBeforeUpdateRequired()`	Is select snapshot before update enabled?
`boolean`	`isSharedColumn(String columnExpression)`
`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`	`isSubclassPropertyNullable(int i)`	Is the numbered property of the class of subclass nullable?
`protected boolean`	`isSubclassTableIndicatedByTreatAsDeclarations(int subclassTableNumber, Set<String> treatAsDeclarations)`
`protected boolean`	`isSubclassTableSequentialSelect(int j)`	Deprecated, for removal: This API element is subject to removal in a future version. With no replacement
`abstract @org.hibernate.Remove boolean`	`isTableCascadeDeleteEnabled(int j)`	Deprecated, for removal: This API element is subject to removal in a future version. No longer used
`Boolean`	`isTransient(Object entity, SharedSessionContractImplementor session)`	Is this a new transient instance?
`boolean`	`isTypeOrSuperType(EntityMappingType targetType)`	Whether the passed entity mapping is the same as or is a supertype of this entity mapping
`boolean`	`isUpdateCallable(int j)`	Deprecated, for removal: This API element is subject to removal in a future version. With no replacement
`boolean`	`isVersioned()`	Determine whether optimistic locking by column is enabled for this entity.
`boolean`	`isVersionGeneratedBeforeExecution()`
`boolean`	`isVersionGeneratedOnExecution()`
`boolean`	`isVersionPropertyGenerated()`	Does this entity contain a version property that is defined to be database generated?
`boolean`	`isVersionPropertyInsertable()`	Is the version property included in insert statements?
`protected void`	`linkToSession(Object entity, SharedSessionContractImplementor session)`
`void`	`linkWithSubType(EntityMappingType sub, MappingModelCreationProcess creationProcess)`	Called from `InFlightEntityMappingType.linkWithSuperType(org.hibernate.metamodel.mapping.internal.MappingModelCreationProcess)`.
`void`	`linkWithSuperType(MappingModelCreationProcess creationProcess)`	Link an entity type with its super-type, if one.
`Object`	`load(Object id, Object optionalObject, LockMode lockMode, SharedSessionContractImplementor session)`	Load an instance using either the `forUpdateLoader` or the outer joining `loader`, depending upon the value of the `lock` parameter
`Object`	`load(Object id, Object optionalObject, LockOptions lockOptions, SharedSessionContractImplementor session)`	Load an instance using either the `forUpdateLoader` or the outer joining `loader`, depending upon the value of the `lock` parameter
`Object`	`load(Object id, Object optionalObject, LockOptions lockOptions, SharedSessionContractImplementor session, Boolean readOnly)`
`Object`	`loadByUniqueKey(String propertyName, Object uniqueKey, Boolean readOnly, SharedSessionContractImplementor session)`
`Object`	`loadByUniqueKey(String propertyName, Object uniqueKey, SharedSessionContractImplementor session)`	Load an instance of the persistent class, by a unique key other than the primary key.
`Object`	`loadEntityIdByNaturalId(Object[] naturalIdValues, LockOptions lockOptions, SharedSessionContractImplementor session)`	Load the id for the entity based on the natural id.
`void`	`lock(Object id, Object version, Object object, LockMode lockMode, EventSource session)`	Do a version check (optional operation)
`void`	`lock(Object id, Object version, Object object, LockOptions lockOptions, EventSource session)`	Do a version check (optional operation)
`protected void`	`logStaticSQL()`
`void`	`merge(Object id, Object[] values, int[] dirtyAttributeIndexes, boolean hasDirtyCollection, Object[] oldValues, Object oldVersion, Object object, Object rowId, SharedSessionContractImplementor session)`	Merge an object
`List<?>`	`multiLoad(Object[] ids, EventSource session, MultiIdLoadOptions loadOptions)`	Performs a load of multiple entities (of this type) by identifier simultaneously.
`abstract boolean`	`needsDiscriminator()`
`OptimisticLockStyle`	`optimisticLockStyle()`	The type of optimistic locking, if any, defined for this entity mapping
`String`	`physicalTableNameForMutation(SelectableMapping selectableMapping)`	Unfortunately we cannot directly use `SelectableMapping#getContainingTableExpression()` as that blows up for attributes declared on super-type for union-subclass mappings
`protected void`	`postConstruct(Metadata mapping)`	Post-construct is a callback for AbstractEntityPersister subclasses to call after they are all done with their constructor processing.
`void`	`postInstantiate()`	Finish the initialization of this object.
`void`	`prepareLoaders()`	Prepare loaders associated with the persister.
`void`	`prepareMappingModel(MappingModelCreationProcess creationProcess)`	After all hierarchy types have been linked, this method is called to allow the mapping model to be prepared which generally includes creating attribute mapping descriptors, identifier mapping descriptor, etc.
`void`	`processInsertGeneratedProperties(Object 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(Object 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`	`registerAffectingFetchProfile(String fetchProfileName)`	Register the profile name with the entity/collection
`void`	`resetIdentifier(Object entity, Object currentId, Object currentVersion, SharedSessionContractImplementor session)`	Set the identifier and version of the given instance back to its "unsaved" value, that is, the value it had before it was made persistent.
`int[]`	`resolveAttributeIndexes(String[] attributeNames)`	Converts an array of attribute names to a set of indexes, according to the entity metamodel
`int[]`	`resolveDirtyAttributeIndexes(Object[] currentState, Object[] previousState, String[] attributeNames, SessionImplementor session)`	Like `EntityPersister.resolveAttributeIndexes(String[])` but also always returns mutable attributes
`protected DiscriminatorType`	`resolveDiscriminatorType()`
`String`	`selectFragment(String alias, String suffix)`	Generate a list of collection index, key and element columns
`void`	`setIdentifier(Object entity, Object 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 of the given instance.
`void`	`setPropertyValue(Object object, String propertyName, Object value)`	Set the value of a particular (named) property
`void`	`setPropertyValues(Object object, Object[] values)`	Set the given values to the mapped properties of the given object.
`protected boolean`	`shouldGetAllProperties(Object entity)`
`protected boolean`	`shouldInnerJoinSubclassTable(int subclassTableNumber, Set<String> treatAsDeclarations)`
`protected boolean`	`shouldProcessSuperMapping()`
`protected String`	`substituteBrackets(String sql)`
`String[]`	`toColumns(String propertyName)`	Given a property path, return the corresponding column name(s).
`String[]`	`toColumns(String name, int i)`	Given the number of a property of a subclass, and a table alias, return the aliased column names.
`String`	`toString()`
`Type`	`toType(String propertyName)`	Given a component path expression, get the type of the property
`Iterable<UniqueKeyEntry>`	`uniqueKeyEntries()`
`void`	`update(Object id, Object[] values, int[] dirtyAttributeIndexes, boolean hasDirtyCollection, Object[] oldValues, Object oldVersion, Object object, Object rowId, SharedSessionContractImplementor session)`	Update an object
`protected void`	`verifyHasNaturalId()`
`void`	`visitAttributeMappings(Consumer<? super AttributeMapping> action, EntityMappingType targetType)`	Visit the mappings, but limited to just attributes defined in the targetType or its super-type(s) if any.
`void`	`visitDeclaredAttributeMappings(Consumer<? super AttributeMapping> action)`	Visit attributes defined on this class - do not visit attributes defined on the super
`void`	`visitFetchables(Consumer<? super Fetchable> fetchableConsumer, EntityMappingType treatTargetType)`
`void`	`visitFetchables(IndexedConsumer<? super Fetchable> fetchableConsumer, EntityMappingType treatTargetType)`
`void`	`visitKeyFetchables(Consumer<? super Fetchable> fetchableConsumer, EntityMappingType treatTargetType)`
`void`	`visitKeyFetchables(IndexedConsumer<? super Fetchable> fetchableConsumer, EntityMappingType treatTargetType)`
`protected abstract void`	`visitMutabilityOrderedTables(org.hibernate.persister.entity.AbstractEntityPersister.MutabilityOrderedTableConsumer consumer)`	Visit details about each table for this entity, using "mutability ordering".
`void`	`visitSubParts(Consumer<ModelPart> consumer, EntityMappingType treatTargetType)`
`void`	`visitSubTypeAttributeMappings(Consumer<? super AttributeMapping> action)`	Walk this type's attributes as well as its sub-type's
`void`	`visitSuperTypeAttributeMappings(Consumer<? super AttributeMapping> action)`	Walk this type's attributes as well as its super-type's

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

Methods inherited from interface org.hibernate.metamodel.mapping.Bindable
forEachDisassembledJdbcValue, forEachDisassembledJdbcValue, forEachDisassembledJdbcValue, forEachJdbcType, forEachJdbcValue, forEachJdbcValue, forEachJdbcValue

Methods inherited from interface org.hibernate.metadata.ClassMetadata
getIdentifier, getIdentifier, getPropertyValuesToInsert, instantiate, setIdentifier

Methods inherited from interface org.hibernate.metamodel.mapping.EntityMappingType
asEntityMappingType, extractConcreteTypeStateValues, findContainingEntityMapping, findSubPart, getContributor, getIdentifierTableDetails, getJavaType, getMappedTableDetails, getPartMappingType, getRootEntityDescriptor, getRootPathName, getSubclassEntityNames, getSubclassId, isTypeOrSuperType, pruneForSubclasses, pruneForSubclasses, visitConstraintOrderedTables

Methods inherited from interface org.hibernate.persister.entity.EntityPersister
addToCacheKey, breakDownJdbcValues, canExtractIdOutOfEntity, getEntityMappingType, getFilterAliasGenerator, getFilterAliasGenerator, getPropertySpaces, getSynchronizationSpaces, getSynchronizedQuerySpaces, getValue, getValues, getVersionJavaType, load, setValue, setValues, visitQuerySpaces

Methods inherited from interface org.hibernate.metamodel.mapping.EntityValuedModelPart
forEachSubPart

Methods inherited from interface org.hibernate.sql.results.graph.FetchableContainer
getSelectableIndex, visitFetchables, visitKeyFetchables

Methods inherited from interface org.hibernate.metamodel.mapping.JdbcMappingContainer
getSingleJdbcMapping

Methods inherited from interface org.hibernate.persister.entity.Joinable
getTableName

Methods inherited from interface org.hibernate.loader.ast.spi.Loadable
isAffectedByInfluencers, isNotAffectedByInfluencers

Methods inherited from interface org.hibernate.persister.entity.Loadable
getDiscriminatorValue, getSubclassForDiscriminatorValue

Methods inherited from interface org.hibernate.metamodel.mapping.ManagedMappingType
anyRequiresAggregateColumnWriter

Methods inherited from interface org.hibernate.metamodel.mapping.ModelPart
areEqual, asAttributeMapping, breakDownJdbcValues, decompose, decompose, forEachSelectable, isEntityIdentifierMapping, isVirtual

Methods inherited from interface org.hibernate.metamodel.mapping.ModelPartContainer
findByPath, findByPath, forEachSubPart

Methods inherited from interface org.hibernate.sql.model.MutationTarget
getRolePath

Methods inherited from interface org.hibernate.persister.entity.OuterJoinLoadable
fromTableFragment, getAttributeMutationTableName, getSubclassPropertyTableName

Methods inherited from interface org.hibernate.persister.entity.Queryable
getConstraintOrderedTableNameClosure, getContraintOrderedTableKeyColumnClosure, getDiscriminatorSQLValue

- Field Detail
  - ENTITY_CLASS
```
public static final String ENTITY_CLASS
```
    See Also:
    
    Constant Field Values
  - VERSION_COLUMN_ALIAS
```
public static final String VERSION_COLUMN_ALIAS
```
    See Also:
    
    Constant Field Values
  - batchSize
```
protected final int batchSize
```
  - rowIdName
```
protected final String rowIdName
```
  - declaredAttributeMappings
```
protected AttributeMappingsMap declaredAttributeMappings
```
  - staticFetchableList
```
protected AttributeMappingsList staticFetchableList
```
  - accessOptimizer
```
protected ReflectionOptimizer.AccessOptimizer accessOptimizer
```
  - fullDiscriminatorSQLValues
```
protected final String[] fullDiscriminatorSQLValues
```
  - propertyMapping
```
protected final BasicEntityPropertyMapping propertyMapping
```
    Warning: When there are duplicated property names in the subclasses then propertyMapping will only contain one of those properties. To ensure correct results, propertyMapping should only be used for the concrete EntityPersister (since the concrete EntityPersister cannot have duplicated property names).
  - insertExpectations
```
@Deprecated
protected Expectation[] insertExpectations
```
    Deprecated.
  - updateExpectations
```
@Deprecated
protected Expectation[] updateExpectations
```
    Deprecated.
  - deleteExpectations
```
@Deprecated
protected Expectation[] deleteExpectations
```
    Deprecated.
  - insertCallable
```
@Deprecated
protected boolean[] insertCallable
```
    Deprecated.
  - updateCallable
```
@Deprecated
protected boolean[] updateCallable
```
    Deprecated.
  - deleteCallable
```
@Deprecated
protected boolean[] deleteCallable
```
    Deprecated.
  - customSQLInsert
```
@Deprecated
protected String[] customSQLInsert
```
    Deprecated.
  - customSQLUpdate
```
@Deprecated
protected String[] customSQLUpdate
```
    Deprecated.
  - customSQLDelete
```
@Deprecated
protected String[] customSQLDelete
```
    Deprecated.
- Constructor Detail
  - AbstractEntityPersister
```
@Deprecated(since="6.0")
public AbstractEntityPersister(PersistentClass persistentClass,
                               EntityDataAccess cacheAccessStrategy,
                               NaturalIdDataAccess naturalIdRegionAccessStrategy,
                               PersisterCreationContext creationContext)
                        throws HibernateException
```
    Deprecated.
    
    Throws:
    
    HibernateException
  - AbstractEntityPersister
```
public AbstractEntityPersister(PersistentClass persistentClass,
                               EntityDataAccess cacheAccessStrategy,
                               NaturalIdDataAccess naturalIdRegionAccessStrategy,
                               RuntimeModelCreationContext creationContext)
                        throws HibernateException
```
    Throws:
    
    HibernateException
- Method Detail
  - buildSingleIdEntityLoader
```
protected SingleIdEntityLoader<?> buildSingleIdEntityLoader()
```
    For Hibernate Reactive
  - getEntityNameByTableNameMap
```
public static Map<String,String> getEntityNameByTableNameMap(PersistentClass persistentClass,
                                                                   SqlStringGenerationContext stringGenerationContext)
```
  - buildMultiIdLoader
```
protected MultiIdEntityLoader<Object> buildMultiIdLoader()
```
  - getSubclassTableName
```
public abstract String getSubclassTableName(int j)
```
    Description copied from interface: Queryable
    
    Get the name of the table with the given index from the internal array.
    
    Specified by:
    
    getSubclassTableName in interface Queryable
    
    Parameters:
    
    j - The index into the internal array.
  - getSubclassTableNames
```
protected abstract String[] getSubclassTableNames()
```
  - getSubclassTableKeyColumns
```
protected abstract String[] getSubclassTableKeyColumns(int j)
```
  - isClassOrSuperclassTable
```
protected abstract boolean isClassOrSuperclassTable(int j)
```
  - isClassOrSuperclassJoin
```
protected boolean isClassOrSuperclassJoin(int j)
```
  - getSubclassTableSpan
```
public abstract int getSubclassTableSpan()
```
  - getTableSpan
```
public abstract int getTableSpan()
```
  - hasDuplicateTables
```
public abstract boolean hasDuplicateTables()
```
  - getTableName
```
@Deprecated(since="6.2")
public abstract String getTableName(int j)
```
    Deprecated.
    Only ever used from places where we really want to use
    
    SelectStatement (select generator)
    
    InsertSelectStatement
    
    UpdateStatement
    
    DeleteStatement
  - getKeyColumns
```
public abstract String[] getKeyColumns(int j)
```
  - isPropertyOfTable
```
public abstract boolean isPropertyOfTable(int property,
                                          int j)
```
  - getPropertyTableNumbers
```
protected abstract int[] getPropertyTableNumbers()
```
  - getSubclassPropertyTableNumber
```
protected abstract int getSubclassPropertyTableNumber(int i)
```
  - getDiscriminatorColumnName
```
public String getDiscriminatorColumnName()
```
    Specified by:
    
    getDiscriminatorColumnName in interface Loadable
    
    Returns:
    
    the column name for the discriminator as specified in the mapping.
  - getDiscriminatorColumnReaders
```
public String getDiscriminatorColumnReaders()
```
  - getDiscriminatorColumnReaderTemplate
```
public String getDiscriminatorColumnReaderTemplate()
```
  - getDiscriminatorFormulaTemplate
```
public String getDiscriminatorFormulaTemplate()
```
  - isInverseTable
```
public boolean isInverseTable(int j)
```
  - isNullableTable
```
public boolean isNullableTable(int j)
```
  - isNullableSubclassTable
```
protected boolean isNullableSubclassTable(int j)
```
  - isSubclassEntityName
```
public boolean isSubclassEntityName(String entityName)
```
    Description copied from interface: EntityPersister
    
    Determine whether the given name represents a subclass entity (or this entity itself) of the entity mapped by this persister.
    
    Specified by:
    
    isSubclassEntityName in interface EntityPersister
    
    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.
  - isSharedColumn
```
public boolean isSharedColumn(String columnExpression)
```
  - getTableHasColumns
```
protected boolean[] getTableHasColumns()
```
  - getRootTableKeyColumnNames
```
public String[] getRootTableKeyColumnNames()
```
    Description copied from interface: PostInsertIdentityPersister
    
    The names of the primary key columns in the root table.
    
    Specified by:
    
    getRootTableKeyColumnNames in interface PostInsertIdentityPersister
    
    Returns:
    
    The primary key column names.
  - getInsertCoordinator
```
@Internal
public InsertCoordinator getInsertCoordinator()
```
  - getUpdateCoordinator
```
@Internal
public UpdateCoordinator getUpdateCoordinator()
```
  - getDeleteCoordinator
```
@Internal
public DeleteCoordinator getDeleteCoordinator()
```
  - getMergeCoordinator
```
@Internal
public UpdateCoordinator getMergeCoordinator()
```
  - getVersionSelectString
```
public String getVersionSelectString()
```
  - getInsertGeneratedValuesProcessor
```
@Internal
public GeneratedValuesProcessor getInsertGeneratedValuesProcessor()
```
  - getUpdateGeneratedValuesProcessor
```
@Internal
public GeneratedValuesProcessor getUpdateGeneratedValuesProcessor()
```
  - hasRowId
```
public boolean hasRowId()
```
    Description copied from interface: Loadable
    
    Does the result set contain rowids?
    
    Specified by:
    
    hasRowId in interface Loadable
  - getPropertyColumnUpdateable
```
public boolean[][] getPropertyColumnUpdateable()
```
    For Hibernate Reactive
  - getPropertyColumnInsertable
```
public boolean[][] getPropertyColumnInsertable()
```
    For Hibernate Reactive
  - getTableNames
```
public String[] getTableNames()
```
  - buildCacheEntryHelper
```
protected AbstractEntityPersister.CacheEntryHelper buildCacheEntryHelper(SessionFactoryOptions options)
```
  - canUseReferenceCacheEntries
```
public boolean canUseReferenceCacheEntries()
```
    Specified by:
    
    canUseReferenceCacheEntries in interface EntityPersister
  - uniqueKeyEntries
```
public Iterable<UniqueKeyEntry> uniqueKeyEntries()
```
    Specified by:
    
    uniqueKeyEntries in interface EntityPersister
    
    Returns:
    
    Metadata for each unique key defined
  - getLazyLoadPlanByFetchGroup
```
protected Map<String,SingleIdArrayLoadPlan> getLazyLoadPlanByFetchGroup()
```
  - getSqlAliasStem
```
public String getSqlAliasStem()
```
    Description copied from interface: TableGroupProducer
    
    Get the "stem" used as the base for generating SQL table aliases for table references that are part of the TableGroup being generated
    Note that this is a metadata-ive value. It is only ever used internal to the producer producing its TableGroup.
    
    Specified by:
    
    getSqlAliasStem in interface EntityMappingType
    
    Specified by:
    
    getSqlAliasStem in interface EntityPersister
    
    Specified by:
    
    getSqlAliasStem in interface TableGroupProducer
    
    See Also:
    
    SqlAliasBaseManager.createSqlAliasBase(java.lang.String)
  - containsTableReference
```
public boolean containsTableReference(String tableExpression)
```
    Specified by:
    
    containsTableReference in interface TableGroupProducer
  - getPartName
```
public String getPartName()
```
    Description copied from interface: ModelPart
    
    The local part name, which is generally the unqualified role name
    
    Specified by:
    
    getPartName in interface EntityMappingType
    
    Specified by:
    
    getPartName in interface ModelPart
  - createDomainResult
```
public <T> DomainResult<T> createDomainResult(NavigablePath navigablePath,
                                              TableGroup tableGroup,
                                              String resultVariable,
                                              DomainResultCreationState creationState)
```
    Description copied from interface: ModelPart
    
    Create a DomainResult for a specific reference to this ModelPart.
    
    Specified by:
    
    createDomainResult in interface EntityValuedModelPart
    
    Specified by:
    
    createDomainResult in interface ModelPart
  - applySqlSelections
```
public void applySqlSelections(NavigablePath navigablePath,
                               TableGroup tableGroup,
                               DomainResultCreationState creationState)
```
    Description copied from interface: ModelPart
    
    Apply SQL selections for a specific reference to this ModelPart outside the domain query's root select clause.
    
    Specified by:
    
    applySqlSelections in interface EntityValuedModelPart
    
    Specified by:
    
    applySqlSelections in interface ModelPart
  - applySqlSelections
```
public void applySqlSelections(NavigablePath navigablePath,
                               TableGroup tableGroup,
                               DomainResultCreationState creationState,
                               BiConsumer<SqlSelection,JdbcMapping> selectionConsumer)
```
    Description copied from interface: ModelPart
    
    Apply SQL selections for a specific reference to this ModelPart outside the domain query's root select clause.
    
    Specified by:
    
    applySqlSelections in interface EntityValuedModelPart
    
    Specified by:
    
    applySqlSelections in interface ModelPart
  - getNaturalIdMapping
```
public NaturalIdMapping getNaturalIdMapping()
```
    Description copied from interface: EntityMappingType
    
    The mapping for the natural-id of the entity, if one is defined
    
    Specified by:
    
    getNaturalIdMapping in interface EntityMappingType
  - createPrimaryTableReference
```
public TableReference createPrimaryTableReference(SqlAliasBase sqlAliasBase,
                                                  SqlAstCreationState sqlAstCreationState)
```
    Specified by:
    
    createPrimaryTableReference in interface EntityMappingType
  - createTableReferenceJoin
```
public TableReferenceJoin createTableReferenceJoin(String joinTableExpression,
                                                   SqlAliasBase sqlAliasBase,
                                                   TableReference lhs,
                                                   SqlAstCreationState creationState)
```
    Specified by:
    
    createTableReferenceJoin in interface EntityMappingType
  - generateTableReferenceJoin
```
protected TableReferenceJoin generateTableReferenceJoin(TableReference lhs,
                                                        String joinTableExpression,
                                                        SqlAliasBase sqlAliasBase,
                                                        boolean innerJoin,
                                                        String[] targetColumns,
                                                        SqlAstCreationState creationState)
```
  - generateJoinPredicate
```
protected Predicate generateJoinPredicate(TableReference rootTableReference,
                                          TableReference joinedTableReference,
                                          String[] pkColumnNames,
                                          String[] fkColumnNames,
                                          SqlAstCreationState creationState)
```
  - initializeLazyProperty
```
public Object initializeLazyProperty(String fieldName,
                                     Object entity,
                                     SharedSessionContractImplementor session)
```
    Description copied from interface: LazyPropertyInitializer
    
    Initialize the property, and return its new value.
    
    Specified by:
    
    initializeLazyProperty in interface LazyPropertyInitializer
    
    Parameters:
    
    fieldName - The name of the field being initialized
    
    entity - The entity on which the initialization is occurring
    
    session - The session from which the initialization originated.
    
    Returns:
    
    ?
  - getCollectionKey
```
public Object getCollectionKey(CollectionPersister persister,
                               Object owner,
                               EntityEntry ownerEntry,
                               SharedSessionContractImplementor session)
```
  - initializeLazyPropertiesFromDatastore
```
protected Object initializeLazyPropertiesFromDatastore(Object entity,
                                                       Object id,
                                                       EntityEntry entry,
                                                       String fieldName,
                                                       SharedSessionContractImplementor session)
```
  - initializeLazyPropertiesFromCache
```
protected Object initializeLazyPropertiesFromCache(String fieldName,
                                                   Object entity,
                                                   SharedSessionContractImplementor session,
                                                   EntityEntry entry,
                                                   CacheEntry cacheEntry)
```
  - initializeLazyProperty
```
protected boolean initializeLazyProperty(String fieldName,
                                         Object entity,
                                         EntityEntry entry,
                                         int index,
                                         Object propValue)
```
    Called by Hibernate Reactive
  - getNavigableRole
```
public NavigableRole getNavigableRole()
```
    Description copied from interface: MutationTarget
    
    The model role of this target
    
    Specified by:
    
    getNavigableRole in interface ModelPart
    
    Specified by:
    
    getNavigableRole in interface MutationTarget<EntityTableMapping>
    
    See Also:
    
    ModelPart.getPartName()
  - getQuerySpaces
```
public Serializable[] getQuerySpaces()
```
    Description copied from interface: EntityPersister
    
    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 EntityPersister.getPropertySpaces(), except that here we include subclass entity spaces.
    
    Specified by:
    
    getQuerySpaces in interface EntityPersister
    
    Returns:
    
    The query spaces.
  - isBatchLoadable
```
public boolean isBatchLoadable()
```
    Description copied from interface: EntityPersister
    
    Is batch loading enabled?
    
    Specified by:
    
    isBatchLoadable in interface EntityPersister
    
    See Also:
    
    LoadQueryInfluencers.effectivelyBatchLoadable(EntityPersister)
  - getBatchSize
```
public int getBatchSize()
```
    Description copied from interface: EntityPersister
    
    The batch size for batch loading.
    
    Specified by:
    
    getBatchSize in interface EntityPersister
    
    Specified by:
    
    getBatchSize in interface Loadable
    
    See Also:
    
    LoadQueryInfluencers.effectiveBatchSize(EntityPersister)
  - getIdentifierColumnNames
```
public String[] getIdentifierColumnNames()
```
    Description copied from interface: Loadable
    
    Get the names of columns used to persist the identifier
    
    Specified by:
    
    getIdentifierColumnNames in interface Loadable
    
    Specified by:
    
    getIdentifierColumnNames in interface PostInsertIdentityPersister
    
    Specified by:
    
    getIdentifierColumnNames in interface Queryable
  - getIdentifierColumnReaders
```
public String[] getIdentifierColumnReaders()
```
  - getIdentifierColumnReaderTemplates
```
public String[] getIdentifierColumnReaderTemplates()
```
  - getIdentifierColumnSpan
```
public int getIdentifierColumnSpan()
```
  - getIdentifierAliases
```
public String[] getIdentifierAliases()
```
  - getVersionColumnName
```
public String getVersionColumnName()
```
    Description copied from interface: Lockable
    
    For versioned entities, get the name of the column (again, expected on the root table) used to store the version values.
    
    Specified by:
    
    getVersionColumnName in interface Lockable
    
    Returns:
    
    The version column name.
  - getVersionedTableName
```
public String getVersionedTableName()
```
  - isCacheInvalidationRequired
```
public boolean isCacheInvalidationRequired()
```
    We can't immediately add to the cache if we have formulas which must be evaluated, or if we have the possibility of two concurrent updates to the same item being merged on the database. This second case can happen if:
    
    the item is not versioned, and either
    we have dynamic update enabled, or
    the state of the item spans multiple tables.
    Therefore, we're careful, and just invalidate the cache in these cases (the item will be readded when it's read again fresh from the database).
    Specified by:
    
    isCacheInvalidationRequired in interface EntityPersister
  - isLazyPropertiesCacheable
```
public boolean isLazyPropertiesCacheable()
```
    Description copied from interface: EntityPersister
    
    Should lazy properties of this entity be cached?
    
    Specified by:
    
    isLazyPropertiesCacheable in interface EntityPersister
  - selectFragment
```
public String selectFragment(String alias,
                             String suffix)
```
    Description copied from interface: OuterJoinLoadable
    
    Generate a list of collection index, key and element columns
    
    Specified by:
    
    selectFragment in interface OuterJoinLoadable
    
    Specified by:
    
    selectFragment in interface SQLLoadable
  - isSelectable
```
@Deprecated
public boolean isSelectable(FetchParent fetchParent,
                            Fetchable fetchable)
```
    Deprecated.
    use Fetchable.isSelectable() instead.
  - getIdentifierAliases
```
public String[] getIdentifierAliases(String suffix)
```
    Description copied from interface: Loadable
    
    Get the result set aliases used for the identifier columns, given a suffix
    
    Specified by:
    
    getIdentifierAliases in interface Loadable
  - getPropertyAliases
```
public String[] getPropertyAliases(String suffix,
                                   int i)
```
    Description copied from interface: Loadable
    
    Get the result set aliases used for the property columns, given a suffix (properties of this class, only).
    
    Specified by:
    
    getPropertyAliases in interface Loadable
  - getDiscriminatorAlias
```
public String getDiscriminatorAlias(String suffix)
```
    Description copied from interface: Loadable
    
    Get the result set aliases used for the identifier columns, given a suffix
    
    Specified by:
    
    getDiscriminatorAlias in interface Loadable
  - getDatabaseSnapshot
```
public Object[] getDatabaseSnapshot(Object id,
                                    SharedSessionContractImplementor session)
                             throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Get the current database state of the object, in a "hydrated" form, without resolving identifiers.
    
    Specified by:
    
    getDatabaseSnapshot in interface EntityPersister
    
    Returns:
    
    null if there is no row in the database
    
    Throws:
    
    HibernateException
  - getIdByUniqueKey
```
public Object getIdByUniqueKey(Object key,
                               String uniquePropertyName,
                               SharedSessionContractImplementor session)
```
    Specified by:
    
    getIdByUniqueKey in interface EntityPersister
  - generateSelectVersionString
```
public String generateSelectVersionString()
```
    Generate the SQL that selects the version number by id
  - forceVersionIncrement
```
public Object forceVersionIncrement(Object id,
                                    Object currentVersion,
                                    SharedSessionContractImplementor session)
```
    Specified by:
    
    forceVersionIncrement in interface EntityPersister
  - forceVersionIncrement
```
public Object forceVersionIncrement(Object id,
                                    Object currentVersion,
                                    boolean batching,
                                    SharedSessionContractImplementor session)
                             throws HibernateException
```
    Specified by:
    
    forceVersionIncrement in interface EntityPersister
    
    Throws:
    
    HibernateException
  - getCurrentVersion
```
public Object getCurrentVersion(Object id,
                                SharedSessionContractImplementor session)
                         throws HibernateException
```
    Retrieve the version number
    
    Specified by:
    
    getCurrentVersion in interface EntityPersister
    
    Throws:
    
    HibernateException
  - getJdbcMapping
```
public JdbcMapping getJdbcMapping(int index)
```
    Specified by:
    
    getJdbcMapping in interface JdbcMappingContainer
  - generateLocker
```
protected LockingStrategy generateLocker(LockMode lockMode)
```
  - lock
```
public void lock(Object id,
                 Object version,
                 Object object,
                 LockMode lockMode,
                 EventSource session)
          throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Do a version check (optional operation)
    
    Specified by:
    
    lock in interface EntityPersister
    
    Throws:
    
    HibernateException
  - lock
```
public void lock(Object id,
                 Object version,
                 Object object,
                 LockOptions lockOptions,
                 EventSource session)
          throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Do a version check (optional operation)
    
    Specified by:
    
    lock in interface EntityPersister
    
    Throws:
    
    HibernateException
  - getRootTableName
```
public String getRootTableName()
```
    Description copied from interface: Lockable
    
    Locks are always applied to the "root table".
    
    Specified by:
    
    getRootTableName in interface Lockable
    
    Returns:
    
    The root table name
  - getRootTableAlias
```
public String getRootTableAlias(String drivingAlias)
```
    Description copied from interface: Lockable
    
    Get the SQL alias this persister would use for the root table given the passed driving alias.
    
    Specified by:
    
    getRootTableAlias in interface Lockable
    
    Parameters:
    
    drivingAlias - The driving alias; or the alias for the table mapped by this persister in the hierarchy.
    
    Returns:
    
    The root table alias.
  - getRootTableIdentifierColumnNames
```
public String[] getRootTableIdentifierColumnNames()
```
    Description copied from interface: Lockable
    
    Get the names of columns on the root table used to persist the identifier.
    
    Specified by:
    
    getRootTableIdentifierColumnNames in interface Lockable
    
    Returns:
    
    The root table identifier column names.
  - toColumns
```
public String[] toColumns(String propertyName)
                   throws QueryException
```
    Given a property path, return the corresponding column name(s). Warning: When there are duplicated property names in the subclasses then this method may return the wrong results. To ensure correct results, this method should only be used when this is the concrete EntityPersister (since the concrete EntityPersister cannot have duplicated property names).
    
    Specified by:
    
    toColumns in interface PropertyMapping
    
    Throws:
    
    QueryException
  - toType
```
public Type toType(String propertyName)
            throws QueryException
```
    Given a component path expression, get the type of the property Warning: When there are duplicated property names in the subclasses then this method may return the wrong results. To ensure correct results, this method should only be used when this is the concrete EntityPersister (since the concrete EntityPersister cannot have duplicated property names).
    
    Specified by:
    
    toType in interface PropertyMapping
    
    Throws:
    
    QueryException
  - getPropertyColumnNames
```
public String[] getPropertyColumnNames(String propertyName)
```
    Get the column names for the given property path Warning: When there are duplicated property names in the subclasses then this method may return the wrong results. To ensure correct results, this method should only be used when this is the concrete EntityPersister (since the concrete EntityPersister cannot have duplicated property names).
    
    Specified by:
    
    getPropertyColumnNames in interface OuterJoinLoadable
  - getSubclassPropertyTableNumber
```
public int getSubclassPropertyTableNumber(String propertyPath)
```
    Warning: When there are duplicated property names in the subclasses of the class, this method may return the wrong table number for the duplicated subclass property (note that SingleTableEntityPersister defines an overloaded form which takes the entity name.
    
    Specified by:
    
    getSubclassPropertyTableNumber in interface Queryable
    
    Parameters:
    
    propertyPath - The name of the property.
    
    Returns:
    
    The number of the table to which the property is mapped.
  - getSubclassPropertyDeclarer
```
public Queryable.Declarer getSubclassPropertyDeclarer(String propertyPath)
```
    Description copied from interface: Queryable
    
    Determine whether the given property is declared by our mapped class, our super class, or one of our subclasses...
    Note: the method is called 'subclass property...' simply for consistency sake (e.g. Queryable.getSubclassPropertyTableNumber(java.lang.String)
    
    Specified by:
    
    getSubclassPropertyDeclarer in interface Queryable
    
    Parameters:
    
    propertyPath - The property name.
    
    Returns:
    
    The property declarer
  - getPropertyTableName
```
public String getPropertyTableName(String propertyName)
```
    Description copied from interface: OuterJoinLoadable
    
    Get the table name for the given property path
    
    Specified by:
    
    getPropertyTableName in interface OuterJoinLoadable
  - resolveDiscriminatorType
```
protected DiscriminatorType resolveDiscriminatorType()
```
  - getTypeDiscriminatorMetadata
```
public DiscriminatorMetadata getTypeDiscriminatorMetadata()
```
    Description copied from interface: Queryable
    
    Retrieve the information needed to properly deal with this entity's discriminator in a query.
    
    Specified by:
    
    getTypeDiscriminatorMetadata in interface Queryable
    
    Returns:
    
    The entity discriminator metadata
  - generateTableAlias
```
public static String generateTableAlias(String rootAlias,
                                        int tableNumber)
```
  - toColumns
```
public String[] toColumns(String name,
                          int i)
```
    Description copied from interface: OuterJoinLoadable
    
    Given the number of a property of a subclass, and a table alias, return the aliased column names.
    
    Specified by:
    
    toColumns in interface OuterJoinLoadable
  - getPropertyColumnNames
```
public String[] getPropertyColumnNames(int i)
```
    Description copied from interface: Loadable
    
    Get the result set column names mapped for this property (properties of this class, only).
    
    Specified by:
    
    getPropertyColumnNames in interface Loadable
  - getPropertyColumnWriters
```
public String[] getPropertyColumnWriters(int i)
```
  - getPropertyColumnSpan
```
public int getPropertyColumnSpan(int i)
```
  - hasFormulaProperties
```
public boolean hasFormulaProperties()
```
  - getFetchMode
```
public FetchMode getFetchMode(int i)
```
    Description copied from interface: OuterJoinLoadable
    
    May this (subclass closure) property be fetched using an SQL outerjoin?
    
    Specified by:
    
    getFetchMode in interface OuterJoinLoadable
  - getCascadeStyle
```
public CascadeStyle getCascadeStyle(int i)
```
    Description copied from interface: OuterJoinLoadable
    
    Get the cascade style of this (subclass closure) property
    
    Specified by:
    
    getCascadeStyle in interface OuterJoinLoadable
  - getSubclassPropertyType
```
public Type getSubclassPropertyType(int i)
```
    Description copied from interface: OuterJoinLoadable
    
    Get the type of the numbered property of the class or a subclass.
    
    Specified by:
    
    getSubclassPropertyType in interface OuterJoinLoadable
  - getSubclassPropertyName
```
public String getSubclassPropertyName(int i)
```
    Description copied from interface: OuterJoinLoadable
    
    Get the name of the numbered property of the class or a subclass.
    
    Specified by:
    
    getSubclassPropertyName in interface OuterJoinLoadable
  - countSubclassProperties
```
public int countSubclassProperties()
```
    Description copied from interface: OuterJoinLoadable
    
    How many properties are there, for this class and all subclasses?
    
    Specified by:
    
    countSubclassProperties in interface OuterJoinLoadable
  - getSubclassPropertyColumnNames
```
public String[] getSubclassPropertyColumnNames(int i)
```
    Description copied from interface: OuterJoinLoadable
    
    Return the column names used to persist the numbered property of the class or a subclass.
    
    Specified by:
    
    getSubclassPropertyColumnNames in interface OuterJoinLoadable
  - isDefinedOnSubclass
```
public boolean isDefinedOnSubclass(int i)
```
    Description copied from interface: OuterJoinLoadable
    
    Is this property defined on a subclass of the mapped class.
    
    Specified by:
    
    isDefinedOnSubclass in interface OuterJoinLoadable
  - getSubclassPropertyFormulaTemplateClosure
```
public String[][] getSubclassPropertyFormulaTemplateClosure()
```
    Specified by:
    
    getSubclassPropertyFormulaTemplateClosure in interface Queryable
  - getSubclassPropertyTypeClosure
```
protected Type[] getSubclassPropertyTypeClosure()
```
  - getSubclassPropertyColumnNameClosure
```
protected String[][] getSubclassPropertyColumnNameClosure()
```
  - getSubclassPropertyColumnReaderClosure
```
public String[][] getSubclassPropertyColumnReaderClosure()
```
  - getSubclassPropertyColumnReaderTemplateClosure
```
public String[][] getSubclassPropertyColumnReaderTemplateClosure()
```
  - getSubclassPropertyNameClosure
```
protected String[] getSubclassPropertyNameClosure()
```
  - resolveAttributeIndexes
```
public int[] resolveAttributeIndexes(String[] attributeNames)
```
    Description copied from interface: EntityPersister
    
    Converts an array of attribute names to a set of indexes, according to the entity metamodel
    
    Specified by:
    
    resolveAttributeIndexes in interface EntityPersister
    
    Parameters:
    
    attributeNames - Array of names to be resolved
    
    Returns:
    
    A set of unique indexes of the attribute names found in the metamodel
  - resolveDirtyAttributeIndexes
```
public int[] resolveDirtyAttributeIndexes(Object[] currentState,
                                          Object[] previousState,
                                          String[] attributeNames,
                                          SessionImplementor session)
```
    Description copied from interface: EntityPersister
    
    Like EntityPersister.resolveAttributeIndexes(String[]) but also always returns mutable attributes
    
    Specified by:
    
    resolveDirtyAttributeIndexes in interface EntityPersister
    
    attributeNames - Array of names to be resolved
    
    Returns:
    
    A set of unique indexes of the attribute names found in the metamodel
  - getSubclassPropertyColumnNames
```
public String[] getSubclassPropertyColumnNames(String propertyName)
```
    Description copied from interface: SQLLoadable
    
    Return the column names used to persist/query the named property of the class or a subclass (optional operation).
    
    Specified by:
    
    getSubclassPropertyColumnNames in interface SQLLoadable
  - loadByUniqueKey
```
public Object loadByUniqueKey(String propertyName,
                              Object uniqueKey,
                              SharedSessionContractImplementor session)
                       throws HibernateException
```
    Description copied from interface: EntityMappingType
    
    Load an instance of the persistent class, by a unique key other than the primary key.
    
    Specified by:
    
    loadByUniqueKey in interface EntityMappingType
    
    Specified by:
    
    loadByUniqueKey in interface EntityPersister
    
    Specified by:
    
    loadByUniqueKey in interface UniqueKeyLoadable
    
    Throws:
    
    HibernateException
  - loadByUniqueKey
```
public Object loadByUniqueKey(String propertyName,
                              Object uniqueKey,
                              Boolean readOnly,
                              SharedSessionContractImplementor session)
                       throws HibernateException
```
    Throws:
    
    HibernateException
  - getUniqueKeyLoader
```
protected SingleUniqueKeyEntityLoader<?> getUniqueKeyLoader(String attributeName)
```
  - getPropertyIndex
```
public int getPropertyIndex(String propertyName)
```
    Description copied from interface: UniqueKeyLoadable
    
    Get the property number of the unique key property
    
    Specified by:
    
    getPropertyIndex in interface AttributeSource
    
    Specified by:
    
    getPropertyIndex in interface UniqueKeyLoadable
  - initPropertyPaths
```
protected void initPropertyPaths(Metadata mapping)
                          throws MappingException
```
    Throws:
    
    MappingException
  - check
```
protected boolean check(int rows,
                        Object id,
                        int tableNumber,
                        Expectation expectation,
                        PreparedStatement statement,
                        String statementSQL)
                 throws HibernateException
```
    Throws:
    
    HibernateException
  - checkVersion
```
public final boolean checkVersion(boolean[] includeProperty)
```
  - getIdentitySelectString
```
public String getIdentitySelectString()
```
    Description copied from interface: PostInsertIdentityPersister
    
    Get the database-specific SQL command to retrieve the last generated IDENTITY value.
    
    Specified by:
    
    getIdentitySelectString in interface PostInsertIdentityPersister
    
    Returns:
    
    The SQL command string
  - getSelectByUniqueKeyString
```
public String getSelectByUniqueKeyString(String propertyName)
```
    Description copied from interface: PostInsertIdentityPersister
    
    Get a SQL select string that performs a select based on a unique key determined by the given property name.
    
    Specified by:
    
    getSelectByUniqueKeyString in interface PostInsertIdentityPersister
    
    Parameters:
    
    propertyName - The name of the property which maps to the column(s) to use in the select statement restriction.
    
    Returns:
    
    The SQL select string
  - getSelectByUniqueKeyString
```
public String getSelectByUniqueKeyString(String[] propertyNames)
```
    Description copied from interface: PostInsertIdentityPersister
    
    Get a SQL select string that performs a select based on a unique key determined by the given property names.
    
    Specified by:
    
    getSelectByUniqueKeyString in interface PostInsertIdentityPersister
    
    Parameters:
    
    propertyNames - The names of the properties which maps to the column(s) to use in the select statement restriction.
    
    Returns:
    
    The SQL select string
  - update
```
public void update(Object id,
                   Object[] values,
                   int[] dirtyAttributeIndexes,
                   boolean hasDirtyCollection,
                   Object[] oldValues,
                   Object oldVersion,
                   Object object,
                   Object rowId,
                   SharedSessionContractImplementor session)
            throws HibernateException
```
    Update an object
    
    Specified by:
    
    update in interface EntityPersister
    
    Throws:
    
    HibernateException
  - merge
```
public void merge(Object id,
                  Object[] values,
                  int[] dirtyAttributeIndexes,
                  boolean hasDirtyCollection,
                  Object[] oldValues,
                  Object oldVersion,
                  Object object,
                  Object rowId,
                  SharedSessionContractImplementor session)
           throws HibernateException
```
    Merge an object
    
    Specified by:
    
    merge in interface EntityPersister
    
    Throws:
    
    HibernateException
  - hasLazyDirtyFields
```
@Internal
public boolean hasLazyDirtyFields(int[] dirtyFields)
```
  - getIdentityInsertDelegate
```
public InsertGeneratedIdentifierDelegate getIdentityInsertDelegate()
```
    Description copied from interface: EntityMutationTarget
    
    The delegate for executing inserts against the root table for targets defined using post-insert id generation
    
    Specified by:
    
    getIdentityInsertDelegate in interface EntityMutationTarget
  - insert
```
public Object insert(Object[] fields,
                     Object object,
                     SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Persist an instance, using a natively generated identifier (optional operation)
    
    Specified by:
    
    insert in interface EntityPersister
  - insert
```
public void insert(Object id,
                   Object[] fields,
                   Object object,
                   SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Persist an instance
    
    Specified by:
    
    insert in interface EntityPersister
  - getTableMappings
```
protected EntityTableMapping[] getTableMappings()
```
  - getTableMappingsCount
```
@Deprecated(since="6",
            forRemoval=true)
public int getTableMappingsCount()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    this method is no longer used
  - getTableMapping
```
public EntityTableMapping getTableMapping(int i)
```
  - physicalTableNameForMutation
```
public String physicalTableNameForMutation(SelectableMapping selectableMapping)
```
    Unfortunately we cannot directly use `SelectableMapping#getContainingTableExpression()` as that blows up for attributes declared on super-type for union-subclass mappings
  - getPhysicalTableMappingForMutation
```
public EntityTableMapping getPhysicalTableMappingForMutation(SelectableMapping selectableMapping)
```
  - getTargetPart
```
public EntityMappingType getTargetPart()
```
    Description copied from interface: MutationTarget
    
    The ModelPart describing the mutation target
    
    Specified by:
    
    getTargetPart in interface EntityMutationTarget
    
    Specified by:
    
    getTargetPart in interface MutationTarget<EntityTableMapping>
  - forEachMutableTable
```
public void forEachMutableTable(Consumer<EntityTableMapping> consumer)
```
    Description copied from interface: MutationTarget
    
    Visit each table.
    
    Specified by:
    
    forEachMutableTable in interface MutationTarget<EntityTableMapping>
  - forEachMutableTableReverse
```
public void forEachMutableTableReverse(Consumer<EntityTableMapping> consumer)
```
    Description copied from interface: MutationTarget
    
    Same as MutationTarget.forEachMutableTable(java.util.function.Consumer<T>) except that here the tables are visited in reverse order
    
    Specified by:
    
    forEachMutableTableReverse in interface MutationTarget<EntityTableMapping>
  - getIdentifierTableName
```
public String getIdentifierTableName()
```
    Description copied from interface: MutationTarget
    
    The name of the table defining the identifier for this target
    
    Specified by:
    
    getIdentifierTableName in interface MutationTarget<EntityTableMapping>
  - getIdentifierTableMapping
```
public EntityTableMapping getIdentifierTableMapping()
```
    Description copied from interface: MutationTarget
    
    The descriptor for the table containing the identifier for the target
    
    Specified by:
    
    getIdentifierTableMapping in interface EntityMutationTarget
    
    Specified by:
    
    getIdentifierTableMapping in interface MutationTarget<EntityTableMapping>
  - getIdentifierDescriptor
```
public ModelPart getIdentifierDescriptor()
```
    Description copied from interface: EntityMutationTarget
    
    The ModelPart describing the identifier/key for this target
    
    Specified by:
    
    getIdentifierDescriptor in interface EntityMutationTarget
  - hasSkippableTables
```
public boolean hasSkippableTables()
```
    Description copied from interface: EntityMutationTarget
    
    Whether this target defines any potentially skippable tables.
    A table is considered potentially skippable if it is defined as inverse or as optional.
    
    Specified by:
    
    hasSkippableTables in interface EntityMutationTarget
    
    See Also:
    
    Table.inverse(), Table.optional()
  - hasAnySkippableTables
```
protected boolean hasAnySkippableTables(boolean[] optionalTables,
                                        boolean[] inverseTables)
```
  - delete
```
public void delete(Object id,
                   Object version,
                   Object object,
                   SharedSessionContractImplementor session)
```
    Delete an object
    
    Specified by:
    
    delete in interface EntityPersister
  - isAllOrDirtyOptLocking
```
@Deprecated(since="6",
            forRemoval=true)
protected boolean isAllOrDirtyOptLocking()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    this method is no longer used
  - logStaticSQL
```
protected void logStaticSQL()
```
  - getSubclassByDiscriminatorValue
```
public abstract Map<Object,String> getSubclassByDiscriminatorValue()
```
  - needsDiscriminator
```
public abstract boolean needsDiscriminator()
```
  - isDiscriminatorFormula
```
protected boolean isDiscriminatorFormula()
```
  - createRootTableGroup
```
public TableGroup createRootTableGroup(boolean canUseInnerJoins,
                                       NavigablePath navigablePath,
                                       String explicitSourceAlias,
                                       SqlAliasBase explicitSqlAliasBase,
                                       Supplier<Consumer<Predicate>> additionalPredicateCollectorAccess,
                                       SqlAstCreationState creationState)
```
    Description copied from interface: RootTableGroupProducer
    
    Create a root TableGroup as defined by this producer
    
    Specified by:
    
    createRootTableGroup in interface EntityMappingType
    
    Specified by:
    
    createRootTableGroup in interface RootTableGroupProducer
    
    Parameters:
    
    canUseInnerJoins - Whether inner joins can be used when creating table-references within this group
    
    navigablePath - The overall NavigablePath for the root
    
    explicitSourceAlias - The alias, if one, explicitly provided by the application for this root
    
    explicitSqlAliasBase - A specific SqlAliasBase to use. May be null indicating one should be created using the SqlAliasBaseGenerator from creationState
    
    additionalPredicateCollectorAccess - Collector for additional predicates associated with this producer
    
    creationState - The creation state
  - applyDiscriminator
```
public void applyDiscriminator(Consumer<Predicate> predicateConsumer,
                               String alias,
                               TableGroup tableGroup,
                               SqlAstCreationState creationState)
```
    Description copied from interface: Discriminable
    
    Apply the discriminator as a predicate via the predicateConsumer
    
    Specified by:
    
    applyDiscriminator in interface Discriminable
    
    Specified by:
    
    applyDiscriminator in interface EntityMappingType
  - getPrunedDiscriminatorPredicate
```
protected String getPrunedDiscriminatorPredicate(Map<String,EntityNameUse> entityNameUses,
                                                 MappingMetamodelImplementor mappingMetamodel,
                                                 String alias)
```
  - applyFilterRestrictions
```
public void applyFilterRestrictions(Consumer<Predicate> predicateConsumer,
                                    TableGroup tableGroup,
                                    boolean useQualifier,
                                    Map<String,Filter> enabledFilters,
                                    SqlAstCreationState creationState)
```
    Description copied from interface: FilterRestrictable
    
    Applies just the Filter values enabled for the associated entity
    
    Specified by:
    
    applyFilterRestrictions in interface EntityMappingType
    
    Specified by:
    
    applyFilterRestrictions in interface FilterRestrictable
  - applyBaseRestrictions
```
public void applyBaseRestrictions(Consumer<Predicate> predicateConsumer,
                                  TableGroup tableGroup,
                                  boolean useQualifier,
                                  Map<String,Filter> enabledFilters,
                                  Set<String> treatAsDeclarations,
                                  SqlAstCreationState creationState)
```
    Description copied from interface: Restrictable
    
    Applies the base set of restrictions.
    
    Specified by:
    
    applyBaseRestrictions in interface EntityMappingType
    
    Specified by:
    
    applyBaseRestrictions in interface Restrictable
  - hasWhereRestrictions
```
public boolean hasWhereRestrictions()
```
    Description copied from interface: WhereRestrictable
    
    Does this restrictable have a where restriction?
    
    Specified by:
    
    hasWhereRestrictions in interface EntityMappingType
    
    Specified by:
    
    hasWhereRestrictions in interface WhereRestrictable
  - applyWhereRestrictions
```
public void applyWhereRestrictions(Consumer<Predicate> predicateConsumer,
                                   TableGroup tableGroup,
                                   boolean useQualifier,
                                   SqlAstCreationState creationState)
```
    Description copied from interface: WhereRestrictable
    
    Apply the Where restrictions
    
    Specified by:
    
    applyWhereRestrictions in interface EntityMappingType
    
    Specified by:
    
    applyWhereRestrictions in interface WhereRestrictable
  - generateFilterConditionAlias
```
public String generateFilterConditionAlias(String rootAlias)
```
    Description copied from interface: Queryable
    
    The alias used for any filter conditions (mapped where-fragments or enabled-filters).
    This may or may not be different from the root alias depending upon the inheritance mapping strategy.
    
    Specified by:
    
    generateFilterConditionAlias in interface Queryable
    
    Parameters:
    
    rootAlias - The root alias
    
    Returns:
    
    The alias used for "filter conditions" within the where clause.
  - shouldInnerJoinSubclassTable
```
protected boolean shouldInnerJoinSubclassTable(int subclassTableNumber,
                                               Set<String> treatAsDeclarations)
```
  - isSubclassTableIndicatedByTreatAsDeclarations
```
protected boolean isSubclassTableIndicatedByTreatAsDeclarations(int subclassTableNumber,
                                                                Set<String> treatAsDeclarations)
```
  - postConstruct
```
protected void postConstruct(Metadata mapping)
                      throws MappingException
```
    Post-construct is a callback for AbstractEntityPersister subclasses to call after they are all done with their constructor processing. It allows AbstractEntityPersister to extend its construction after all subclass-specific details have been handled.
    
    Parameters:
    
    mapping - The mapping
    
    Throws:
    
    MappingException - Indicates a problem accessing the Mapping
  - prepareLoaders
```
public void prepareLoaders()
```
    Description copied from interface: EntityPersister
    
    Prepare loaders associated with the persister. Distinct "phase" in building the persister after InFlightEntityMappingType.prepareMappingModel(org.hibernate.metamodel.mapping.internal.MappingModelCreationProcess) and EntityPersister.postInstantiate() have occurred.
    The distinct phase is used to ensure that all TableDetails are available across the entire model
    
    Specified by:
    
    prepareLoaders in interface EntityPersister
  - buildTableMappings
```
protected EntityTableMapping[] buildTableMappings()
```
    Builds the EntityTableMapping descriptors for the tables mapped by this entity.
    
    See Also:
    
    visitMutabilityOrderedTables(org.hibernate.persister.entity.AbstractEntityPersister.MutabilityOrderedTableConsumer)
  - visitMutabilityOrderedTables
```
protected abstract void visitMutabilityOrderedTables(org.hibernate.persister.entity.AbstractEntityPersister.MutabilityOrderedTableConsumer consumer)
```
    Visit details about each table for this entity, using "mutability ordering". When inserting rows, the order we go through the tables to avoid foreign key problems among the entity's group of tables.
    Used while building the table mapping descriptors for each table.
    
    See Also:
    
    forEachMutableTable(java.util.function.Consumer<org.hibernate.persister.entity.mutation.EntityTableMapping>), forEachMutableTableReverse(java.util.function.Consumer<org.hibernate.persister.entity.mutation.EntityTableMapping>)
  - isIdentifierTable
```
protected abstract boolean isIdentifierTable(String tableExpression)
```
  - buildInsertCoordinator
```
protected InsertCoordinator buildInsertCoordinator()
```
  - buildUpdateCoordinator
```
protected UpdateCoordinator buildUpdateCoordinator()
```
  - buildMergeCoordinator
```
protected UpdateCoordinator buildMergeCoordinator()
```
  - buildDeleteCoordinator
```
protected DeleteCoordinator buildDeleteCoordinator()
```
  - addDiscriminatorToInsertGroup
```
public void addDiscriminatorToInsertGroup(MutationGroupBuilder insertGroupBuilder)
```
  - addSoftDeleteToInsertGroup
```
public void addSoftDeleteToInsertGroup(MutationGroupBuilder insertGroupBuilder)
```
  - substituteBrackets
```
protected String substituteBrackets(String sql)
```
  - postInstantiate
```
public final void postInstantiate()
                           throws MappingException
```
    Description copied from interface: EntityPersister
    
    Finish the initialization of this object.
    The method InFlightEntityMappingType.prepareMappingModel(org.hibernate.metamodel.mapping.internal.MappingModelCreationProcess) must have been called for every entity persister before this method is invoked.
    Called only once per SessionFactory lifecycle, after all entity persisters have been instantiated.
    
    Specified by:
    
    postInstantiate in interface EntityPersister
    
    Throws:
    
    MappingException - Indicates an issue in the metadata.
  - load
```
public Object load(Object id,
                   Object optionalObject,
                   LockMode lockMode,
                   SharedSessionContractImplementor session)
```
    Load an instance using either the forUpdateLoader or the outer joining loader, depending upon the value of the lock parameter
    
    Specified by:
    
    load in interface EntityPersister
  - load
```
public Object load(Object id,
                   Object optionalObject,
                   LockOptions lockOptions,
                   SharedSessionContractImplementor session)
            throws HibernateException
```
    Load an instance using either the forUpdateLoader or the outer joining loader, depending upon the value of the lock parameter
    
    Specified by:
    
    load in interface EntityPersister
    
    Throws:
    
    HibernateException
  - load
```
public Object load(Object id,
                   Object optionalObject,
                   LockOptions lockOptions,
                   SharedSessionContractImplementor session,
                   Boolean readOnly)
            throws HibernateException
```
    Specified by:
    
    load in interface EntityPersister
    
    Throws:
    
    HibernateException
  - determineLoaderToUse
```
protected SingleIdEntityLoader<?> determineLoaderToUse(SharedSessionContractImplementor session)
```
  - getSingleIdLoader
```
public SingleIdEntityLoader<?> getSingleIdLoader()
```
  - initializeEnhancedEntityUsedAsProxy
```
public Object initializeEnhancedEntityUsedAsProxy(Object entity,
                                                  String nameOfAttributeBeingAccessed,
                                                  SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    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.
    
    Specified by:
    
    initializeEnhancedEntityUsedAsProxy in interface EntityPersister
  - multiLoad
```
public List<?> multiLoad(Object[] ids,
                         EventSource session,
                         MultiIdLoadOptions loadOptions)
```
    Description copied from interface: EntityPersister
    
    Performs a load of multiple entities (of this type) by identifier simultaneously.
    
    Specified by:
    
    multiLoad in interface EntityPersister
    
    Parameters:
    
    ids - The identifiers to load
    
    session - The originating Session
    
    loadOptions - The options for loading
    
    Returns:
    
    The loaded, matching entities
  - registerAffectingFetchProfile
```
public void registerAffectingFetchProfile(String fetchProfileName)
```
    Description copied from interface: FetchProfileAffectee
    
    Register the profile name with the entity/collection
    
    Specified by:
    
    registerAffectingFetchProfile in interface FetchProfileAffectee
    
    Specified by:
    
    registerAffectingFetchProfile in interface Loadable
    
    Parameters:
    
    fetchProfileName - The name of the profile affecting this.
  - isAffectedByEntityGraph
```
public boolean isAffectedByEntityGraph(LoadQueryInfluencers loadQueryInfluencers)
```
    Description copied from interface: Loadable
    
    Whether the effective entity-graph applies to this loadable
    
    Specified by:
    
    isAffectedByEntityGraph in interface EntityMappingType
    
    Specified by:
    
    isAffectedByEntityGraph in interface Loadable
  - isAffectedByEnabledFetchProfiles
```
public boolean isAffectedByEnabledFetchProfiles(LoadQueryInfluencers loadQueryInfluencers)
```
    Description copied from interface: Loadable
    
    Whether any of the LoadQueryInfluencers.getEnabledFetchProfileNames() apply to this loadable
    
    Specified by:
    
    isAffectedByEnabledFetchProfiles in interface EntityMappingType
    
    Specified by:
    
    isAffectedByEnabledFetchProfiles in interface Loadable
  - isAffectedByEnabledFilters
```
public boolean isAffectedByEnabledFilters(LoadQueryInfluencers loadQueryInfluencers)
```
    Description copied from interface: Loadable
    
    Whether any of the "influencers" affect this loadable.
    
    Specified by:
    
    isAffectedByEnabledFilters in interface EntityMappingType
    
    Specified by:
    
    isAffectedByEnabledFilters in interface Loadable
  - isSubclassPropertyNullable
```
public boolean isSubclassPropertyNullable(int i)
```
    Description copied from interface: OuterJoinLoadable
    
    Is the numbered property of the class of subclass nullable?
    
    Specified by:
    
    isSubclassPropertyNullable in interface OuterJoinLoadable
  - findDirty
```
public int[] findDirty(Object[] currentState,
                       Object[] previousState,
                       Object entity,
                       SharedSessionContractImplementor session)
                throws HibernateException
```
    Locate the property-indices of all properties considered to be dirty.
    
    Specified by:
    
    findDirty in interface EntityPersister
    
    Parameters:
    
    currentState - The current state of the entity (the state to be checked).
    
    previousState - The previous state of the entity (the state to be checked against).
    
    entity - The entity for which we are checking state dirtiness.
    
    session - The session in which the check is occurring.
    
    Returns:
    
    null or the indices of the dirty properties
    
    Throws:
    
    HibernateException
  - findModified
```
public int[] findModified(Object[] old,
                          Object[] current,
                          Object entity,
                          SharedSessionContractImplementor session)
                   throws HibernateException
```
    Locate the property-indices of all properties considered to be dirty.
    
    Specified by:
    
    findModified in interface EntityPersister
    
    Parameters:
    
    old - The old state of the entity.
    
    current - The current state of the entity.
    
    entity - The entity for which we are checking state modification.
    
    session - The session in which the check is occurring.
    
    Returns:
    
    null or the indices of the modified properties
    
    Throws:
    
    HibernateException
  - getPropertyUpdateability
```
public boolean[] getPropertyUpdateability(Object entity)
```
    Which properties appear in the SQL update? (Initialized, updateable ones!)
  - getFactory
```
public SessionFactoryImplementor getFactory()
```
    Description copied from interface: EntityPersister
    
    Return the SessionFactory to which this persister belongs.
    
    Specified by:
    
    getFactory in interface EntityPersister
    
    Returns:
    
    The owning SessionFactory.
  - getEntityMetamodel
```
public EntityMetamodel getEntityMetamodel()
```
    Description copied from interface: EntityPersister
    
    Retrieve the underlying entity metamodel instance.
    
    Specified by:
    
    getEntityMetamodel in interface EntityPersister
    
    Returns:
    
    The metamodel
  - canReadFromCache
```
public boolean canReadFromCache()
```
    Specified by:
    
    canReadFromCache in interface EntityPersister
  - canWriteToCache
```
public boolean canWriteToCache()
```
    Specified by:
    
    canWriteToCache in interface EntityPersister
  - hasCache
```
public boolean hasCache()
```
    Description copied from interface: EntityPersister
    
    Does this class have a cache.
    
    Specified by:
    
    hasCache in interface EntityPersister
  - getCacheAccessStrategy
```
public EntityDataAccess getCacheAccessStrategy()
```
    Description copied from interface: EntityPersister
    
    Get the cache (optional operation)
    
    Specified by:
    
    getCacheAccessStrategy in interface EntityPersister
  - getCacheEntryStructure
```
public CacheEntryStructure getCacheEntryStructure()
```
    Description copied from interface: EntityPersister
    
    Get the cache structure
    
    Specified by:
    
    getCacheEntryStructure in interface EntityPersister
  - buildCacheEntry
```
public CacheEntry buildCacheEntry(Object entity,
                                  Object[] state,
                                  Object version,
                                  SharedSessionContractImplementor session)
```
    Specified by:
    
    buildCacheEntry in interface EntityPersister
  - hasNaturalIdCache
```
public boolean hasNaturalIdCache()
```
    Description copied from interface: EntityPersister
    
    Does this class have a natural id cache
    
    Specified by:
    
    hasNaturalIdCache in interface EntityPersister
  - getNaturalIdCacheAccessStrategy
```
public NaturalIdDataAccess getNaturalIdCacheAccessStrategy()
```
    Description copied from interface: EntityPersister
    
    Get the NaturalId cache (optional operation)
    
    Specified by:
    
    getNaturalIdCacheAccessStrategy in interface EntityPersister
  - getEntityName
```
public final String getEntityName()
```
    Description copied from interface: EntityMappingType
    
    The entity name.
    For most entities, this will be the fully-qualified name of the entity class. The alternative is an explicit entity-name which takes precedence if provided
    
    Specified by:
    
    getEntityName in interface ClassMetadata
    
    Specified by:
    
    getEntityName in interface EntityMappingType
    
    Specified by:
    
    getEntityName in interface EntityPersister
    
    Returns:
    
    The name of the entity which this persister maps.
  - getEntityType
```
public EntityType getEntityType()
```
    Specified by:
    
    getEntityType in interface OuterJoinLoadable
  - isPolymorphic
```
public boolean isPolymorphic()
```
  - isInherited
```
public boolean isInherited()
```
    Description copied from interface: EntityPersister
    
    Determine whether the entity is inherited one or more other entities. In other words, is this entity a subclass of other entities.
    
    Specified by:
    
    isInherited in interface ClassMetadata
    
    Specified by:
    
    isInherited in interface EntityPersister
    
    Returns:
    
    True if other entities extend this entity; false otherwise.
  - hasCascades
```
public boolean hasCascades()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity has any (non-none) cascading.
    
    Specified by:
    
    hasCascades in interface EntityPersister
    
    Returns:
    
    True if the entity has any properties with a cascade other than NONE; false otherwise (aka, no cascading).
  - hasCascadeDelete
```
public boolean hasCascadeDelete()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity has any delete cascading.
    
    Specified by:
    
    hasCascadeDelete in interface EntityPersister
    
    Returns:
    
    True if the entity has any properties with a cascade other than NONE; false otherwise.
  - hasOwnedCollections
```
public boolean hasOwnedCollections()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity has any owned collections.
    
    Specified by:
    
    hasOwnedCollections in interface EntityPersister
    
    Returns:
    
    True if the entity has an owned collection; false otherwise.
  - hasIdentifierProperty
```
public boolean hasIdentifierProperty()
```
    Description copied from interface: EntityPersister
    
    Determine whether the entity has a particular property holding the identifier value.
    
    Specified by:
    
    hasIdentifierProperty in interface ClassMetadata
    
    Specified by:
    
    hasIdentifierProperty in interface EntityPersister
    
    Returns:
    
    True if the entity has a specific property holding identifier value.
  - getVersionType
```
public BasicType<?> getVersionType()
```
    Description copied from interface: EntityPersister
    
    If EntityPersister.isVersioned(), then what is the type of the property holding the locking value.
    
    Specified by:
    
    getVersionType in interface EntityPersister
    
    Returns:
    
    The type of the version property; or null, if not versioned.
  - getVersionProperty
```
public int getVersionProperty()
```
    Description copied from interface: EntityPersister
    
    If EntityPersister.isVersioned(), then what is the index of the property holding the locking value.
    
    Specified by:
    
    getVersionProperty in interface ClassMetadata
    
    Specified by:
    
    getVersionProperty in interface EntityPersister
    
    Returns:
    
    The type of the version property; or -66, if not versioned.
  - isVersioned
```
public boolean isVersioned()
```
    Description copied from interface: EntityPersister
    
    Determine whether optimistic locking by column is enabled for this entity.
    
    Specified by:
    
    isVersioned in interface ClassMetadata
    
    Specified by:
    
    isVersioned in interface EntityPersister
    
    Returns:
    
    True if optimistic locking by column (i.e., <version/> or <timestamp/>) is enabled; false otherwise.
  - isIdentifierAssignedByInsert
```
public boolean isIdentifierAssignedByInsert()
```
    Description copied from interface: EntityPersister
    
    Are identifiers of this entity assigned known before the insert execution? Or, are they generated (in the database) by the insert execution.
    
    Specified by:
    
    isIdentifierAssignedByInsert in interface EntityPersister
    
    Returns:
    
    True if identifiers for this entity are generated by the insert execution.
  - hasLazyProperties
```
public boolean hasLazyProperties()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity defines any lazy properties (when bytecode instrumentation is enabled).
    
    Specified by:
    
    hasLazyProperties in interface EntityPersister
    
    Returns:
    
    True if the entity has properties mapped as lazy; false otherwise.
  - afterReassociate
```
public void afterReassociate(Object entity,
                             SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Called just after the entity has been reassociated with the session
    
    Specified by:
    
    afterReassociate in interface EntityPersister
  - isTransient
```
public Boolean isTransient(Object entity,
                           SharedSessionContractImplementor session)
                    throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Is this a new transient instance?
    
    Specified by:
    
    isTransient in interface EntityPersister
    
    Throws:
    
    HibernateException
  - hasCollections
```
public boolean hasCollections()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity contains references to persistent collections.
    
    Specified by:
    
    hasCollections in interface EntityPersister
    
    Returns:
    
    True if the entity does contain persistent collections; false otherwise.
  - hasMutableProperties
```
public boolean hasMutableProperties()
```
    Description copied from interface: EntityPersister
    
    Determine whether any properties of this entity are considered mutable.
    
    Specified by:
    
    hasMutableProperties in interface EntityPersister
    
    Returns:
    
    True if any properties of the entity are mutable; false otherwise (meaning none are).
  - isMutable
```
public boolean isMutable()
```
    Description copied from interface: EntityPersister
    
    Determine whether instances of this entity are considered mutable.
    
    Specified by:
    
    isMutable in interface ClassMetadata
    
    Specified by:
    
    isMutable in interface EntityPersister
    
    Returns:
    
    True if the entity is considered mutable; false otherwise.
  - isAbstract
```
public boolean isAbstract()
```
    Description copied from interface: EntityMappingType
    
    Whether this entity is defined as abstract using the Java abstract keyword
    
    Specified by:
    
    isAbstract in interface EntityMappingType
    
    Specified by:
    
    isAbstract in interface Loadable
    
    Specified by:
    
    isAbstract in interface Queryable
    
    See Also:
    
    EntityMappingType.isAbstract()
  - hasSubclasses
```
public boolean hasSubclasses()
```
    Description copied from interface: EntityMappingType
    
    Whether this entity mapping has any subtype mappings
    
    Specified by:
    
    hasSubclasses in interface ClassMetadata
    
    Specified by:
    
    hasSubclasses in interface EntityMappingType
    
    Specified by:
    
    hasSubclasses in interface Loadable
  - hasProxy
```
public boolean hasProxy()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity supports dynamic proxies.
    
    Specified by:
    
    hasProxy in interface ClassMetadata
    
    Specified by:
    
    hasProxy in interface EntityPersister
    
    Returns:
    
    True if the entity has dynamic proxy support; false otherwise.
  - getIdentifierGenerator
```
@Deprecated
public IdentifierGenerator getIdentifierGenerator()
                                           throws HibernateException
```
    Deprecated.
    
    Description copied from interface: EntityPersister
    
    Determine which identifier generation strategy is used for this entity.
    
    Specified by:
    
    getIdentifierGenerator in interface EntityPersister
    
    Returns:
    
    The identifier generation strategy.
    
    Throws:
    
    HibernateException
  - getGenerator
```
public Generator getGenerator()
```
    Specified by:
    
    getGenerator in interface EntityPersister
  - getVersionGenerator
```
public BeforeExecutionGenerator getVersionGenerator()
```
    Specified by:
    
    getVersionGenerator in interface EntityPersister
  - getRootEntityName
```
public String getRootEntityName()
```
    Description copied from interface: EntityPersister
    
    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.
    
    Specified by:
    
    getRootEntityName in interface EntityPersister
    
    Returns:
    
    The root entity name.
  - getClassMetadata
```
@Deprecated
public ClassMetadata getClassMetadata()
```
    Deprecated.
    
    Description copied from interface: EntityPersister
    
    Get the user-visible metadata for the class (optional operation)
    
    Specified by:
    
    getClassMetadata in interface EntityPersister
  - getMappedSuperclass
```
public String getMappedSuperclass()
```
    Description copied from interface: EntityMappingType
    
    Get the name of the entity that is the "super class" for this entity
    
    Specified by:
    
    getMappedSuperclass in interface EntityMappingType
    
    Specified by:
    
    getMappedSuperclass in interface Queryable
    
    See Also:
    
    EntityMappingType.getSuperMappingType()
  - isExplicitPolymorphism
```
public boolean isExplicitPolymorphism()
```
    Description copied from interface: EntityMappingType
    
    Is this class explicit polymorphism only?
    
    Specified by:
    
    isExplicitPolymorphism in interface EntityMappingType
    
    Specified by:
    
    isExplicitPolymorphism in interface Queryable
    
    See Also:
    
    EntityMappingType.isExplicitPolymorphism()
  - getKeyColumnNames
```
public String[] getKeyColumnNames()
```
    Description copied from interface: Joinable
    
    The columns to join on
    
    Specified by:
    
    getKeyColumnNames in interface Joinable
  - getName
```
public String getName()
```
    Description copied from interface: Joinable
    
    An identifying name; a class name or collection role name.
    
    Specified by:
    
    getName in interface Joinable
  - isCollection
```
public boolean isCollection()
```
    Description copied from interface: Joinable
    
    Is this instance actually a CollectionPersister?
    
    Specified by:
    
    isCollection in interface Joinable
  - consumesEntityAlias
```
public boolean consumesEntityAlias()
```
    Description copied from interface: Joinable
    
    Very, very, very ugly...
    
    Specified by:
    
    consumesEntityAlias in interface Joinable
    
    Returns:
    
    Does this persister "consume" entity column aliases in the result set?
  - consumesCollectionAlias
```
public boolean consumesCollectionAlias()
```
    Description copied from interface: Joinable
    
    Very, very, very ugly...
    
    Specified by:
    
    consumesCollectionAlias in interface Joinable
    
    Returns:
    
    Does this persister "consume" collection column aliases in the result set?
  - getPropertyType
```
@Deprecated
public Type getPropertyType(String propertyName)
                     throws MappingException
```
    Deprecated.
    by the supertypes
    
    Get the type of a particular property by name. Warning: When there are duplicated property names in the subclasses then this method may return the wrong results. To ensure correct results, this method should only be used when this is the concrete EntityPersister (since the concrete EntityPersister cannot have duplicated property names).
    
    Specified by:
    
    getPropertyType in interface ClassMetadata
    
    Specified by:
    
    getPropertyType in interface EntityPersister
    
    Parameters:
    
    propertyName - The name of the property for which to retrieve the type.
    
    Returns:
    
    The type.
    
    Throws:
    
    MappingException - Typically indicates an unknown property name.
  - getType
```
public Type getType()
```
    Description copied from interface: SQLLoadable
    
    Get the type
    
    Specified by:
    
    getType in interface SQLLoadable
  - isSelectBeforeUpdateRequired
```
public boolean isSelectBeforeUpdateRequired()
```
    Description copied from interface: EntityPersister
    
    Is select snapshot before update enabled?
    
    Specified by:
    
    isSelectBeforeUpdateRequired in interface EntityPersister
  - optimisticLockStyle
```
public final OptimisticLockStyle optimisticLockStyle()
```
    Description copied from interface: EntityMappingType
    
    The type of optimistic locking, if any, defined for this entity mapping
    
    Specified by:
    
    optimisticLockStyle in interface EntityMappingType
  - createProxy
```
public Object createProxy(Object id,
                          SharedSessionContractImplementor session)
                   throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Create a new proxy instance
    
    Specified by:
    
    createProxy in interface EntityPersister
    
    Throws:
    
    HibernateException
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - isInstrumented
```
public boolean isInstrumented()
```
    Description copied from interface: EntityPersister
    
    Has the class actually been bytecode instrumented?
    
    Specified by:
    
    isInstrumented in interface EntityPersister
  - hasInsertGeneratedProperties
```
public boolean hasInsertGeneratedProperties()
```
    Description copied from interface: EntityPersister
    
    Does this entity define any properties as being database generated on insert?
    
    Specified by:
    
    hasInsertGeneratedProperties in interface EntityPersister
    
    Returns:
    
    True if this entity contains at least one property defined as generated (including version property, but not identifier).
  - hasUpdateGeneratedProperties
```
public boolean hasUpdateGeneratedProperties()
```
    Description copied from interface: EntityPersister
    
    Does this entity define any properties as being database generated on update?
    
    Specified by:
    
    hasUpdateGeneratedProperties in interface EntityPersister
    
    Returns:
    
    True if this entity contains at least one property defined as generated (including version property, but not identifier).
  - isVersionPropertyGenerated
```
public boolean isVersionPropertyGenerated()
```
    Description copied from interface: EntityPersister
    
    Does this entity contain a version property that is defined to be database generated?
    
    Specified by:
    
    isVersionPropertyGenerated in interface EntityPersister
    
    Returns:
    
    true if this entity contains a version property and that property has been marked as generated.
  - isVersionPropertyInsertable
```
public boolean isVersionPropertyInsertable()
```
    Description copied from interface: Queryable
    
    Is the version property included in insert statements?
    
    Specified by:
    
    isVersionPropertyInsertable in interface Queryable
  - isVersionGeneratedOnExecution
```
public boolean isVersionGeneratedOnExecution()
```
  - isVersionGeneratedBeforeExecution
```
public boolean isVersionGeneratedBeforeExecution()
```
  - afterInitialize
```
public void afterInitialize(Object entity,
                            SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Called just after the entities properties have been initialized
    
    Specified by:
    
    afterInitialize in interface EntityPersister
  - getPropertyNames
```
public String[] getPropertyNames()
```
    Description copied from interface: EntityPersister
    
    Get the names of the class properties - doesn't have to be the names of the actual Java properties (used for XML generation only)
    
    Specified by:
    
    getPropertyNames in interface ClassMetadata
    
    Specified by:
    
    getPropertyNames in interface EntityPersister
  - getPropertyTypes
```
public Type[] getPropertyTypes()
```
    Description copied from interface: EntityPersister
    
    Get the Hibernate types of the class properties
    
    Specified by:
    
    getPropertyTypes in interface ClassMetadata
    
    Specified by:
    
    getPropertyTypes in interface EntityPersister
  - getPropertyLaziness
```
public boolean[] getPropertyLaziness()
```
    Description copied from interface: ClassMetadata
    
    Get the "laziness" of the properties of this class
    
    Specified by:
    
    getPropertyLaziness in interface ClassMetadata
    
    Specified by:
    
    getPropertyLaziness in interface EntityPersister
  - getPropertyUpdateability
```
public boolean[] getPropertyUpdateability()
```
    Description copied from interface: EntityPersister
    
    Get the "updateability" of the properties of this class (does the property appear in an SQL UPDATE)
    
    Specified by:
    
    getPropertyUpdateability in interface EntityPersister
  - getPropertyCheckability
```
public boolean[] getPropertyCheckability()
```
    Description copied from interface: EntityPersister
    
    Get the "checkability" of the properties of this class (is the property dirty checked, does the cache need to be updated)
    
    Specified by:
    
    getPropertyCheckability in interface EntityPersister
  - getNonLazyPropertyUpdateability
```
public boolean[] getNonLazyPropertyUpdateability()
```
  - getPropertyInsertability
```
public boolean[] getPropertyInsertability()
```
    Description copied from interface: EntityPersister
    
    Get the "insertability" of the properties of this class (does the property appear in an SQL INSERT)
    
    Specified by:
    
    getPropertyInsertability in interface EntityPersister
  - getPropertyNullability
```
public boolean[] getPropertyNullability()
```
    Description copied from interface: EntityPersister
    
    Get the nullability of the properties of this class
    
    Specified by:
    
    getPropertyNullability in interface ClassMetadata
    
    Specified by:
    
    getPropertyNullability in interface EntityPersister
  - getPropertyVersionability
```
public boolean[] getPropertyVersionability()
```
    Description copied from interface: EntityPersister
    
    Get the "versionability" of the properties of this class (is the property optimistic-locked)
    
    Specified by:
    
    getPropertyVersionability in interface EntityPersister
  - getPropertyCascadeStyles
```
public CascadeStyle[] getPropertyCascadeStyles()
```
    Description copied from interface: EntityPersister
    
    Get the cascade styles of the properties (optional operation)
    
    Specified by:
    
    getPropertyCascadeStyles in interface EntityPersister
  - isPropertySelectable
```
public boolean isPropertySelectable(int propertyNumber)
```
    Specified by:
    
    isPropertySelectable in interface EntityPersister
  - getMappedClass
```
public final Class<?> getMappedClass()
```
    Description copied from interface: EntityPersister
    
    The persistent class, or null
    
    Specified by:
    
    getMappedClass in interface ClassMetadata
    
    Specified by:
    
    getMappedClass in interface EntityPersister
  - implementsLifecycle
```
public boolean implementsLifecycle()
```
    Description copied from interface: EntityPersister
    
    Does the class implement the Lifecycle interface?
    
    Specified by:
    
    implementsLifecycle in interface ClassMetadata
    
    Specified by:
    
    implementsLifecycle in interface EntityPersister
  - getConcreteProxyClass
```
public Class<?> getConcreteProxyClass()
```
    Description copied from interface: EntityPersister
    
    Get the proxy interface that instances of this concrete class will be cast to (optional operation).
    
    Specified by:
    
    getConcreteProxyClass in interface EntityPersister
  - setPropertyValues
```
public void setPropertyValues(Object object,
                              Object[] values)
```
    Description copied from interface: EntityPersister
    
    Set the given values to the mapped properties of the given object.
    
    Specified by:
    
    setPropertyValues in interface ClassMetadata
    
    Specified by:
    
    setPropertyValues in interface EntityPersister
  - setPropertyValue
```
public void setPropertyValue(Object object,
                             int i,
                             Object value)
```
    Description copied from interface: EntityPersister
    
    Set the value of a particular property of the given instance.
    
    Specified by:
    
    setPropertyValue in interface EntityPersister
  - getPropertyValues
```
public Object[] getPropertyValues(Object object)
```
    Description copied from interface: ClassMetadata
    
    Extract the property values from the given entity.
    
    Specified by:
    
    getPropertyValues in interface ClassMetadata
    
    Specified by:
    
    getPropertyValues in interface EntityPersister
    
    Parameters:
    
    object - The entity from which to extract the property values.
    
    Returns:
    
    The property values.
  - getPropertyValue
```
public Object getPropertyValue(Object object,
                               int i)
```
    Specified by:
    
    getPropertyValue in interface EntityPersister
  - getPropertyValue
```
public Object getPropertyValue(Object object,
                               String propertyName)
```
    Description copied from interface: EntityPersister
    
    Get the value of a particular property
    
    Specified by:
    
    getPropertyValue in interface ClassMetadata
    
    Specified by:
    
    getPropertyValue in interface EntityPersister
  - getIdentifier
```
public Object getIdentifier(Object entity,
                            SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Get the identifier of an instance from the object's identifier property. Throw an exception if it has no identifier property.
    
    Specified by:
    
    getIdentifier in interface ClassMetadata
    
    Specified by:
    
    getIdentifier in interface EntityPersister
    
    Parameters:
    
    entity - The entity for which to get the identifier
    
    session - The session from which the request originated
    
    Returns:
    
    The identifier
  - setIdentifier
```
public void setIdentifier(Object entity,
                          Object id,
                          SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Inject the identifier value into the given entity.
    
    Specified by:
    
    setIdentifier in interface ClassMetadata
    
    Specified by:
    
    setIdentifier in interface EntityPersister
    
    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
```
public Object getVersion(Object object)
```
    Description copied from interface: EntityPersister
    
    Get the version number (or timestamp) from the object's version property. Return null if it is not versioned.
    
    Specified by:
    
    getVersion in interface ClassMetadata
    
    Specified by:
    
    getVersion in interface EntityPersister
  - instantiate
```
public Object instantiate(Object id,
                          SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Create a class instance initialized with the given identifier
    
    Specified by:
    
    instantiate in interface ClassMetadata
    
    Specified by:
    
    instantiate in interface EntityPersister
    
    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.
  - linkToSession
```
protected void linkToSession(Object entity,
                             SharedSessionContractImplementor session)
```
  - isInstance
```
public boolean isInstance(Object object)
```
    Description copied from interface: EntityPersister
    
    Is the given object an instance of this entity?
    
    Specified by:
    
    isInstance in interface EntityPersister
  - hasUninitializedLazyProperties
```
public boolean hasUninitializedLazyProperties(Object object)
```
    Description copied from interface: EntityPersister
    
    Does the given instance have any uninitialized lazy properties?
    
    Specified by:
    
    hasUninitializedLazyProperties in interface EntityPersister
  - resetIdentifier
```
public void resetIdentifier(Object entity,
                            Object currentId,
                            Object currentVersion,
                            SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Set the identifier and version of the given instance back to its "unsaved" value, that is, the value it had before it was made persistent.
    
    Specified by:
    
    resetIdentifier in interface EntityPersister
  - getSubclassEntityPersister
```
public EntityPersister getSubclassEntityPersister(Object instance,
                                                  SessionFactoryImplementor factory)
```
    Description copied from interface: EntityPersister
    
    Obtain the EntityPersister for the concrete class of the given entity instance which participates in a mapped inheritance hierarchy with this persister. The given instance must be an instance of a subclass of the persistent class managed by this persister.
    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 reroute 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's also possible that the instance is actually an Animal instance in the above example in which case we would return this from this method.
    
    Specified by:
    
    getSubclassEntityPersister in interface EntityPersister
    
    Parameters:
    
    instance - The entity instance
    
    factory - Reference to the SessionFactory
    
    Returns:
    
    The appropriate persister
  - isMultiTable
```
@Deprecated(since="6.0")
public boolean isMultiTable()
```
    Deprecated.
    
    Description copied from interface: Queryable
    
    Is the inheritance hierarchy described by this persister contained across multiple tables?
    
    Specified by:
    
    isMultiTable in interface Queryable
    
    Returns:
    
    True if the inheritance hierarchy is spread across multiple tables; false otherwise.
  - hasMultipleTables
```
protected boolean hasMultipleTables()
```
  - getPropertySpan
```
public int getPropertySpan()
```
  - getPropertyValuesToInsert
```
public Object[] getPropertyValuesToInsert(Object entity,
                                          Map<Object,Object> mergeMap,
                                          SharedSessionContractImplementor session)
                                   throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Return the values of the insertable properties of the object (including backrefs)
    
    Specified by:
    
    getPropertyValuesToInsert in interface ClassMetadata
    
    Specified by:
    
    getPropertyValuesToInsert in interface EntityPersister
    
    Throws:
    
    HibernateException
  - shouldGetAllProperties
```
protected boolean shouldGetAllProperties(Object entity)
```
  - processInsertGeneratedProperties
```
public void processInsertGeneratedProperties(Object id,
                                             Object entity,
                                             Object[] state,
                                             SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    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.
    
    Specified by:
    
    processInsertGeneratedProperties in interface EntityPersister
  - processUpdateGeneratedProperties
```
public void processUpdateGeneratedProperties(Object id,
                                             Object entity,
                                             Object[] state,
                                             SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    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.
    
    Specified by:
    
    processUpdateGeneratedProperties in interface EntityPersister
  - getIdentifierPropertyName
```
public String getIdentifierPropertyName()
```
    Description copied from interface: EntityPersister
    
    Get the name of the identifier property (or return null) - need not return the name of an actual Java property
    
    Specified by:
    
    getIdentifierPropertyName in interface ClassMetadata
    
    Specified by:
    
    getIdentifierPropertyName in interface EntityPersister
  - getIdentifierType
```
public Type getIdentifierType()
```
    Description copied from interface: EntityPersister
    
    Get the identifier type
    
    Specified by:
    
    getIdentifierType in interface ClassMetadata
    
    Specified by:
    
    getIdentifierType in interface EntityPersister
  - hasSubselectLoadableCollections
```
public boolean hasSubselectLoadableCollections()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity contains references to persistent collections which are fetchable by subselect?
    
    Specified by:
    
    hasSubselectLoadableCollections in interface EntityPersister
    
    Returns:
    
    True if the entity contains collections fetchable by subselect; false otherwise.
  - hasCollectionNotReferencingPK
```
public boolean hasCollectionNotReferencingPK()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity contains references to persistent collections not referencing the primary key.
    
    Specified by:
    
    hasCollectionNotReferencingPK in interface EntityPersister
    
    Returns:
    
    True if the entity contains a collection not referencing the primary key; false otherwise.
  - getNaturalIdentifierProperties
```
public int[] getNaturalIdentifierProperties()
```
    Description copied from interface: EntityPersister
    
    If the entity defines a natural id, that is, if EntityPersister.hasNaturalIdentifier() returns true, the indices of the properties which make up the natural id.
    
    Specified by:
    
    getNaturalIdentifierProperties in interface ClassMetadata
    
    Specified by:
    
    getNaturalIdentifierProperties in interface EntityPersister
    
    Returns:
    
    The indices of the properties making up the natural id; or null, if no natural id is defined.
  - verifyHasNaturalId
```
protected void verifyHasNaturalId()
```
  - getNaturalIdentifierSnapshot
```
public Object getNaturalIdentifierSnapshot(Object id,
                                           SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Retrieve the current state of the natural-id properties from the database.
    
    Specified by:
    
    getNaturalIdentifierSnapshot in interface EntityPersister
    
    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.
  - getNaturalIdLoader
```
public NaturalIdLoader<?> getNaturalIdLoader()
```
    Description copied from interface: EntityMappingType
    
    Access to performing natural-id database selection. This is per-entity in the hierarchy
    
    Specified by:
    
    getNaturalIdLoader in interface EntityMappingType
    
    Specified by:
    
    getNaturalIdLoader in interface EntityPersister
  - getMultiNaturalIdLoader
```
public MultiNaturalIdLoader<?> getMultiNaturalIdLoader()
```
    Description copied from interface: EntityMappingType
    
    Access to performing multi-value natural-id database selection. This is per-entity in the hierarchy
    
    Specified by:
    
    getMultiNaturalIdLoader in interface EntityMappingType
    
    Specified by:
    
    getMultiNaturalIdLoader in interface EntityPersister
  - loadEntityIdByNaturalId
```
public Object loadEntityIdByNaturalId(Object[] naturalIdValues,
                                      LockOptions lockOptions,
                                      SharedSessionContractImplementor session)
```
    Description copied from interface: EntityPersister
    
    Load the id for the entity based on the natural id.
    
    Specified by:
    
    loadEntityIdByNaturalId in interface EntityPersister
  - hasNaturalIdentifier
```
public boolean hasNaturalIdentifier()
```
    Description copied from interface: EntityPersister
    
    Determine whether this entity defines a natural identifier.
    
    Specified by:
    
    hasNaturalIdentifier in interface ClassMetadata
    
    Specified by:
    
    hasNaturalIdentifier in interface EntityPersister
    
    Returns:
    
    True if the entity defines a natural id; false otherwise.
  - setPropertyValue
```
public void setPropertyValue(Object object,
                             String propertyName,
                             Object value)
```
    Description copied from interface: ClassMetadata
    
    Set the value of a particular (named) property
    
    Specified by:
    
    setPropertyValue in interface ClassMetadata
  - getTableId
```
public static int getTableId(String tableName,
                             String[] tables)
```
  - getRepresentationStrategy
```
public EntityRepresentationStrategy getRepresentationStrategy()
```
    Description copied from interface: EntityMappingType
    
    Describes how the entity is represented in the application's domain model.
    
    Specified by:
    
    getRepresentationStrategy in interface EntityMappingType
    
    Specified by:
    
    getRepresentationStrategy in interface EntityPersister
  - getInstrumentationMetadata
```
public BytecodeEnhancementMetadata getInstrumentationMetadata()
```
    Specified by:
    
    getInstrumentationMetadata in interface EntityPersister
  - getBytecodeEnhancementMetadata
```
public BytecodeEnhancementMetadata getBytecodeEnhancementMetadata()
```
    Specified by:
    
    getBytecodeEnhancementMetadata in interface EntityPersister
  - getTableAliasForColumn
```
public String getTableAliasForColumn(String columnName,
                                     String rootAlias)
```
    Description copied from interface: Loadable
    
    Given a column name and the root table alias in use for the entity hierarchy, determine the proper table alias for the table in that hierarchy that contains said column.
    
    Specified by:
    
    getTableAliasForColumn in interface Loadable
    
    Parameters:
    
    columnName - The column name
    
    rootAlias - The hierarchy root alias
    
    Returns:
    
    The proper table alias for qualifying the given column.
  - determineTableNumberForColumn
```
public int determineTableNumberForColumn(String columnName)
```
  - determineTableName
```
protected String determineTableName(Table table)
```
  - getEntityEntryFactory
```
public EntityEntryFactory getEntityEntryFactory()
```
    Description copied from interface: EntityPersister
    
    Get the EntityEntryFactory indicated for the entity mapped by this persister.
    
    Specified by:
    
    getEntityEntryFactory in interface EntityPersister
    
    Returns:
    
    The proper EntityEntryFactory.
  - forEachAttributeMapping
```
public void forEachAttributeMapping(Consumer<? super AttributeMapping> action)
```
    Description copied from interface: EntityMappingType
    
    Visit each attribute mapping
    
    Specified by:
    
    forEachAttributeMapping in interface EntityMappingType
    
    Specified by:
    
    forEachAttributeMapping in interface ManagedMappingType
    
    See Also:
    
    EntityMappingType.getAttributeMappings()
  - forEachAttributeMapping
```
public void forEachAttributeMapping(IndexedConsumer<? super AttributeMapping> consumer)
```
    Description copied from interface: ManagedMappingType
    
    Visit attributes defined on this class and any supers
    
    Specified by:
    
    forEachAttributeMapping in interface ManagedMappingType
  - prepareMappingModel
```
public void prepareMappingModel(MappingModelCreationProcess creationProcess)
```
    Description copied from interface: InFlightEntityMappingType
    
    After all hierarchy types have been linked, this method is called to allow the mapping model to be prepared which generally includes creating attribute mapping descriptors, identifier mapping descriptor, etc.
    
    Specified by:
    
    prepareMappingModel in interface InFlightEntityMappingType
  - generateNaturalIdMapping
```
protected NaturalIdMapping generateNaturalIdMapping(MappingModelCreationProcess creationProcess,
                                                    PersistentClass bootEntityDescriptor)
```
  - interpretSqmMultiTableStrategy
```
protected static SqmMultiTableMutationStrategy interpretSqmMultiTableStrategy(AbstractEntityPersister entityMappingDescriptor,
                                                                              MappingModelCreationProcess creationProcess)
```
  - interpretSqmMultiTableInsertStrategy
```
protected static SqmMultiTableInsertStrategy interpretSqmMultiTableInsertStrategy(AbstractEntityPersister entityMappingDescriptor,
                                                                                  MappingModelCreationProcess creationProcess)
```
  - getSqmMultiTableMutationStrategy
```
public SqmMultiTableMutationStrategy getSqmMultiTableMutationStrategy()
```
    Description copied from interface: EntityPersister
    
    The strategy to use for SQM mutation statements where the target entity has multiple tables. Returns null to indicate that the entity does not have multiple tables.
    
    Specified by:
    
    getSqmMultiTableMutationStrategy in interface EntityMappingType
    
    Specified by:
    
    getSqmMultiTableMutationStrategy in interface EntityPersister
  - getSqmMultiTableInsertStrategy
```
public SqmMultiTableInsertStrategy getSqmMultiTableInsertStrategy()
```
    Specified by:
    
    getSqmMultiTableInsertStrategy in interface EntityMappingType
    
    Specified by:
    
    getSqmMultiTableInsertStrategy in interface EntityPersister
  - getStateArrayInitialPosition
```
protected int getStateArrayInitialPosition(MappingModelCreationProcess creationProcess)
```
  - isPhysicalDiscriminator
```
protected boolean isPhysicalDiscriminator()
```
  - generateDiscriminatorMapping
```
protected EntityDiscriminatorMapping generateDiscriminatorMapping(PersistentClass bootEntityDescriptor,
                                                                  MappingModelCreationProcess modelCreationProcess)
```
  - getDiscriminatorType
```
public abstract BasicType<?> getDiscriminatorType()
```
    Description copied from interface: Loadable
    
    Get the discriminator type
    
    Specified by:
    
    getDiscriminatorType in interface Loadable
  - generateVersionMapping
```
protected EntityVersionMapping generateVersionMapping(Supplier<?> templateInstanceCreator,
                                                      PersistentClass bootEntityDescriptor,
                                                      MappingModelCreationProcess creationProcess)
```
  - shouldProcessSuperMapping
```
protected boolean shouldProcessSuperMapping()
```
  - linkWithSuperType
```
public void linkWithSuperType(MappingModelCreationProcess creationProcess)
```
    Description copied from interface: InFlightEntityMappingType
    
    Link an entity type with its super-type, if one.
    
    Specified by:
    
    linkWithSuperType in interface InFlightEntityMappingType
  - linkWithSubType
```
public void linkWithSubType(EntityMappingType sub,
                            MappingModelCreationProcess creationProcess)
```
    Description copied from interface: InFlightEntityMappingType
    
    Called from InFlightEntityMappingType.linkWithSuperType(org.hibernate.metamodel.mapping.internal.MappingModelCreationProcess). A callback from the entity-type to the super-type it resolved.
    
    Specified by:
    
    linkWithSubType in interface InFlightEntityMappingType
  - getNumberOfAttributeMappings
```
public int getNumberOfAttributeMappings()
```
    Description copied from interface: EntityMappingType
    
    The total number of attributes for this entity, including those declared on supertype mappings
    
    Specified by:
    
    getNumberOfAttributeMappings in interface EntityMappingType
    
    Specified by:
    
    getNumberOfAttributeMappings in interface ManagedMappingType
  - getAttributeMapping
```
public AttributeMapping getAttributeMapping(int position)
```
    Description copied from interface: EntityMappingType
    
    Retrieve an attribute mapping by position, relative to all attributes
    
    Specified by:
    
    getAttributeMapping in interface EntityMappingType
    
    Specified by:
    
    getAttributeMapping in interface EntityPersister
    
    Specified by:
    
    getAttributeMapping in interface ManagedMappingType
  - getNumberOfDeclaredAttributeMappings
```
public int getNumberOfDeclaredAttributeMappings()
```
    Description copied from interface: EntityMappingType
    
    Get the number of attributes defined on this entity mapping - do not access attributes defined on the super
    
    Specified by:
    
    getNumberOfDeclaredAttributeMappings in interface EntityMappingType
  - getDeclaredAttributeMappings
```
public AttributeMappingsMap getDeclaredAttributeMappings()
```
    Description copied from interface: EntityMappingType
    
    Get access to the attributes defined on this class - do not access attributes defined on the super
    
    Specified by:
    
    getDeclaredAttributeMappings in interface EntityMappingType
  - visitDeclaredAttributeMappings
```
public void visitDeclaredAttributeMappings(Consumer<? super AttributeMapping> action)
```
    Description copied from interface: EntityMappingType
    
    Visit attributes defined on this class - do not visit attributes defined on the super
    
    Specified by:
    
    visitDeclaredAttributeMappings in interface EntityMappingType
  - getSuperMappingType
```
public EntityMappingType getSuperMappingType()
```
    Description copied from interface: EntityMappingType
    
    The mapping for the entity which is the supertype for this entity mapping.
    
    Specified by:
    
    getSuperMappingType in interface EntityMappingType
    
    Returns:
    
    The supertype mapping, or null if there is no supertype
  - getSubMappingTypes
```
public Collection<EntityMappingType> getSubMappingTypes()
```
    Description copied from interface: EntityMappingType
    
    Retrieve mappings for all subtypes
    
    Specified by:
    
    getSubMappingTypes in interface EntityMappingType
  - isTypeOrSuperType
```
public boolean isTypeOrSuperType(EntityMappingType targetType)
```
    Description copied from interface: EntityMappingType
    
    Whether the passed entity mapping is the same as or is a supertype of this entity mapping
    
    Specified by:
    
    isTypeOrSuperType in interface EntityMappingType
  - generateIdentifierMapping
```
protected EntityIdentifierMapping generateIdentifierMapping(Supplier<?> templateInstanceCreator,
                                                            PersistentClass bootEntityDescriptor,
                                                            MappingModelCreationProcess creationProcess)
```
  - generateNonEncapsulatedCompositeIdentifierMapping
```
protected EntityIdentifierMapping generateNonEncapsulatedCompositeIdentifierMapping(MappingModelCreationProcess creationProcess,
                                                                                    PersistentClass bootEntityDescriptor)
```
  - generateVersionMapping
```
protected static EntityVersionMapping generateVersionMapping(AbstractEntityPersister entityPersister,
                                                             Supplier<?> templateInstanceCreator,
                                                             PersistentClass bootModelRootEntityDescriptor,
                                                             MappingModelCreationProcess creationProcess)
```
    Parameters:
    
    entityPersister - The AbstractEntityPersister being constructed - still initializing
    
    bootModelRootEntityDescriptor - The boot-time entity descriptor for the "root entity" in the hierarchy
    
    creationProcess - The SF creation process - access to useful things
  - generateNonIdAttributeMapping
```
protected AttributeMapping generateNonIdAttributeMapping(NonIdentifierAttribute tupleAttrDefinition,
                                                         Property bootProperty,
                                                         int stateArrayPosition,
                                                         int fetchableIndex,
                                                         MappingModelCreationProcess creationProcess)
```
  - buildEmbeddedAttributeMapping
```
protected EmbeddedAttributeMapping buildEmbeddedAttributeMapping(String attrName,
                                                                 int stateArrayPosition,
                                                                 int fetchableIndex,
                                                                 Property bootProperty,
                                                                 DependantValue dependantValue,
                                                                 int dependantColumnIndex,
                                                                 ManagedMappingType declaringType,
                                                                 CompositeType attrType,
                                                                 String tableExpression,
                                                                 String[] rootTableKeyColumnNames,
                                                                 PropertyAccess propertyAccess,
                                                                 CascadeStyle cascadeStyle,
                                                                 MappingModelCreationProcess creationProcess)
```
    For Hibernate Reactive
  - buildSingularAssociationAttributeMapping
```
protected AttributeMapping buildSingularAssociationAttributeMapping(String attrName,
                                                                    NavigableRole navigableRole,
                                                                    int stateArrayPosition,
                                                                    int fetchableIndex,
                                                                    Property bootProperty,
                                                                    ManagedMappingType declaringType,
                                                                    EntityPersister declaringEntityPersister,
                                                                    EntityType attrType,
                                                                    PropertyAccess propertyAccess,
                                                                    CascadeStyle cascadeStyle,
                                                                    MappingModelCreationProcess creationProcess)
```
    For Hibernate Reactive
  - buildPluralAttributeMapping
```
protected AttributeMapping buildPluralAttributeMapping(String attrName,
                                                       int stateArrayPosition,
                                                       int fetchableIndex,
                                                       Property bootProperty,
                                                       ManagedMappingType declaringType,
                                                       PropertyAccess propertyAccess,
                                                       CascadeStyle cascadeStyle,
                                                       FetchMode fetchMode,
                                                       MappingModelCreationProcess creationProcess)
```
    For Hibernate Reactive
  - getMappedJavaType
```
public JavaType<?> getMappedJavaType()
```
    Description copied from interface: MappingType
    
    The descriptor descriptor for the mapped Java type
    
    Specified by:
    
    getMappedJavaType in interface EntityMappingType
    
    Specified by:
    
    getMappedJavaType in interface MappingType
  - getEntityPersister
```
public EntityPersister getEntityPersister()
```
    Description copied from interface: EntityMappingType
    
    Safety-net.
    
    Specified by:
    
    getEntityPersister in interface EntityMappingType
  - getIdentifierMapping
```
public EntityIdentifierMapping getIdentifierMapping()
```
    Description copied from interface: EntityMappingType
    
    Mapping details for the entity's identifier. This is shared across all entity mappings within an inheritance hierarchy.
    
    Specified by:
    
    getIdentifierMapping in interface EntityMappingType
  - getVersionMapping
```
public EntityVersionMapping getVersionMapping()
```
    Description copied from interface: EntityMappingType
    
    Mapping details for the entity's version when using the version strategy. This is shared across all entity mappings within an inheritance hierarchy.
    
    Specified by:
    
    getVersionMapping in interface EntityMappingType
    
    Returns:
    
    The version mapping, or null if the entity is (1) defined with a strategy other than OptimisticLockStyle.VERSION or (2) defined without optimistic locking
    
    See Also:
    
    EntityMappingType.optimisticLockStyle()
  - getRowIdMapping
```
public EntityRowIdMapping getRowIdMapping()
```
    Description copied from interface: EntityMappingType
    
    The mapping for the row-id of the entity, if one is defined.
    
    Specified by:
    
    getRowIdMapping in interface EntityMappingType
  - getDiscriminatorMapping
```
public EntityDiscriminatorMapping getDiscriminatorMapping()
```
    Description copied from interface: EntityMappingType
    
    Mapping details for the entity's discriminator. This is shared across all entity mappings within an inheritance hierarchy.
    
    Specified by:
    
    getDiscriminatorMapping in interface Discriminable
    
    Specified by:
    
    getDiscriminatorMapping in interface EntityMappingType
  - getSoftDeleteMapping
```
public SoftDeleteMapping getSoftDeleteMapping()
```
    Description copied from interface: EntityMappingType
    
    Mapping for soft-delete support, or null if soft-delete not defined
    
    Specified by:
    
    getSoftDeleteMapping in interface EntityMappingType
    
    Specified by:
    
    getSoftDeleteMapping in interface SoftDeletableModelPart
  - getSoftDeleteTableDetails
```
public TableDetails getSoftDeleteTableDetails()
```
    Specified by:
    
    getSoftDeleteTableDetails in interface EntityMappingType
    
    Specified by:
    
    getSoftDeleteTableDetails in interface SoftDeletableModelPart
  - getAttributeMappings
```
public AttributeMappingsList getAttributeMappings()
```
    Description copied from interface: EntityMappingType
    
    The attributes mapping for this entity, including those declared on supertype mappings
    
    Specified by:
    
    getAttributeMappings in interface EntityMappingType
    
    Specified by:
    
    getAttributeMappings in interface ManagedMappingType
  - findDeclaredAttributeMapping
```
public AttributeMapping findDeclaredAttributeMapping(String name)
```
    Description copied from interface: EntityMappingType
    
    Find an attribute-mapping, declared on this entity mapping (not super or subs), by name
    
    Specified by:
    
    findDeclaredAttributeMapping in interface EntityMappingType
  - findAttributeMapping
```
public AttributeMapping findAttributeMapping(String name)
```
    Description copied from interface: ManagedMappingType
    
    Find an attribute by name.
    
    Specified by:
    
    findAttributeMapping in interface ManagedMappingType
    
    Returns:
    
    The named attribute, or null if no match was found
  - findSubPart
```
public ModelPart findSubPart(String name,
                             EntityMappingType treatTargetType)
```
    Specified by:
    
    findSubPart in interface EntityValuedModelPart
    
    Specified by:
    
    findSubPart in interface ModelPartContainer
  - findSubTypesSubPart
```
public ModelPart findSubTypesSubPart(String name,
                                     EntityMappingType treatTargetType)
```
    Specified by:
    
    findSubTypesSubPart in interface EntityMappingType
  - visitSubParts
```
public void visitSubParts(Consumer<ModelPart> consumer,
                          EntityMappingType treatTargetType)
```
    Specified by:
    
    visitSubParts in interface EntityValuedModelPart
    
    Specified by:
    
    visitSubParts in interface ModelPartContainer
  - visitKeyFetchables
```
public void visitKeyFetchables(Consumer<? super Fetchable> fetchableConsumer,
                               EntityMappingType treatTargetType)
```
    Specified by:
    
    visitKeyFetchables in interface FetchableContainer
  - visitKeyFetchables
```
public void visitKeyFetchables(IndexedConsumer<? super Fetchable> fetchableConsumer,
                               EntityMappingType treatTargetType)
```
    Specified by:
    
    visitKeyFetchables in interface FetchableContainer
  - getNumberOfFetchables
```
public int getNumberOfFetchables()
```
    Description copied from interface: FetchableContainer
    
    The number of fetchables in the container
    
    Specified by:
    
    getNumberOfFetchables in interface EntityMappingType
    
    Specified by:
    
    getNumberOfFetchables in interface FetchableContainer
  - getNumberOfFetchableKeys
```
public int getNumberOfFetchableKeys()
```
    Description copied from interface: FetchableContainer
    
    The number of fetchables in the container
    
    Specified by:
    
    getNumberOfFetchableKeys in interface FetchableContainer
  - getNumberOfKeyFetchables
```
public int getNumberOfKeyFetchables()
```
    Description copied from interface: FetchableContainer
    
    The number of key fetchables in the container
    
    Specified by:
    
    getNumberOfKeyFetchables in interface FetchableContainer
  - getKeyFetchable
```
public Fetchable getKeyFetchable(int position)
```
    Specified by:
    
    getKeyFetchable in interface FetchableContainer
  - getFetchable
```
public Fetchable getFetchable(int position)
```
    Specified by:
    
    getFetchable in interface EntityMappingType
    
    Specified by:
    
    getFetchable in interface FetchableContainer
  - visitFetchables
```
public void visitFetchables(Consumer<? super Fetchable> fetchableConsumer,
                            EntityMappingType treatTargetType)
```
    Specified by:
    
    visitFetchables in interface FetchableContainer
  - visitFetchables
```
public void visitFetchables(IndexedConsumer<? super Fetchable> fetchableConsumer,
                            EntityMappingType treatTargetType)
```
    Specified by:
    
    visitFetchables in interface FetchableContainer
  - getStaticFetchableList
```
protected AttributeMappingsList getStaticFetchableList()
```
  - visitAttributeMappings
```
public void visitAttributeMappings(Consumer<? super AttributeMapping> action,
                                   EntityMappingType targetType)
```
    Description copied from interface: EntityMappingType
    
    Visit the mappings, but limited to just attributes defined in the targetType or its super-type(s) if any.
    
    Specified by:
    
    visitAttributeMappings in interface EntityMappingType
  - visitSuperTypeAttributeMappings
```
public void visitSuperTypeAttributeMappings(Consumer<? super AttributeMapping> action)
```
    Description copied from interface: EntityMappingType
    
    Walk this type's attributes as well as its super-type's
    
    Specified by:
    
    visitSuperTypeAttributeMappings in interface EntityMappingType
  - forEachSelectable
```
public int forEachSelectable(int offset,
                             SelectableConsumer selectableConsumer)
```
    Description copied from interface: ModelPart
    
    Visits each selectable mapping with the selectable index offset by the given value. Returns the amount of jdbc types that have been visited.
    
    Specified by:
    
    forEachSelectable in interface ModelPart
  - visitSubTypeAttributeMappings
```
public void visitSubTypeAttributeMappings(Consumer<? super AttributeMapping> action)
```
    Description copied from interface: EntityMappingType
    
    Walk this type's attributes as well as its sub-type's
    
    Specified by:
    
    visitSubTypeAttributeMappings in interface EntityMappingType
  - getJdbcTypeCount
```
public int getJdbcTypeCount()
```
    Description copied from interface: Bindable
    
    The number of JDBC mappings
    
    Specified by:
    
    getJdbcTypeCount in interface Bindable
    
    Specified by:
    
    getJdbcTypeCount in interface EntityMappingType
    
    Specified by:
    
    getJdbcTypeCount in interface EntityValuedModelPart
    
    Specified by:
    
    getJdbcTypeCount in interface JdbcMappingContainer
  - forEachJdbcType
```
public int forEachJdbcType(int offset,
                           IndexedConsumer<JdbcMapping> action)
```
    Description copied from interface: JdbcMappingContainer
    
    Visit each JdbcMapping starting from the given offset
    
    Specified by:
    
    forEachJdbcType in interface EntityValuedModelPart
    
    Specified by:
    
    forEachJdbcType in interface JdbcMappingContainer
  - disassemble
```
public Object disassemble(Object value,
                          SharedSessionContractImplementor session)
```
    Description copied from interface: Bindable
    Breaks down a value of J into its simple pieces. E.g., an embedded value gets broken down into an array of its attribute state; a basic value converts to itself; etc.
    Generally speaking, this is the form in which entity state is kept relative to a Session via EntityEntry.
    
    @Entity class Person { @Id Integer id; @Embedded Name name; int age; } @Embeddable class Name { String familiarName; String familyName; }
    
    At the top level, we would want to disassemble a Person value, so we'd ask the Bindable for the Person entity to disassemble. Given a Person value:
    
    Person( id=1, name=Name( 'Steve', 'Ebersole' ), 28 )
    
    this disassemble would result in a multidimensional array:
    
    [ ["Steve", "Ebersole"], 28 ]
    
    Note that the identifier is not part of this disassembled state. Note also how the embedded value results in a sub-array.
    Specified by:
    
    disassemble in interface Bindable
    
    Specified by:
    
    disassemble in interface EntityValuedModelPart
    
    See Also:
    
    EntityEntry
  - forEachDisassembledJdbcValue
```
public <X,Y> int forEachDisassembledJdbcValue(Object value,
                                                    int offset,
                                                    X x,
                                                    Y y,
                                                    Bindable.JdbcValuesBiConsumer<X,Y> valuesConsumer,
                                                    SharedSessionContractImplementor session)
```
    Description copied from interface: Bindable
    
    Like Bindable.forEachDisassembledJdbcValue(Object, Object, Object, JdbcValuesBiConsumer, SharedSessionContractImplementor), but additionally receives an offset by which the selectionIndex is incremented when calling Bindable.JdbcValuesBiConsumer.consume(int, Object, Object, Object, JdbcMapping).
    
    Specified by:
    
    forEachDisassembledJdbcValue in interface Bindable
    
    Specified by:
    
    forEachDisassembledJdbcValue in interface EntityValuedModelPart
  - forEachJdbcValue
```
public <X,Y> int forEachJdbcValue(Object value,
                                        int offset,
                                        X x,
                                        Y y,
                                        Bindable.JdbcValuesBiConsumer<X,Y> consumer,
                                        SharedSessionContractImplementor session)
```
    Description copied from interface: Bindable
    
    Visit each constituent JDBC value extracted from the entity instance itself. Short-hand form of calling Bindable.disassemble(java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor) and piping its result to Bindable.forEachDisassembledJdbcValue(Object, int, JdbcValuesConsumer, SharedSessionContractImplementor)
    
    Specified by:
    
    forEachJdbcValue in interface Bindable
    
    Specified by:
    
    forEachJdbcValue in interface EntityValuedModelPart
  - hasPartitionedSelectionMapping
```
public boolean hasPartitionedSelectionMapping()
```
    Specified by:
    
    hasPartitionedSelectionMapping in interface ManagedMappingType
    
    Specified by:
    
    hasPartitionedSelectionMapping in interface ModelPart
  - isInsertCallable
```
@Deprecated(since="6",
            forRemoval=true)
public boolean isInsertCallable(int j)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    With no replacement
    
    See Also:
    
    getInsertCoordinator(), tableMappings, EntityTableMapping.isInsertCallable()
  - isUpdateCallable
```
@Deprecated(since="6",
            forRemoval=true)
public boolean isUpdateCallable(int j)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    With no replacement
    
    See Also:
    
    getUpdateCoordinator(), tableMappings, EntityTableMapping.isUpdateCallable()
  - isDeleteCallable
```
@Deprecated(since="6",
            forRemoval=true)
public boolean isDeleteCallable(int j)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    With no replacement
    
    See Also:
    
    getDeleteCoordinator(), tableMappings, EntityTableMapping.isDeleteCallable()
  - isSubclassTableSequentialSelect
```
@Deprecated(since="6",
            forRemoval=true)
protected boolean isSubclassTableSequentialSelect(int j)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    With no replacement
  - getElementTypeDescriptor
```
@Deprecated(since="6",
            forRemoval=true)
public EntityMappingType getElementTypeDescriptor()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    With no replacement.
  - isTableCascadeDeleteEnabled
```
@Deprecated(forRemoval=true)
@Remove
public abstract @org.hibernate.Remove boolean isTableCascadeDeleteEnabled(int j)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used
  - isInverseSubclassTable
```
@Deprecated(forRemoval=true)
@Remove
protected @org.hibernate.Remove boolean isInverseSubclassTable(int j)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used
  - getSQLDeleteStrings
```
@Deprecated(forRemoval=true)
@Remove
public @Remove String[] getSQLDeleteStrings()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used. See getDeleteCoordinator()
  - getSQLUpdateStrings
```
@Deprecated(forRemoval=true)
@Remove
public @Remove String[] getSQLUpdateStrings()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used. See getUpdateCoordinator()
  - getTableUpdateNeeded
```
@Deprecated(forRemoval=true)
@Remove
public @org.hibernate.Remove boolean[] getTableUpdateNeeded(int[] dirtyProperties,
                                                            boolean hasDirtyCollection)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used. See UpdateCoordinator
    
    Decide which tables need to be updated.
    The return here is an array of boolean values with each index corresponding to a given table in the scope of this persister.
    
    Parameters:
    
    dirtyProperties - The indices of all the entity properties considered dirty.
    
    hasDirtyCollection - Whether any collections owned by the entity which were considered dirty.
    
    Returns:
    
    Array of booleans indicating which table require updating.
  - isBatchable
```
@Deprecated(forRemoval=true)
@Remove
public @org.hibernate.Remove boolean isBatchable()
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used. See MutationExecutorService
  - generateDeleteString
```
@Deprecated(forRemoval=true)
@Remove
public @Remove String generateDeleteString(int j)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used. See DeleteCoordinatorStandard
    
    Generate the SQL that deletes a row by id (and version)
  - dehydrate
```
@Deprecated(forRemoval=true)
@Remove
public @org.hibernate.Remove int dehydrate(Object id,
                                           Object[] fields,
                                           Object rowId,
                                           boolean[] includeProperty,
                                           boolean[][] includeColumns,
                                           int j,
                                           PreparedStatement ps,
                                           SharedSessionContractImplementor session,
                                           int index,
                                           boolean isUpdate)
                                    throws SQLException,
                                           HibernateException
```
    Deprecated, for removal: This API element is subject to removal in a future version.
    No longer used.
    
    Marshall the fields of a persistent instance to a prepared statement
    
    Throws:
    
    SQLException
    
    HibernateException
  - generateSQLDeleteStrings
```
@Deprecated(since="6.2",
            forRemoval=true)
@Remove
protected @Remove String[] generateSQLDeleteStrings(Object[] loadedState)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
  - isAllNull
```
@Deprecated(since="6.2",
            forRemoval=true)
@Remove
public final @org.hibernate.Remove boolean isAllNull(Object[] array,
                                                     int tableNumber)
```
    Deprecated, for removal: This API element is subject to removal in a future version.
  - getSubclassColumnAliasClosure
```
@Deprecated
protected String[] getSubclassColumnAliasClosure()
```
    Deprecated.
    Hibernate no longer uses aliases to read from result sets
  - getSubclassFormulaAliasClosure
```
@Deprecated
protected String[] getSubclassFormulaAliasClosure()
```
    Deprecated.
    Hibernate no longer uses aliases to read from result sets
  - getSubclassPropertyColumnAliases
```
@Deprecated
public String[] getSubclassPropertyColumnAliases(String propertyName,
                                                 String suffix)
```
    Deprecated.
    Hibernate no longer uses aliases to read from result sets
    
    Description copied from interface: SQLLoadable
    
    Return the column alias names used to persist/query the named property of the class or a subclass (optional operation).
    
    Specified by:
    
    getSubclassPropertyColumnAliases in interface SQLLoadable
  - initSubclassPropertyAliasesMap
```
@Deprecated
protected void initSubclassPropertyAliasesMap(PersistentClass model)
                                       throws MappingException
```
    Deprecated.
    Hibernate no longer uses aliases to read from result sets
    
    Must be called by subclasses, at the end of their constructors
    
    Throws:
    
    MappingException
  - getLazyPropertyColumnAliases
```
@Deprecated
protected String[][] getLazyPropertyColumnAliases()
```
    Deprecated.
    Hibernate no longer uses aliases to read from result sets
    
    Called by Hibernate Reactive
  - getDiscriminatorAlias
```
@Deprecated
public String getDiscriminatorAlias()
```
    Deprecated.
    Hibernate no longer uses aliases to read from result sets
  - getSqlWhereStringTableExpression
```
protected String getSqlWhereStringTableExpression()
```

Class AbstractEntityPersister

Nested Class Summary

Nested classes/interfaces inherited from interface org.hibernate.metamodel.mapping.Bindable

Nested classes/interfaces inherited from interface org.hibernate.metamodel.mapping.EntityMappingType

Nested classes/interfaces inherited from interface org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer

Nested classes/interfaces inherited from interface org.hibernate.metamodel.mapping.ModelPart

Nested classes/interfaces inherited from interface org.hibernate.persister.entity.Queryable

Field Summary

Fields inherited from interface org.hibernate.persister.entity.EntityPersister

Fields inherited from interface org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer

Fields inherited from interface org.hibernate.persister.entity.Loadable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.hibernate.metamodel.mapping.Bindable

Methods inherited from interface org.hibernate.metadata.ClassMetadata

Methods inherited from interface org.hibernate.metamodel.mapping.EntityMappingType

Methods inherited from interface org.hibernate.persister.entity.EntityPersister

Methods inherited from interface org.hibernate.metamodel.mapping.EntityValuedModelPart

Methods inherited from interface org.hibernate.sql.results.graph.FetchableContainer

Methods inherited from interface org.hibernate.metamodel.mapping.JdbcMappingContainer

Methods inherited from interface org.hibernate.persister.entity.Joinable

Methods inherited from interface org.hibernate.loader.ast.spi.Loadable

Methods inherited from interface org.hibernate.persister.entity.Loadable

Methods inherited from interface org.hibernate.metamodel.mapping.ManagedMappingType

Methods inherited from interface org.hibernate.metamodel.mapping.ModelPart

Methods inherited from interface org.hibernate.metamodel.mapping.ModelPartContainer

Methods inherited from interface org.hibernate.sql.model.MutationTarget

Methods inherited from interface org.hibernate.persister.entity.OuterJoinLoadable

Methods inherited from interface org.hibernate.persister.entity.Queryable

Field Detail

ENTITY_CLASS

VERSION_COLUMN_ALIAS

batchSize

rowIdName

declaredAttributeMappings

staticFetchableList

accessOptimizer

fullDiscriminatorSQLValues

propertyMapping

insertExpectations

updateExpectations

deleteExpectations

insertCallable

updateCallable

deleteCallable

customSQLInsert

customSQLUpdate

customSQLDelete

Constructor Detail

AbstractEntityPersister

AbstractEntityPersister

Method Detail

buildSingleIdEntityLoader

getEntityNameByTableNameMap

buildMultiIdLoader

getSubclassTableName

getSubclassTableNames

getSubclassTableKeyColumns

isClassOrSuperclassTable

isClassOrSuperclassJoin

getSubclassTableSpan

getTableSpan

hasDuplicateTables

getTableName

getKeyColumns

isPropertyOfTable

getPropertyTableNumbers

getSubclassPropertyTableNumber

getDiscriminatorColumnName

getDiscriminatorColumnReaders

getDiscriminatorColumnReaderTemplate

getDiscriminatorFormulaTemplate

isInverseTable

isNullableTable

isNullableSubclassTable

isSubclassEntityName

isSharedColumn

getTableHasColumns

getRootTableKeyColumnNames