org.hibernate.boot.internal

Class SessionFactoryBuilderImpl

java.lang.Object

org.hibernate.boot.internal.SessionFactoryBuilderImpl

All Implemented Interfaces:

SessionFactoryBuilder, SessionFactoryBuilderImplementor

public class SessionFactoryBuilderImpl
extends Object
implements SessionFactoryBuilderImplementor

Author:

Gail Badner, Steve Ebersole

Constructor Summary

Constructors

Constructor and Description
SessionFactoryBuilderImpl(MetadataImplementor metadata, BootstrapContext bootstrapContext)

Method Summary

Modifier and Type	Method and Description
SessionFactoryBuilder	addEntityNameResolver(EntityNameResolver... entityNameResolvers) Specifies one or more entity name resolvers to be applied to the SessionFactory (see the EntityNameResolver contract for more information..
SessionFactoryBuilder	addSessionFactoryObservers(SessionFactoryObserver... observers) Specifies one or more observers to be applied to the SessionFactory.
SessionFactoryBuilder	allowOutOfTransactionUpdateOperations(boolean allow)
SessionFactoryBuilder	applyAutoClosing(boolean enabled) Applies whether Sessions should be automatically closed at the end of the transaction.
SessionFactoryBuilder	applyAutoFlushing(boolean enabled) Applies whether Sessions should be automatically flushed at the end of the transaction.
SessionFactoryBuilder	applyAutomaticEvictionOfCollectionCaches(boolean enabled) When using bi-directional many-to-one associations and caching the one-to-many side it is expected that both sides of the association are managed (actually that is true of all bi-directional associations).
SessionFactoryBuilder	applyBatchFetchStyle(BatchFetchStyle style) What style of batching should be used?
SessionFactoryBuilder	applyBeanManager(Object beanManager) Apply a CDI BeanManager to the SessionFactory being built.
SessionFactoryBuilder	applyCacheRegionPrefix(String prefix) Apply a prefix to prepended to all cache region names for this SessionFactory.
SessionFactoryBuilder	applyConnectionHandlingMode(PhysicalConnectionHandlingMode connectionHandlingMode) Apply the specified handling mode for JDBC connections
SessionFactoryBuilder	applyConnectionProviderDisablesAutoCommit(boolean providerDisablesAutoCommit)
SessionFactoryBuilder	applyConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode) Apply a ConnectionReleaseMode.
SessionFactoryBuilder	applyCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver resolver) Specifies a strategy for resolving the notion of a "current" tenant-identifier when using multi-tenancy together with current sessions
SessionFactoryBuilder	applyCustomEntityDirtinessStrategy(CustomEntityDirtinessStrategy strategy) Specifies a custom entity dirtiness strategy to be applied to the SessionFactory.
SessionFactoryBuilder	applyDefaultBatchFetchSize(int size) Allows specifying a default batch-fetch size for all entities and collections which do not otherwise specify a batch-fetch size.
SessionFactoryBuilder	applyDefaultEntityMode(EntityMode entityMode) Applies the given entity mode as the default for the SessionFactory.
SessionFactoryBuilder	applyDefaultNullPrecedence(NullPrecedence nullPrecedence) Apply a null precedence (NULLS FIRST, NULLS LAST) to be applied order-by clauses rendered into SQL queries.
SessionFactoryBuilder	applyDelayedEntityLoaderCreations(boolean delay) Should entity Loaders be generated immediately? Or should the creation be delayed until first need?
SessionFactoryBuilder	applyDirectReferenceCaching(boolean enabled) Generally, Hibernate will extract the information from an entity and put that extracted information into the second-level cache.
SessionFactoryBuilder	applyEntityNotFoundDelegate(EntityNotFoundDelegate entityNotFoundDelegate) Names the EntityNotFoundDelegate to be applied to the SessionFactory.
SessionFactoryBuilder	applyEntityTuplizer(EntityMode entityMode, Class<? extends EntityTuplizer> tuplizerClass) Register the default EntityTuplizer to be applied to the SessionFactory.
SessionFactoryBuilder	applyEntityTuplizerFactory(EntityTuplizerFactory entityTuplizerFactory) Specify the EntityTuplizerFactory to use.
SessionFactoryBuilder	applyGetGeneratedKeysSupport(boolean enabled) Should JDBC Statement.getGeneratedKeys() feature be used for retrieval of *insert-generated* ids?
SessionFactoryBuilder	applyIdentifierRollbackSupport(boolean enabled) Should generated identifiers be "unset" on entities during a rollback?
SessionFactoryBuilder	applyInterceptor(Interceptor interceptor) Names an interceptor to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.interceptor(org.hibernate.Interceptor)
SessionFactoryBuilder	applyJdbcBatchingForVersionedEntities(boolean enabled) This setting controls whether versioned entities will be included in JDBC batching.
SessionFactoryBuilder	applyJdbcBatchSize(int size) Specifies the maximum number of statements to batch together in a JDBC batch for insert, update and delete operations.
SessionFactoryBuilder	applyJdbcFetchSize(int size) Apply a fetch size to the JDBC driver for fetching results.
SessionFactoryBuilder	applyJtaTrackingByThread(boolean enabled) If using the built-in Hibernate JTA-based TransactionCoordinator/Builder, should it track JTA transactions by thread in an attempt to detect timeouts?
SessionFactoryBuilder	applyLazyInitializationOutsideTransaction(boolean enabled) Should the application be allowed to initialize uninitialized lazy state outside the bounds of a transaction?
SessionFactoryBuilder	applyMaximumFetchDepth(int depth) Apply a limit to the depth Hibernate will use for outer joins.
SessionFactoryBuilder	applyMinimalPutsForCaching(boolean enabled) By default, Hibernate will always just push data into the cache without first checking if that data already exists.
SessionFactoryBuilder	applyMultiTableBulkIdStrategy(MultiTableBulkIdStrategy strategy) How should updates and deletes that span multiple tables be handled?
SessionFactoryBuilder	applyMultiTenancyStrategy(MultiTenancyStrategy strategy) Apply the form of multi-tenancy used by the application
SessionFactoryBuilder	applyName(String sessionFactoryName) Applies a SessionFactory name.
SessionFactoryBuilder	applyNameAsJndiName(boolean isJndiName) Applies a SessionFactory name.
SessionFactoryBuilder	applyNamedQueryCheckingOnStartup(boolean enabled) Should named queries be checked on startup?
SessionFactoryBuilder	applyNullabilityChecking(boolean enabled) Should attributes using columns marked as not-null be checked (by Hibernate) for nullness?
SessionFactoryBuilder	applyOrderingOfInserts(boolean enabled) Apply whether ordering of inserts should be enabled.
SessionFactoryBuilder	applyOrderingOfUpdates(boolean enabled) Apply whether ordering of updates should be enabled.
SessionFactoryBuilder	applyPreferUserTransactions(boolean preferUserTransactions) If using the built-in Hibernate JTA-based TransactionCoordinator/Builder, should it prefer to use UserTransaction over Transaction?
SessionFactoryBuilder	applyQueryCacheSupport(boolean enabled) Should second level query caching support be enabled?
SessionFactoryBuilder	applyQuerySubstitutions(Map substitutions) Apply query substitutions to use in HQL queries.
SessionFactoryBuilder	applyResultSetsWrapping(boolean enabled) Hibernate currently accesses results from the JDBC ResultSet by name.
SessionFactoryBuilder	applyScrollableResultsSupport(boolean enabled) Should scrollable results be supported in queries? We ask the JDBC driver whether it supports scrollable result sets as the default for this setting, but some drivers do not accurately report this via DatabaseMetaData.
SessionFactoryBuilder	applySecondLevelCacheSupport(boolean enabled) Should second level caching support be enabled?
SessionFactoryBuilder	applySqlComments(boolean enabled) Should Hibernate apply comments to SQL it generates?
SessionFactoryBuilder	applySqlFunction(String registrationName, SQLFunction sqlFunction) Apply a SQLFunction to the underlying SQLFunctionRegistry.
SessionFactoryBuilder	applyStatelessInterceptor(Class<? extends Interceptor> statelessInterceptorClass) Names an interceptor Class to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.interceptor(org.hibernate.Interceptor)
SessionFactoryBuilder	applyStatelessInterceptor(Supplier<? extends Interceptor> statelessInterceptorSupplier) Names a Supplier instance which is used to retrieve the interceptor to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.interceptor(org.hibernate.Interceptor)
SessionFactoryBuilder	applyStatementInspector(StatementInspector statementInspector) Names a StatementInspector to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.statementInspector(org.hibernate.resource.jdbc.spi.StatementInspector)
SessionFactoryBuilder	applyStatisticsSupport(boolean enabled) Applies whether statistics gathering is enabled.
SessionFactoryBuilder	applyStrictJpaQueryLanguageCompliance(boolean enabled) Should we strictly adhere to JPA Query Language (JPQL) syntax, or more broadly support all of Hibernate's superset (HQL)? Setting this to true may cause valid HQL to throw an exception because it violates the JPQL subset.
SessionFactoryBuilder	applyStructuredCacheEntries(boolean enabled) By default, Hibernate stores data in the cache in its own optimized format.
SessionFactoryBuilder	applyTempTableDdlTransactionHandling(TempTableDdlTransactionHandling handling)
SessionFactoryBuilder	applyTimestampsCacheFactory(TimestampsCacheFactory factory) Specifies a QueryCacheFactory to use for building query cache handlers.
SessionFactoryBuilder	applyValidatorFactory(Object validatorFactory) Apply a Bean Validation ValidatorFactory to the SessionFactory being built.
SessionFactory	build() After all options have been set, build the SessionFactory.
SessionFactoryOptions	buildSessionFactoryOptions() Build the SessionFactoryOptions that will ultimately be passed to SessionFactoryImpl constructor.
void	disableJtaTransactionAccess()
void	disableRefreshDetachedEntity()
void	enableJdbcStyleParamsZeroBased()
SessionFactoryBuilder	enableJpaClosedCompliance(boolean enabled)
SessionFactoryBuilder	enableJpaListCompliance(boolean enabled)
SessionFactoryBuilder	enableJpaQueryCompliance(boolean enabled)
SessionFactoryBuilder	enableJpaTransactionCompliance(boolean enabled)
SessionFactoryBuilder	enableReleaseResourcesOnCloseEnabled(boolean enable) Should resources held by EntityManager instance be released immediately on close? The other option is to release them as part of an after-transaction callback.
void	markAsJpaBootstrap() Indicates that the SessionFactory being built comes from JPA bootstrapping.
<T extends SessionFactoryBuilder> T	unwrap(Class<T> type) Allows unwrapping this builder as another, more specific type.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SessionFactoryBuilderImpl

