Deprecated List (hibernate-core JavaDocs)

Interfaces
Interface	Description
org.hibernate.boot.model.IdGeneratorStrategyInterpreter	(as of 6.0) see `GenerationTypeStrategy` and `GenerationTypeStrategyRegistration`
org.hibernate.boot.spi.AdditionalJaxbMappingProducer	Intended for Envers integration until we can migrate Envers away from XML generation for building its model.
org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer.InterceptorImplementor	Prefer the form of these methods defined on `BytecodeLazyAttributeInterceptor` instead
org.hibernate.cache.RegionFactory	Moved, but still need this definition for ehcache
org.hibernate.cfg.NamingStrategy	`ImplicitNamingStrategy` and `PhysicalNamingStrategy` should be used instead.
org.hibernate.ejb.HibernateEntityManager	Use `HibernateEntityManager` instead
org.hibernate.ejb.HibernateEntityManagerFactory	Use `HibernateEntityManagerFactory` instead
org.hibernate.engine.spi.Mapping	(since 6.0) Use `TypeConfiguration`, `Metadata` or `RuntimeMetamodels` to access such information
org.hibernate.engine.spi.SessionOwner	(since 5.2) since consolidating hibernate-entitymanager into hibernate-core I believe this is no longer needed.
org.hibernate.id.Configurable	All methods are already defined in `IdentifierGenerator`. Just implement `IdentifierGenerator`.
org.hibernate.id.UUIDGenerationStrategy	see `UUIDGenerator`
org.hibernate.integrator.spi.ServiceContributingIntegrator	A separate `ServiceContributor` should be used instead.
org.hibernate.jpa.event.spi.CallbackBuilder	This SPI has never been functional and is no longer used. It will eventually be removed.
org.hibernate.jpa.event.spi.CallbackBuilder.CallbackRegistrar	Use `CallbackRegistrar` instead.
org.hibernate.jpa.event.spi.jpa.ExtendedBeanManager	Use `ExtendedBeanManager` instead
org.hibernate.jpa.event.spi.jpa.ExtendedBeanManager.LifecycleListener	Use `ExtendedBeanManager.LifecycleListener` instead
org.hibernate.jpa.HibernateEntityManager	(since 5.2) Use Session (or SessionImplementor), as it now extends EntityManager directly
org.hibernate.jpa.HibernateEntityManagerFactory	(since 5.2) Use SessionFactory (or SessionFactoryImplementor) as it now extends EntityManagerFactory directly
org.hibernate.jpa.spi.IdentifierGeneratorStrategyProvider	(as of 6.0) supply a `GenerationTypeStrategyRegistration` instead
org.hibernate.mapping.AuxiliaryDatabaseObject	Use `AuxiliaryDatabaseObject` instead.
org.hibernate.mapping.RelationalModel	(since 5.2) not needed anymore.
org.hibernate.metadata.ClassMetadata	(since 6.0) Use Hibernate's mapping model `MappingMetamodel`
org.hibernate.metadata.CollectionMetadata	(since 6.0) Use Hibernate's mapping model `MappingMetamodel`
org.hibernate.Metamodel	(since 6.0) Prefer `JpaMetamodel`
org.hibernate.metamodel.model.domain.EmbeddedDomainType	(since 6.0) Use `EmbeddableDomainType` instead. Originally intended to describe the actual usage of an embeddable (the embedded) because it was intended to include the mapping (column, etc) information. However, that causes us to need multiple embeddable instances per embeddable class.
org.hibernate.metamodel.spi.MetamodelImplementor	(since 6.0) - Prefer `MappingMetamodel`
org.hibernate.persister.entity.Queryable	See `Queryable`
org.hibernate.persister.spi.PersisterCreationContext	Use `RuntimeModelCreationContext` instead
org.hibernate.query.criteria.JpaPathSource	This makes the SQM tree awkward and is not needed for JPA - JPA has no notion of a "path source" as a tree contract.
org.hibernate.resource.jdbc.spi.JdbcObserver	It is no longer possible to plug custom implementations of this SPI. It will be removed.
org.hibernate.stat.NaturalIdCacheStatistics	(since 5.3) Use `NaturalIdStatistics` - unfortunately the old statistics contracts exposed these by region name, rather than the name of the entity defining the natural-id
org.hibernate.stat.SecondLevelCacheStatistics	Use `CacheRegionStatistics` instead
org.hibernate.transform.ResultTransformer	ResultTransformer is no longer supported. It has been split into `TupleTransformer` and `ResultListTransformer` to define functional interfaces.
org.hibernate.tuple.entity.EntityTuplizer	See `EntityRepresentationStrategy`
org.hibernate.tuple.Instantiator	(as of 6.0) This contract is no longer used by Hibernate. Implement/use `Instantiator` instead. See `ManagedTypeRepresentationStrategy`
org.hibernate.tuple.Property	Use the direct `Attribute` hierarchy
org.hibernate.tuple.Tuplizer	See `ManagedTypeRepresentationStrategy`

Classes
Class	Description
org.hibernate.cfg.AttributeConverterDefinition	(since 5.3) forces the converter instance to be built too early, which precludes the ability to resolve them from CDI, etc. See `ConverterDescriptor` instead
org.hibernate.cfg.Settings	Use `SessionFactoryOptions` instead.
org.hibernate.dialect.DB2390Dialect	Use `DB2zDialect`
org.hibernate.dialect.DB2390V8Dialect	use `DB2390Dialect(8)`
org.hibernate.dialect.DB2400Dialect	Use `DB2iDialect`
org.hibernate.dialect.DB2400V7R3Dialect	Use `DB2iDialect`
org.hibernate.dialect.DB297Dialect	use `DB2Dialect(970)`
org.hibernate.dialect.DerbyTenFiveDialect	use `DerbyDialect(1050)`
org.hibernate.dialect.DerbyTenSevenDialect	use `DerbyDialect(1070)`
org.hibernate.dialect.DerbyTenSixDialect	use `DerbyDialect(1060)`
org.hibernate.dialect.HANACloudColumnStoreDialect	use HANAColumnStoreDialect(400)
org.hibernate.dialect.MariaDB102Dialect	use `MariaDBDialect(1020)`
org.hibernate.dialect.MariaDB103Dialect	use `MariaDBDialect(1030)`
org.hibernate.dialect.MariaDB106Dialect	use `MariaDBDialect(1060)`
org.hibernate.dialect.MariaDB10Dialect	use `MariaDBDialect(1000)`
org.hibernate.dialect.MariaDB53Dialect	use `MariaDBDialect(530)`
org.hibernate.dialect.MySQL55Dialect	use `MySQLDialect(550)`
org.hibernate.dialect.MySQL57Dialect	use `MySQLDialect(570)`
org.hibernate.dialect.MySQL5Dialect	use `MySQLDialect(500)`
org.hibernate.dialect.MySQL8Dialect	use `MySQLDialect(800)`
org.hibernate.dialect.Oracle10gDialect	use `OracleDialect(10)`
org.hibernate.dialect.Oracle12cDialect	use `OracleDialect(12)`
org.hibernate.dialect.Oracle8iDialect	use `OracleDialect(8)`
org.hibernate.dialect.Oracle9iDialect	use `OracleDialect(9)`
org.hibernate.dialect.PostgreSQL81Dialect	use `PostgreSQLDialect(810)`
org.hibernate.dialect.PostgreSQL82Dialect	use `PostgreSQLDialect(820)`
org.hibernate.dialect.PostgreSQL91Dialect	use `PostgreSQLDialect(910)`
org.hibernate.dialect.PostgreSQL92Dialect	use `PostgreSQLDialect(920)`
org.hibernate.dialect.PostgreSQL93Dialect	use `PostgreSQLDialect(810)`
org.hibernate.dialect.PostgreSQL94Dialect	use `PostgreSQLDialect(940)`
org.hibernate.dialect.PostgreSQL95Dialect	use `PostgreSQLDialect(950)`
org.hibernate.dialect.PostgreSQL9Dialect	use `PostgreSQLDialect(900)`
org.hibernate.dialect.SQLServer2005Dialect	use `SQLServerDialect(9)`
org.hibernate.dialect.SQLServer2008Dialect	use `SQLServerDialect(10)`
org.hibernate.dialect.SQLServer2012Dialect	use `SQLServerDialect(11)`
org.hibernate.dialect.SQLServer2016Dialect	use `SQLServerDialect(11)`
org.hibernate.dialect.Sybase11Dialect	use `SybaseASEDialect` instead
org.hibernate.dialect.SybaseASE157Dialect	use `SybaseASEDialect(1570)`
org.hibernate.dialect.SybaseASE15Dialect	use `SybaseASEDialect(1500)`
org.hibernate.EmptyInterceptor	implement `Interceptor` directly
org.hibernate.engine.query.spi.EntityGraphQueryHint	(6.0) - use `AppliedGraph` instead
org.hibernate.id.GUIDGenerator	(as of 6.0)
org.hibernate.id.UUIDGenerator	(since 6.0) - use `UuidGenerator` and `UuidGenerator` instead
org.hibernate.lob.ReaderInputStream	Should not be used anymore.
org.hibernate.mapping.PropertyGeneration	This is replaced by `ValueGeneration` and `GenerationTiming`
org.hibernate.tuple.PojoInstantiator	(as of 6.0) Like `Instantiator` itself, deprecated.
org.hibernate.tuple.StandardProperty	Use one of the `Attribute`-based impls instead.
org.hibernate.type.descriptor.jdbc.RealJdbcType	use `FloatJdbcType`
org.hibernate.type.TypeHelper	with no real replacement. this was always intended as an internal class

