Deprecated API

Contents

• Interfaces
• Classes
• Enums
• Exceptions
• Annotation Types
• Fields
• Methods
• Constructors
• Enum Constants
• Annotation Type Elements

Interfaces

Interface	Description
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.SessionOwner	(since 5.2) since consolidating hibernate-entitymanager into hibernate-core I believe this is no longer needed.
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.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.component.ComponentTuplizer	for removal in 6.0. See instead `ManagedTypeRepresentationStrategy` and `RepresentationMode` in 6.0
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.MultipleHiLoPerTableGenerator	Use TableGenerator instead.
org.hibernate.id.SequenceGenerator	Use SequenceStyleGenerator instead
org.hibernate.id.SequenceHiLoGenerator	See deprecation discussion on SequenceGenerator
org.hibernate.id.SequenceIdentityGenerator	See deprecation discussion on SequenceGenerator
org.hibernate.lob.ReaderInputStream	Should not be used anymore.
org.hibernate.mapping.PropertyGeneration	This is replaced by ValueGeneration and GenerationTiming
org.hibernate.property.access.spi.EnhancedGetterMethodImpl	No longer used; GetterFieldImpl or GetterMethodImpl should be used instead.
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

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.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.id.enhanced.SequenceStyleGenerator.DEF_SEQUENCE_NAME	As of 6.0 with no replacement - `hibernate_sequence` as a real, implicit exportable name is no longer supported. No effect
org.hibernate.id.SequenceGenerator.PARAMETERS	No longer supported. To specify initial-value or increment use the org.hibernate.id.enhanced.SequenceStyleGenerator generator 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.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.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.Mapping.getIdentifierGeneratorFactory()	temporary solution
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.OptimizerFactory.buildOptimizer(String, Class, int)	Use OptimizerFactory.buildOptimizer(String, Class, int, long) instead
org.hibernate.id.factory.IdentifierGeneratorFactory.setDialect(Dialect)	The intention is that Dialect should be required to be specified up-front and it would then get ctor injected.
org.hibernate.id.IdentifierGeneratorHelper.createNumber(long, Class)	Use the holders instead.
org.hibernate.id.PersistentIdentifierGenerator.sqlCreateStrings(Dialect)	Utilize the ExportableProducer contract instead
org.hibernate.id.PersistentIdentifierGenerator.sqlDropStrings(Dialect)	Utilize the ExportableProducer contract instead
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.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.Table.getQualifiedName(Dialect, String, String)	Should use QualifiedObjectNameFormatter.format(org.hibernate.boot.model.relational.QualifiedTableName, org.hibernate.dialect.Dialect) on QualifiedObjectNameFormatter obtained from JdbcEnvironment
org.hibernate.mapping.Table.qualify(String, String, String)	Should use QualifiedObjectNameFormatter.format(org.hibernate.boot.model.relational.QualifiedTableName, org.hibernate.dialect.Dialect) on QualifiedObjectNameFormatter obtained from JdbcEnvironment
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.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.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.StatelessSession.connection()	just missed when deprecating same method from Session
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.TypeHelperTypeHelper.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.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.component.ComponentMetamodel(Component, MetadataBuildingOptions)
org.hibernate.tuple.component.ComponentTuplizerFactory(MetadataBuildingOptions)	Use ComponentTuplizerFactory(BootstrapContext) 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()