AbstractEntityPersister (Hibernate Core Aggregator 3.6.10.Final API)

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

All Implemented Interfaces:

OptimisticCacheSource, PostInsertIdentityPersister, LazyPropertyInitializer, ClassMetadata, EntityPersister, Joinable, Loadable, Lockable, OuterJoinLoadable, PropertyMapping, Queryable, SQLLoadable, UniqueKeyLoadable

Direct Known Subclasses:

JoinedSubclassEntityPersister, SingleTableEntityPersister, UnionSubclassEntityPersister
```
public abstract class AbstractEntityPersister
extends Object
implements OuterJoinLoadable, Queryable, ClassMetadata, UniqueKeyLoadable, SQLLoadable, LazyPropertyInitializer, PostInsertIdentityPersister, Lockable
```
Basic functionality for persisting an entity via JDBC through either generated or custom SQL

Author:

Gavin King

Property Summary

Properties
Type Property and Description

boolean hasIdentifier
Determine whether the entity has a particular property holding the identifier value.

Properties
Type	Property and Description
`boolean`	`hasIdentifier` Determine whether the entity has a particular property holding the identifier value.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static interface AbstractEntityPersister.InclusionChecker
- Nested classes/interfaces inherited from interface org.hibernate.persister.entity.Queryable
  Queryable.Declarer

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`AbstractEntityPersister.InclusionChecker`

Field Summary

Fields
Modifier and Type	Field and Description
`protected String[]`	`customSQLDelete`
`protected String[]`	`customSQLInsert`
`protected String[]`	`customSQLUpdate`
`protected boolean[]`	`deleteCallable`
`protected ExecuteUpdateResultCheckStyle[]`	`deleteResultCheckStyles`
`static String`	`ENTITY_CLASS`
`protected boolean[]`	`insertCallable`
`protected ExecuteUpdateResultCheckStyle[]`	`insertResultCheckStyles`
`protected BasicEntityPropertyMapping`	`propertyMapping`
`protected String`	`rowIdName`
`protected boolean[]`	`updateCallable`
`protected ExecuteUpdateResultCheckStyle[]`	`updateResultCheckStyles`

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

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

Fields inherited from interface org.hibernate.intercept.LazyPropertyInitializer
UNFETCHED_PROPERTY

Constructor Summary