Enums
Enum Description

org.hibernate.loader.BatchFetchStyle
(since 6.0) : see BatchLoadSizingStrategy instead

Enums
Enum	Description
org.hibernate.loader.BatchFetchStyle	(since 6.0) : see `BatchLoadSizingStrategy` instead

Exceptions
Exceptions Description

org.hibernate.cfg.RecoverableException
Was only ever referenced in a single place, in an extremely dubious way.

Exceptions
Exceptions	Description
org.hibernate.cfg.RecoverableException	Was only ever referenced in a single place, in an extremely dubious way.

Annotation Types
Annotation Type	Description
org.hibernate.annotations.CollectionType	Custom handling for "collection types" will be handled differently in 6.0
org.hibernate.annotations.ForeignKey	Prefer the JPA 2.1 introduced `ForeignKey` instead.
org.hibernate.annotations.GeneratorType	Most uses can be changed to use `ValueGenerationType` + `AnnotationValueGeneration`
org.hibernate.annotations.Index	Using `Index` instead.
org.hibernate.annotations.IndexColumn	Prefer the standard JPA `OrderColumn` annotation and the Hibernate specific `ListIndexBase` (for replacing `IndexColumn.base()`).

Fields
Field	Description
org.hibernate.cfg.AvailableSettings.ALLOW_ENHANCEMENT_AS_PROXY	(as of 5.5) with no replacement. When using enhancement based lazy loading using the enhanced class as proxy is always used when appropriate.
org.hibernate.cfg.AvailableSettings.BATCH_FETCH_STYLE	(since 6.0) : An appropriate batch-fetch style is selected automatically
org.hibernate.cfg.AvailableSettings.CDI_BEAN_MANAGER	Use `AvailableSettings.JAKARTA_CDI_BEAN_MANAGER` instead
org.hibernate.cfg.AvailableSettings.DIALECT_DB_MAJOR_VERSION	Use `AvailableSettings.JAKARTA_HBM2DDL_DB_MAJOR_VERSION` instead
org.hibernate.cfg.AvailableSettings.DIALECT_DB_MINOR_VERSION	Use `AvailableSettings.JAKARTA_HBM2DDL_DB_MINOR_VERSION` instead
org.hibernate.cfg.AvailableSettings.DIALECT_DB_NAME	Use `AvailableSettings.JAKARTA_HBM2DDL_DB_NAME` instead
org.hibernate.cfg.AvailableSettings.DIALECT_DB_VERSION	Use `AvailableSettings.JAKARTA_HBM2DDL_DB_VERSION` instead
org.hibernate.cfg.AvailableSettings.HBM2DDL_CONNECTION	Use `AvailableSettings.JAKARTA_HBM2DDL_CONNECTION` instead
org.hibernate.cfg.AvailableSettings.HBM2DDL_CREATE_SCHEMAS	Use `AvailableSettings.JAKARTA_HBM2DDL_CREATE_SCHEMAS` instead
org.hibernate.cfg.AvailableSettings.HBM2DDL_DATABASE_ACTION	Use `AvailableSettings.JAKARTA_HBM2DDL_SCRIPTS_ACTION` instead
org.hibernate.cfg.AvailableSettings.HBM2DDL_LOAD_SCRIPT_SOURCE	Use `AvailableSettings.JAKARTA_HBM2DDL_LOAD_SCRIPT_SOURCE` instead
org.hibernate.cfg.AvailableSettings.HBM2DDL_SCRIPTS_ACTION	Use `AvailableSettings.JAKARTA_HBM2DDL_SCRIPTS_ACTION` instead
org.hibernate.cfg.AvailableSettings.HQL_BULK_ID_STRATEGY	Use `AvailableSettings.QUERY_MULTI_TABLE_MUTATION_STRATEGY` instead
org.hibernate.cfg.AvailableSettings.ID_TABLE_STRATEGY	Use `AvailableSettings.QUERY_MULTI_TABLE_MUTATION_STRATEGY` instead
org.hibernate.cfg.AvailableSettings.IDENTIFIER_GENERATOR_STRATEGY_PROVIDER	(as of 6.0) use `GenerationTypeStrategyRegistration` instead
org.hibernate.cfg.AvailableSettings.JPA_JDBC_DRIVER	Use `AvailableSettings.JAKARTA_JDBC_DRIVER` instead
org.hibernate.cfg.AvailableSettings.JPA_JDBC_PASSWORD	Use `AvailableSettings.JAKARTA_JDBC_PASSWORD` instead
org.hibernate.cfg.AvailableSettings.JPA_JDBC_URL	Use `AvailableSettings.JAKARTA_JDBC_URL` instead
org.hibernate.cfg.AvailableSettings.JPA_JDBC_USER	Use `AvailableSettings.JAKARTA_JDBC_USER` instead
org.hibernate.cfg.AvailableSettings.JPA_JTA_DATASOURCE	Use `AvailableSettings.JAKARTA_JTA_DATASOURCE` instead
org.hibernate.cfg.AvailableSettings.JPA_LOCK_SCOPE	Use `AvailableSettings.JAKARTA_LOCK_SCOPE` instead
org.hibernate.cfg.AvailableSettings.JPA_LOCK_TIMEOUT	Use `AvailableSettings.JAKARTA_LOCK_TIMEOUT` instead
org.hibernate.cfg.AvailableSettings.JPA_NON_JTA_DATASOURCE	Use `AvailableSettings.JAKARTA_NON_JTA_DATASOURCE` instead
org.hibernate.cfg.AvailableSettings.JPA_PERSIST_VALIDATION_GROUP	Use `AvailableSettings.JAKARTA_PERSIST_VALIDATION_GROUP` instead
org.hibernate.cfg.AvailableSettings.JPA_PERSISTENCE_PROVIDER	Use `AvailableSettings.JAKARTA_PERSISTENCE_PROVIDER` instead
org.hibernate.cfg.AvailableSettings.JPA_REMOVE_VALIDATION_GROUP	Use `AvailableSettings.JAKARTA_REMOVE_VALIDATION_GROUP` instead
org.hibernate.cfg.AvailableSettings.JPA_SHARED_CACHE_MODE	Use `AvailableSettings.JAKARTA_SHARED_CACHE_MODE` instead
org.hibernate.cfg.AvailableSettings.JPA_SHARED_CACHE_RETRIEVE_MODE	Use `AvailableSettings.JAKARTA_SHARED_CACHE_RETRIEVE_MODE` instead
org.hibernate.cfg.AvailableSettings.JPA_SHARED_CACHE_STORE_MODE	Use `AvailableSettings.JAKARTA_SHARED_CACHE_STORE_MODE` instead
org.hibernate.cfg.AvailableSettings.JPA_TRANSACTION_TYPE	Use `AvailableSettings.JAKARTA_TRANSACTION_TYPE` instead
org.hibernate.cfg.AvailableSettings.JPA_UPDATE_VALIDATION_GROUP	Use `AvailableSettings.JAKARTA_UPDATE_VALIDATION_GROUP` instead
org.hibernate.cfg.AvailableSettings.JPA_VALIDATION_FACTORY	Use `AvailableSettings.JAKARTA_VALIDATION_FACTORY` instead
org.hibernate.cfg.AvailableSettings.JPA_VALIDATION_MODE	Use `AvailableSettings.JAKARTA_VALIDATION_MODE` instead
org.hibernate.cfg.AvailableSettings.QUERY_TRANSLATOR	Use `AvailableSettings.SEMANTIC_QUERY_PRODUCER`
org.hibernate.cfg.AvailableSettings.USE_LEGACY_LIMIT_HANDLERS	this setting now has no effect
org.hibernate.cfg.AvailableSettings.WRAP_RESULT_SETS	(since 5.5) Scheduled for removal in 6.0 as ResultSet wrapping is no longer needed
org.hibernate.FetchMode.EAGER	use `FetchMode.JOIN`
org.hibernate.FetchMode.LAZY	use `FetchMode.SELECT`
org.hibernate.grammars.graph.GraphLanguageLexer.tokenNames	Use `GraphLanguageLexer.VOCABULARY` instead.
org.hibernate.grammars.graph.GraphLanguageParser.tokenNames	Use `GraphLanguageParser.VOCABULARY` instead.
org.hibernate.grammars.hql.HqlLexer.tokenNames	Use `HqlLexer.VOCABULARY` instead.
org.hibernate.grammars.hql.HqlParser.tokenNames	Use `HqlParser.VOCABULARY` instead.
org.hibernate.grammars.importsql.SqlScriptLexer.tokenNames	Use `SqlScriptLexer.VOCABULARY` instead.
org.hibernate.grammars.importsql.SqlScriptParser.tokenNames	Use `SqlScriptParser.VOCABULARY` instead.
org.hibernate.grammars.ordering.OrderingLexer.tokenNames	Use `OrderingLexer.VOCABULARY` instead.
org.hibernate.grammars.ordering.OrderingParser.tokenNames	Use `OrderingParser.VOCABULARY` instead.
org.hibernate.jpa.QueryHints.HINT_FETCHGRAPH	Use `QueryHints.JAKARTA_HINT_FETCH_GRAPH` instead
org.hibernate.jpa.QueryHints.HINT_LOADGRAPH	Use `QueryHints.JAKARTA_HINT_LOAD_GRAPH` instead
org.hibernate.jpa.QueryHints.HINT_TIMEOUT	use `QueryHints.SPEC_HINT_TIMEOUT` instead
org.hibernate.sql.results.graph.collection.CollectionLoadingLogger.INSTANCE	Use `CollectionLoadingLogger.COLL_LOAD_LOGGER`
org.hibernate.type.descriptor.jdbc.LobTypeMappings.INSTANCE	use the static method helpers instead.
org.hibernate.type.descriptor.jdbc.NationalizedTypeMappings.INSTANCE	use the static methods instead

