SessionFactoryBuilderImpl (Hibernate JavaDocs)

java.lang.Object
- org.hibernate.boot.internal.SessionFactoryBuilderImpl

All Implemented Interfaces:: SessionFactoryOptionsState, SessionFactoryBuilder, SessionFactoryBuilderImplementor

public class SessionFactoryBuilderImpl
extends java.lang.Object
implements SessionFactoryBuilderImplementor, SessionFactoryOptionsState

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SessionFactoryBuilderImpl.SessionFactoryOptionsStateStandardImpl

Nested Classes
Modifier and Type	Class and Description
`static class`	`SessionFactoryBuilderImpl.SessionFactoryOptionsStateStandardImpl`

Constructor Summary

Constructors
Constructor and Description

SessionFactoryBuilderImpl(MetadataImplementor metadata)

Constructors
Constructor and Description
`SessionFactoryBuilderImpl(MetadataImplementor metadata)`

Method Summary

All Methods Instance Methods Concrete Methods
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(java.lang.Object beanManager)` Apply a CDI BeanManager to the SessionFactory being built.
`SessionFactoryBuilder`	`applyCacheRegionPrefix(java.lang.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`	`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, java.lang.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(java.lang.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`	`applyQueryCacheFactory(QueryCacheFactory factory)` Specifies a QueryCacheFactory to use for building query cache handlers.
`SessionFactoryBuilder`	`applyQueryCacheSupport(boolean enabled)` Should second level query caching support be enabled?
`SessionFactoryBuilder`	`applyQuerySubstitutions(java.util.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(java.lang.String registrationName, SQLFunction sqlFunction)` Apply a SQLFunction to the underlying `SQLFunctionRegistry`.
`SessionFactoryBuilder`	`applyStatelessInterceptor(java.lang.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(java.util.function.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`	`applyValidatorFactory(java.lang.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.
`boolean`	`connectionProviderDisablesAutoCommit()`
`void`	`disableJtaTransactionAccess()`
`void`	`disableRefreshDetachedEntity()`
`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.
`BaselineSessionEventsListenerBuilder`	`getBaselineSessionEventsListenerBuilder()`
`BatchFetchStyle`	`getBatchFetchStyle()`
`java.lang.Object`	`getBeanManagerReference()`
`java.lang.String`	`getCacheRegionPrefix()`
`ConnectionReleaseMode`	`getConnectionReleaseMode()`
`LiteralHandlingMode`	`getCriteriaLiteralHandlingMode()`
`CurrentTenantIdentifierResolver`	`getCurrentTenantIdentifierResolver()`
`CustomEntityDirtinessStrategy`	`getCustomEntityDirtinessStrategy()`
`java.util.Map<java.lang.String,SQLFunction>`	`getCustomSqlFunctionMap()`
`int`	`getDefaultBatchFetchSize()`
`EntityMode`	`getDefaultEntityMode()`
`NullPrecedence`	`getDefaultNullPrecedence()`
`EntityNameResolver[]`	`getEntityNameResolvers()`
`EntityNotFoundDelegate`	`getEntityNotFoundDelegate()`
`EntityTuplizerFactory`	`getEntityTuplizerFactory()`
`ImmutableEntityUpdateQueryHandlingMode`	`getImmutableEntityUpdateQueryHandlingMode()`
`Interceptor`	`getInterceptor()`
`int`	`getJdbcBatchSize()`
`java.lang.Integer`	`getJdbcFetchSize()`
`java.util.TimeZone`	`getJdbcTimeZone()`
`java.lang.Integer`	`getMaximumFetchDepth()`
`MultiTableBulkIdStrategy`	`getMultiTableBulkIdStrategy()`
`MultiTenancyStrategy`	`getMultiTenancyStrategy()`
`PhysicalConnectionHandlingMode`	`getPhysicalConnectionHandlingMode()`
`QueryCacheFactory`	`getQueryCacheFactory()`
`java.util.Map`	`getQuerySubstitutions()`
`SchemaAutoTooling`	`getSchemaAutoTooling()`
`StandardServiceRegistry`	`getServiceRegistry()`
`java.lang.String`	`getSessionFactoryName()`
`SessionFactoryObserver[]`	`getSessionFactoryObservers()`
`java.lang.Class<? extends Interceptor>`	`getStatelessInterceptorImplementor()` Returns an `Interceptor` class.
`java.util.function.Supplier<? extends Interceptor>`	`getStatelessInterceptorImplementorSupplier()`
`StatementInspector`	`getStatementInspector()`
`TempTableDdlTransactionHandling`	`getTempTableDdlTransactionHandling()`
`java.lang.Object`	`getValidatorFactoryReference()`
`boolean`	`inClauseParameterPaddingEnabled()`
`boolean`	`isAllowOutOfTransactionUpdateOperations()`
`boolean`	`isAllowRefreshDetachedEntity()`
`boolean`	`isAutoCloseSessionEnabled()`
`boolean`	`isAutoEvictCollectionCache()`
`boolean`	`isCheckNullability()`
`boolean`	`isCollectionJoinSubqueryRewriteEnabled()`
`boolean`	`isCommentsEnabled()`
`boolean`	`isConventionalJavaConstants()`
`boolean`	`isDirectReferenceCacheEntriesEnabled()`
`boolean`	`isFailOnPaginationOverCollectionFetchEnabled()`
`boolean`	`isFlushBeforeCompletionEnabled()`
`boolean`	`isGetGeneratedKeysEnabled()`
`boolean`	`isIdentifierRollbackEnabled()`
`boolean`	`isInitializeLazyStateOutsideTransactionsEnabled()`
`boolean`	`isJdbcBatchVersionedData()`
`boolean`	`isJpaBootstrap()`
`boolean`	`isJpaProxyComplianceEnabled()`
`boolean`	`isJtaTrackByThread()`
`boolean`	`isJtaTransactionAccessEnabled()`
`boolean`	`isMinimalPutsEnabled()`
`boolean`	`isNamedQueryStartupCheckingEnabled()`
`boolean`	`isOrderInsertsEnabled()`
`boolean`	`isOrderUpdatesEnabled()`
`boolean`	`isPreferUserTransaction()`
`boolean`	`isProcedureParameterNullPassingEnabled()`
`boolean`	`isQueryCacheEnabled()`
`boolean`	`isQueryParametersValidationEnabled()`
`boolean`	`isReleaseResourcesOnCloseEnabled()`
`boolean`	`isScrollableResultSetsEnabled()`
`boolean`	`isSecondLevelCacheEnabled()`
`boolean`	`isSessionFactoryNameAlsoJndiName()`
`boolean`	`isStatisticsEnabled()`
`boolean`	`isStrictJpaQueryLanguageCompliance()`
`boolean`	`isStructuredCacheEntriesEnabled()`
`boolean`	`isWrapResultSetsEnabled()`
`void`	`markAsJpaBootstrap()` Indicates that the SessionFactory being built comes from JPA bootstrapping.
`<T extends SessionFactoryBuilder> T`	`unwrap(java.lang.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)
```
- Method Detail
  - applyValidatorFactory
```
public SessionFactoryBuilder applyValidatorFactory(java.lang.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
  - applyBeanManager
```
public SessionFactoryBuilder applyBeanManager(java.lang.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
  - applyName
```
public SessionFactoryBuilder applyName(java.lang.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(java.lang.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(java.util.function.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,
                                                 java.lang.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
  - 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(java.util.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
  - 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
  - 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
  - applyQueryCacheFactory
```
public SessionFactoryBuilder applyQueryCacheFactory(QueryCacheFactory factory)
```
    Description copied from interface: SessionFactoryBuilder
    
    Specifies a QueryCacheFactory to use for building query cache handlers.
    
    Specified by:
    
    applyQueryCacheFactory in interface SessionFactoryBuilder
    
    Parameters:
    
    factory - The QueryCacheFactory to use
    
    Returns:
    
    this, for method chaining
    
    See Also:
    
    AvailableSettings.QUERY_CACHE_FACTORY
  - applyCacheRegionPrefix
```
public SessionFactoryBuilder applyCacheRegionPrefix(java.lang.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(java.lang.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
  - unwrap
```
public <T extends SessionFactoryBuilder> T unwrap(java.lang.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.
  - 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
  - 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.
  - getServiceRegistry
```
public StandardServiceRegistry getServiceRegistry()
```
    Specified by:
    
    getServiceRegistry in interface SessionFactoryOptionsState
  - isJpaBootstrap
```
public boolean isJpaBootstrap()
```
    Specified by:
    
    isJpaBootstrap in interface SessionFactoryOptionsState
  - isJtaTransactionAccessEnabled
```
public boolean isJtaTransactionAccessEnabled()
```
    Specified by:
    
    isJtaTransactionAccessEnabled in interface SessionFactoryOptionsState
  - isAllowRefreshDetachedEntity
```
public boolean isAllowRefreshDetachedEntity()
```
    Specified by:
    
    isAllowRefreshDetachedEntity in interface SessionFactoryOptionsState
  - isAllowOutOfTransactionUpdateOperations
```
public boolean isAllowOutOfTransactionUpdateOperations()
```
    Specified by:
    
    isAllowOutOfTransactionUpdateOperations in interface SessionFactoryOptionsState
  - isReleaseResourcesOnCloseEnabled
```
public boolean isReleaseResourcesOnCloseEnabled()
```
    Specified by:
    
    isReleaseResourcesOnCloseEnabled in interface SessionFactoryOptionsState
  - getBeanManagerReference
```
public java.lang.Object getBeanManagerReference()
```
    Specified by:
    
    getBeanManagerReference in interface SessionFactoryOptionsState
  - getValidatorFactoryReference
```
public java.lang.Object getValidatorFactoryReference()
```
    Specified by:
    
    getValidatorFactoryReference in interface SessionFactoryOptionsState
  - getSessionFactoryName
```
public java.lang.String getSessionFactoryName()
```
    Specified by:
    
    getSessionFactoryName in interface SessionFactoryOptionsState
  - isSessionFactoryNameAlsoJndiName
```
public boolean isSessionFactoryNameAlsoJndiName()
```
    Specified by:
    
    isSessionFactoryNameAlsoJndiName in interface SessionFactoryOptionsState
  - isFlushBeforeCompletionEnabled
```
public boolean isFlushBeforeCompletionEnabled()
```
    Specified by:
    
    isFlushBeforeCompletionEnabled in interface SessionFactoryOptionsState
  - isAutoCloseSessionEnabled
```
public boolean isAutoCloseSessionEnabled()
```
    Specified by:
    
    isAutoCloseSessionEnabled in interface SessionFactoryOptionsState
  - isStatisticsEnabled
```
public boolean isStatisticsEnabled()
```
    Specified by:
    
    isStatisticsEnabled in interface SessionFactoryOptionsState
  - getInterceptor
```
public Interceptor getInterceptor()
```
    Specified by:
    
    getInterceptor in interface SessionFactoryOptionsState
  - getStatelessInterceptorImplementor
```
public java.lang.Class<? extends Interceptor> getStatelessInterceptorImplementor()
```
    Description copied from interface: SessionFactoryOptionsState
    
    Returns an Interceptor class.
    
    Specified by:
    
    getStatelessInterceptorImplementor in interface SessionFactoryOptionsState
    
    Returns:
    
    Interceptor class
  - getStatelessInterceptorImplementorSupplier
```
public java.util.function.Supplier<? extends Interceptor> getStatelessInterceptorImplementorSupplier()
```
    Specified by:
    
    getStatelessInterceptorImplementorSupplier in interface SessionFactoryOptionsState
  - getStatementInspector
```
public StatementInspector getStatementInspector()
```
    Specified by:
    
    getStatementInspector in interface SessionFactoryOptionsState
  - getSessionFactoryObservers
```
public SessionFactoryObserver[] getSessionFactoryObservers()
```
    Specified by:
    
    getSessionFactoryObservers in interface SessionFactoryOptionsState
  - getBaselineSessionEventsListenerBuilder
```
public BaselineSessionEventsListenerBuilder getBaselineSessionEventsListenerBuilder()
```
    Specified by:
    
    getBaselineSessionEventsListenerBuilder in interface SessionFactoryOptionsState
  - isIdentifierRollbackEnabled
```
public boolean isIdentifierRollbackEnabled()
```
    Specified by:
    
    isIdentifierRollbackEnabled in interface SessionFactoryOptionsState
  - getDefaultEntityMode
```
public EntityMode getDefaultEntityMode()
```
    Specified by:
    
    getDefaultEntityMode in interface SessionFactoryOptionsState
  - getEntityTuplizerFactory
```
public EntityTuplizerFactory getEntityTuplizerFactory()
```
    Specified by:
    
    getEntityTuplizerFactory in interface SessionFactoryOptionsState
  - isCheckNullability
```
public boolean isCheckNullability()
```
    Specified by:
    
    isCheckNullability in interface SessionFactoryOptionsState
  - isInitializeLazyStateOutsideTransactionsEnabled
```
public boolean isInitializeLazyStateOutsideTransactionsEnabled()
```
    Specified by:
    
    isInitializeLazyStateOutsideTransactionsEnabled in interface SessionFactoryOptionsState
  - getMultiTableBulkIdStrategy
```
public MultiTableBulkIdStrategy getMultiTableBulkIdStrategy()
```
    Specified by:
    
    getMultiTableBulkIdStrategy in interface SessionFactoryOptionsState
  - getTempTableDdlTransactionHandling
```
public TempTableDdlTransactionHandling getTempTableDdlTransactionHandling()
```
    Specified by:
    
    getTempTableDdlTransactionHandling in interface SessionFactoryOptionsState
  - getBatchFetchStyle
```
public BatchFetchStyle getBatchFetchStyle()
```
    Specified by:
    
    getBatchFetchStyle in interface SessionFactoryOptionsState
  - getDefaultBatchFetchSize
```
public int getDefaultBatchFetchSize()
```
    Specified by:
    
    getDefaultBatchFetchSize in interface SessionFactoryOptionsState
  - getMaximumFetchDepth
```
public java.lang.Integer getMaximumFetchDepth()
```
    Specified by:
    
    getMaximumFetchDepth in interface SessionFactoryOptionsState
  - getDefaultNullPrecedence
```
public NullPrecedence getDefaultNullPrecedence()
```
    Specified by:
    
    getDefaultNullPrecedence in interface SessionFactoryOptionsState
  - isOrderUpdatesEnabled
```
public boolean isOrderUpdatesEnabled()
```
    Specified by:
    
    isOrderUpdatesEnabled in interface SessionFactoryOptionsState
  - isOrderInsertsEnabled
```
public boolean isOrderInsertsEnabled()
```
    Specified by:
    
    isOrderInsertsEnabled in interface SessionFactoryOptionsState
  - getMultiTenancyStrategy
```
public MultiTenancyStrategy getMultiTenancyStrategy()
```
    Specified by:
    
    getMultiTenancyStrategy in interface SessionFactoryOptionsState
  - getCurrentTenantIdentifierResolver
```
public CurrentTenantIdentifierResolver getCurrentTenantIdentifierResolver()
```
    Specified by:
    
    getCurrentTenantIdentifierResolver in interface SessionFactoryOptionsState
  - isJtaTrackByThread
```
public boolean isJtaTrackByThread()
```
    Specified by:
    
    isJtaTrackByThread in interface SessionFactoryOptionsState
  - getQuerySubstitutions
```
public java.util.Map getQuerySubstitutions()
```
    Specified by:
    
    getQuerySubstitutions in interface SessionFactoryOptionsState
  - isStrictJpaQueryLanguageCompliance
```
public boolean isStrictJpaQueryLanguageCompliance()
```
    Specified by:
    
    isStrictJpaQueryLanguageCompliance in interface SessionFactoryOptionsState
  - isNamedQueryStartupCheckingEnabled
```
public boolean isNamedQueryStartupCheckingEnabled()
```
    Specified by:
    
    isNamedQueryStartupCheckingEnabled in interface SessionFactoryOptionsState
  - isConventionalJavaConstants
```
public boolean isConventionalJavaConstants()
```
    Specified by:
    
    isConventionalJavaConstants in interface SessionFactoryOptionsState
  - isProcedureParameterNullPassingEnabled
```
public boolean isProcedureParameterNullPassingEnabled()
```
    Specified by:
    
    isProcedureParameterNullPassingEnabled in interface SessionFactoryOptionsState
  - isCollectionJoinSubqueryRewriteEnabled
```
public boolean isCollectionJoinSubqueryRewriteEnabled()
```
    Specified by:
    
    isCollectionJoinSubqueryRewriteEnabled in interface SessionFactoryOptionsState
  - isSecondLevelCacheEnabled
```
public boolean isSecondLevelCacheEnabled()
```
    Specified by:
    
    isSecondLevelCacheEnabled in interface SessionFactoryOptionsState
  - isQueryCacheEnabled
```
public boolean isQueryCacheEnabled()
```
    Specified by:
    
    isQueryCacheEnabled in interface SessionFactoryOptionsState
  - getQueryCacheFactory
```
public QueryCacheFactory getQueryCacheFactory()
```
    Specified by:
    
    getQueryCacheFactory in interface SessionFactoryOptionsState
  - getCacheRegionPrefix
```
public java.lang.String getCacheRegionPrefix()
```
    Specified by:
    
    getCacheRegionPrefix in interface SessionFactoryOptionsState
  - isMinimalPutsEnabled
```
public boolean isMinimalPutsEnabled()
```
    Specified by:
    
    isMinimalPutsEnabled in interface SessionFactoryOptionsState
  - isStructuredCacheEntriesEnabled
```
public boolean isStructuredCacheEntriesEnabled()
```
    Specified by:
    
    isStructuredCacheEntriesEnabled in interface SessionFactoryOptionsState
  - isDirectReferenceCacheEntriesEnabled
```
public boolean isDirectReferenceCacheEntriesEnabled()
```
    Specified by:
    
    isDirectReferenceCacheEntriesEnabled in interface SessionFactoryOptionsState
  - isAutoEvictCollectionCache
```
public boolean isAutoEvictCollectionCache()
```
    Specified by:
    
    isAutoEvictCollectionCache in interface SessionFactoryOptionsState
  - getSchemaAutoTooling
```
public SchemaAutoTooling getSchemaAutoTooling()
```
    Specified by:
    
    getSchemaAutoTooling in interface SessionFactoryOptionsState
  - getJdbcBatchSize
```
public int getJdbcBatchSize()
```
    Specified by:
    
    getJdbcBatchSize in interface SessionFactoryOptionsState
  - isJdbcBatchVersionedData
```
public boolean isJdbcBatchVersionedData()
```
    Specified by:
    
    isJdbcBatchVersionedData in interface SessionFactoryOptionsState
  - isScrollableResultSetsEnabled
```
public boolean isScrollableResultSetsEnabled()
```
    Specified by:
    
    isScrollableResultSetsEnabled in interface SessionFactoryOptionsState
  - isWrapResultSetsEnabled
```
public boolean isWrapResultSetsEnabled()
```
    Specified by:
    
    isWrapResultSetsEnabled in interface SessionFactoryOptionsState
  - isGetGeneratedKeysEnabled
```
public boolean isGetGeneratedKeysEnabled()
```
    Specified by:
    
    isGetGeneratedKeysEnabled in interface SessionFactoryOptionsState
  - getJdbcFetchSize
```
public java.lang.Integer getJdbcFetchSize()
```
    Specified by:
    
    getJdbcFetchSize in interface SessionFactoryOptionsState
  - getPhysicalConnectionHandlingMode
```
public PhysicalConnectionHandlingMode getPhysicalConnectionHandlingMode()
```
    Specified by:
    
    getPhysicalConnectionHandlingMode in interface SessionFactoryOptionsState
  - connectionProviderDisablesAutoCommit
```
public boolean connectionProviderDisablesAutoCommit()
```
    Specified by:
    
    connectionProviderDisablesAutoCommit in interface SessionFactoryOptionsState
  - getConnectionReleaseMode
```
public ConnectionReleaseMode getConnectionReleaseMode()
```
    Specified by:
    
    getConnectionReleaseMode in interface SessionFactoryOptionsState
  - isCommentsEnabled
```
public boolean isCommentsEnabled()
```
    Specified by:
    
    isCommentsEnabled in interface SessionFactoryOptionsState
  - getCustomEntityDirtinessStrategy
```
public CustomEntityDirtinessStrategy getCustomEntityDirtinessStrategy()
```
    Specified by:
    
    getCustomEntityDirtinessStrategy in interface SessionFactoryOptionsState
  - getEntityNameResolvers
```
public EntityNameResolver[] getEntityNameResolvers()
```
    Specified by:
    
    getEntityNameResolvers in interface SessionFactoryOptionsState
  - getEntityNotFoundDelegate
```
public EntityNotFoundDelegate getEntityNotFoundDelegate()
```
    Specified by:
    
    getEntityNotFoundDelegate in interface SessionFactoryOptionsState
  - getCustomSqlFunctionMap
```
public java.util.Map<java.lang.String,SQLFunction> getCustomSqlFunctionMap()
```
    Specified by:
    
    getCustomSqlFunctionMap in interface SessionFactoryOptionsState
  - isPreferUserTransaction
```
public boolean isPreferUserTransaction()
```
    Specified by:
    
    isPreferUserTransaction in interface SessionFactoryOptionsState
  - getJdbcTimeZone
```
public java.util.TimeZone getJdbcTimeZone()
```
    Specified by:
    
    getJdbcTimeZone in interface SessionFactoryOptionsState
  - isQueryParametersValidationEnabled
```
public boolean isQueryParametersValidationEnabled()
```
    Specified by:
    
    isQueryParametersValidationEnabled in interface SessionFactoryOptionsState
  - getCriteriaLiteralHandlingMode
```
public LiteralHandlingMode getCriteriaLiteralHandlingMode()
```
    Specified by:
    
    getCriteriaLiteralHandlingMode in interface SessionFactoryOptionsState
  - isFailOnPaginationOverCollectionFetchEnabled
```
public boolean isFailOnPaginationOverCollectionFetchEnabled()
```
    Specified by:
    
    isFailOnPaginationOverCollectionFetchEnabled in interface SessionFactoryOptionsState
  - isJpaProxyComplianceEnabled
```
public boolean isJpaProxyComplianceEnabled()
```
    Specified by:
    
    isJpaProxyComplianceEnabled in interface SessionFactoryOptionsState
  - getImmutableEntityUpdateQueryHandlingMode
```
public ImmutableEntityUpdateQueryHandlingMode getImmutableEntityUpdateQueryHandlingMode()
```
    Specified by:
    
    getImmutableEntityUpdateQueryHandlingMode in interface SessionFactoryOptionsState
  - inClauseParameterPaddingEnabled
```
public boolean inClauseParameterPaddingEnabled()
```
    Specified by:
    
    inClauseParameterPaddingEnabled in interface SessionFactoryOptionsState

Class SessionFactoryBuilderImpl

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SessionFactoryBuilderImpl

Method Detail

applyValidatorFactory

applyBeanManager

applyName

applyNameAsJndiName

applyAutoClosing

applyAutoFlushing

applyJtaTrackingByThread

applyPreferUserTransactions

applyStatisticsSupport

addSessionFactoryObservers

applyInterceptor

applyStatelessInterceptor

applyStatelessInterceptor

applyStatementInspector

applyCustomEntityDirtinessStrategy

addEntityNameResolver

applyEntityNotFoundDelegate

applyIdentifierRollbackSupport

applyDefaultEntityMode

applyNullabilityChecking

applyLazyInitializationOutsideTransaction

applyEntityTuplizerFactory

applyEntityTuplizer

applyMultiTableBulkIdStrategy

applyTempTableDdlTransactionHandling

applyBatchFetchStyle

applyDefaultBatchFetchSize

applyMaximumFetchDepth

applyDefaultNullPrecedence

applyOrderingOfInserts

applyOrderingOfUpdates

applyMultiTenancyStrategy

applyCurrentTenantIdentifierResolver

applyQuerySubstitutions

applyStrictJpaQueryLanguageCompliance

applyNamedQueryCheckingOnStartup

applySecondLevelCacheSupport

applyQueryCacheSupport

applyQueryCacheFactory

applyCacheRegionPrefix

applyMinimalPutsForCaching

applyStructuredCacheEntries

applyDirectReferenceCaching

applyAutomaticEvictionOfCollectionCaches

applyJdbcBatchSize

applyJdbcBatchingForVersionedEntities

applyScrollableResultsSupport

applyResultSetsWrapping

applyGetGeneratedKeysSupport

applyJdbcFetchSize

applyConnectionHandlingMode

applyConnectionReleaseMode

applyConnectionProviderDisablesAutoCommit

applySqlComments

applySqlFunction

allowOutOfTransactionUpdateOperations

enableReleaseResourcesOnCloseEnabled

unwrap

build

markAsJpaBootstrap

disableRefreshDetachedEntity

disableJtaTransactionAccess

buildSessionFactoryOptions

getServiceRegistry

isJpaBootstrap

isJtaTransactionAccessEnabled

isAllowRefreshDetachedEntity

isAllowOutOfTransactionUpdateOperations

isReleaseResourcesOnCloseEnabled

getBeanManagerReference

getValidatorFactoryReference

getSessionFactoryName