public SessionFactoryBuilderImpl(MetadataImplementor metadata,
                                 BootstrapContext bootstrapContext)

Method Detail

applyBeanManager

public SessionFactoryBuilder applyBeanManager(Object beanManager)

Description copied from interface: SessionFactoryBuilder

Apply a CDI BeanManager to the SessionFactory being built. NOTE : De-typed to avoid hard dependency on CDI jar at runtime.

Specified by:

applyBeanManager in interface SessionFactoryBuilder

Parameters:

beanManager - The CDI BeanManager to use

Returns:

this, for method chaining

applyValidatorFactory

public SessionFactoryBuilder applyValidatorFactory(Object validatorFactory)

Description copied from interface: SessionFactoryBuilder

Apply a Bean Validation ValidatorFactory to the SessionFactory being built. NOTE : De-typed to avoid hard dependency on Bean Validation jar at runtime.

Specified by:

applyValidatorFactory in interface SessionFactoryBuilder

Parameters:

validatorFactory - The Bean Validation ValidatorFactory to use

Returns:

this, for method chaining

applyName

public SessionFactoryBuilder applyName(String sessionFactoryName)

Description copied from interface: SessionFactoryBuilder

Applies a SessionFactory name.

Specified by:

applyName in interface SessionFactoryBuilder