Methods
Method	Description
org.hibernate.annotations.AttributeAccessor.value()	use `AttributeAccessor.strategy()`
org.hibernate.boot.archive.scan.spi.ScanOptions.canDetectHibernateMappingFiles()	With move to unified schema, this setting is now deprecated and will be removed once support for reading `hbm.xml` files is fully removed.
org.hibernate.boot.archive.spi.ArchiveDescriptorFactory.getURLFromPath(String)	Not used!
org.hibernate.boot.MetadataSources.addClass(Class)	hbm.xml is a legacy mapping format now considered deprecated.
org.hibernate.boot.MetadataSources.addDocument(Document)	since 5.0. Use one of the other methods for passing mapping source(s).
org.hibernate.boot.MetadataSources.getMetadataBuilder(StandardServiceRegistry)	Use `MetadataSources.getMetadataBuilder()` instead
org.hibernate.boot.model.relational.AuxiliaryDatabaseObject.sqlCreateStrings(Dialect)	Implement `AuxiliaryDatabaseObject.sqlCreateStrings(SqlStringGenerationContext)` instead.
org.hibernate.boot.model.relational.AuxiliaryDatabaseObject.sqlDropStrings(Dialect)	Implement `AuxiliaryDatabaseObject.sqlDropStrings(SqlStringGenerationContext)` instead.
org.hibernate.boot.model.TypeContributions.contributeType(BasicType)	(6.0) See user-guide section `2.2.46. TypeContributor` for details - `basic_types.adoc`
org.hibernate.boot.registry.BootstrapServiceRegistryBuilder.with(Integrator)	Use `BootstrapServiceRegistryBuilder.applyIntegrator(org.hibernate.integrator.spi.Integrator)` instead
org.hibernate.boot.registry.BootstrapServiceRegistryBuilder.withStrategySelector(Class<T>, String, Class<? extends T>)	Use `BootstrapServiceRegistryBuilder.applyStrategySelector(java.lang.Class<T>, java.lang.String, java.lang.Class<? extends T>)` instead
org.hibernate.boot.registry.BootstrapServiceRegistryBuilder.withStrategySelectors(StrategyRegistrationProvider)	Use `BootstrapServiceRegistryBuilder.applyStrategySelectors(org.hibernate.boot.registry.selector.StrategyRegistrationProvider)` instead
org.hibernate.boot.registry.StandardServiceRegistryBuilder.getSettings()	Temporarily exposed since Configuration is still around and much code still uses Configuration. This allows code to configure the builder and access that to configure Configuration object.
org.hibernate.boot.SessionFactoryBuilder.applyBatchFetchStyle(BatchFetchStyle)	(since 6.0) : an appropriate style is selected
org.hibernate.boot.SessionFactoryBuilder.applyConnectionReleaseMode(ConnectionReleaseMode)	Use `SessionFactoryBuilder.applyConnectionHandlingMode(org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode)` instead
org.hibernate.boot.SessionFactoryBuilder.applyQuerySubstitutions(Map)	This is a legacy feature and should never be needed anymore...
org.hibernate.boot.SessionFactoryBuilder.applyStrictJpaQueryLanguageCompliance(boolean)	Use `SessionFactoryBuilder.enableJpaQueryCompliance(boolean)` instead
org.hibernate.boot.spi.AbstractDelegatingMetadataBuilderImplementor.getDelegate()	use `AbstractDelegatingMetadataBuilderImplementor.delegate()` instead
org.hibernate.boot.spi.BootstrapContext.getReflectionManager()	Deprecated (with no replacement) to indicate that this will go away as we migrate away from Hibernate Commons Annotations to Jandex for annotation handling and XMl->annotation merging.
org.hibernate.boot.spi.InFlightMetadataCollector.addAttributeConverter(AttributeConverterDefinition)	AttributeConverterDefinition forces early resolution of the AttributeConverter instance, which precludes resolution of the converter from `ManagedBeanRegistry` (CDI, etc). Instead one of: * `InFlightMetadataCollector.addAttributeConverter(ConverterDescriptor)` * `InFlightMetadataCollector.addAttributeConverter(Class)` * `InFlightMetadataCollector.addAttributeConverter(Class)`
org.hibernate.boot.spi.InFlightMetadataCollector.addTypeDefinition(TypeDefinition)	Use `InFlightMetadataCollector.getTypeDefinitionRegistry()` instead
org.hibernate.boot.spi.InFlightMetadataCollector.getClassmateContext()	Use `BootstrapContext.getClassmateContext()` instead.
org.hibernate.boot.spi.MetadataBuildingContext.getClassLoaderAccess()	Use `BootstrapContext.getClassLoaderAccess()`} instead.
org.hibernate.boot.spi.MetadataBuildingOptions.getArchiveDescriptorFactory()	Use `BootstrapContext.getArchiveDescriptorFactory()` instead.
org.hibernate.boot.spi.MetadataBuildingOptions.getCacheRegionDefinitions()	Use `BootstrapContext.getClassmateContext()` instead.
org.hibernate.boot.spi.MetadataBuildingOptions.getJandexView()	Use `BootstrapContext.getJandexView()` instead.
org.hibernate.boot.spi.MetadataBuildingOptions.getReflectionManager()	Use `BootstrapContext.getReflectionManager()` instead, The plan is to remove first `MetadataBuildingOptions.getReflectionManager()` keeping `BootstrapContext.getReflectionManager()` till the migration from Hibernate Commons Annotations to Jandex.
org.hibernate.boot.spi.MetadataBuildingOptions.getScanEnvironment()	Use `BootstrapContext.getScanEnvironment()` instead.
org.hibernate.boot.spi.MetadataBuildingOptions.getScanner()	Use `BootstrapContext.getScanner()` instead.
org.hibernate.boot.spi.MetadataBuildingOptions.getScanOptions()	Use `BootstrapContext.getScanOptions()` instead.
org.hibernate.boot.spi.MetadataBuildingOptions.getTempClassLoader()	Use `BootstrapContext.getJpaTempClassLoader()` instead.
org.hibernate.boot.spi.SessionFactoryOptions.getBatchFetchStyle()	(since 6.0) : No longer used internally
org.hibernate.boot.spi.SessionFactoryOptions.getConnectionReleaseMode()	Use `SessionFactoryOptions.getPhysicalConnectionHandlingMode()` instead
org.hibernate.boot.spi.SessionFactoryOptions.getStatelessInterceptorImplementor()	use `SessionFactoryOptions.getStatelessInterceptorImplementorSupplier()` instead.
org.hibernate.boot.spi.SessionFactoryOptions.isEnhancementAsProxyEnabled()	(since 5.5) use of enhanced proxies is always enabled
org.hibernate.boot.spi.SessionFactoryOptions.isPostInsertIdentifierDelayableEnabled()	Since 5.4.1, this is no longer used.
org.hibernate.boot.spi.SessionFactoryOptions.isStrictJpaQueryLanguageCompliance()	Use `JpaCompliance.isJpaQueryComplianceEnabled()` instead via `SessionFactoryOptions.getJpaCompliance()`
org.hibernate.boot.spi.SessionFactoryOptions.isWrapResultSetsEnabled()	(since 5.5) Scheduled for removal in 6.0 as ResultSet wrapping is no longer needed
org.hibernate.bytecode.enhance.spi.interceptor.LazyAttributesMetadata.getAttributesInSameFetchGroup(String)	This method is not being used and as such will be removed
org.hibernate.bytecode.spi.ProxyFactoryFactory.buildBasicProxyFactory(Class, Class[])	Use `ProxyFactoryFactory.buildBasicProxyFactory(Class)` instead.
org.hibernate.Cache.evictCollection(String, Serializable)	Use `Cache#evictCollectionData(String, Serializable)` instead
org.hibernate.Cache.evictCollectionRegion(String)	Use `Cache.evictCollectionData(String)` instead
org.hibernate.Cache.evictCollectionRegions()	Use `Cache.evictCollectionData()` instead
org.hibernate.Cache.evictEntity(Class, Object)	Use `Cache#evictEntityData(Class, Serializable)` instead
org.hibernate.Cache.evictEntityRegion(Class)	Use `Cache.evictEntityData(Class)` instead
org.hibernate.Cache.evictEntityRegions()	Use `Cache.evictEntityData()` instead
org.hibernate.Cache.evictNaturalIdRegion(Class)	Use `Cache.evictNaturalIdData(Class)` instead
org.hibernate.Cache.evictNaturalIdRegions()	Use `Cache.evictNaturalIdData()` instead
org.hibernate.cache.spi.CacheImplementor.getCollectionRegionAccess(NavigableRole)	Use `EntityPersister.getNaturalIdCacheAccessStrategy()` ()} instead
org.hibernate.cache.spi.CacheImplementor.getEntityRegionAccess(NavigableRole)	Use `EntityPersister.getCacheAccessStrategy()` instead
org.hibernate.cache.spi.CacheImplementor.getNaturalIdAccessesInRegion(String)	No replacement - added just for support of the newly deprecated methods expecting a qualified region name
org.hibernate.cache.spi.CacheImplementor.getNaturalIdCacheRegionAccessStrategy(NavigableRole)	Use `EntityPersister.getNaturalIdCacheAccessStrategy()` ()} instead
org.hibernate.cache.spi.CacheImplementor.getRegionByLegacyName(String)	No replacement - added just for support of the newly deprecated methods expecting a qualified region name
org.hibernate.cache.spi.CacheImplementor.getSecondLevelCacheRegionNames()	(since 5.3) Use `CacheImplementor.getCacheRegionNames()` instead
org.hibernate.cache.spi.CacheImplementor.unqualifyRegionName(String)	(since 5.3) No replacement - added just to continue some backwards compatibility in supporting the newly deprecated methods expecting a qualified (prefix +) region name
org.hibernate.cfg.annotations.HCANNHelper.annotatedElementSignature(XProperty)	Prefer using `HCANNHelper.annotatedElementSignature(JavaXMember)`
org.hibernate.cfg.annotations.HCANNHelper.getUnderlyingMember(XProperty)	Prefer using `HCANNHelper.getUnderlyingMember(JavaXMember)`
org.hibernate.cfg.annotations.TableBinder.buildUniqueConstraints(UniqueConstraint[])	Use `TableBinder.buildUniqueConstraintHolders(jakarta.persistence.UniqueConstraint[])` instead
org.hibernate.cfg.BaselineSessionEventsListenerBuilder.setAutoListener(Class<? extends SessionEventListener>)
org.hibernate.cfg.BaselineSessionEventsListenerBuilder.setLogSessionMetrics(boolean)
org.hibernate.cfg.Configuration.add(XmlDocument)	No longer supported.
org.hibernate.cfg.Configuration.addDocument(Document)	Use addURL, addResource, addFile, etc. instead
org.hibernate.cfg.Configuration.addResource(String, ClassLoader)	This form (accepting a ClassLoader) is no longer supported. Instead, add the ClassLoader to the ClassLoaderService on the ServiceRegistry associated with this Configuration
org.hibernate.cfg.Configuration.addXML(String)	No longer supported
org.hibernate.cfg.Configuration.buildMappings()	Does nothing
org.hibernate.cfg.Configuration.configure(Document)	No longer supported.
org.hibernate.cfg.Environment.getBytecodeProvider()	Deprecated to indicate that the method will be moved to `SessionFactoryOptions` / `SessionFactoryBuilder` - probably in 6.0. See HHH-12194 and HHH-12193 for details
org.hibernate.cfg.Environment.isolationLevelToString(int)	Use `ConnectionProviderInitiator.toIsolationNiceName(java.lang.Integer)` instead
org.hibernate.cfg.Environment.jvmHasTimestampBug()	removed as unnecessary
org.hibernate.cfg.Environment.useLegacyProxyClassnames()	This option will be removed soon and should not be relied on.
org.hibernate.cfg.Environment.useReflectionOptimizer()	Deprecated to indicate that the method will be moved to `SessionFactoryOptions` / `SessionFactoryBuilder` - probably in 6.0. See HHH-12194 and HHH-12193 for details
org.hibernate.cfg.Environment.useStreamsForBinary()	Deprecated to indicate that the method will be moved to `SessionFactoryOptions` / `SessionFactoryBuilder` - probably in 6.0. See HHH-12194 and HHH-12193 for details
org.hibernate.cfg.Environment.verifyProperties(Map<?, ?>)	without replacement. Such verification is best done ad hoc, case by case.
org.hibernate.cfg.Settings.getBatchFetchStyle()	(since 6.0) : No longer used internally
org.hibernate.classic.Lifecycle.onLoad(Session, Serializable)	use `Lifecycle.onLoad(Session, Object)`
org.hibernate.engine.config.spi.ConfigurationService.cast(Class<T>, Object)	No idea why this is exposed here...
org.hibernate.engine.jdbc.env.spi.JdbcEnvironment.getQualifiedObjectNameFormatter()	Use a provided `SqlStringGenerationContext` instead.
org.hibernate.engine.jdbc.env.spi.JdbcEnvironment.getTypeInfoForJdbcCode(int)	This is currently not implemented an will likely be removed (A default method is provided to facilitate removal from implementors)
org.hibernate.engine.jdbc.SerializableNClobProxy.isNClob(Clob)	ORM baselines on JDK 1.6, so optional support for NClob (JDK 1,6 addition) is no longer needed.
org.hibernate.engine.jdbc.spi.JdbcCoordinator.getResourceRegistry()	(since 5.2) access via `JdbcCoordinator.getLogicalConnection()` instead
org.hibernate.engine.jdbc.spi.SqlStatementLogger.setFormat(boolean)	Will likely be removed: Should either become immutable or threadsafe.
org.hibernate.engine.jdbc.spi.SqlStatementLogger.setLogToStdout(boolean)	Will likely be removed: Should either become immutable or threadsafe.
org.hibernate.engine.jdbc.WrappedNClob.getWrappedClob()	Use `WrappedNClob.getWrappedNClob()` instead
org.hibernate.engine.spi.LoadQueryInfluencers.getFetchGraph()	(since 5.4) `LoadQueryInfluencers.getFetchGraph()`, `LoadQueryInfluencers.getLoadGraph()`, `LoadQueryInfluencers.setFetchGraph(jakarta.persistence.EntityGraph)` and `LoadQueryInfluencers.setLoadGraph(jakarta.persistence.EntityGraph)` (as well as JPA itself honestly) all make it very unclear that there can be only one graph applied at any one time and that graph is either a load or a fetch graph. These have all been replaced with `LoadQueryInfluencers.getEffectiveEntityGraph()`.
org.hibernate.engine.spi.LoadQueryInfluencers.getInternalFetchProfile()	Use `LoadQueryInfluencers.getEnabledCascadingFetchProfile()` instead
org.hibernate.engine.spi.LoadQueryInfluencers.getLoadGraph()	(since 5.4) `LoadQueryInfluencers.getFetchGraph()`, `LoadQueryInfluencers.getLoadGraph()`, `LoadQueryInfluencers.setFetchGraph(jakarta.persistence.EntityGraph)` and `LoadQueryInfluencers.setLoadGraph(jakarta.persistence.EntityGraph)` (as well as JPA itself honestly) all make it very unclear that there can be only one graph applied at any one time and that graph is either a load or a fetch graph. These have all been replaced with `LoadQueryInfluencers.getEffectiveEntityGraph()`.
org.hibernate.engine.spi.LoadQueryInfluencers.setFetchGraph(EntityGraph)	(since 5.4) `LoadQueryInfluencers.getFetchGraph()`, `LoadQueryInfluencers.getLoadGraph()`, `LoadQueryInfluencers.setFetchGraph(jakarta.persistence.EntityGraph)` and `LoadQueryInfluencers.setLoadGraph(jakarta.persistence.EntityGraph)` (as well as JPA itself honestly) all make it very unclear that there can be only one graph applied at any one time and that graph is either a load or a fetch graph. These have all been replaced with `LoadQueryInfluencers.getEffectiveEntityGraph()`.
org.hibernate.engine.spi.LoadQueryInfluencers.setInternalFetchProfile(String)	Use `LoadQueryInfluencers.setEnabledCascadingFetchProfile(org.hibernate.loader.ast.spi.CascadingFetchProfile)` instead
org.hibernate.engine.spi.LoadQueryInfluencers.setLoadGraph(EntityGraph)	(since 5.4) `LoadQueryInfluencers.getFetchGraph()`, `LoadQueryInfluencers.getLoadGraph()`, `LoadQueryInfluencers.setFetchGraph(jakarta.persistence.EntityGraph)` and `LoadQueryInfluencers.setLoadGraph(jakarta.persistence.EntityGraph)` (as well as JPA itself honestly) all make it very unclear that there can be only one graph applied at any one time and that that graph is either a load or a fetch graph. These have all been replaced with `LoadQueryInfluencers.getEffectiveEntityGraph()`.
org.hibernate.engine.spi.PersistenceContext.getCollectionEntries()	use `PersistenceContext.removeCollectionEntry(PersistentCollection)` or `PersistenceContext.getCollectionEntriesSize()`, `PersistenceContext.forEachCollectionEntry(BiConsumer,boolean)`.
org.hibernate.engine.spi.PersistenceContext.getCollectionEntryOrNull(Object)	Intended use was in handling Hibernate's legacy "collection filter via Query" feature which has been removed
org.hibernate.engine.spi.PersistenceContext.getCollectionsByKey()	this method should be removed; alternative methods are available that better express the intent, allowing for better optimisations. Not aggressively removing this as it's an SPI, but also useful for testing and other contexts which are not performance sensitive. N.B. This might return an immutable map: do not use for mutations!
org.hibernate.engine.spi.PersistenceContext.getEntitiesByKey()	this will be removed: it provides too wide access, making it hard to optimise the internals for specific access needs. Consider using #iterateEntities instead.
org.hibernate.engine.spi.PersistenceContext.getEntityEntries()	Due to the introduction of EntityEntryContext and bytecode enhancement; only valid really for sizing, see `PersistenceContext.getNumberOfManagedEntities()`. For iterating the entity/EntityEntry combos, see `PersistenceContext.reentrantSafeEntityEntries()`
org.hibernate.engine.spi.PersistenceContext.getNullifiableEntityKeys()	Use `PersistenceContext.containsNullifiableEntityKey(Supplier)` or `PersistenceContext.registerNullifiableEntityKey(EntityKey)` or `PersistenceContext.isNullifiableEntityKeysEmpty()`
org.hibernate.engine.spi.PersistentAttributeInterceptor.attributeInitialized(String)	Just as the method it overrides. Interceptors that deal with lazy state should implement `BytecodeLazyAttributeInterceptor`
org.hibernate.engine.spi.PersistentAttributeInterceptor.getInitializedLazyAttributeNames()	Just as the method it overrides. Interceptors that deal with lazy state should implement `BytecodeLazyAttributeInterceptor`
org.hibernate.engine.spi.SessionBuilderImplementor.owner(SessionOwner)	(since 5.2) since consolidating hibernate-entitymanager into hibernate-core I believe this is no longer needed.
org.hibernate.engine.spi.SessionFactoryImplementor.getCollectionPersister(String)	(since 5.2) Use `MetamodelImplementor.collectionPersister(String)` instead.
org.hibernate.engine.spi.SessionFactoryImplementor.getCollectionPersisters()	(since 5.2) Use `MetamodelImplementor.collectionPersisters()` instead.
org.hibernate.engine.spi.SessionFactoryImplementor.getCollectionRolesByEntityParticipant(String)	(since 5.2) Use `MetamodelImplementor.collectionPersisters()` instead. Retrieves a set of all the collection roles in which the given entity is a participant, as either an index or an element.
org.hibernate.engine.spi.SessionFactoryImplementor.getDialect()	(since 5.2) instead, use `JdbcServices.getDialect()`
org.hibernate.engine.spi.SessionFactoryImplementor.getEntityPersister(String)	(since 5.2) Use `MetamodelImplementor.entityPersister(Class)` instead.
org.hibernate.engine.spi.SessionFactoryImplementor.getEntityPersisters()	(since 5.2) Use `MetamodelImplementor.entityPersisters()` instead.
org.hibernate.engine.spi.SessionFactoryImplementor.getImplementors(String)	Use `Metamodel.getImplementors(String)` instead
org.hibernate.engine.spi.SessionFactoryImplementor.getImportedClassName(String)	Use `Metamodel.getImportedClassName(String)` instead
org.hibernate.engine.spi.SessionFactoryImplementor.getSettings()	since 5.0; use `SessionFactory.getSessionFactoryOptions()` instead
org.hibernate.engine.spi.SessionFactoryImplementor.getSQLExceptionConverter()	since 5.0; use `JdbcServices.getSqlExceptionHelper()` -> `SqlExceptionHelper.getSqlExceptionConverter()` instead as obtained from `SessionFactoryImplementor.getServiceRegistry()`
org.hibernate.engine.spi.SessionFactoryImplementor.getSQLExceptionHelper()	since 5.0; use `JdbcServices.getSqlExceptionHelper()` instead as obtained from `SessionFactoryImplementor.getServiceRegistry()`
org.hibernate.engine.spi.SessionFactoryImplementor.getStatisticsImplementor()	(since 5.2) Just use `SessionFactoryImplementor.getStatistics()` (with covariant return here as `StatisticsImplementor`).
org.hibernate.engine.spi.SessionFactoryImplementor.iterateEntityNameResolvers()	(since 5.2) use `SessionFactoryImplementor.getMetamodel()` -> `MetamodelImplementor.getEntityNameResolvers()`
org.hibernate.engine.spi.SessionFactoryImplementor.locateEntityPersister(Class)	(since 5.2) Use `MappingMetamodel.locateEntityPersister(Class)` instead.
org.hibernate.engine.spi.SessionImplementor.delete(String, Object, boolean, Set)	OperationalContext should cover this overload I believe; Gail?
org.hibernate.engine.spi.SessionImplementor.isFlushBeforeCompletionEnabled()	(since 5.2) use `Session.getHibernateFlushMode()` instead.
org.hibernate.engine.spi.SessionImplementor.merge(String, Object, Map)	OperationalContext should cover this overload I believe; Gail?
org.hibernate.engine.spi.SessionImplementor.persist(String, Object, Map)	OperationalContext should cover this overload I believe; Gail?
org.hibernate.engine.spi.SessionImplementor.persistOnFlush(String, Object, Map)	OperationalContext should cover this overload I believe; Gail?
org.hibernate.engine.spi.SessionImplementor.refresh(String, Object, Map)	OperationalContext should cover this overload I believe; Gail?
org.hibernate.engine.spi.SessionImplementor.removeOrphanBeforeUpdates(String, Object)	OperationalContext should cover this overload I believe; Gail?
org.hibernate.engine.spi.SharedSessionContractImplementor.getTimestamp()	(since 5.3) Use `SharedSessionContractImplementor.getTransactionStartTimestamp()` instead.
org.hibernate.engine.spi.SharedSessionContractImplementor.setFlushMode(FlushMode)	(since 5.2) use `SharedSessionContractImplementor.setHibernateFlushMode(FlushMode)` instead
org.hibernate.engine.transaction.spi.TransactionImplementor.invalidate()	(since 5.2) as part of effort to consolidate support for JPA and Hibernate SessionFactory, Session, etc natively, support for local Transaction delegates to remain "valid" after they are committed or rolled-back (and to a degree after the owning Session is closed) to more closely comply with the JPA spec natively in terms of allowing that extended access after Session is closed. Hibernate impls have all been changed to no-op here.
org.hibernate.event.service.spi.EventListenerGroup.clear()	likely want to use `EventListenerGroup.clearListeners()` instead, which doesn't also reset the registered DuplicationStrategy(ies).
org.hibernate.event.service.spi.EventListenerGroup.listeners()	this is not the most efficient way for iterating the event listeners. See `EventListenerGroup.fireEventOnEachListener(Object, BiConsumer)` and its overloaded variants for better alternatives.
org.hibernate.event.service.spi.EventListenerRegistry.prepare(MetadataImplementor)	this method was only ever used to initialize the CallbackRegistry which is now managed as part of the EventEngine
org.hibernate.event.spi.AbstractPreDatabaseOperationEvent.getEntity()	Support for JACC will be removed in 6.0
org.hibernate.event.spi.AbstractPreDatabaseOperationEvent.getSource()	Use `AbstractEvent.getSession()` instead
org.hibernate.FlushMode.isManualFlushMode(FlushMode)	Just use equality check against `FlushMode.MANUAL`. Legacy from before this was an enum
org.hibernate.grammars.graph.GraphLanguageLexer.getTokenNames()
org.hibernate.grammars.graph.GraphLanguageParser.getTokenNames()
org.hibernate.grammars.hql.HqlLexer.getTokenNames()
org.hibernate.grammars.hql.HqlParser.getTokenNames()
org.hibernate.grammars.importsql.SqlScriptLexer.getTokenNames()
org.hibernate.grammars.importsql.SqlScriptParser.getTokenNames()
org.hibernate.grammars.ordering.OrderingLexer.getTokenNames()
org.hibernate.grammars.ordering.OrderingParser.getTokenNames()
org.hibernate.id.enhanced.DatabaseStructure.getAllSqlForTests()	Exposed for tests only.
org.hibernate.id.enhanced.DatabaseStructure.prepare(Optimizer)	Use `DatabaseStructure.configure(Optimizer)` instead.
org.hibernate.id.enhanced.OptimizerFactory.buildOptimizer(String, Class, int)	Use `OptimizerFactory.buildOptimizer(String, Class, int, long)` instead
org.hibernate.id.enhanced.TableGenerator.getAllSqlForTests()	Exposed for tests only.
org.hibernate.id.factory.IdentifierGeneratorFactory.createIdentifierGenerator(String, Type, Properties)	(since 6.0) use `IdentifierGeneratorFactory.createIdentifierGenerator(GenerationType, String, String, JavaType, Properties, GeneratorDefinitionResolver)` instead
org.hibernate.id.factory.IdentifierGeneratorFactory.getIdentifierGeneratorClass(String)	(since 6.0) with no replacement. See `IdentifierGeneratorFactory.createIdentifierGenerator(GenerationType, String, String, JavaType, Properties, GeneratorDefinitionResolver)`
org.hibernate.id.IdentifierGeneratorHelper.createNumber(long, Class)	Use the `holders` instead.
org.hibernate.id.IncrementGenerator.getAllSqlForTests()	Exposed for tests only.
org.hibernate.InstantiationException.getPersistentClass()	Use `InstantiationException.getUninstantiatableClass()` instead
org.hibernate.integrator.spi.Integrator.integrate(Metadata, SessionFactoryImplementor, SessionFactoryServiceRegistry)	(since 6.0) - use
org.hibernate.Interceptor.findDirty(Object, Serializable, Object[], Object[], String[], Type[])	use `Interceptor.findDirty(Object, Object, Object[], Object[], String[], Type[])`
org.hibernate.Interceptor.getEntity(String, Serializable)	use `Interceptor.getEntity(String, Object)`
org.hibernate.Interceptor.onCollectionRecreate(Object, Serializable)	use `Interceptor.onCollectionRecreate(Object, Object)`
org.hibernate.Interceptor.onCollectionRemove(Object, Serializable)	use `Interceptor.onCollectionRemove(Object, Object)`
org.hibernate.Interceptor.onCollectionUpdate(Object, Serializable)	use `Interceptor.onCollectionUpdate(Object, Object)`
org.hibernate.Interceptor.onDelete(Object, Serializable, Object[], String[], Type[])	use `Interceptor.onDelete(Object, Object, Object[], String[], Type[])`
org.hibernate.Interceptor.onFlushDirty(Object, Serializable, Object[], Object[], String[], Type[])	use `Interceptor.onFlushDirty(Object, Object, Object[], Object[], String[], Type[])`
org.hibernate.Interceptor.onLoad(Object, Serializable, Object[], String[], Type[])	use `Interceptor.onLoad(Object, Object, Object[], String[], Type[])`
org.hibernate.Interceptor.onPrepareStatement(String)	Supply a `StatementInspector` instead, if you wish to inspect and alter SQL statements.
org.hibernate.jpa.event.spi.CallbackRegistry.hasPostCreateCallbacks(Class)	Use `CallbackRegistry.hasRegisteredCallbacks(Class, CallbackType)` instead passing `CallbackType.POST_PERSIST`
org.hibernate.jpa.event.spi.CallbackRegistry.hasPostRemoveCallbacks(Class)	Use `CallbackRegistry.hasRegisteredCallbacks(Class, CallbackType)` instead passing `CallbackType.POST_REMOVE`
org.hibernate.jpa.event.spi.CallbackRegistry.hasPostUpdateCallbacks(Class)	Use `CallbackRegistry.hasRegisteredCallbacks(Class, CallbackType)` instead passing `CallbackType.POST_UPDATE`
org.hibernate.jpa.event.spi.CallbackRegistry.hasRegisteredCallbacks(Class, Class)	Use `CallbackRegistry.hasRegisteredCallbacks(Class, CallbackType)` instead.
org.hibernate.jpa.HibernateEntityManagerFactory.getEntityManagerFactoryName()	- no longer necessary. all references can be directly replaced with calls to `SessionFactoryOptions.getSessionFactoryName()` via `HibernateEntityManagerFactory.getSessionFactory()` -> `SessionFactory.getSessionFactoryOptions()`
org.hibernate.jpa.HibernateEntityManagerFactory.getEntityTypeByName(String)	Use org.hibernate.MetamodelImplementor#getEntityTypeByName instead.
org.hibernate.jpa.HibernateEntityManagerFactory.getSessionFactory()	The expectation is that SessionFactory implementors also implement EntityManagerFactory; so this call really should just return `this`. As an alternative, call `EntityManagerFactory.unwrap(java.lang.Class<T>)` passing `SessionFactoryImplementor.class`
org.hibernate.mapping.Collection.setOwner(PersistentClass)	Inject the owner into constructor.
org.hibernate.mapping.KeyValue.createIdentifierGenerator(IdentifierGeneratorFactory, Dialect, String, String, RootClass)	Use `KeyValue.createIdentifierGenerator(IdentifierGeneratorFactory, Dialect, RootClass)` instead.
org.hibernate.mapping.PersistentClass.getOptimisticLockMode()	prefer `PersistentClass.getOptimisticLockStyle()`
org.hibernate.mapping.PersistentClass.isCachingExplicitlyRequested()	Use `PersistentClass.isCached` instead
org.hibernate.mapping.PersistentClass.setCachingExplicitlyRequested(boolean)	Use `PersistentClass.setCached(boolean)` instead
org.hibernate.mapping.PersistentClass.setOptimisticLockMode(int)	prefer `PersistentClass.setOptimisticLockStyle(org.hibernate.engine.OptimisticLockStyle)`
org.hibernate.mapping.Selectable.getAlias(Dialect)	(since 6.0) new read-by-position paradigm means that these generated aliases are no longer needed
org.hibernate.mapping.Selectable.getTemplate(Dialect, SqmFunctionRegistry)	(since 6.0) use `Selectable.getCustomWriteExpression()` instead
org.hibernate.mapping.SimpleValue.getIdentifierGenerator()	(as of 6.0) - not used and no longer supported.
org.hibernate.mapping.Table.addInitCommand(InitCommand)	Use `Table.addInitCommand(Function)` instead.
org.hibernate.mapping.Table.qualify(String, String, String)	Should build a `QualifiedTableName` then use `SqlStringGenerationContext.format(QualifiedTableName)`.
org.hibernate.metadata.ClassMetadata.getIdentifier(Object)	Use `ClassMetadata.getIdentifier(Object,SharedSessionContractImplementor)` instead
org.hibernate.metadata.ClassMetadata.getPropertyValuesToInsert(Object, Map, SessionImplementor)	(since 5.3) Use the form accepting SharedSessionContractImplementor instead
org.hibernate.metadata.ClassMetadata.instantiate(Object, SessionImplementor)	(since 5.3) Use the form accepting SharedSessionContractImplementor instead
org.hibernate.metadata.ClassMetadata.setIdentifier(Object, Object, SessionImplementor)	Use `ClassMetadata.setIdentifier(Object, Object, SharedSessionContractImplementor)` instead
org.hibernate.Metamodel.getEntityTypeByName(String)	since 5.2
org.hibernate.metamodel.MappingMetamodel.locateEntityPersister(Class)	(since 6.0) use `MappingMetamodel.locateEntityDescriptor(Class)` instead
org.hibernate.metamodel.model.convert.spi.EnumValueConverter.writeValue(PreparedStatement, O, int, SharedSessionContractImplementor)	Added temporarily in support of dual SQL execution until fully migrated to `SelectStatement` and `JdbcOperation`
org.hibernate.metamodel.spi.MetamodelImplementor.addNamedEntityGraph(String, EntityGraph<T>)	Use `JpaMetamodel.addNamedEntityGraph(String, RootGraphImplementor)` instead.
org.hibernate.metamodel.spi.MetamodelImplementor.findEntityGraphsByType(Class<T>)	Use `JpaMetamodel.findEntityGraphsByJavaType(Class)` instead.
org.hibernate.persister.collection.AbstractCollectionPersister.doProcessQueuedOps(PersistentCollection, Object, int, SharedSessionContractImplementor)	Use `AbstractCollectionPersister.doProcessQueuedOps(PersistentCollection, Object, SharedSessionContractImplementor)`
org.hibernate.persister.entity.AbstractEntityPersister.getIdentityDelegate()	Exposed for tests only
org.hibernate.persister.entity.AbstractEntityPersister.getPropertyInsertGenerationInclusions()	no simple, direct replacement
org.hibernate.persister.entity.AbstractEntityPersister.getPropertyUpdateGenerationInclusions()	no simple, direct replacement
org.hibernate.persister.entity.AbstractPropertyMapping.addPropertyPath(String, Type, String[], String[], String[], String[])	Use `AbstractPropertyMapping.addPropertyPath(String, Type, String[], String[], String[], String[], Mapping)` instead
org.hibernate.persister.entity.EntityPersister.canIdentityInsertBeDelayed()	Since 5.4.1, this is no longer used.
org.hibernate.persister.entity.EntityPersister.generateEntityDefinition()	The legacy "walking model" is deprecated in favor of the newer "mapping model". This method is no longer called by Hibernate. See `InFlightEntityMappingType.prepareMappingModel(org.hibernate.metamodel.mapping.internal.MappingModelCreationProcess)` instead
org.hibernate.persister.entity.EntityPersister.getEntityTuplizer()	Use `EntityPersister.getRepresentationStrategy()`
org.hibernate.persister.entity.EntityPersister.getPropertyInsertGenerationInclusions()	Replaced internally with InMemoryValueGenerationStrategy / InDatabaseValueGenerationStrategy
org.hibernate.persister.entity.EntityPersister.getPropertyUpdateGenerationInclusions()	Replaced internally with InMemoryValueGenerationStrategy / InDatabaseValueGenerationStrategy
org.hibernate.persister.entity.EntityPersister.getPropertyValue(Object, int)	as of 6.0. Use `EntityPersister.getValue(java.lang.Object, int)` instead
org.hibernate.persister.entity.EntityPersister.getPropertyValues(Object)	as of 6.0. Use `EntityPersister.getValues(java.lang.Object)` instead
org.hibernate.persister.entity.EntityPersister.hasCache()	Use `EntityPersister.canReadFromCache()` and/or `EntityPersister.canWriteToCache()` depending on need
org.hibernate.persister.entity.EntityPersister.setPropertyValue(Object, int, Object)	as of 6.0. Use `EntityPersister.setValue(java.lang.Object, int, java.lang.Object)` instead
org.hibernate.persister.entity.EntityPersister.setPropertyValues(Object, Object[])	as of 6.0. Use `EntityPersister.setValues(java.lang.Object, java.lang.Object[])` instead
org.hibernate.persister.entity.Queryable.isMultiTable()	(since 6.0) Use `EntityPersister.getSqmMultiTableMutationStrategy()` instead
org.hibernate.persister.spi.PersisterFactory.createCollectionPersister(Collection, CollectionDataAccess, PersisterCreationContext)	(since 6.0) use `PersisterFactory.createCollectionPersister(Collection, CollectionDataAccess, RuntimeModelCreationContext)` instead
org.hibernate.persister.spi.PersisterFactory.createEntityPersister(PersistentClass, EntityDataAccess, NaturalIdDataAccess, PersisterCreationContext)	(since 6.0) use `PersisterFactory.createEntityPersister(PersistentClass, EntityDataAccess, NaturalIdDataAccess, RuntimeModelCreationContext)` instead
org.hibernate.proxy.AbstractSerializableProxy.setReadOnlyBeforeAttachedToSession(AbstractLazyInitializer)	Use `AbstractSerializableProxy.afterDeserialization(AbstractLazyInitializer)` instead.
org.hibernate.query.procedure.ProcedureParameter.enablePassingNulls(boolean)	(since 6.0) : see `ProcedureParameter.isPassNullsEnabled()`
org.hibernate.query.procedure.ProcedureParameter.isPassNullsEnabled()	(since 6.0) : Passing null or not is now triggered by whether setting the parameter was called at all. In other words a distinction is made between calling `setParameter` passing `null` versus not calling `setParameter` at all. In the first case, we pass along the `null`; in the second we do not pass `null`.
org.hibernate.query.Query.setResultTransformer(ResultTransformer)	(since 5.2) Use `Query.setTupleTransformer(org.hibernate.query.TupleTransformer<R>)` or `Query.setResultListTransformer(org.hibernate.query.ResultListTransformer)`
org.hibernate.query.sql.spi.ParameterRecognizer.outParameter(int)	(since 5.2) Application should use `ProcedureCall` instead
org.hibernate.query.sqm.tree.expression.SqmExpression.applyInferableType(SqmExpressable<?>)	- type inference is now handled during the SQM -> SQL AST transformation
org.hibernate.resource.transaction.spi.DdlTransactionIsolator.prepare()	Instances should be returned from `TransactionCoordinatorBuilder.buildDdlTransactionIsolator(org.hibernate.tool.schema.internal.exec.JdbcContext)` already prepared for use
org.hibernate.service.spi.SessionFactoryServiceInitiator.initiateService(SessionFactoryImplementor, SessionFactoryOptions, ServiceRegistryImplementor)	Use `SessionFactoryServiceInitiator.initiateService(SessionFactoryServiceInitiatorContext)` instead.
org.hibernate.Session.setFlushMode(FlushMode)	(since 5.2) use `Session.setHibernateFlushMode(FlushMode)` instead
org.hibernate.SessionBuilder.autoClose(boolean)	Only integrations can specify autoClosing behavior of individual sessions. See `SessionOwner`
org.hibernate.SessionBuilder.connectionReleaseMode(ConnectionReleaseMode)	(since 5.2) use `SessionBuilder.connectionHandlingMode(org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode)` instead
org.hibernate.SessionBuilder.flushBeforeCompletion(boolean)	(since 5.2) use `SessionBuilder.flushMode(FlushMode)` instead.
org.hibernate.SessionFactory.getAllClassMetadata()	Use the descriptors from `EntityManagerFactory.getMetamodel()` instead
org.hibernate.SessionFactory.getAllCollectionMetadata()	Use the descriptors from `EntityManagerFactory.getMetamodel()` instead
org.hibernate.SessionFactory.getClassMetadata(Class)	Use the descriptors from `EntityManagerFactory.getMetamodel()` instead
org.hibernate.SessionFactory.getCollectionMetadata(String)	Use the descriptors from `EntityManagerFactory.getMetamodel()` instead
org.hibernate.SharedSessionBuilder.connectionReleaseMode()	(snce 6.0) use `SharedSessionBuilder.connectionHandlingMode()` instead.
org.hibernate.SharedSessionBuilder.flushBeforeCompletion()	(since 5.2) use `SharedSessionBuilder.flushMode()` instead.
org.hibernate.SharedSessionBuilder.transactionContext()	Use `SharedSessionBuilder.connection()` instead
org.hibernate.sql.Template.renderWhereStringTemplate(String, String, Dialect)	Only intended for annotations usage; use `Template.renderWhereStringTemplate(String, String, Dialect, SqmFunctionRegistry)` instead
org.hibernate.stat.Statistics.getNaturalIdCacheStatistics(String)	(since 5.3) Use `Statistics.getNaturalIdStatistics(java.lang.String)` or `Statistics.getDomainDataRegionStatistics(java.lang.String)` instead depending on need
org.hibernate.stat.Statistics.getSecondLevelCacheStatistics(String)	(since 5.3) Use `Statistics.getDomainDataRegionStatistics(java.lang.String)` instead
org.hibernate.tool.schema.extract.spi.SequenceInformation.getIncrementSize()	use `SequenceInformation.getIncrementValue()` instead.
org.hibernate.tuple.entity.EntityTuplizer.getIdentifier(Object, SharedSessionContractImplementor)	(as of 6.0) - no longer used internally and to be removed. Use `EntityIdentifierMapping.getIdentifier(java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor)` instead
org.hibernate.tuple.NonIdentifierAttribute.isDirtyCheckable(boolean)	Use `NonIdentifierAttribute.isDirtyCheckable()` instead
org.hibernate.tuple.Property.getNode()	DOM4j entity mode is no longer supported
org.hibernate.tuple.PropertyFactory.buildStandardProperty(Property, boolean)	See mainly `PropertyFactory.buildEntityBasedAttribute(org.hibernate.persister.entity.EntityPersister, org.hibernate.engine.spi.SessionFactoryImplementor, int, org.hibernate.mapping.Property, boolean, org.hibernate.persister.spi.PersisterCreationContext)`
org.hibernate.type.descriptor.jdbc.LobTypeMappings.getCorrespondingLobCode(int)	use `LobTypeMappings.getLobCodeTypeMapping(int)`
org.hibernate.type.descriptor.jdbc.LobTypeMappings.hasCorrespondingLobCode(int)	use `LobTypeMappings.isMappedToKnownLobCode(int)`
org.hibernate.type.descriptor.jdbc.NationalizedTypeMappings.getCorrespondingNationalizedCode(int)	use `NationalizedTypeMappings.toNationalizedTypeCode(int)`
org.hibernate.type.TypeHelper.findDirty(NonIdentifierAttribute[], Object[], Object[], boolean[][], boolean, SharedSessionContractImplementor)	Use {org.hibernate.type.TypeHelper`TypeHelper.findDirty(NonIdentifierAttribute[], Object[], Object[], boolean[][], SharedSessionContractImplementor)` indtead
org.hibernate.type.TypeHelper.findModified(NonIdentifierAttribute[], Object[], Object[], boolean[][], boolean[], boolean, SharedSessionContractImplementor)	Use `TypeHelper.findModified(NonIdentifierAttribute[], Object[], Object[], boolean[][], boolean[], boolean, SharedSessionContractImplementor)` instead.

Constructors
Constructor	Description
org.hibernate.boot.registry.StandardServiceRegistryBuilder(BootstrapServiceRegistry, Map, LoadedConfig, List<StandardServiceInitiator>)	Quarkus will switch to use `StandardServiceRegistryBuilder(BootstrapServiceRegistry, Map, ConfigLoader, LoadedConfig, List)`
org.hibernate.dialect.Dialect()	provide a `DatabaseVersion`
org.hibernate.DuplicateMappingException(String, String)	Use the for taking `DuplicateMappingException.Type` instead.
org.hibernate.proxy.AbstractLazyInitializer()	This constructor was initially intended for serialization only, and is not useful anymore. In any case it should not be relied on by user code. Subclasses should rather implement Serializable with an `Object writeReplace()` method returning a subclass of `AbstractSerializableProxy`, which in turn implements Serializable and an `Object readResolve()` method instantiating the `AbstractLazyInitializer` subclass and calling `AbstractSerializableProxy.afterDeserialization(AbstractLazyInitializer)` on it. See `ByteBuddyInterceptor` and `SerializableProxy` for examples.
org.hibernate.proxy.AbstractSerializableProxy()	This constructor was initially intended for serialization only, and is not useful anymore. In any case it should not be relied on by user code.
org.hibernate.proxy.pojo.bytebuddy.SerializableProxy(String, Class, Class[], Serializable, Boolean, Method, Method, CompositeType)	use `SerializableProxy(String, Class, Class[], Object, Boolean, String, boolean, Method, Method, CompositeType)` instead.
org.hibernate.tuple.PojoInstantiator(Class, ReflectionOptimizer.InstantiationOptimizer, boolean)	(as of 6.0) See `PojoInstantiator`

Enum Constants
Enum Constant	Description
org.hibernate.annotations.CascadeType.DELETE_ORPHAN	use @OneToOne(orphanRemoval=true) or @OneToMany(orphanRemoval=true)
org.hibernate.LockMode.FORCE	instead use PESSIMISTIC_FORCE_INCREMENT
org.hibernate.LockMode.UPGRADE	instead use PESSIMISTIC_WRITE

Annotation Type Elements
Annotation Type Element Description

org.hibernate.annotations.AttributeAccessor.value()
use AttributeAccessor.strategy()

Deprecated API

Contents