Constructors
Constructor and Description
`AbstractEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, SessionFactoryImplementor factory)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addDiscriminatorToInsert(Insert insert)`
`protected void`	`addDiscriminatorToSelect(SelectFragment select, String name, String suffix)`
`void`	`afterInitialize(Object entity, boolean lazyPropertiesAreUnfetched, SessionImplementor session)` Called just after the entities properties have been initialized
`void`	`afterReassociate(Object entity, SessionImplementor session)` Called just after the entity has been reassociated with the session
`boolean`	`canExtractIdOutOfEntity()` Determine whether detached instances of this entity carry their own identifier value.
`protected boolean`	`check(int rows, Serializable id, int tableNumber, Expectation expectation, PreparedStatement statement)`
`protected String`	`concretePropertySelectFragment(String alias, AbstractEntityPersister.InclusionChecker inclusionChecker)`
`protected String`	`concretePropertySelectFragment(String alias, boolean[] includeProperty)`
`protected String`	`concretePropertySelectFragment(String alias, ValueInclusion[] inclusions)`
`protected String`	`concretePropertySelectFragmentSansLeadingComma(String alias, boolean[] include)`
`boolean`	`consumesCollectionAlias()` Very, very, very ugly...
`boolean`	`consumesEntityAlias()` Very, very, very ugly...
`int`	`countSubclassProperties()` How many properties are there, for this class and all subclasses?
`protected UniqueEntityLoader`	`createEntityLoader(LockMode lockMode)`
`protected UniqueEntityLoader`	`createEntityLoader(LockMode lockMode, LoadQueryInfluencers loadQueryInfluencers)`
`protected UniqueEntityLoader`	`createEntityLoader(LockOptions lockOptions, LoadQueryInfluencers loadQueryInfluencers)`
`protected String`	`createFrom(int tableNumber, String alias)`
`protected JoinFragment`	`createJoin(int[] tableNumbers, String drivingAlias)`
`protected JoinFragment`	`createJoin(String name, boolean innerJoin, boolean includeSubclasses)`
`protected void`	`createLoaders()`
`Object`	`createProxy(Serializable id, SessionImplementor session)` Create a new proxy instance
`protected void`	`createQueryLoader()`
`protected SelectFragment`	`createSelect(int[] subclassColumnNumbers, int[] subclassFormulaNumbers)`
`protected void`	`createUniqueKeyLoaders()`
`protected String`	`createWhereByKey(int tableNumber, String alias)`
`protected int`	`dehydrate(Serializable id, Object[] fields, boolean[] includeProperty, boolean[][] includeColumns, int j, PreparedStatement st, SessionImplementor session)`
`protected int`	`dehydrate(Serializable id, Object[] fields, Object rowId, boolean[] includeProperty, boolean[][] includeColumns, int j, PreparedStatement ps, SessionImplementor session, int index)` Marshall the fields of a persistent instance to a prepared statement
`protected void`	`delete(Serializable id, Object version, int j, Object object, String sql, SessionImplementor session, Object[] loadedState)` Perform an SQL DELETE
`void`	`delete(Serializable id, Object version, Object object, SessionImplementor session)` Delete an object
`protected abstract String`	`filterFragment(String alias)`
`String`	`filterFragment(String alias, Map enabledFilters)` Get the where clause filter, given a query alias and considering enabled session filters
`int[]`	`findDirty(Object[] currentState, Object[] previousState, Object entity, SessionImplementor session)` Locate the property-indices of all properties considered to be dirty.
`int[]`	`findModified(Object[] old, Object[] current, Object entity, SessionImplementor session)` Locate the property-indices of all properties considered to be dirty.
`Object`	`forceVersionIncrement(Serializable id, Object currentVersion, SessionImplementor session)`
`String`	`fromJoinFragment(String alias, boolean innerJoin, boolean includeSubclasses)` Get the from clause part of any joins (optional operation)
`protected String`	`generateDeleteString(int j)` Generate the SQL that deletes a row by id (and version)
`String`	`generateFilterConditionAlias(String rootAlias)` The alias used for any filter conditions (mapped where-fragments or enabled-filters).
`protected String`	`generateIdentityInsertString(boolean[] includeProperty)` Used to generate an insery statement against the root table in the case of identifier generation strategies where the insert statement executions actually generates the identifier value.
`protected String`	`generateInsertGeneratedValuesSelectString()`
`protected String`	`generateInsertString(boolean[] includeProperty, int j)`
`protected String`	`generateInsertString(boolean identityInsert, boolean[] includeProperty)`
`protected String`	`generateInsertString(boolean identityInsert, boolean[] includeProperty, int j)` Generate the SQL that inserts a row
`protected String`	`generateLazySelectString()`
`protected LockingStrategy`	`generateLocker(LockMode lockMode)`
`protected String`	`generateSelectVersionString()` Generate the SQL that selects the version number by id
`protected String`	`generateSnapshotSelectString()`
`protected String`	`generateTableAlias(String rootAlias, int tableNumber)`
`protected String`	`generateUpdateGeneratedValuesSelectString()`
`protected String`	`generateUpdateString(boolean[] includeProperty, int j, boolean useRowId)`
`protected String`	`generateUpdateString(boolean[] includeProperty, int j, Object[] oldFields, boolean useRowId)` Generate the SQL that updates a row by id (and version)
`EntityRegionAccessStrategy`	`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()` Get the user-visible metadata for the class (optional operation)
`Class`	`getConcreteProxyClass(EntityMode entityMode)` Get the proxy interface that instances of this concrete class will be cast to (optional operation).
`Object`	`getCurrentVersion(Serializable id, SessionImplementor session)` Retrieve the version number
`Object[]`	`getDatabaseSnapshot(Serializable id, SessionImplementor session)` Get the current database state of the object, in a "hydrated" form, without resolving identifiers
`protected String`	`getDiscriminatorAlias()`
`String`	`getDiscriminatorAlias(String suffix)` Get the result set aliases used for the identifier columns, given a suffix
`String`	`getDiscriminatorColumnName()`
`String`	`getDiscriminatorColumnReaders()`
`String`	`getDiscriminatorColumnReaderTemplate()`
`protected String`	`getDiscriminatorFormulaTemplate()`
`EntityMetamodel`	`getEntityMetamodel()` Retrieve the underlying entity metamodel instance...
`String`	`getEntityName()` The entity name which this persister maps.
`EntityType`	`getEntityType()`
`SessionFactoryImplementor`	`getFactory()` Return the SessionFactory to which this persister "belongs".
`FetchMode`	`getFetchMode(int i)` May this (subclass closure) property be fetched using an SQL outerjoin?
`Serializable`	`getIdentifier(Object object, EntityMode entityMode)` Get the identifier of an instance (throw an exception if no identifier property)
`Serializable`	`getIdentifier(Object entity, SessionImplementor session)` Get the identifier of an instance (throw an exception if no identifier property)
`protected 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()`
`protected int`	`getIdentifierColumnSpan()`
`IdentifierGenerator`	`getIdentifierGenerator()` Determine which identifier generation strategy is used for this entity.
`String`	`getIdentifierPropertyName()` Get the name of the identifier property (or return null) - need not return the name of an actual Java property
`Type`	`getIdentifierType()` Get the identifier type
`String`	`getIdentitySelectString()` Get the database-specific SQL command to retrieve the last generated IDENTITY value.
`String[]`	`getKeyColumnNames()` The columns to join on
`protected abstract String[]`	`getKeyColumns(int j)`
`protected Set`	`getLazyProperties()`
`protected Map`	`getLoaders()`
`Class`	`getMappedClass(EntityMode entityMode)` The persistent class, or null
`String`	`getMappedSuperclass()` Get the class that this class is mapped as a subclass of - not necessarily the direct superclass
`String`	`getName()` An identifying name; a class name or collection role name.
`int[]`	`getNaturalIdentifierProperties()` If the entity defines a natural id (`EntityPersister.hasNaturalIdentifier()`), which properties make up the natural id.
`Object[]`	`getNaturalIdentifierSnapshot(Serializable id, SessionImplementor session)` Retrieve the current state of the natural-id properties from the database.
`boolean[]`	`getNonLazyPropertyUpdateability()`
`protected boolean[]`	`getPropertiesToInsert(Object[] fields)` Transform the array of property indexes to an array of booleans, true when the property is insertable and non-null
`protected boolean[]`	`getPropertiesToUpdate(int[] dirtyProperties, boolean hasDirtyCollection)` Transform the array of property indexes to an array of booleans, true when the property is dirty
`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)
`protected boolean[][]`	`getPropertyColumnInsertable()`
`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
`protected int`	`getPropertyColumnSpan(int i)`
`protected boolean[][]`	`getPropertyColumnUpdateable()`
`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)
`ValueInclusion[]`	`getPropertyInsertGenerationInclusions()` Which of the properties of this class are database generated values on 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
`protected boolean[]`	`getPropertySelectable()`
`protected int`	`getPropertySpan()`
`protected String[]`	`getPropertySubclassNames()`
`protected abstract int[]`	`getPropertyTableNumbers()`
`protected abstract int[]`	`getPropertyTableNumbersInSelect()`
`Type`	`getPropertyType(String propertyName)` Get the type of a particular property by name.
`Type[]`	`getPropertyTypes()` Get the Hibernate types of the class properties
`boolean[]`	`getPropertyUniqueness()`
`boolean[]`	`getPropertyUpdateability()` Get the "updateability" of the properties of this class (does the property appear in an SQL UPDATE)
`protected boolean[]`	`getPropertyUpdateability(Object entity, EntityMode entityMode)` Which properties appear in the SQL update? (Initialized, updateable ones!)
`ValueInclusion[]`	`getPropertyUpdateGenerationInclusions()` Which of the properties of this class are database generated values on update?
`Object`	`getPropertyValue(Object object, int i, EntityMode entityMode)` Get the value of a particular property
`Object`	`getPropertyValue(Object object, String propertyName, EntityMode entityMode)` Get the value of a particular property
`Object[]`	`getPropertyValues(Object object, EntityMode entityMode)` Return the (loaded) values of the mapped properties of the object (not including backrefs)
`Object[]`	`getPropertyValuesToInsert(Object object, Map mergeMap, SessionImplementor session)` Return the values of the insertable properties of the object (including backrefs)
`boolean[]`	`getPropertyVersionability()` Get the "versionability" of the properties of this class (is the property optimistic-locked)
`Serializable[]`	`getQuerySpaces()` Returns an array of objects that identify spaces in which properties of this entity are persisted, for instances of this class and its subclasses.
`String`	`getRootEntityName()` Returns an object that identifies the space in which identifiers of this entity hierarchy are unique.
`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".
`String`	`getSelectByUniqueKeyString(String propertyName)` Get a SQL select string that performs a select based on a unique key determined by the given property name).
`protected String`	`getSequentialSelect(String entityName)`
`protected String[]`	`getSQLDeleteStrings()`
`protected String`	`getSQLIdentityInsertString()` The query that inserts a row, letting the database generate an id
`protected String[]`	`getSQLInsertStrings()`
`protected String`	`getSQLLazySelectString()`
`protected String[]`	`getSQLLazyUpdateByRowIdStrings()`
`protected String[]`	`getSQLLazyUpdateStrings()`
`protected String`	`getSQLSnapshotSelectString()`
`protected String[]`	`getSQLUpdateByRowIdStrings()`
`protected String[]`	`getSQLUpdateStrings()`
`protected String`	`getSQLWhereString(String alias)`
`protected String[]`	`getSubclassColumnAliasClosure()`
`protected String[]`	`getSubclassColumnClosure()`
`protected boolean[]`	`getSubclassColumnLazyiness()`
`String[]`	`getSubclassColumnReaderTemplateClosure()`
`protected abstract int[]`	`getSubclassColumnTableNumberClosure()`
`EntityPersister`	`getSubclassEntityPersister(Object instance, SessionFactoryImplementor factory, EntityMode entityMode)` A request has already identified the entity-name of this persister as the mapping for the given instance.
`protected String[]`	`getSubclassFormulaAliasClosure()`
`protected String[]`	`getSubclassFormulaClosure()`
`protected boolean[]`	`getSubclassFormulaLazyiness()`
`protected abstract int[]`	`getSubclassFormulaTableNumberClosure()`
`protected String[]`	`getSubclassFormulaTemplateClosure()`
`String[]`	`getSubclassPropertyColumnAliases(String propertyName, String suffix)` Return the column alias names used to persist/query the named property of the class or a subclass (optional operation).
`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...
`protected String[][]`	`getSubclassPropertyFormulaTemplateClosure()`
`String`	`getSubclassPropertyName(int i)` Get the name of the numbered property of the class or a subclass.
`protected String[]`	`getSubclassPropertyNameClosure()`
`protected String[]`	`getSubclassPropertySubclassNameClosure()`
`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 int`	`getSubclassTableSpan()`
`protected abstract String`	`getTableName(int j)`
`protected abstract int`	`getTableSpan()`
`protected boolean[]`	`getTableUpdateNeeded(int[] dirtyProperties, boolean hasDirtyCollection)` Decide which tables need to be updated.
`String`	`getTemporaryIdTableDDL()` Get the appropriate DDL command for generating the temporary table to be used to (potentially) store id values when performing bulk update/deletes.
`String`	`getTemporaryIdTableName()` Get the name of the temporary table to be used to (potentially) store id values when performing bulk update/deletes.
`protected EntityTuplizer`	`getTuplizer(EntityMode entityMode)`
`protected EntityTuplizer`	`getTuplizer(SessionImplementor session)`
`Type`	`getType()` Get the type of the thing containing the properties
`DiscriminatorMetadata`	`getTypeDiscriminatorMetadata()` Retrieve the information needed to properly deal with this entity's discriminator in a query.
`Object`	`getVersion(Object object, EntityMode entityMode)` Get the version number (or timestamp) from the object's version property (or return null if not versioned)
`String`	`getVersionColumnName()` For versioned entities, get the name of the column (again, expected on the root table) used to store the version values.
`Comparator`	`getVersionComparator()` Get the comparator used to compare two different version values.
`protected String`	`getVersionedTableName()`
`int`	`getVersionProperty()` If `EntityPersister.isVersioned()`, then what is the index of the property holding the locking value.
`protected String`	`getVersionSelectString()`
`VersionType`	`getVersionType()` If `EntityPersister.isVersioned()`, then what is the type of the property holding the locking value.
`EntityMode`	`guessEntityMode(Object object)` Try to discover the entity mode from the entity instance
`boolean`	`hasCache()` Does this class have a cache.
`boolean`	`hasCascades()` Determine whether this entity has any non-none cascading.
`boolean`	`hasCollections()` Determine whether this entity contains references to persistent collections.
`protected boolean`	`hasEmbeddedCompositeIdentifier()`
`protected 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`	`hasLazyProperties()` Determine whether this entity defines any lazy properties (ala bytecode instrumentation).
`boolean`	`hasMutableProperties()` Determine whether any properties of this entity are considered mutable.
`boolean`	`hasNaturalIdentifier()` Determine whether this entity defines a natural identifier.
`boolean`	`hasProxy()` Determine whether this entity supports dynamic proxies.
`boolean`	`hasRowId()` Does the result set contain rowids?
`boolean`	`hasSequentialSelect()`
`boolean`	`hasSubclasses()` Does this persistent class have subclasses?
`boolean`	`hasSubselectLoadableCollections()` Determine whether this entity contains references to persistent collections which are fetchable by subselect?
`boolean`	`hasUninitializedLazyProperties(Object object, EntityMode entityMode)` Does the given instance have any uninitialized lazy properties?
`boolean`	`hasUpdateGeneratedProperties()` Does this entity define any properties as being database generated on update?
`protected boolean`	`hasWhere()`
`Object[]`	`hydrate(ResultSet rs, Serializable id, Object object, Loadable rootLoadable, String[][] suffixedPropertyColumns, boolean allProperties, SessionImplementor session)` Unmarshall the fields of a persistent instance from a result set, without resolving associations or collections.
`String`	`identifierSelectFragment(String name, String suffix)` Given a query alias and an identifying suffix, render the intentifier select fragment.
`boolean`	`implementsLifecycle(EntityMode entityMode)` Does the class implement the `Lifecycle` interface.
`boolean`	`implementsValidatable(EntityMode entityMode)` Does the class implement the `Validatable` interface.
`Object`	`initializeLazyProperty(String fieldName, Object entity, SessionImplementor session)` Initialize the property, and return its new value
`protected void`	`initLockers()`
`protected void`	`initPropertyPaths(Mapping mapping)`
`protected void`	`initSubclassPropertyAliasesMap(PersistentClass model)` Must be called by subclasses, at the end of their constructors
`protected Serializable`	`insert(Object[] fields, boolean[] notNull, String sql, Object object, SessionImplementor session)` Perform an SQL INSERT, and then retrieve a generated identifier.
`Serializable`	`insert(Object[] fields, Object object, SessionImplementor session)` Persist an instance, using a natively generated identifier (optional operation)
`protected void`	`insert(Serializable id, Object[] fields, boolean[] notNull, int j, String sql, Object object, SessionImplementor session)` Perform an SQL INSERT.
`void`	`insert(Serializable id, Object[] fields, Object object, SessionImplementor session)` Persist an instance
`Object`	`instantiate(Serializable id, EntityMode entityMode)` Create a class instance initialized with the given identifier
`Object`	`instantiate(Serializable id, SessionImplementor session)` Create a class instance initialized with the given identifier
`boolean`	`isAbstract()` Is this an abstract class?
`boolean`	`isBatchable()`
`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 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.
`protected boolean`	`isDeleteCallable(int j)`
`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.
`boolean`	`isInherited()` Determine whether the entity is inherited one or more other entities.
`protected boolean`	`isInsertCallable(int j)`
`boolean`	`isInstance(Object object, EntityMode entityMode)` Is the given object an instance of this entity?
`boolean`	`isInstrumented(EntityMode entityMode)` Has the class actually been bytecode instrumented?
`protected boolean`	`isInverseSubclassTable(int j)`
`protected boolean`	`isInverseTable(int j)`
`boolean`	`isLazyPropertiesCacheable()` Should lazy properties of this entity be cached?
`boolean`	`isMultiTable()` Is the inheritence hierarchy described by this persister contained across multiple tables?
`boolean`	`isMutable()` Determine whether instances of this entity are considered mutable.
`protected boolean`	`isNullableSubclassTable(int j)`
`protected boolean`	`isNullableTable(int j)`
`boolean`	`isPolymorphic()`
`protected abstract boolean`	`isPropertyOfTable(int property, int j)`
`boolean`	`isSelectBeforeUpdateRequired()` Is select snapshot before update enabled?
`boolean`	`isSubclassEntityName(String entityName)` Determine whether the given name represents a subclass entity (or this entity itself) of the entity mapped by this persister.
`protected boolean`	`isSubclassPropertyDeferred(String propertyName, String entityName)`
`boolean`	`isSubclassPropertyNullable(int i)` Is the numbered property of the class of subclass nullable?
`protected boolean`	`isSubclassTableLazy(int j)`
`protected boolean`	`isSubclassTableSequentialSelect(int j)`
`protected abstract boolean`	`isTableCascadeDeleteEnabled(int j)`
`Boolean`	`isTransient(Object entity, SessionImplementor session)` Is this a new transient instance?
`protected boolean`	`isUpdateCallable(int j)`
`boolean`	`isVersioned()` Determine whether optimistic locking by column is enabled for this entity.
`boolean`	`isVersionPropertyGenerated()` Does this entity contain a version property that is defined to be database generated?
`boolean`	`isVersionPropertyInsertable()` Is the version property included in insert statements?
`Object`	`load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)` Load an instance using either the `forUpdateLoader` or the outer joining `loader`, depending upon the value of the `lock` parameter
`Object`	`load(Serializable id, Object optionalObject, LockOptions lockOptions, SessionImplementor session)` Load an instance using either the `forUpdateLoader` or the outer joining `loader`, depending upon the value of the `lock` parameter
`Object`	`loadByUniqueKey(String propertyName, Object uniqueKey, SessionImplementor session)` Load an instance of the persistent class, by a unique key other than the primary key.
`void`	`lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)` Do a version check (optional operation)
`void`	`lock(Serializable id, Object version, Object object, LockOptions lockOptions, SessionImplementor session)` Do a version check (optional operation)
`protected void`	`logStaticSQL()`
`String`	`oneToManyFilterFragment(String alias)`
`protected int`	`optimisticLockMode()`
`protected void`	`postConstruct(Mapping mapping)`
`void`	`postInstantiate()` Finish the initialization of this object.
`void`	`processInsertGeneratedProperties(Serializable id, Object entity, Object[] state, SessionImplementor session)` Perform a select to retrieve the values of any generated properties back from the database, injecting these generated values into the given entity as well as writing this state to the `PersistenceContext`.
`void`	`processUpdateGeneratedProperties(Serializable id, Object entity, Object[] state, SessionImplementor 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`.
`String`	`propertySelectFragment(String tableAlias, String suffix, boolean allProperties)` Given a query alias and an identifying suffix, render the property select fragment.
`SelectFragment`	`propertySelectFragmentFragment(String tableAlias, String suffix, boolean allProperties)`
`void`	`registerAffectingFetchProfile(String fetchProfileName)` Register the name of a fetch profile determined to have an affect on the underlying loadable in regards to the fact that the underlying load SQL needs to be adjust when the given fetch profile is enabled.
`protected String`	`renderSelect(int[] tableNumbers, int[] columnNumbers, int[] formulaNumbers)`
`void`	`resetIdentifier(Object entity, Serializable currentId, Object currentVersion, EntityMode entityMode)` Set the identifier and version of the given instance back to its "unsaved" value.
`void`	`resetIdentifier(Object entity, Serializable currentId, Object currentVersion, SessionImplementor session)` Set the identifier and version of the given instance back to its "unsaved" value.
`String`	`selectFragment(Joinable rhs, String rhsAlias, String lhsAlias, String entitySuffix, String collectionSuffix, boolean includeCollectionColumns)` All columns to select, when loading.
`String`	`selectFragment(String alias, String suffix)` Generate a list of collection index, key and element columns
`void`	`setIdentifier(Object entity, Serializable id, EntityMode entityMode)` Inject the identifier value into the given entity.
`void`	`setIdentifier(Object entity, Serializable id, SessionImplementor session)` Inject the identifier value into the given entity.
`void`	`setPropertyValue(Object object, int i, Object value, EntityMode entityMode)` Set the value of a particular property
`void`	`setPropertyValue(Object object, String propertyName, Object value, EntityMode entityMode)` Set the value of a particular (named) property
`void`	`setPropertyValues(Object object, Object[] values, EntityMode entityMode)` Set the given values to the mapped properties of the given object
`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[]`	`toColumns(String alias, String propertyName)` Given a query alias and a property path, return the qualified column name
`String`	`toString()`
`Type`	`toType(String propertyName)` Given a component path expression, get the type of the property
`void`	`update(Serializable id, Object[] fields, int[] dirtyFields, boolean hasDirtyCollection, Object[] oldFields, Object oldVersion, Object object, Object rowId, SessionImplementor session)` Update an object
`protected boolean`	`update(Serializable id, Object[] fields, Object[] oldFields, Object rowId, boolean[] includeProperty, int j, Object oldVersion, Object object, String sql, SessionImplementor session)`
`protected void`	`updateOrInsert(Serializable id, Object[] fields, Object[] oldFields, Object rowId, boolean[] includeProperty, int j, Object oldVersion, Object object, String sql, SessionImplementor session)` Perform an SQL UPDATE or SQL INSERT
`protected boolean`	`useDynamicInsert()`
`protected boolean`	`useDynamicUpdate()`
`protected boolean`	`useGetGeneratedKeys()`
`protected boolean`	`useInsertSelectIdentity()`
`String`	`whereJoinFragment(String alias, boolean innerJoin, boolean includeSubclasses)` Get the where clause part of any joins (optional operation)

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

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

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

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

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

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

- Property Detail
  - hasIdentifier
    
    Specified by:
    
    hasIdentifierProperty in interface ClassMetadata
    
    Specified by:
    
    hasIdentifierProperty in interface EntityPersister
    
    Returns:
    True if the entity has a specific property holding identifier value.
- Field Detail
  - ENTITY_CLASS
```
public static final String ENTITY_CLASS
```
    See Also:
    Constant Field Values
  - rowIdName
```
protected final String rowIdName
```
  - insertCallable
```
protected boolean[] insertCallable
```
  - updateCallable
```
protected boolean[] updateCallable
```
  - deleteCallable
```
protected boolean[] deleteCallable
```
  - customSQLInsert
```
protected String[] customSQLInsert
```
  - customSQLUpdate
```
protected String[] customSQLUpdate
```
  - customSQLDelete
```
protected String[] customSQLDelete
```
  - insertResultCheckStyles
```
protected ExecuteUpdateResultCheckStyle[] insertResultCheckStyles
```
  - updateResultCheckStyles
```
protected ExecuteUpdateResultCheckStyle[] updateResultCheckStyles
```
  - deleteResultCheckStyles
```
protected ExecuteUpdateResultCheckStyle[] deleteResultCheckStyles
```
  - propertyMapping
```
protected final BasicEntityPropertyMapping propertyMapping
```
- Constructor Detail
  - AbstractEntityPersister
```
public AbstractEntityPersister(PersistentClass persistentClass,
                       EntityRegionAccessStrategy cacheAccessStrategy,
                       SessionFactoryImplementor factory)
                        throws HibernateException
```
    Throws:
    
    HibernateException
- Method Detail
  - addDiscriminatorToInsert
```
protected void addDiscriminatorToInsert(Insert insert)
```
  - addDiscriminatorToSelect
```
protected void addDiscriminatorToSelect(SelectFragment select,
                            String name,
                            String suffix)
```
  - getSubclassColumnTableNumberClosure
```
protected abstract int[] getSubclassColumnTableNumberClosure()
```
  - getSubclassFormulaTableNumberClosure
```
protected abstract int[] getSubclassFormulaTableNumberClosure()
```
  - 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.
    
    Returns:
  - getSubclassTableKeyColumns
```
protected abstract String[] getSubclassTableKeyColumns(int j)
```
  - isClassOrSuperclassTable
```
protected abstract boolean isClassOrSuperclassTable(int j)
```
  - getSubclassTableSpan
```
protected abstract int getSubclassTableSpan()
```
  - getTableSpan
```
protected abstract int getTableSpan()
```
  - isTableCascadeDeleteEnabled
```
protected abstract boolean isTableCascadeDeleteEnabled(int j)
```
  - getTableName
```
protected abstract String getTableName(int j)
```
  - getKeyColumns
```
protected abstract String[] getKeyColumns(int j)
```
  - isPropertyOfTable
```
protected abstract boolean isPropertyOfTable(int property,
                        int j)
```
  - getPropertyTableNumbersInSelect
```
protected abstract int[] getPropertyTableNumbersInSelect()
```
  - getPropertyTableNumbers
```
protected abstract int[] getPropertyTableNumbers()
```
  - getSubclassPropertyTableNumber
```
protected abstract int getSubclassPropertyTableNumber(int i)
```
  - filterFragment
```
protected abstract String filterFragment(String alias)
                                  throws MappingException
```
    Throws:
    
    MappingException
  - 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()
```
  - getDiscriminatorAlias
```
protected String getDiscriminatorAlias()
```
  - getDiscriminatorFormulaTemplate
```
protected String getDiscriminatorFormulaTemplate()
```
  - isInverseTable
```
protected boolean isInverseTable(int j)
```
  - isNullableTable
```
protected boolean isNullableTable(int j)
```
  - isNullableSubclassTable
```
protected boolean isNullableSubclassTable(int j)
```
  - isInverseSubclassTable
```
protected boolean isInverseSubclassTable(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.
  - 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.
  - getSQLUpdateByRowIdStrings
```
protected String[] getSQLUpdateByRowIdStrings()
```
  - getSQLLazyUpdateByRowIdStrings
```
protected String[] getSQLLazyUpdateByRowIdStrings()
```
  - getSQLSnapshotSelectString
```
protected String getSQLSnapshotSelectString()
```
  - getSQLLazySelectString
```
protected String getSQLLazySelectString()
```
  - getSQLDeleteStrings
```
protected String[] getSQLDeleteStrings()
```
  - getSQLInsertStrings
```
protected String[] getSQLInsertStrings()
```
  - getSQLUpdateStrings
```
protected String[] getSQLUpdateStrings()
```
  - getSQLLazyUpdateStrings
```
protected String[] getSQLLazyUpdateStrings()
```
  - getSQLIdentityInsertString
```
protected String getSQLIdentityInsertString()
```
    The query that inserts a row, letting the database generate an id
    
    Returns:
    The IDENTITY-based insertion query.
  - getVersionSelectString
```
protected String getVersionSelectString()
```
  - isInsertCallable
```
protected boolean isInsertCallable(int j)
```
  - isUpdateCallable
```
protected boolean isUpdateCallable(int j)
```
  - isDeleteCallable
```
protected boolean isDeleteCallable(int j)
```
  - isSubclassPropertyDeferred
```
protected boolean isSubclassPropertyDeferred(String propertyName,
                                 String entityName)
```
  - isSubclassTableSequentialSelect
```
protected boolean isSubclassTableSequentialSelect(int j)
```
  - hasSequentialSelect
```
public boolean hasSequentialSelect()
```
  - getTableUpdateNeeded
```
protected boolean[] getTableUpdateNeeded(int[] dirtyProperties,
                             boolean hasDirtyCollection)
```
    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.
  - hasRowId
```
public boolean hasRowId()
```
    Description copied from interface: Loadable
    
    Does the result set contain rowids?
    
    Specified by:
    
    hasRowId in interface Loadable
  - getPropertyColumnUpdateable
```
protected boolean[][] getPropertyColumnUpdateable()
```
  - getPropertyColumnInsertable
```
protected boolean[][] getPropertyColumnInsertable()
```
  - getPropertySelectable
```
protected boolean[] getPropertySelectable()
```
  - generateLazySelectString
```
protected String generateLazySelectString()
```
  - initializeLazyProperty
```
public Object initializeLazyProperty(String fieldName,
                            Object entity,
                            SessionImplementor session)
                              throws HibernateException
```
    Description copied from interface: LazyPropertyInitializer
    
    Initialize the property, and return its new value
    
    Specified by:
    
    initializeLazyProperty in interface LazyPropertyInitializer
    
    Throws:
    
    HibernateException
  - isBatchable
```
public boolean isBatchable()
```
  - 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.
  - getLazyProperties
```
protected Set getLazyProperties()
```
  - isBatchLoadable
```
public boolean isBatchLoadable()
```
    Description copied from interface: EntityPersister
    
    Is batch loading enabled?
    
    Specified by:
    
    isBatchLoadable in interface 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 PostInsertIdentityPersister
    
    Specified by:
    
    getIdentifierColumnNames in interface Loadable
    
    Specified by:
    
    getIdentifierColumnNames in interface Queryable
  - getIdentifierColumnReaders
```
public String[] getIdentifierColumnReaders()
```
  - getIdentifierColumnReaderTemplates
```
public String[] getIdentifierColumnReaderTemplates()
```
  - getIdentifierColumnSpan
```
protected int getIdentifierColumnSpan()
```
  - getIdentifierAliases
```
protected 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
```
protected String getVersionedTableName()
```
  - getSubclassColumnLazyiness
```
protected boolean[] getSubclassColumnLazyiness()
```
  - getSubclassFormulaLazyiness
```
protected boolean[] getSubclassFormulaLazyiness()
```
  - 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 can happen if (a) the item is not versioned and either (b) we have dynamic update enabled or (c) we have multiple tables holding the state of the item.
    
    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
  - 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
  - identifierSelectFragment
```
public String identifierSelectFragment(String name,
                              String suffix)
```
    Description copied from interface: Queryable
    
    Given a query alias and an identifying suffix, render the intentifier select fragment.
    
    Specified by:
    
    identifierSelectFragment in interface Queryable
  - propertySelectFragment
```
public String propertySelectFragment(String tableAlias,
                            String suffix,
                            boolean allProperties)
```
    Description copied from interface: Queryable
    
    Given a query alias and an identifying suffix, render the property select fragment.
    
    Specified by:
    
    propertySelectFragment in interface Queryable
  - propertySelectFragmentFragment
```
public SelectFragment propertySelectFragmentFragment(String tableAlias,
                                            String suffix,
                                            boolean allProperties)
```
    Specified by:
    
    propertySelectFragmentFragment in interface Queryable
  - getDatabaseSnapshot
```
public Object[] getDatabaseSnapshot(Serializable id,
                           SessionImplementor 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
  - generateSelectVersionString
```
protected String generateSelectVersionString()
```
    Generate the SQL that selects the version number by id
  - getPropertyUniqueness
```
public boolean[] getPropertyUniqueness()
```
  - generateInsertGeneratedValuesSelectString
```
protected String generateInsertGeneratedValuesSelectString()
```
  - generateUpdateGeneratedValuesSelectString
```
protected String generateUpdateGeneratedValuesSelectString()
```
  - concretePropertySelectFragment
```
protected String concretePropertySelectFragment(String alias,
                                    ValueInclusion[] inclusions)
```
  - concretePropertySelectFragment
```
protected String concretePropertySelectFragment(String alias,
                                    boolean[] includeProperty)
```
  - concretePropertySelectFragment
```
protected String concretePropertySelectFragment(String alias,
                                    AbstractEntityPersister.InclusionChecker inclusionChecker)
```
  - generateSnapshotSelectString
```
protected String generateSnapshotSelectString()
```
  - forceVersionIncrement
```
public Object forceVersionIncrement(Serializable id,
                           Object currentVersion,
                           SessionImplementor session)
```
    Specified by:
    
    forceVersionIncrement in interface EntityPersister
  - getCurrentVersion
```
public Object getCurrentVersion(Serializable id,
                       SessionImplementor session)
                         throws HibernateException
```
    Retrieve the version number
    
    Specified by:
    
    getCurrentVersion in interface EntityPersister
    
    Throws:
    
    HibernateException
  - initLockers
```
protected void initLockers()
```
  - generateLocker
```
protected LockingStrategy generateLocker(LockMode lockMode)
```
  - lock
```
public void lock(Serializable id,
        Object version,
        Object object,
        LockMode lockMode,
        SessionImplementor 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(Serializable id,
        Object version,
        Object object,
        LockOptions lockOptions,
        SessionImplementor 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 alias,
                 String propertyName)
                   throws QueryException
```
    Description copied from interface: PropertyMapping
    
    Given a query alias and a property path, return the qualified column name
    
    Specified by:
    
    toColumns in interface PropertyMapping
    
    Throws:
    
    QueryException
  - toColumns
```
public String[] toColumns(String propertyName)
                   throws QueryException
```
    Description copied from interface: PropertyMapping
    
    Given a property path, return the corresponding column name(s).
    
    Specified by:
    
    toColumns in interface PropertyMapping
    
    Throws:
    
    QueryException
  - toType
```
public Type toType(String propertyName)
            throws QueryException
```
    Description copied from interface: PropertyMapping
    
    Given a component path expression, get the type of the property
    
    Specified by:
    
    toType in interface PropertyMapping
    
    Throws:
    
    QueryException
  - getPropertyColumnNames
```
public String[] getPropertyColumnNames(String propertyName)
```
    Description copied from interface: OuterJoinLoadable
    
    Get the column names for the given property path
    
    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 nunber 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
  - 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
```
protected 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
  - getPropertySubclassNames
```
protected String[] getPropertySubclassNames()
```
  - 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
```
protected int getPropertyColumnSpan(int i)
```
  - hasFormulaProperties
```
protected 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
```
protected String[][] getSubclassPropertyFormulaTemplateClosure()
```
  - getSubclassPropertyTypeClosure
```
protected Type[] getSubclassPropertyTypeClosure()
```
  - getSubclassPropertyColumnNameClosure
```
protected String[][] getSubclassPropertyColumnNameClosure()
```
  - getSubclassPropertyColumnReaderClosure
```
public String[][] getSubclassPropertyColumnReaderClosure()
```
  - getSubclassPropertyColumnReaderTemplateClosure
```
public String[][] getSubclassPropertyColumnReaderTemplateClosure()
```
  - getSubclassPropertyNameClosure
```
protected String[] getSubclassPropertyNameClosure()
```
  - getSubclassPropertySubclassNameClosure
```
protected String[] getSubclassPropertySubclassNameClosure()
```
  - getSubclassColumnClosure
```
protected String[] getSubclassColumnClosure()
```
  - getSubclassColumnAliasClosure
```
protected String[] getSubclassColumnAliasClosure()
```
  - getSubclassColumnReaderTemplateClosure
```
public String[] getSubclassColumnReaderTemplateClosure()
```
  - getSubclassFormulaClosure
```
protected String[] getSubclassFormulaClosure()
```
  - getSubclassFormulaTemplateClosure
```
protected String[] getSubclassFormulaTemplateClosure()
```
  - getSubclassFormulaAliasClosure
```
protected String[] getSubclassFormulaAliasClosure()
```
  - getSubclassPropertyColumnAliases
```
public String[] getSubclassPropertyColumnAliases(String propertyName,
                                        String suffix)
```
    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
  - 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
  - initSubclassPropertyAliasesMap
```
protected void initSubclassPropertyAliasesMap(PersistentClass model)
                                       throws MappingException
```
    Must be called by subclasses, at the end of their constructors
    
    Throws:
    
    MappingException
  - loadByUniqueKey
```
public Object loadByUniqueKey(String propertyName,
                     Object uniqueKey,
                     SessionImplementor session)
                       throws HibernateException
```
    Description copied from interface: UniqueKeyLoadable
    
    Load an instance of the persistent class, by a unique key other than the primary key.
    
    Specified by:
    
    loadByUniqueKey in interface UniqueKeyLoadable
    
    Throws:
    
    HibernateException
  - 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 UniqueKeyLoadable
  - createUniqueKeyLoaders
```
protected void createUniqueKeyLoaders()
                               throws MappingException
```
    Throws:
    
    MappingException
  - getSQLWhereString
```
protected String getSQLWhereString(String alias)
```
  - hasWhere
```
protected boolean hasWhere()
```
  - initPropertyPaths
```
protected void initPropertyPaths(Mapping mapping)
                          throws MappingException
```
    Throws:
    
    MappingException
  - createEntityLoader
```
protected UniqueEntityLoader createEntityLoader(LockMode lockMode,
                                    LoadQueryInfluencers loadQueryInfluencers)
                                         throws MappingException
```
    Throws:
    
    MappingException
  - createEntityLoader
```
protected UniqueEntityLoader createEntityLoader(LockOptions lockOptions,
                                    LoadQueryInfluencers loadQueryInfluencers)
                                         throws MappingException
```
    Throws:
    
    MappingException
  - createEntityLoader
```
protected UniqueEntityLoader createEntityLoader(LockMode lockMode)
                                         throws MappingException
```
    Throws:
    
    MappingException
  - check
```
protected boolean check(int rows,
            Serializable id,
            int tableNumber,
            Expectation expectation,
            PreparedStatement statement)
                 throws HibernateException
```
    Throws:
    
    HibernateException
  - generateUpdateString
```
protected String generateUpdateString(boolean[] includeProperty,
                          int j,
                          boolean useRowId)
```
  - generateUpdateString
```
protected String generateUpdateString(boolean[] includeProperty,
                          int j,
                          Object[] oldFields,
                          boolean useRowId)
```
    Generate the SQL that updates a row by id (and version)
  - generateInsertString
```
protected String generateInsertString(boolean[] includeProperty,
                          int j)
```
  - generateInsertString
```
protected String generateInsertString(boolean identityInsert,
                          boolean[] includeProperty)
```
  - generateInsertString
```
protected String generateInsertString(boolean identityInsert,
                          boolean[] includeProperty,
                          int j)
```
    Generate the SQL that inserts a row
  - generateIdentityInsertString
```
protected String generateIdentityInsertString(boolean[] includeProperty)
```
    Used to generate an insery statement against the root table in the case of identifier generation strategies where the insert statement executions actually generates the identifier value.
    
    Parameters:
    includeProperty - indices of the properties to include in the insert statement.
    
    Returns:
    The insert SQL statement string
  - generateDeleteString
```
protected String generateDeleteString(int j)
```
    Generate the SQL that deletes a row by id (and version)
  - dehydrate
```
protected int dehydrate(Serializable id,
            Object[] fields,
            boolean[] includeProperty,
            boolean[][] includeColumns,
            int j,
            PreparedStatement st,
            SessionImplementor session)
                 throws HibernateException,
                        SQLException
```
    Throws:
    
    HibernateException
    
    SQLException
  - dehydrate
```
protected int dehydrate(Serializable id,
            Object[] fields,
            Object rowId,
            boolean[] includeProperty,
            boolean[][] includeColumns,
            int j,
            PreparedStatement ps,
            SessionImplementor session,
            int index)
                 throws SQLException,
                        HibernateException
```
    Marshall the fields of a persistent instance to a prepared statement
    
    Throws:
    
    SQLException
    
    HibernateException
  - hydrate
```
public Object[] hydrate(ResultSet rs,
               Serializable id,
               Object object,
               Loadable rootLoadable,
               String[][] suffixedPropertyColumns,
               boolean allProperties,
               SessionImplementor session)
                 throws SQLException,
                        HibernateException
```
    Unmarshall the fields of a persistent instance from a result set, without resolving associations or collections. Question: should this really be here, or should it be sent back to Loader?
    
    Specified by:
    
    hydrate in interface Loadable
    
    Throws:
    
    SQLException
    
    HibernateException
  - useInsertSelectIdentity
```
protected boolean useInsertSelectIdentity()
```
  - useGetGeneratedKeys
```
protected boolean useGetGeneratedKeys()
```
  - getSequentialSelect
```
protected String getSequentialSelect(String entityName)
```
  - insert
```
protected Serializable insert(Object[] fields,
                  boolean[] notNull,
                  String sql,
                  Object object,
                  SessionImplementor session)
                       throws HibernateException
```
    Perform an SQL INSERT, and then retrieve a generated identifier.
    This form is used for PostInsertIdentifierGenerator-style ids (IDENTITY, select, etc).
    
    Throws:
    
    HibernateException
  - 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
  - insert
```
protected void insert(Serializable id,
          Object[] fields,
          boolean[] notNull,
          int j,
          String sql,
          Object object,
          SessionImplementor session)
               throws HibernateException
```
    Perform an SQL INSERT.
    This for is used for all non-root tables as well as the root table in cases where the identifier value is known before the insert occurs.
    
    Throws:
    
    HibernateException
  - updateOrInsert
```
protected void updateOrInsert(Serializable id,
                  Object[] fields,
                  Object[] oldFields,
                  Object rowId,
                  boolean[] includeProperty,
                  int j,
                  Object oldVersion,
                  Object object,
                  String sql,
                  SessionImplementor session)
                       throws HibernateException
```
    Perform an SQL UPDATE or SQL INSERT
    
    Throws:
    
    HibernateException
  - update
```
protected boolean update(Serializable id,
             Object[] fields,
             Object[] oldFields,
             Object rowId,
             boolean[] includeProperty,
             int j,
             Object oldVersion,
             Object object,
             String sql,
             SessionImplementor session)
                  throws HibernateException
```
    Throws:
    
    HibernateException
  - delete
```
protected void delete(Serializable id,
          Object version,
          int j,
          Object object,
          String sql,
          SessionImplementor session,
          Object[] loadedState)
               throws HibernateException
```
    Perform an SQL DELETE
    
    Throws:
    
    HibernateException
  - update
```
public void update(Serializable id,
          Object[] fields,
          int[] dirtyFields,
          boolean hasDirtyCollection,
          Object[] oldFields,
          Object oldVersion,
          Object object,
          Object rowId,
          SessionImplementor session)
            throws HibernateException
```
    Update an object
    
    Specified by:
    
    update in interface EntityPersister
    
    Throws:
    
    HibernateException
  - insert
```
public Serializable insert(Object[] fields,
                  Object object,
                  SessionImplementor session)
                    throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Persist an instance, using a natively generated identifier (optional operation)
    
    Specified by:
    
    insert in interface EntityPersister
    
    Throws:
    
    HibernateException
  - insert
```
public void insert(Serializable id,
          Object[] fields,
          Object object,
          SessionImplementor session)
            throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Persist an instance
    
    Specified by:
    
    insert in interface EntityPersister
    
    Throws:
    
    HibernateException
  - delete
```
public void delete(Serializable id,
          Object version,
          Object object,
          SessionImplementor session)
            throws HibernateException
```
    Delete an object
    
    Specified by:
    
    delete in interface EntityPersister
    
    Throws:
    
    HibernateException
  - logStaticSQL
```
protected void logStaticSQL()
```
  - filterFragment
```
public String filterFragment(String alias,
                    Map enabledFilters)
                      throws MappingException
```
    Description copied from interface: Joinable
    
    Get the where clause filter, given a query alias and considering enabled session filters
    
    Specified by:
    
    filterFragment in interface Joinable
    
    Throws:
    
    MappingException
  - 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 inheritence mapping strategy.
    
    Specified by:
    
    generateFilterConditionAlias in interface Queryable
    
    Parameters:
    rootAlias - The root alias
    
    Returns:
    The alias used for "filter conditions" within the where clause.
  - oneToManyFilterFragment
```
public String oneToManyFilterFragment(String alias)
                               throws MappingException
```
    Specified by:
    
    oneToManyFilterFragment in interface Joinable
    
    Throws:
    
    MappingException
  - fromJoinFragment
```
public String fromJoinFragment(String alias,
                      boolean innerJoin,
                      boolean includeSubclasses)
```
    Description copied from interface: Joinable
    
    Get the from clause part of any joins (optional operation)
    
    Specified by:
    
    fromJoinFragment in interface Joinable
  - whereJoinFragment
```
public String whereJoinFragment(String alias,
                       boolean innerJoin,
                       boolean includeSubclasses)
```
    Description copied from interface: Joinable
    
    Get the where clause part of any joins (optional operation)
    
    Specified by:
    
    whereJoinFragment in interface Joinable
  - isSubclassTableLazy
```
protected boolean isSubclassTableLazy(int j)
```
  - createJoin
```
protected JoinFragment createJoin(String name,
                      boolean innerJoin,
                      boolean includeSubclasses)
```
  - createJoin
```
protected JoinFragment createJoin(int[] tableNumbers,
                      String drivingAlias)
```
  - createSelect
```
protected SelectFragment createSelect(int[] subclassColumnNumbers,
                          int[] subclassFormulaNumbers)
```
  - createFrom
```
protected String createFrom(int tableNumber,
                String alias)
```
  - createWhereByKey
```
protected String createWhereByKey(int tableNumber,
                      String alias)
```
  - renderSelect
```
protected String renderSelect(int[] tableNumbers,
                  int[] columnNumbers,
                  int[] formulaNumbers)
```
  - postConstruct
```
protected void postConstruct(Mapping mapping)
                      throws MappingException
```
    Throws:
    
    MappingException
  - postInstantiate
```
public void postInstantiate()
                     throws MappingException
```
    Description copied from interface: EntityPersister
    
    Finish the initialization of this object.
    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.
  - getLoaders
```
protected Map getLoaders()
```
  - createLoaders
```
protected void createLoaders()
```
  - createQueryLoader
```
protected void createQueryLoader()
```
  - load
```
public Object load(Serializable id,
          Object optionalObject,
          LockMode lockMode,
          SessionImplementor 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(Serializable id,
          Object optionalObject,
          LockOptions lockOptions,
          SessionImplementor 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
  - registerAffectingFetchProfile
```
public void registerAffectingFetchProfile(String fetchProfileName)
```
    Description copied from interface: Loadable
    
    Register the name of a fetch profile determined to have an affect on the underlying loadable in regards to the fact that the underlying load SQL needs to be adjust when the given fetch profile is enabled.
    
    Specified by:
    
    registerAffectingFetchProfile in interface Loadable
    
    Parameters:
    fetchProfileName - The name of the profile affecting this.
  - 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
  - getPropertiesToUpdate
```
protected final boolean[] getPropertiesToUpdate(int[] dirtyProperties,
                              boolean hasDirtyCollection)
```
    Transform the array of property indexes to an array of booleans, true when the property is dirty
  - getPropertiesToInsert
```
protected boolean[] getPropertiesToInsert(Object[] fields)
```
    Transform the array of property indexes to an array of booleans, true when the property is insertable and non-null
  - findDirty
```
public int[] findDirty(Object[] currentState,
              Object[] previousState,
              Object entity,
              SessionImplementor 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 ccurring.
    
    Returns:
    null or the indices of the dirty properties
    
    Throws:
    
    HibernateException
  - findModified
```
public int[] findModified(Object[] old,
                 Object[] current,
                 Object entity,
                 SessionImplementor 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 ccurring.
    
    Returns:
    null or the indices of the modified properties
    
    Throws:
    
    HibernateException
  - getPropertyUpdateability
```
protected boolean[] getPropertyUpdateability(Object entity,
                                 EntityMode entityMode)
```
    Which properties appear in the SQL update? (Initialized, updateable ones!)
  - getTuplizer
```
protected EntityTuplizer getTuplizer(SessionImplementor session)
```
  - getTuplizer
```
protected EntityTuplizer getTuplizer(EntityMode entityMode)
```
  - 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
  - hasCache
```
public boolean hasCache()
```
    Description copied from interface: EntityPersister
    
    Does this class have a cache.
    
    Specified by:
    
    hasCache in interface EntityPersister
  - getCacheAccessStrategy
```
public EntityRegionAccessStrategy 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
  - getVersionComparator
```
public Comparator getVersionComparator()
```
    Description copied from interface: OptimisticCacheSource
    
    Get the comparator used to compare two different version values.
    May return null if OptimisticCacheSource.isVersioned() returns false.
    
    Specified by:
    
    getVersionComparator in interface OptimisticCacheSource
    
    Returns:
  - getEntityName
```
public final String getEntityName()
```
    Description copied from interface: EntityPersister
    
    The entity name which this persister maps.
    
    Specified by:
    
    getEntityName in interface ClassMetadata
    
    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).
  - 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 VersionType 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 OptimisticCacheSource
    
    Specified by:
    
    isVersioned in interface ClassMetadata
    
    Specified by:
    
    isVersioned in interface EntityPersister
    
    Returns:
    True if optimistic locking by column (i.e., or ) 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 (ala bytecode instrumentation).
    
    Specified by:
    
    hasLazyProperties in interface EntityPersister
    
    Returns:
    True if the entity has properties mapped as lazy; false otherwise.
  - afterReassociate
```
public void afterReassociate(Object entity,
                    SessionImplementor 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,
                  SessionImplementor 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: Queryable
    
    Is this an abstract class?
    
    Specified by:
    
    isAbstract in interface Loadable
    
    Specified by:
    
    isAbstract in interface Queryable
  - hasSubclasses
```
public boolean hasSubclasses()
```
    Description copied from interface: Loadable
    
    Does this persistent class have subclasses?
    
    Specified by:
    
    hasSubclasses in interface ClassMetadata
    
    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
```
public IdentifierGenerator getIdentifierGenerator()
                                           throws HibernateException
```
    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
  - 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
```
public ClassMetadata getClassMetadata()
```
    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: Queryable
    
    Get the class that this class is mapped as a subclass of - not necessarily the direct superclass
    
    Specified by:
    
    getMappedSuperclass in interface Queryable
  - isExplicitPolymorphism
```
public boolean isExplicitPolymorphism()
```
    Description copied from interface: Queryable
    
    Is this class explicit polymorphism only?
    
    Specified by:
    
    isExplicitPolymorphism in interface Queryable
  - useDynamicUpdate
```
protected boolean useDynamicUpdate()
```
  - useDynamicInsert
```
protected boolean useDynamicInsert()
```
  - hasEmbeddedCompositeIdentifier
```
protected boolean hasEmbeddedCompositeIdentifier()
```
  - canExtractIdOutOfEntity
```
public boolean canExtractIdOutOfEntity()
```
    Description copied from interface: EntityPersister
    
    Determine whether detached instances of this entity carry their own identifier value.
    The other option is the deprecated feature where users could supply the id during session calls.
    
    Specified by:
    
    canExtractIdOutOfEntity in interface EntityPersister
    
    Returns:
    True if either (1) EntityPersister.hasIdentifierProperty() or (2) the identifier is an embedded composite identifier; false otherwise.
  - 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
```
public Type getPropertyType(String propertyName)
                     throws MappingException
```
    Description copied from interface: EntityPersister
    
    Get the type of a particular property by name.
    
    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: PropertyMapping
    
    Get the type of the thing containing the properties
    
    Specified by:
    
    getType in interface PropertyMapping
    
    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
  - optimisticLockMode
```
protected final int optimisticLockMode()
```
  - createProxy
```
public Object createProxy(Serializable id,
                 SessionImplementor 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
  - selectFragment
```
public final String selectFragment(Joinable rhs,
                    String rhsAlias,
                    String lhsAlias,
                    String entitySuffix,
                    String collectionSuffix,
                    boolean includeCollectionColumns)
```
    Description copied from interface: Joinable
    
    All columns to select, when loading.
    
    Specified by:
    
    selectFragment in interface Joinable
  - isInstrumented
```
public boolean isInstrumented(EntityMode entityMode)
```
    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
  - afterInitialize
```
public void afterInitialize(Object entity,
                   boolean lazyPropertiesAreUnfetched,
                   SessionImplementor 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
  - getPropertyInsertGenerationInclusions
```
public ValueInclusion[] getPropertyInsertGenerationInclusions()
```
    Description copied from interface: EntityPersister
    
    Which of the properties of this class are database generated values on insert?
    
    Specified by:
    
    getPropertyInsertGenerationInclusions in interface EntityPersister
  - getPropertyUpdateGenerationInclusions
```
public ValueInclusion[] getPropertyUpdateGenerationInclusions()
```
    Description copied from interface: EntityPersister
    
    Which of the properties of this class are database generated values on update?
    
    Specified by:
    
    getPropertyUpdateGenerationInclusions 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
  - getMappedClass
```
public final Class getMappedClass(EntityMode entityMode)
```
    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(EntityMode entityMode)
```
    Description copied from interface: EntityPersister
    
    Does the class implement the Lifecycle interface.
    
    Specified by:
    
    implementsLifecycle in interface ClassMetadata
    
    Specified by:
    
    implementsLifecycle in interface EntityPersister
  - implementsValidatable
```
public boolean implementsValidatable(EntityMode entityMode)
```
    Description copied from interface: EntityPersister
    
    Does the class implement the Validatable interface.
    
    Specified by:
    
    implementsValidatable in interface ClassMetadata
    
    Specified by:
    
    implementsValidatable in interface EntityPersister
  - getConcreteProxyClass
```
public Class getConcreteProxyClass(EntityMode entityMode)
```
    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,
                     EntityMode entityMode)
                       throws HibernateException
```
    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
    
    Throws:
    
    HibernateException
  - setPropertyValue
```
public void setPropertyValue(Object object,
                    int i,
                    Object value,
                    EntityMode entityMode)
                      throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Set the value of a particular property
    
    Specified by:
    
    setPropertyValue in interface EntityPersister
    
    Throws:
    
    HibernateException
  - getPropertyValues
```
public Object[] getPropertyValues(Object object,
                         EntityMode entityMode)
                           throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Return the (loaded) values of the mapped properties of the object (not including backrefs)
    
    Specified by:
    
    getPropertyValues in interface ClassMetadata
    
    Specified by:
    
    getPropertyValues in interface EntityPersister
    
    Parameters:
    object - The entity from which to extract the property values.
    entityMode - The entity-mode of the given entity
    
    Returns:
    The property values.
    
    Throws:
    
    HibernateException
  - getPropertyValue
```
public Object getPropertyValue(Object object,
                      int i,
                      EntityMode entityMode)
                        throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Get the value of a particular property
    
    Specified by:
    
    getPropertyValue in interface EntityPersister
    
    Throws:
    
    HibernateException
  - getPropertyValue
```
public Object getPropertyValue(Object object,
                      String propertyName,
                      EntityMode entityMode)
                        throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Get the value of a particular property
    
    Specified by:
    
    getPropertyValue in interface ClassMetadata
    
    Specified by:
    
    getPropertyValue in interface EntityPersister
    
    Throws:
    
    HibernateException
  - getIdentifier
```
public Serializable getIdentifier(Object object,
                         EntityMode entityMode)
                           throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Get the identifier of an instance (throw an exception if no identifier property)
    
    Specified by:
    
    getIdentifier in interface ClassMetadata
    
    Specified by:
    
    getIdentifier in interface EntityPersister
    
    Throws:
    
    HibernateException
  - getIdentifier
```
public Serializable getIdentifier(Object entity,
                         SessionImplementor session)
```
    Description copied from interface: EntityPersister
    
    Get the identifier of an instance (throw an exception if 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,
                 Serializable id,
                 EntityMode entityMode)
                   throws HibernateException
```
    Inject the identifier value into the given entity.
    Has no effect if the entity does not define an identifier property
    
    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.
    entityMode - The entity mode
    
    Throws:
    
    HibernateException
  - setIdentifier
```
public void setIdentifier(Object entity,
                 Serializable id,
                 SessionImplementor session)
```
    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,
                EntityMode entityMode)
                  throws HibernateException
```
    Description copied from interface: EntityPersister
    
    Get the version number (or timestamp) from the object's version property (or return null if not versioned)
    
    Specified by:
    
    getVersion in interface ClassMetadata
    
    Specified by:
    
    getVersion in interface EntityPersister
    
    Throws:
    
    HibernateException
  - instantiate
```
public Object instantiate(Serializable id,
                 EntityMode entityMode)
                   throws HibernateException
```
    Create a class instance initialized with the given identifier
    
    Specified by:
    
    instantiate in interface ClassMetadata
    
    Specified by:
    
    instantiate in interface EntityPersister
    
    Throws:
    
    HibernateException
  - instantiate
```
public Object instantiate(Serializable id,
                 SessionImplementor session)
                   throws HibernateException
```
    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.
    
    Throws:
    
    HibernateException
  - isInstance
```
public boolean isInstance(Object object,
                 EntityMode entityMode)
```
    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,
                                     EntityMode entityMode)
```
    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,
                   Serializable currentId,
                   Object currentVersion,
                   EntityMode entityMode)
```
    Description copied from interface: EntityPersister
    
    Set the identifier and version of the given instance back to its "unsaved" value.
    
    Specified by:
    
    resetIdentifier in interface EntityPersister
    
    Parameters:
    entity - The entity instance
    currentId - The currently assigned identifier value.
    currentVersion - The currently assigned version value.
    entityMode - The entity mode represented by the entity instance.
  - resetIdentifier
```
public void resetIdentifier(Object entity,
                   Serializable currentId,
                   Object currentVersion,
                   SessionImplementor session)
```
    Description copied from interface: EntityPersister
    
    Set the identifier and version of the given instance back to its "unsaved" value.
    
    Specified by:
    
    resetIdentifier in interface EntityPersister
    
    Parameters:
    entity - The entity instance
    currentId - The currently assigned identifier value.
    currentVersion - The currently assigned version value.
    session - The session from which the request originated.
  - getSubclassEntityPersister
```
public EntityPersister getSubclassEntityPersister(Object instance,
                                         SessionFactoryImplementor factory,
                                         EntityMode entityMode)
```
    A request has already identified the entity-name of this persister as the mapping for the given instance. However, we still need to account for possible subclassing and potentially re-route to the more appropriate persister.
    For example, a request names Animal as the entity-name which gets resolved to this persister. But the actual instance is really an instance of Cat which is a subclass of Animal. So, here the Animal persister is being asked to return the persister specific to Cat.
    It is also possible that the instance is actually an Animal instance in the above example in which case we would return this from this method.
    
    Specified by:
    
    getSubclassEntityPersister in interface EntityPersister
    
    Parameters:
    instance - The entity instance
    factory - Reference to the SessionFactory
    entityMode - The entity mode represented by the entity instance.
    
    Returns:
    The appropriate persister
  - guessEntityMode
```
public EntityMode guessEntityMode(Object object)
```
    Description copied from interface: EntityPersister
    
    Try to discover the entity mode from the entity instance
    
    Specified by:
    
    guessEntityMode in interface EntityPersister
  - isMultiTable
```
public boolean isMultiTable()
```
    Description copied from interface: Queryable
    
    Is the inheritence hierarchy described by this persister contained across multiple tables?
    
    Specified by:
    
    isMultiTable in interface Queryable
    
    Returns:
    True if the inheritence hierarchy is spread across multiple tables; false otherwise.
  - getTemporaryIdTableName
```
public String getTemporaryIdTableName()
```
    Description copied from interface: Queryable
    
    Get the name of the temporary table to be used to (potentially) store id values when performing bulk update/deletes.
    
    Specified by:
    
    getTemporaryIdTableName in interface Queryable
    
    Returns:
    The appropriate temporary table name.
  - getTemporaryIdTableDDL
```
public String getTemporaryIdTableDDL()
```
    Description copied from interface: Queryable
    
    Get the appropriate DDL command for generating the temporary table to be used to (potentially) store id values when performing bulk update/deletes.
    
    Specified by:
    
    getTemporaryIdTableDDL in interface Queryable
    
    Returns:
    The appropriate temporary table creation command.
  - getPropertySpan
```
protected int getPropertySpan()
```
  - getPropertyValuesToInsert
```
public Object[] getPropertyValuesToInsert(Object object,
                                 Map mergeMap,
                                 SessionImplementor 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
  - processInsertGeneratedProperties
```
public void processInsertGeneratedProperties(Serializable id,
                                    Object entity,
                                    Object[] state,
                                    SessionImplementor 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
    
    Parameters:
    id - The entity's id value.
    entity - The entity for which to get the state.
    session - The session
  - processUpdateGeneratedProperties
```
public void processUpdateGeneratedProperties(Serializable id,
                                    Object entity,
                                    Object[] state,
                                    SessionImplementor 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
    
    Parameters:
    id - The entity's id value.
    entity - The entity for which to get the state.
    session - The session
  - 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.
  - getNaturalIdentifierProperties
```
public int[] getNaturalIdentifierProperties()
```
    Description copied from interface: EntityPersister
    
    If the entity defines a natural id (EntityPersister.hasNaturalIdentifier()), which properties make up the natural id.
    
    Specified by:
    
    getNaturalIdentifierProperties in interface ClassMetadata
    
    Specified by:
    
    getNaturalIdentifierProperties in interface EntityPersister
    
    Returns:
    The indices of the properties making of the natural id; or null, if no natural id is defined.
  - getNaturalIdentifierSnapshot
```
public Object[] getNaturalIdentifierSnapshot(Serializable id,
                                    SessionImplementor session)
                                      throws HibernateException
```
    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.
    
    Throws:
    
    HibernateException
  - concretePropertySelectFragmentSansLeadingComma
```
protected String concretePropertySelectFragmentSansLeadingComma(String alias,
                                                    boolean[] include)
```
  - 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,
                    EntityMode entityMode)
                      throws HibernateException
```
    Description copied from interface: ClassMetadata
    
    Set the value of a particular (named) property
    
    Specified by:
    
    setPropertyValue in interface ClassMetadata
    
    Throws:
    
    HibernateException

Class AbstractEntityPersister

Property Summary

Nested Class Summary

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

Field Summary

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

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

Fields inherited from interface org.hibernate.intercept.LazyPropertyInitializer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

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

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

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

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

Property Detail

hasIdentifier

Field Detail

ENTITY_CLASS

rowIdName

insertCallable

updateCallable

deleteCallable

customSQLInsert

customSQLUpdate

customSQLDelete

insertResultCheckStyles

updateResultCheckStyles

deleteResultCheckStyles

propertyMapping

Constructor Detail

AbstractEntityPersister

Method Detail

addDiscriminatorToInsert

addDiscriminatorToSelect

getSubclassColumnTableNumberClosure

getSubclassFormulaTableNumberClosure

getSubclassTableName

getSubclassTableKeyColumns

isClassOrSuperclassTable

getSubclassTableSpan

getTableSpan

isTableCascadeDeleteEnabled

getTableName

getKeyColumns

isPropertyOfTable

getPropertyTableNumbersInSelect

getPropertyTableNumbers

getSubclassPropertyTableNumber

filterFragment

getDiscriminatorColumnName

getDiscriminatorColumnReaders

getDiscriminatorColumnReaderTemplate

getDiscriminatorAlias

getDiscriminatorFormulaTemplate

isInverseTable

isNullableTable

isNullableSubclassTable

isInverseSubclassTable

isSubclassEntityName

getRootTableKeyColumnNames

getSQLUpdateByRowIdStrings

getSQLLazyUpdateByRowIdStrings

getSQLSnapshotSelectString

getSQLLazySelectString

getSQLDeleteStrings

getSQLInsertStrings

getSQLUpdateStrings

getSQLLazyUpdateStrings

getSQLIdentityInsertString

getVersionSelectString

isInsertCallable

isUpdateCallable

isDeleteCallable

isSubclassPropertyDeferred

isSubclassTableSequentialSelect

hasSequentialSelect

getTableUpdateNeeded

hasRowId