Parameters:

sessionFactoryName - The name to use for the SessionFactory being built

Returns:

this, for method chaining

See Also:

AvailableSettings.SESSION_FACTORY_NAME

applyNameAsJndiName

public SessionFactoryBuilder applyNameAsJndiName(boolean isJndiName)

Description copied from interface: SessionFactoryBuilder

Applies a SessionFactory name.

Specified by:

applyNameAsJndiName in interface SessionFactoryBuilder

Parameters:

isJndiName - true indicates that the name specified in SessionFactoryBuilder.applyName(java.lang.String) will be used for binding the SessionFactory into JNDI.

Returns:

this, for method chaining

See Also:

AvailableSettings.SESSION_FACTORY_NAME_IS_JNDI

applyAutoClosing

public SessionFactoryBuilder applyAutoClosing(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Applies whether Sessions should be automatically closed at the end of the transaction.

Specified by:

applyAutoClosing in interface SessionFactoryBuilder

Parameters:

enabled - true indicates they should be auto-closed; false indicates not.

Returns:

this, for method chaining

See Also:

AvailableSettings.AUTO_CLOSE_SESSION

applyAutoFlushing

public SessionFactoryBuilder applyAutoFlushing(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Applies whether Sessions should be automatically flushed at the end of the transaction.

Specified by:

applyAutoFlushing in interface SessionFactoryBuilder

Parameters:

enabled - true indicates they should be auto-flushed; false indicates not.

Returns:

this, for method chaining

See Also:

AvailableSettings.FLUSH_BEFORE_COMPLETION

applyJtaTrackingByThread

public SessionFactoryBuilder applyJtaTrackingByThread(boolean enabled)

Description copied from interface: SessionFactoryBuilder

If using the built-in Hibernate JTA-based TransactionCoordinator/Builder, should it track JTA transactions by thread in an attempt to detect timeouts?

Specified by:

applyJtaTrackingByThread in interface SessionFactoryBuilder

Parameters:

enabled - true indicates we should track by thread; false indicates not

Returns:

this, for method chaining

See Also:

AvailableSettings.JTA_TRACK_BY_THREAD

applyPreferUserTransactions

public SessionFactoryBuilder applyPreferUserTransactions(boolean preferUserTransactions)

Description copied from interface: SessionFactoryBuilder

If using the built-in Hibernate JTA-based TransactionCoordinator/Builder, should it prefer to use UserTransaction over Transaction?

Specified by:

applyPreferUserTransactions in interface SessionFactoryBuilder

Parameters:

preferUserTransactions - true indicates we should prefer UserTransaction; false indicates we should prefer Transaction

Returns:

this, for method chaining

See Also:

AvailableSettings.PREFER_USER_TRANSACTION

applyStatisticsSupport

public SessionFactoryBuilder applyStatisticsSupport(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Applies whether statistics gathering is enabled.

Specified by:

applyStatisticsSupport in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that statistics gathering should be enabled; false indicates not.

Returns:

this, for method chaining

See Also:

AvailableSettings.GENERATE_STATISTICS

addSessionFactoryObservers

public SessionFactoryBuilder addSessionFactoryObservers(SessionFactoryObserver... observers)

Description copied from interface: SessionFactoryBuilder

Specifies one or more observers to be applied to the SessionFactory. Can be called multiple times to add additional observers.

Specified by:

addSessionFactoryObservers in interface SessionFactoryBuilder

Parameters:

observers - The observers to add

Returns:

this, for method chaining

applyInterceptor

public SessionFactoryBuilder applyInterceptor(Interceptor interceptor)

Description copied from interface: SessionFactoryBuilder

Names an interceptor to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.interceptor(org.hibernate.Interceptor)

Specified by:

applyInterceptor in interface SessionFactoryBuilder

Parameters:

interceptor - The interceptor

Returns:

this, for method chaining

See Also:

AvailableSettings.INTERCEPTOR

applyStatelessInterceptor

public SessionFactoryBuilder applyStatelessInterceptor(Class<? extends Interceptor> statelessInterceptorClass)

Description copied from interface: SessionFactoryBuilder

Names an interceptor Class to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.interceptor(org.hibernate.Interceptor)

Specified by:

applyStatelessInterceptor in interface SessionFactoryBuilder

Parameters:

statelessInterceptorClass - The interceptor class

Returns:

this, for method chaining

See Also:

AvailableSettings.SESSION_SCOPED_INTERCEPTOR

applyStatelessInterceptor

public SessionFactoryBuilder applyStatelessInterceptor(Supplier<? extends Interceptor> statelessInterceptorSupplier)

Description copied from interface: SessionFactoryBuilder

Names a Supplier instance which is used to retrieve the interceptor to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.interceptor(org.hibernate.Interceptor)

Specified by:

applyStatelessInterceptor in interface SessionFactoryBuilder

Parameters:

statelessInterceptorSupplier - Supplier instance which is used to retrieve the interceptor

Returns:

this, for method chaining

See Also:

AvailableSettings.SESSION_SCOPED_INTERCEPTOR

applyStatementInspector

public SessionFactoryBuilder applyStatementInspector(StatementInspector statementInspector)

Description copied from interface: SessionFactoryBuilder

Names a StatementInspector to be applied to the SessionFactory, which in turn means it will be used by all Sessions unless one is explicitly specified in SessionBuilder.statementInspector(org.hibernate.resource.jdbc.spi.StatementInspector)

Specified by:

applyStatementInspector in interface SessionFactoryBuilder

Parameters:

statementInspector - The StatementInspector

Returns:

this, for method chaining

See Also:

AvailableSettings.STATEMENT_INSPECTOR

applyCustomEntityDirtinessStrategy

public SessionFactoryBuilder applyCustomEntityDirtinessStrategy(CustomEntityDirtinessStrategy strategy)

Description copied from interface: SessionFactoryBuilder

Specifies a custom entity dirtiness strategy to be applied to the SessionFactory. See the contract of CustomEntityDirtinessStrategy for details.

Specified by:

applyCustomEntityDirtinessStrategy in interface SessionFactoryBuilder

Parameters:

strategy - The custom strategy to be used.

Returns:

this, for method chaining

See Also:

AvailableSettings.CUSTOM_ENTITY_DIRTINESS_STRATEGY

addEntityNameResolver

public SessionFactoryBuilder addEntityNameResolver(EntityNameResolver... entityNameResolvers)

Description copied from interface: SessionFactoryBuilder

Specifies one or more entity name resolvers to be applied to the SessionFactory (see the EntityNameResolver contract for more information.. Can be called multiple times to add additional resolvers..

Specified by:

addEntityNameResolver in interface SessionFactoryBuilder

Parameters:

entityNameResolvers - The entityNameResolvers to add

Returns:

this, for method chaining

applyEntityNotFoundDelegate

public SessionFactoryBuilder applyEntityNotFoundDelegate(EntityNotFoundDelegate entityNotFoundDelegate)

Description copied from interface: SessionFactoryBuilder

Names the EntityNotFoundDelegate to be applied to the SessionFactory. EntityNotFoundDelegate is a strategy that accounts for different exceptions thrown between Hibernate and JPA when an entity cannot be found.

Specified by:

applyEntityNotFoundDelegate in interface SessionFactoryBuilder

Parameters:

entityNotFoundDelegate - The delegate/strategy to use.

Returns:

this, for method chaining

applyIdentifierRollbackSupport

public SessionFactoryBuilder applyIdentifierRollbackSupport(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should generated identifiers be "unset" on entities during a rollback?

Specified by:

applyIdentifierRollbackSupport in interface SessionFactoryBuilder

Parameters:

enabled - true indicates identifiers should be unset; false indicates not.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_IDENTIFIER_ROLLBACK

applyDefaultEntityMode

public SessionFactoryBuilder applyDefaultEntityMode(EntityMode entityMode)

Description copied from interface: SessionFactoryBuilder

Applies the given entity mode as the default for the SessionFactory.

Specified by:

applyDefaultEntityMode in interface SessionFactoryBuilder

Parameters:

entityMode - The default entity mode to use.

Returns:

this, for method chaining

See Also:

AvailableSettings.DEFAULT_ENTITY_MODE

applyNullabilityChecking

public SessionFactoryBuilder applyNullabilityChecking(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should attributes using columns marked as not-null be checked (by Hibernate) for nullness?

Specified by:

applyNullabilityChecking in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that Hibernate should perform nullness checking; false indicates it should not.

Returns:

this, for method chaining

See Also:

AvailableSettings.CHECK_NULLABILITY

applyLazyInitializationOutsideTransaction

public SessionFactoryBuilder applyLazyInitializationOutsideTransaction(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should the application be allowed to initialize uninitialized lazy state outside the bounds of a transaction?

Specified by:

applyLazyInitializationOutsideTransaction in interface SessionFactoryBuilder

Parameters:

enabled - true indicates initialization outside the transaction should be allowed; false indicates it should not.

Returns:

this, for method chaining

See Also:

AvailableSettings.ENABLE_LAZY_LOAD_NO_TRANS

applyEntityTuplizerFactory

public SessionFactoryBuilder applyEntityTuplizerFactory(EntityTuplizerFactory entityTuplizerFactory)

Description copied from interface: SessionFactoryBuilder

Specify the EntityTuplizerFactory to use.

Specified by:

applyEntityTuplizerFactory in interface SessionFactoryBuilder

Parameters:

entityTuplizerFactory - The EntityTuplizerFactory to use.

Returns:

this, for method chaining

applyEntityTuplizer

public SessionFactoryBuilder applyEntityTuplizer(EntityMode entityMode,
                                                 Class<? extends EntityTuplizer> tuplizerClass)

Description copied from interface: SessionFactoryBuilder

Register the default EntityTuplizer to be applied to the SessionFactory.

Specified by:

applyEntityTuplizer in interface SessionFactoryBuilder

Parameters:

entityMode - The entity mode that which this tuplizer will be applied.

tuplizerClass - The custom tuplizer class.

Returns:

this, for method chaining

applyMultiTableBulkIdStrategy

public SessionFactoryBuilder applyMultiTableBulkIdStrategy(MultiTableBulkIdStrategy strategy)

Description copied from interface: SessionFactoryBuilder

How should updates and deletes that span multiple tables be handled?

Specified by:

applyMultiTableBulkIdStrategy in interface SessionFactoryBuilder

Parameters:

strategy - The strategy for handling multi-table updates and deletes.

Returns:

this, for method chaining

See Also:

AvailableSettings.HQL_BULK_ID_STRATEGY

applyTempTableDdlTransactionHandling

public SessionFactoryBuilder applyTempTableDdlTransactionHandling(TempTableDdlTransactionHandling handling)

Specified by:

applyTempTableDdlTransactionHandling in interface SessionFactoryBuilder

applyBatchFetchStyle

public SessionFactoryBuilder applyBatchFetchStyle(BatchFetchStyle style)

Description copied from interface: SessionFactoryBuilder

What style of batching should be used?

Specified by:

applyBatchFetchStyle in interface SessionFactoryBuilder

Parameters:

style - The style to use

Returns:

this, for method chaining

See Also:

AvailableSettings.BATCH_FETCH_STYLE

applyDelayedEntityLoaderCreations

public SessionFactoryBuilder applyDelayedEntityLoaderCreations(boolean delay)

Description copied from interface: SessionFactoryBuilder

Should entity Loaders be generated immediately? Or should the creation be delayed until first need?

Specified by:

applyDelayedEntityLoaderCreations in interface SessionFactoryBuilder

See Also:

AvailableSettings.DELAY_ENTITY_LOADER_CREATIONS

applyDefaultBatchFetchSize

public SessionFactoryBuilder applyDefaultBatchFetchSize(int size)

Description copied from interface: SessionFactoryBuilder

Allows specifying a default batch-fetch size for all entities and collections which do not otherwise specify a batch-fetch size.

Specified by:

applyDefaultBatchFetchSize in interface SessionFactoryBuilder

Parameters:

size - The size to use for batch fetching for entities/collections which do not specify an explicit batch fetch size.

Returns:

this, for method chaining

See Also:

AvailableSettings.DEFAULT_BATCH_FETCH_SIZE

applyMaximumFetchDepth

public SessionFactoryBuilder applyMaximumFetchDepth(int depth)

Description copied from interface: SessionFactoryBuilder

Apply a limit to the depth Hibernate will use for outer joins. Note that this is different than an overall limit on the number of joins...

Specified by:

applyMaximumFetchDepth in interface SessionFactoryBuilder

Parameters:

depth - The depth for limiting joins.

Returns:

this, for method chaining

See Also:

AvailableSettings.MAX_FETCH_DEPTH

applyDefaultNullPrecedence

public SessionFactoryBuilder applyDefaultNullPrecedence(NullPrecedence nullPrecedence)

Description copied from interface: SessionFactoryBuilder

Apply a null precedence (NULLS FIRST, NULLS LAST) to be applied order-by clauses rendered into SQL queries.

Specified by:

applyDefaultNullPrecedence in interface SessionFactoryBuilder

Parameters:

nullPrecedence - The default null precedence to use.

Returns:

this, for method chaining

See Also:

AvailableSettings.DEFAULT_NULL_ORDERING

applyOrderingOfInserts

public SessionFactoryBuilder applyOrderingOfInserts(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Apply whether ordering of inserts should be enabled. This allows more efficient SQL generation via the use of batching for the inserts; the cost is that the determination of the ordering is far more inefficient than not ordering.

Specified by:

applyOrderingOfInserts in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that ordering should be enabled; false indicates not

Returns:

this, for method chaining

See Also:

AvailableSettings.ORDER_INSERTS

applyOrderingOfUpdates

public SessionFactoryBuilder applyOrderingOfUpdates(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Apply whether ordering of updates should be enabled. This allows more efficient SQL generation via the use of batching for the updates; the cost is that the determination of the ordering is far more inefficient than not ordering.

Specified by:

applyOrderingOfUpdates in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that ordering should be enabled; false indicates not

Returns:

this, for method chaining

See Also:

AvailableSettings.ORDER_UPDATES

applyMultiTenancyStrategy

public SessionFactoryBuilder applyMultiTenancyStrategy(MultiTenancyStrategy strategy)

Description copied from interface: SessionFactoryBuilder

Apply the form of multi-tenancy used by the application

Specified by:

applyMultiTenancyStrategy in interface SessionFactoryBuilder

Parameters:

strategy - The form of multi-tenancy in use.

Returns:

this, for method chaining

See Also:

AvailableSettings.MULTI_TENANT

applyCurrentTenantIdentifierResolver

public SessionFactoryBuilder applyCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver resolver)

Description copied from interface: SessionFactoryBuilder

Specifies a strategy for resolving the notion of a "current" tenant-identifier when using multi-tenancy together with current sessions

Specified by:

applyCurrentTenantIdentifierResolver in interface SessionFactoryBuilder

Parameters:

resolver - The resolution strategy to use.

Returns:

this, for method chaining

See Also:

AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER

applyQuerySubstitutions

public SessionFactoryBuilder applyQuerySubstitutions(Map substitutions)

Description copied from interface: SessionFactoryBuilder

Apply query substitutions to use in HQL queries. Note, this is a legacy feature and almost always never needed anymore...

Specified by:

applyQuerySubstitutions in interface SessionFactoryBuilder

Parameters:

substitutions - The substitution map

Returns:

this, for method chaining

See Also:

AvailableSettings.QUERY_SUBSTITUTIONS

applyNamedQueryCheckingOnStartup

public SessionFactoryBuilder applyNamedQueryCheckingOnStartup(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should named queries be checked on startup?

Specified by:

applyNamedQueryCheckingOnStartup in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that they should; false indicates they should not.

Returns:

this, for method chaining

See Also:

AvailableSettings.QUERY_STARTUP_CHECKING

applySecondLevelCacheSupport

public SessionFactoryBuilder applySecondLevelCacheSupport(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should second level caching support be enabled?

Specified by:

applySecondLevelCacheSupport in interface SessionFactoryBuilder

Parameters:

enabled - true indicates we should enable the use of second level caching; false indicates we should disable the use of second level caching.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_SECOND_LEVEL_CACHE

applyQueryCacheSupport

public SessionFactoryBuilder applyQueryCacheSupport(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should second level query caching support be enabled?

Specified by:

applyQueryCacheSupport in interface SessionFactoryBuilder

Parameters:

enabled - true indicates we should enable the use of second level query caching; false indicates we should disable the use of second level query caching.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_QUERY_CACHE

applyTimestampsCacheFactory

public SessionFactoryBuilder applyTimestampsCacheFactory(TimestampsCacheFactory factory)

Description copied from interface: SessionFactoryBuilder

Specifies a QueryCacheFactory to use for building query cache handlers.

Specified by:

applyTimestampsCacheFactory in interface SessionFactoryBuilder

Parameters:

factory - The QueryCacheFactory to use

Returns:

this, for method chaining

See Also:

AvailableSettings.QUERY_CACHE_FACTORY

applyCacheRegionPrefix

public SessionFactoryBuilder applyCacheRegionPrefix(String prefix)

Description copied from interface: SessionFactoryBuilder

Apply a prefix to prepended to all cache region names for this SessionFactory.

Specified by:

applyCacheRegionPrefix in interface SessionFactoryBuilder

Parameters:

prefix - The prefix.

Returns:

this, for method chaining

See Also:

AvailableSettings.CACHE_REGION_PREFIX

applyMinimalPutsForCaching

public SessionFactoryBuilder applyMinimalPutsForCaching(boolean enabled)

Description copied from interface: SessionFactoryBuilder

By default, Hibernate will always just push data into the cache without first checking if that data already exists. For some caches (mainly distributed caches) this can have a major adverse performance impact. For these caches, it is best to enable this "minimal puts" feature.

Cache integrations also report whether "minimal puts" should be enabled by default. So its is very rare that users need to set this, generally speaking.

Specified by:

applyMinimalPutsForCaching in interface SessionFactoryBuilder

Parameters:

enabled - true indicates Hibernate should first check whether data exists and only push to the cache if it does not already exist. false indicates to perform the default behavior.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_MINIMAL_PUTS, RegionFactory.isMinimalPutsEnabledByDefault()

applyStructuredCacheEntries

public SessionFactoryBuilder applyStructuredCacheEntries(boolean enabled)

Description copied from interface: SessionFactoryBuilder

By default, Hibernate stores data in the cache in its own optimized format. However, that format is impossible to "read" if browsing the cache. The use of "structured" cache entries allows the cached data to be read.

Specified by:

applyStructuredCacheEntries in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that structured cache entries (human readable) should be used; false indicates that the native entry structure should be used.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_STRUCTURED_CACHE

applyDirectReferenceCaching

public SessionFactoryBuilder applyDirectReferenceCaching(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Generally, Hibernate will extract the information from an entity and put that extracted information into the second-level cache. This is by far the safest way to second-level cache persistent data. However, there are some cases where it is safe to cache the entity instance directly. This setting controls whether that is used in those cases.

Specified by:

applyDirectReferenceCaching in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that applicable entities will be stored into the second-level cache directly by reference; false indicates that all entities will be stored via the extraction approach.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_DIRECT_REFERENCE_CACHE_ENTRIES

applyAutomaticEvictionOfCollectionCaches

public SessionFactoryBuilder applyAutomaticEvictionOfCollectionCaches(boolean enabled)

Description copied from interface: SessionFactoryBuilder

When using bi-directional many-to-one associations and caching the one-to-many side it is expected that both sides of the association are managed (actually that is true of all bi-directional associations). However, in this case, if the user forgets to manage the one-to-many side stale data can be left in the second-level cache.

Warning: enabling this will have a performance impact. Hence why it is disabled by default (for good citizens) and is an opt-in setting.

Specified by:

applyAutomaticEvictionOfCollectionCaches in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that these collection caches should be evicted automatically.

Returns:

this, for method chaining

See Also:

AvailableSettings.AUTO_EVICT_COLLECTION_CACHE

applyJdbcBatchSize

public SessionFactoryBuilder applyJdbcBatchSize(int size)

Description copied from interface: SessionFactoryBuilder

Specifies the maximum number of statements to batch together in a JDBC batch for insert, update and delete operations. A non-zero number enables batching, but really only a number greater than zero will have any effect. If used, a number great than 5 is suggested.

Specified by:

applyJdbcBatchSize in interface SessionFactoryBuilder

Parameters:

size - The batch size to use.

Returns:

this, for method chaining

See Also:

AvailableSettings.STATEMENT_BATCH_SIZE

applyJdbcBatchingForVersionedEntities

public SessionFactoryBuilder applyJdbcBatchingForVersionedEntities(boolean enabled)

Description copied from interface: SessionFactoryBuilder

This setting controls whether versioned entities will be included in JDBC batching. The reason being that some JDBC drivers have a problems returning "accurate" update counts from batch statements. This is setting is false by default.

Specified by:

applyJdbcBatchingForVersionedEntities in interface SessionFactoryBuilder

Parameters:

enabled - The batch size to use.

Returns:

this, for method chaining

See Also:

AvailableSettings.BATCH_VERSIONED_DATA

applyScrollableResultsSupport

public SessionFactoryBuilder applyScrollableResultsSupport(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should scrollable results be supported in queries? We ask the JDBC driver whether it supports scrollable result sets as the default for this setting, but some drivers do not accurately report this via DatabaseMetaData. Also, needed if user is supplying connections (and so no Connection is available when we bootstrap).

Specified by:

applyScrollableResultsSupport in interface SessionFactoryBuilder

Parameters:

enabled - true to enable this support, false to disable it

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_SCROLLABLE_RESULTSET

applyResultSetsWrapping

public SessionFactoryBuilder applyResultSetsWrapping(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Hibernate currently accesses results from the JDBC ResultSet by name. This is known to be VERY slow on some drivers, especially older Oracle drivers. This setting allows Hibernate to wrap the ResultSet of the JDBC driver to manage the name->position resolution itself.

Specified by:

applyResultSetsWrapping in interface SessionFactoryBuilder

Parameters:

enabled - true indicates Hibernate should wrap result sets; false indicates it should not.

Returns:

this, for method chaining

See Also:

AvailableSettings.WRAP_RESULT_SETS

applyGetGeneratedKeysSupport

public SessionFactoryBuilder applyGetGeneratedKeysSupport(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should JDBC Statement.getGeneratedKeys() feature be used for retrieval of *insert-generated* ids?

Specified by:

applyGetGeneratedKeysSupport in interface SessionFactoryBuilder

Parameters:

enabled - true indicates we should use JDBC getGeneratedKeys support; false indicates we should not.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_GET_GENERATED_KEYS

applyJdbcFetchSize

public SessionFactoryBuilder applyJdbcFetchSize(int size)

Description copied from interface: SessionFactoryBuilder

Apply a fetch size to the JDBC driver for fetching results.

Specified by:

applyJdbcFetchSize in interface SessionFactoryBuilder

Parameters:

size - The fetch saize to be passed to the driver.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_GET_GENERATED_KEYS, Statement.setFetchSize(int)

applyConnectionHandlingMode

public SessionFactoryBuilder applyConnectionHandlingMode(PhysicalConnectionHandlingMode connectionHandlingMode)

Description copied from interface: SessionFactoryBuilder

Apply the specified handling mode for JDBC connections

Specified by:

applyConnectionHandlingMode in interface SessionFactoryBuilder

Parameters:

connectionHandlingMode - The handling mode to apply

Returns:

this, for method chaining

See Also:

AvailableSettings.ACQUIRE_CONNECTIONS, AvailableSettings.RELEASE_CONNECTIONS, ConnectionAcquisitionMode, ConnectionReleaseMode

applyConnectionReleaseMode

public SessionFactoryBuilder applyConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode)

Description copied from interface: SessionFactoryBuilder

Apply a ConnectionReleaseMode.

Specified by:

applyConnectionReleaseMode in interface SessionFactoryBuilder

Parameters:

connectionReleaseMode - The ConnectionReleaseMode to use.

Returns:

this, for method chaining

See Also:

AvailableSettings.RELEASE_CONNECTIONS

applyConnectionProviderDisablesAutoCommit

public SessionFactoryBuilder applyConnectionProviderDisablesAutoCommit(boolean providerDisablesAutoCommit)

Specified by:

applyConnectionProviderDisablesAutoCommit in interface SessionFactoryBuilder

See Also:

AvailableSettings.CONNECTION_PROVIDER_DISABLES_AUTOCOMMIT

applySqlComments

public SessionFactoryBuilder applySqlComments(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should Hibernate apply comments to SQL it generates?

Specified by:

applySqlComments in interface SessionFactoryBuilder

Parameters:

enabled - true indicates comments should be applied; false indicates not.

Returns:

this, for method chaining

See Also:

AvailableSettings.USE_SQL_COMMENTS

applySqlFunction

public SessionFactoryBuilder applySqlFunction(String registrationName,
                                              SQLFunction sqlFunction)

Description copied from interface: SessionFactoryBuilder

Apply a SQLFunction to the underlying SQLFunctionRegistry.

TODO : Ultimately I would like this to move to MetadataBuilder in conjunction with allowing mappings to reference SQLFunctions. today mappings can only name SQL functions directly, not through the SQLFunctionRegistry indirection

Specified by:

applySqlFunction in interface SessionFactoryBuilder

Parameters:

registrationName - The name to register it under.

sqlFunction - The SQLFunction impl

Returns:

this, for method chaining

allowOutOfTransactionUpdateOperations

public SessionFactoryBuilder allowOutOfTransactionUpdateOperations(boolean allow)

Specified by:

allowOutOfTransactionUpdateOperations in interface SessionFactoryBuilder

enableReleaseResourcesOnCloseEnabled

public SessionFactoryBuilder enableReleaseResourcesOnCloseEnabled(boolean enable)

Description copied from interface: SessionFactoryBuilder

Should resources held by EntityManager instance be released immediately on close?

The other option is to release them as part of an after-transaction callback.

Specified by:

enableReleaseResourcesOnCloseEnabled in interface SessionFactoryBuilder

applyStrictJpaQueryLanguageCompliance

public SessionFactoryBuilder applyStrictJpaQueryLanguageCompliance(boolean enabled)

Description copied from interface: SessionFactoryBuilder

Should we strictly adhere to JPA Query Language (JPQL) syntax, or more broadly support all of Hibernate's superset (HQL)?

Setting this to true may cause valid HQL to throw an exception because it violates the JPQL subset.

Specified by:

applyStrictJpaQueryLanguageCompliance in interface SessionFactoryBuilder

Parameters:

enabled - true indicates that we should strictly adhere to the JPQL subset; false indicates we should accept the broader HQL syntax.

Returns:

this, for method chaining

See Also:

AvailableSettings.JPAQL_STRICT_COMPLIANCE

enableJpaQueryCompliance

public SessionFactoryBuilder enableJpaQueryCompliance(boolean enabled)

Specified by:

enableJpaQueryCompliance in interface SessionFactoryBuilder

See Also:

JpaCompliance.isJpaQueryComplianceEnabled()

enableJpaTransactionCompliance

public SessionFactoryBuilder enableJpaTransactionCompliance(boolean enabled)

Specified by:

enableJpaTransactionCompliance in interface SessionFactoryBuilder

See Also:

JpaCompliance.isJpaTransactionComplianceEnabled()

enableJpaListCompliance

public SessionFactoryBuilder enableJpaListCompliance(boolean enabled)

Specified by:

enableJpaListCompliance in interface SessionFactoryBuilder

See Also:

JpaCompliance.isJpaListComplianceEnabled()

enableJpaClosedCompliance

public SessionFactoryBuilder enableJpaClosedCompliance(boolean enabled)

Specified by:

enableJpaClosedCompliance in interface SessionFactoryBuilder

See Also:

JpaCompliance.isJpaClosedComplianceEnabled()

markAsJpaBootstrap

public void markAsJpaBootstrap()

Description copied from interface: SessionFactoryBuilderImplementor

Indicates that the SessionFactory being built comes from JPA bootstrapping. Internally false is the assumed value. We only need to call this to mark that as true.

Specified by:

markAsJpaBootstrap in interface SessionFactoryBuilderImplementor

disableRefreshDetachedEntity

public void disableRefreshDetachedEntity()

Specified by:

disableRefreshDetachedEntity in interface SessionFactoryBuilderImplementor

disableJtaTransactionAccess

public void disableJtaTransactionAccess()

Specified by:

disableJtaTransactionAccess in interface SessionFactoryBuilderImplementor

enableJdbcStyleParamsZeroBased

public void enableJdbcStyleParamsZeroBased()

Specified by:

enableJdbcStyleParamsZeroBased in interface SessionFactoryBuilderImplementor

See Also:

AvailableSettings.JDBC_TYLE_PARAMS_ZERO_BASE

unwrap

public <T extends SessionFactoryBuilder> T unwrap(Class<T> type)

Description copied from interface: SessionFactoryBuilder

Allows unwrapping this builder as another, more specific type.

Specified by:

unwrap in interface SessionFactoryBuilder

Returns:

The unwrapped builder.

build

public SessionFactory build()

Description copied from interface: SessionFactoryBuilder

After all options have been set, build the SessionFactory.

Specified by:

build in interface SessionFactoryBuilder

Returns:

The built SessionFactory.

buildSessionFactoryOptions

public SessionFactoryOptions buildSessionFactoryOptions()

Description copied from interface: SessionFactoryBuilderImplementor

Build the SessionFactoryOptions that will ultimately be passed to SessionFactoryImpl constructor.

Specified by:

buildSessionFactoryOptions in interface SessionFactoryBuilderImplementor

Returns:

The options.