Package org.hibernate.engine.spi

Interface SharedSessionContractImplementor

All Superinterfaces:
AutoCloseable, JavaType.CoercionContext, JdbcSessionOwner, LobCreationContext, QueryProducer, QueryProducerImplementor, Serializable, SharedSessionContract, TransactionCoordinatorBuilder.Options, WrapperOptions
All Known Subinterfaces:
EventSource, SessionImplementor
All Known Implementing Classes:
AbstractDelegateSessionImplementor, AbstractSharedSessionContract, SessionDelegatorBaseImpl, SessionImpl, SharedSessionDelegatorBaseImpl, StatelessSessionImpl, ToOneDelegateSessionImplementor
public interface SharedSessionContractImplementor extends SharedSessionContract, JdbcSessionOwner, TransactionCoordinatorBuilder.Options, LobCreationContext, WrapperOptions, QueryProducerImplementor, JavaType.CoercionContext
Defines the internal contract shared between Session and StatelessSession as used by other parts of Hibernate, including implementors of Type, EntityPersister, and CollectionPersister.

The Session, via this interface, implements:

  • Method Details

    • getFactory

      SessionFactoryImplementor getFactory()
      Obtain the factory which created this session.
      Specified by:
      getFactory in interface QueryProducerImplementor
      Specified by:
      getFactory in interface SharedSessionContract

    • getSessionFactory

      default SessionFactoryImplementor getSessionFactory()
      Obtain the factory which created this session.
      Specified by:
      getSessionFactory in interface WrapperOptions

    • getTypeConfiguration

      default TypeConfiguration getTypeConfiguration()
      Obtain the TypeConfiguration for the factory which created this session.
      Specified by:
      getTypeConfiguration in interface JavaType.CoercionContext
      Specified by:
      getTypeConfiguration in interface WrapperOptions

    • getDialect

      default Dialect getDialect()
      Obtain the Dialect.
      Specified by:
      getDialect in interface WrapperOptions

    • getEventListenerManager

      SessionEventListenerManager getEventListenerManager()
      Get the SessionEventListenerManager associated with this session.

    • getPersistenceContext

      PersistenceContext getPersistenceContext()
      Get the persistence context for this session.

      See getPersistenceContextInternal() for a faster alternative.

      Implementation Note:
      This method is not extremely fast: if you need to call the PersistenceContext multiple times, prefer keeping a reference to it instead of invoking this method multiple times.

    • getJdbcCoordinator

      JdbcCoordinator getJdbcCoordinator()
      Obtain the JdbcCoordinator for this session.

    • getJdbcServices

      JdbcServices getJdbcServices()
      Obtain the JdbcServices for the factory which created this session.

    • getSessionIdentifier

      UUID getSessionIdentifier()
      Obtain a UUID which uniquely identifies this session.

      The UUID is useful mainly for logging.

    • getSession

      default SharedSessionContractImplementor getSession()
      Returns this object, fulfilling the contract of WrapperOptions.
      Specified by:
      getSession in interface WrapperOptions

    • getSessionToken

      default Object getSessionToken()
      Obtain a "token" which uniquely identifies this session.

    • isClosed

      boolean isClosed()
      Determines whether the session is closed.

      Returns:
      true if the session is closed; false otherwise.
      API Note:
      Provided separately from SharedSessionContract.isOpen() as this method does not attempt any JTA synchronization registration, whereas SharedSessionContract.isOpen() does. This one is better for most internal purposes.

    • isOpenOrWaitingForAutoClose

      default boolean isOpenOrWaitingForAutoClose()
      Determines whether the session is open or is waiting for auto-close.
      Returns:
      true if the session is closed, or if it's waiting for auto-close; false otherwise.

    • checkOpen

      default void checkOpen()
      Check whether the session is open, and if not:
      • mark the current transaction, if any, for rollback only, and
      • throw an IllegalStateException. (JPA specifies this exception type.)

    • checkOpen

      void checkOpen(boolean markForRollbackIfClosed)
      Check whether the session is open, and if not:
      • if markForRollbackIfClosed = true, mark the current transaction, if any, for rollback only, and
      • throw an IllegalStateException. (JPA specifies this exception type.)

    • prepareForQueryExecution

      void prepareForQueryExecution(boolean requiresTxn)
      Prepare for the execution of a Query or ProcedureCall

    • markForRollbackOnly

      void markForRollbackOnly()
      Marks current transaction, if any, for rollback only.

    • getCacheTransactionSynchronization

      CacheTransactionSynchronization getCacheTransactionSynchronization()
      The current CacheTransactionSynchronization associated with this session. This may be null if the session is not currently associated with an active transaction.

    • isTransactionInProgress

      boolean isTransactionInProgress()
      Does this session have an active Hibernate transaction, or is it associated with a JTA transaction currently in progress?

    • checkTransactionNeededForUpdateOperation

      default void checkTransactionNeededForUpdateOperation(String exceptionMessage)
      Check if an active Transaction is available before performing an update operation against the database.

      If an active transaction is necessary, but no transaction is active, a TransactionRequiredException is raised.

      Parameters:
      exceptionMessage - the message to use for the TransactionRequiredException

    • accessTransaction

      Transaction accessTransaction()
      Retrieves the current Transaction, or creates a new transaction if there is no transaction active.

      This method is primarily for internal or integrator use.

      Returns:
      the Transaction

    • generateEntityKey

      EntityKey generateEntityKey(Object id, EntityPersister persister)
      Instantiate an EntityKey with the given id and for the entity represented by the given EntityPersister.
      Parameters:
      id - The entity id
      persister - The entity persister
      Returns:
      The entity key

    • getInterceptor

      Interceptor getInterceptor()
      Retrieves the Interceptor associated with this session.

    • setAutoClear

      @Deprecated(since="6") void setAutoClear(boolean enabled)
      Deprecated.
      there's no good reason to expose this here
      Enable or disable automatic cache clearing from after transaction completion.

    • initializeCollection

      void initializeCollection(PersistentCollection<?> collection, boolean writing) throws HibernateException
      Initialize the given collection (if not already initialized).
      Throws:
      HibernateException

    • internalLoad

      Object internalLoad(String entityName, Object id, boolean eager, boolean nullable) throws HibernateException
      Obtain an entity instance with the given id, without checking if it was deleted or scheduled for deletion.
      • When nullable = false, this method may create a new proxy or return an existing proxy; if it does not exist, an exception is thrown.
      • When nullable = true, the method does not create new proxies, though it might return an existing proxy; if it does not exist, a null value is returned.

      When eager = true, the object is eagerly fetched from the database.

      Throws:
      HibernateException

    • immediateLoad

      Object immediateLoad(String entityName, Object id) throws HibernateException
      Load an instance immediately. This method is only called when lazily initializing a proxy. Do not return the proxy.
      Throws:
      HibernateException

    • getEntityPersister

      EntityPersister getEntityPersister(@Nullable String entityName, Object object) throws HibernateException
      Get the EntityPersister for the given entity instance.
      Parameters:
      entityName - optional entity name
      object - the entity instance
      Throws:
      HibernateException

    • getEntityUsingInterceptor

      Object getEntityUsingInterceptor(EntityKey key) throws HibernateException
      Get the entity instance associated with the given EntityKey, calling the Interceptor if necessary.
      Throws:
      HibernateException

    • getContextEntityIdentifier

      Object getContextEntityIdentifier(Object object)
      Return the identifier of the persistent object, or null if it is not associated with this session.

    • bestGuessEntityName

      String bestGuessEntityName(Object object)
      Obtain the best estimate of the entity name of the given entity instance, which is not involved in an association, by also considering information held in the proxy, and whether the object is already associated with this session.

    • bestGuessEntityName

      default String bestGuessEntityName(Object object, EntityEntry entry)
      Obtain the best estimate of the entity name of the given entity instance, which is not involved in an association, by also considering information held in the proxy, and whether the object is already associated with this session.

    • guessEntityName

      String guessEntityName(Object entity) throws HibernateException
      Obtain an estimate of the entity name of the given entity instance, which is not involved in an association, using only the EntityNameResolver.
      Throws:
      HibernateException

    • instantiate

      Object instantiate(String entityName, Object id) throws HibernateException
      Instantiate the entity class, initializing with the given identifier.
      Throws:
      HibernateException

    • instantiate

      Object instantiate(EntityPersister persister, Object id) throws HibernateException
      Instantiate the entity class of the given EntityPersister, initializing the new instance with the given identifier.

      This is more efficient than instantiate(String, Object), but not always interchangeable, since a single persister might be responsible for multiple types.

      Throws:
      HibernateException

    • isDefaultReadOnly

      boolean isDefaultReadOnly()
      Are entities and proxies loaded by this session read-only by default?

    • getCacheMode

      CacheMode getCacheMode()
      Get the current CacheMode for this session.
      Specified by:
      getCacheMode in interface QueryProducerImplementor

    • setCacheMode

      void setCacheMode(CacheMode cm)
      Set the current CacheMode for this session.

    • setCriteriaCopyTreeEnabled

      void setCriteriaCopyTreeEnabled(boolean jpaCriteriaCopyComplianceEnabled)

    • isCriteriaCopyTreeEnabled

      boolean isCriteriaCopyTreeEnabled()

    • getNativeJdbcParametersIgnored

      boolean getNativeJdbcParametersIgnored()

    • setNativeJdbcParametersIgnored

      void setNativeJdbcParametersIgnored(boolean nativeJdbcParametersIgnored)

    • getFlushMode

      @Deprecated(since="6") FlushModeType getFlushMode()
      Deprecated.
      there's no good reason to expose this here
      Get the current FlushModeType for this session.

      For users of the Hibernate native APIs, we've had to rename this method as defined by Hibernate historically because the JPA contract defines a method of the same name, but returning the JPA FlushModeType rather than Hibernate's FlushMode. For the former behavior, use getHibernateFlushMode() instead.

      Returns:
      The FlushModeType in effect for this Session.

    • setHibernateFlushMode

      void setHibernateFlushMode(FlushMode flushMode)
      Set the current FlushMode for this session.

      The flush mode determines the points at which the session is flushed. Flushing is the process of synchronizing the underlying persistent store with persistable state held in memory.

      For a logically "read-only" session, it's reasonable to set the session flush mode to FlushMode.MANUAL at the start of the session (in order skip some work and gain some extra performance).

      Parameters:
      flushMode - the new flush mode

    • getHibernateFlushMode

      FlushMode getHibernateFlushMode()
      Get the current FlushMode for this session.
      Specified by:
      getHibernateFlushMode in interface QueryProducerImplementor
      Returns:
      The flush mode

    • flush

      void flush()
      Flush this session.

    • isEventSource

      default boolean isEventSource()
      Determines if this session implements EventSource.

      Only stateful session are sources of events. If this object is a stateless session, this method return false.

    • asEventSource

      default EventSource asEventSource()
      Cast this session to EventSource if possible.

      Only stateful session are sources of events. If this object is a stateless session, this method throws.

      Throws:
      ClassCastException - if the cast is not possible

    • afterScrollOperation

      void afterScrollOperation()
      Called after each operation on a ScrollableResults, providing an opportunity for a stateless session to clear its temporary persistence context. For a stateful session, this method does nothing.

    • shouldAutoClose

      @Deprecated(since="6") boolean shouldAutoClose()
      Deprecated.
      there's no reason to expose this here
      Should this session be automatically closed after the current transaction completes?

    • isAutoCloseSessionEnabled

      @Deprecated(since="6") boolean isAutoCloseSessionEnabled()
      Deprecated.
      there's no reason to expose this here
      Is auto-close at transaction completion enabled?
      See Also:

    • getLoadQueryInfluencers

      LoadQueryInfluencers getLoadQueryInfluencers()
      Get the LoadQueryInfluencers associated with this session.
      Returns:
      the LoadQueryInfluencers associated with this session; should never be null.

    • getExceptionConverter

      ExceptionConverter getExceptionConverter()
      Obtain an ExceptionConverter for reporting an error.

      The converter associated to a session might be lazily initialized, so only invoke this getter when there's an actual need to use it.

      Returns:
      the ExceptionConverter for this Session.

    • getConfiguredJdbcBatchSize

      default Integer getConfiguredJdbcBatchSize()
      Get the currently configured JDBC batch size, which might have been specified at either the session or factory level.
      Returns:
      the session-level JDBC batch size is set, or the factory-level setting otherwise
      Since:
      5.2
      See Also:

    • getPersistenceContextInternal

      PersistenceContext getPersistenceContextInternal()
      Similar to getPersistenceContext(), with two differences:
      1. this version performs better as it allows for inlining and probably better prediction, and
      2. it skips some checks of the current state of the session.
      Choose wisely: performance is important, but correctness comes first.
      Returns:
      the PersistenceContext associated to this session.

    • autoFlushIfRequired

      boolean autoFlushIfRequired(Set<String> querySpaces) throws HibernateException
      detect in-memory changes, determine if the changes are to tables named in the query and, if so, complete execution the flush
      Parameters:
      querySpaces - the tables named in the query.
      Returns:
      true if flush is required, false otherwise.
      Throws:
      HibernateException

    • autoFlushIfRequired

      default boolean autoFlushIfRequired(Set<String> querySpaces, boolean skipPreFlush) throws HibernateException
      Throws:
      HibernateException

    • autoPreFlush

      default void autoPreFlush()

    • afterOperation

      void afterOperation(boolean success)
      Check if there is a Hibernate or JTA transaction in progress and, if there is not, flush if necessary, making sure that the connection has been committed (if it is not in autocommit mode), and finally run the after completion processing.
      Parameters:
      success - true if the operation a success

    • asSessionImplementor

      default SessionImplementor asSessionImplementor()
      Cast this object to SessionImplementor, if possible.
      Throws:
      ClassCastException - if the cast is not possible

    • isSessionImplementor

      default boolean isSessionImplementor()
      Does this object implement SessionImplementor?

    • asStatelessSession

      default StatelessSession asStatelessSession()
      Cast this object to StatelessSession, if possible.
      Throws:
      ClassCastException - if the cast is not possible

    • isStatelessSession

      default boolean isStatelessSession()
      Does this object implement StatelessSession?