Package org.hibernate.reactive.mutiny

Interface Mutiny.Session

All Superinterfaces:
Mutiny.Closeable, Mutiny.QueryProducer
All Known Implementing Classes:
MutinySessionDelegator, MutinySessionImpl
Enclosing interface:
Mutiny
public static interface Mutiny.Session extends Mutiny.QueryProducer, Mutiny.Closeable
A non-blocking counterpart to the Hibernate Session interface, allowing a reactive style of interaction with the database.

The semantics of operations on this interface are identical to the semantics of the similarly-named operations of Session, except that the operations are performed asynchronously, returning a Uni without blocking the calling thread.

Entities associated with an Session do not support transparent lazy association fetching. Instead, fetch(Object) should be used to explicitly request asynchronous fetching of an association, or the association should be fetched eagerly when the entity is first retrieved, for example, by:

See Also:
  • Session

  • Method Summary

    Modifier and Type
    Method
    Description
    Mutiny.Session
    clear()
    Completely clear the session.
    boolean
    contains(Object entity)
    Determine if the given instance belongs to this persistence context.
    Mutiny.Transaction
    currentTransaction()
    Obtain the transaction currently associated with this session, if any.
    Mutiny.Session
    detach(Object entity)
    Remove this instance from the session cache.
    Mutiny.Session
    disableFetchProfile(String name)
    Disable a particular fetch profile on this session, or do nothing if the requested fetch profile is not enabled.
    void
    disableFilter(String filterName)
    Disable the named filter for this session.
    Mutiny.Session
    enableFetchProfile(String name)
    Enable a particular fetch profile on this session, or do nothing if requested fetch profile is already enabled.
    org.hibernate.Filter
    enableFilter(String filterName)
    Enable the named filter for this session.
    <E, T> io.smallrye.mutiny.Uni<T>
    fetch(E entity, jakarta.persistence.metamodel.Attribute<E,T> field)
    Fetch a lazy property of the given entity, identified by a JPA attribute metamodel.
    <T> io.smallrye.mutiny.Uni<T>
    fetch(T association)
    Asynchronously fetch an association configured for lazy loading.
    <T> io.smallrye.mutiny.Uni<T>
    find(jakarta.persistence.EntityGraph<T> entityGraph, Object id)
    Asynchronously return the persistent instance with the given identifier of an entity class, using the given EntityGraph as a fetch plan.
    <T> io.smallrye.mutiny.Uni<T>
    find(Class<T> entityClass, Object id)
    Asynchronously return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance.
    <T> io.smallrye.mutiny.Uni<List<T>>
    find(Class<T> entityClass, Object... ids)
    Asynchronously return the persistent instances of the given entity class with the given identifiers, or null if there is no such persistent instance.
    default <T> io.smallrye.mutiny.Uni<T>
    find(Class<T> entityClass, Object id, jakarta.persistence.LockModeType lockModeType)
    Asynchronously return the persistent instance of the given entity class with the given identifier, requesting the given LockModeType.
    <T> io.smallrye.mutiny.Uni<T>
    find(Class<T> entityClass, Object id, org.hibernate.LockMode lockMode)
    Asynchronously return the persistent instance of the given entity class with the given identifier, requesting the given LockMode.
    <T> io.smallrye.mutiny.Uni<T>
    find(Class<T> entityClass, Identifier<T> naturalId)
    Asynchronously return the persistent instance of the given entity class with the given natural identifier, or null if there is no such persistent instance.
    io.smallrye.mutiny.Uni<Void>
    flush()
    Force this session to flush asynchronously.
    Integer
    getBatchSize()
    The session-level batch size, or null if it has not been overridden.
    org.hibernate.CacheMode
    getCacheMode()
    Get the current cache mode.
    org.hibernate.Filter
    getEnabledFilter(String filterName)
    Retrieve a currently enabled filter by name.
    Mutiny.SessionFactory
    getFactory()
    The Mutiny.SessionFactory which created this session.
    int
    getFetchBatchSize()
    Get the maximum batch size for batch fetching associations by id in this session.
    org.hibernate.FlushMode
    getFlushMode()
    Get the current flush mode for this session.
    org.hibernate.LockMode
    getLockMode(Object entity)
    Determine the current lock mode of the given entity.
    <T> T
    getReference(Class<T> entityClass, Object id)
    Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists.
    <T> T
    getReference(T entity)
    Return the persistent instance with the same identity as the given instance, which might be detached, assuming that the instance is still persistent in the database.
    boolean
    isDefaultReadOnly()
     
    boolean
    isFetchProfileEnabled(String name)
    Determine if the fetch profile with the given name is enabled for this session.
    boolean
    isOpen()
     
    boolean
    isReadOnly(Object entityOrProxy)
    Is the specified entity or proxy read-only?
    boolean
    isSubselectFetchingEnabled()
    Determine if subselect fetching is enabled in this session.
    default io.smallrye.mutiny.Uni<Void>
    lock(Object entity, jakarta.persistence.LockModeType lockModeType)
    Obtain the specified lock level upon the given object.
    io.smallrye.mutiny.Uni<Void>
    lock(Object entity, org.hibernate.LockMode lockMode)
    Obtain the specified lock level upon the given object.
    <T> io.smallrye.mutiny.Uni<T>
    merge(T entity)
    Copy the state of the given object onto the persistent instance with the same identifier.
    io.smallrye.mutiny.Uni<Void>
    mergeAll(Object... entities)
    Merge multiple entity instances at once.
    io.smallrye.mutiny.Uni<Void>
    persist(Object object)
    Asynchronously persist the given transient instance, first assigning a generated identifier.
    io.smallrye.mutiny.Uni<Void>
    persist(String entityName, Object object)
    Make a transient instance persistent and mark it for later insertion in the database.
    io.smallrye.mutiny.Uni<Void>
    persistAll(Object... entities)
    Persist multiple transient entity instances at once.
    io.smallrye.mutiny.Uni<Void>
    refresh(Object entity)
    Re-read the state of the given instance from the underlying database.
    default io.smallrye.mutiny.Uni<Void>
    refresh(Object entity, jakarta.persistence.LockModeType lockModeType)
    Re-read the state of the given instance from the underlying database, requesting the given LockModeType.
    io.smallrye.mutiny.Uni<Void>
    refresh(Object entity, org.hibernate.LockMode lockMode)
    Re-read the state of the given instance from the underlying database, requesting the given LockMode.
    io.smallrye.mutiny.Uni<Void>
    refreshAll(Object... entities)
    Refresh multiple entity instances at once.
    io.smallrye.mutiny.Uni<Void>
    remove(Object entity)
    Asynchronously remove a persistent instance from the datastore.
    io.smallrye.mutiny.Uni<Void>
    removeAll(Object... entities)
    Remove multiple entity instances at once.
    Mutiny.Session
    setBatchSize(Integer batchSize)
    Set the session-level batch size, overriding the batch size set by the configuration property hibernate.jdbc.batch_size.
    Mutiny.Session
    setCacheMode(org.hibernate.CacheMode cacheMode)
    Set the cache mode for this session.
    default Mutiny.Session
    setCacheRetrieveMode(jakarta.persistence.CacheRetrieveMode cacheRetrieveMode)
    Set the CacheRetrieveMode for this session.
    default Mutiny.Session
    setCacheStoreMode(jakarta.persistence.CacheStoreMode cacheStoreMode)
    Set the CacheStoreMode for this session.
    Mutiny.Session
    setDefaultReadOnly(boolean readOnly)
    Change the default for entities and proxies loaded into this session from modifiable to read-only mode, or from modifiable to read-only mode.
    Mutiny.Session
    setFetchBatchSize(int batchSize)
    Set the maximum batch size for batch fetching associations by id in this session.
    default Mutiny.Session
    setFlushMode(jakarta.persistence.FlushModeType flushModeType)
    Set the flush mode for this session.
    Mutiny.Session
    setFlushMode(org.hibernate.FlushMode flushMode)
    Set the flush mode for this session.
    Mutiny.Session
    setReadOnly(Object entityOrProxy, boolean readOnly)
    Set an unmodified persistent object to read-only mode, or a read-only object to modifiable mode.
    Mutiny.Session
    setSubselectFetchingEnabled(boolean enabled)
    Enable or disable subselect fetching in this session.
    <T> io.smallrye.mutiny.Uni<T>
    unproxy(T association)
    Asynchronously fetch an association that's configured for lazy loading, and unwrap the underlying entity implementation from any proxy.
    <T> io.smallrye.mutiny.Uni<T>
    withTransaction(Function<Mutiny.Transaction,io.smallrye.mutiny.Uni<T>> work)
    Performs the given work within the scope of a database transaction, automatically flushing the session.

    Methods inherited from interface org.hibernate.reactive.mutiny.Mutiny.Closeable

    close

    Methods inherited from interface org.hibernate.reactive.mutiny.Mutiny.QueryProducer

    createEntityGraph, createEntityGraph, createMutationQuery, createMutationQuery, createMutationQuery, createMutationQuery, createNamedQuery, createNamedQuery, createNativeQuery, createNativeQuery, createNativeQuery, createNativeQuery, createNativeQuery, createNativeQuery, createQuery, createQuery, createQuery, createQuery, createQuery, createQuery, createSelectionQuery, getCriteriaBuilder, getEntityGraph, getResultSetMapping

  • Method Details

    • find

      <T> io.smallrye.mutiny.Uni<T> find(Class<T> entityClass, Object id)
      Asynchronously return the persistent instance of the given entity class with the given identifier, or null if there is no such persistent instance. If the instance is already associated with the session, return the associated instance. This method never returns an uninitialized instance. 
       session.find(Book.class, id).map(book -> print(book.getTitle()));
      Parameters:
      entityClass - The entity type
      id - an identifier
      Returns:
      a persistent instance or null via a Uni
      See Also:
      • EntityManager.find(Class, Object)

    • find

      <T> io.smallrye.mutiny.Uni<T> find(Class<T> entityClass, Object id, org.hibernate.LockMode lockMode)
      Asynchronously return the persistent instance of the given entity class with the given identifier, requesting the given LockMode.
      Parameters:
      entityClass - The entity type
      id - an identifier
      lockMode - the requested LockMode
      Returns:
      a persistent instance or null via a Uni
      See Also:

    • find

      default <T> io.smallrye.mutiny.Uni<T> find(Class<T> entityClass, Object id, jakarta.persistence.LockModeType lockModeType)
      Asynchronously return the persistent instance of the given entity class with the given identifier, requesting the given LockModeType.
      Parameters:
      entityClass - The entity type
      id - an identifier
      lockModeType - the requested LockModeType
      Returns:
      a persistent instance or null via a Uni
      See Also:

    • find

      <T> io.smallrye.mutiny.Uni<T> find(jakarta.persistence.EntityGraph<T> entityGraph, Object id)
      Asynchronously return the persistent instance with the given identifier of an entity class, using the given EntityGraph as a fetch plan.
      Parameters:
      entityGraph - an EntityGraph specifying the entity and associations to be fetched
      id - an identifier
      See Also:

    • find

      <T> io.smallrye.mutiny.Uni<List<T>> find(Class<T> entityClass, Object... ids)
      Asynchronously return the persistent instances of the given entity class with the given identifiers, or null if there is no such persistent instance.
      Parameters:
      entityClass - The entity type
      ids - the identifiers
      Returns:
      a list of persistent instances and nulls via a Uni
      See Also:
      • Session.findMultiple(Class, List, FindOption...)

    • find

      @Incubating <T> io.smallrye.mutiny.Uni<T> find(Class<T> entityClass, Identifier<T> naturalId)
      Asynchronously return the persistent instance of the given entity class with the given natural identifier, or null if there is no such persistent instance.
      Parameters:
      entityClass - The entity type
      naturalId - the natural identifier
      Returns:
      a persistent instance or null via a Uni

    • getReference

      <T> T getReference(Class<T> entityClass, Object id)
      Return the persistent instance of the given entity class with the given identifier, assuming that the instance exists. This method never results in access to the underlying data store, and thus might return a proxied instance that must be initialized explicitly using fetch(Object).

      You should not use this method to determine if an instance exists (use find(java.lang.Class<T>, java.lang.Object) instead). Use this only to retrieve an instance which you safely assume exists, where non-existence would be an actual error.

      Parameters:
      entityClass - a persistent class
      id - a valid identifier of an existing persistent instance of the class
      Returns:
      the persistent instance or proxy
      See Also:
      • EntityManager.getReference(Class, Object)

    • getReference

      <T> T getReference(T entity)
      Return the persistent instance with the same identity as the given instance, which might be detached, assuming that the instance is still persistent in the database. This method never results in access to the underlying data store, and thus might return a proxy that must be initialized explicitly using fetch(Object).
      Parameters:
      entity - a detached persistent instance
      Returns:
      the persistent instance or proxy

    • persist

      io.smallrye.mutiny.Uni<Void> persist(Object object)
      Asynchronously persist the given transient instance, first assigning a generated identifier. (Or using the current value of the identifier property if the entity has assigned identifiers.)

      This operation cascades to associated instances if the association is mapped with CascadeType.PERSIST. 

       session.persist(newBook).map(v -> session.flush());
      Parameters:
      object - a transient instance of a persistent class
      See Also:
      • EntityManager.persist(Object)

    • persist

      io.smallrye.mutiny.Uni<Void> persist(String entityName, Object object)
      Make a transient instance persistent and mark it for later insertion in the database. This operation cascades to associated instances if the association is mapped with CascadeType.PERSIST.

      For entities with a generated id, persist() ultimately results in generation of an identifier for the given instance. But this may happen asynchronously, when the session is flushed, depending on the identifier generation strategy.

      Parameters:
      entityName - the entity name
      object - a transient instance to be made persistent
      See Also:

    • persistAll

      io.smallrye.mutiny.Uni<Void> persistAll(Object... entities)
      Persist multiple transient entity instances at once.
      See Also:

    • remove

      io.smallrye.mutiny.Uni<Void> remove(Object entity)
      Asynchronously remove a persistent instance from the datastore. The argument may be an instance associated with the receiving session or a transient instance with an identifier associated with existing persistent state.

      This operation cascades to associated instances if the association is mapped with CascadeType.REMOVE. 

       session.delete(book).thenAccept(v -> session.flush());
      Parameters:
      entity - the managed persistent instance to be removed
      Throws:
      IllegalArgumentException - if the given instance is not managed
      See Also:
      • EntityManager.remove(Object)

    • removeAll

      io.smallrye.mutiny.Uni<Void> removeAll(Object... entities)
      Remove multiple entity instances at once.
      See Also:

    • merge

      <T> io.smallrye.mutiny.Uni<T> merge(T entity)
      Copy the state of the given object onto the persistent instance with the same identifier. If there is no such persistent instance currently associated with the session, it will be loaded. Return the persistent instance. Or, if the given instance is transient, save a copy of it and return the copy as a newly persistent instance. The given instance does not become associated with the session.

      This operation cascades to associated instances if the association is mapped with CascadeType.MERGE.

      Parameters:
      entity - a detached instance with state to be copied
      Returns:
      an updated persistent instance
      See Also:
      • EntityManager.merge(Object)

    • mergeAll

      io.smallrye.mutiny.Uni<Void> mergeAll(Object... entities)
      Merge multiple entity instances at once.
      See Also:

    • refresh

      io.smallrye.mutiny.Uni<Void> refresh(Object entity)
      Re-read the state of the given instance from the underlying database. It is inadvisable to use this to implement long-running sessions that span many business tasks. This method is, however, useful in certain special circumstances, for example:
      • where a database trigger alters the object state after insert or update, or
      • after executing direct native SQL in the same session.
      Parameters:
      entity - a managed persistent instance
      Throws:
      IllegalArgumentException - if the given instance is not managed
      See Also:
      • EntityManager.refresh(Object)

    • refresh

      io.smallrye.mutiny.Uni<Void> refresh(Object entity, org.hibernate.LockMode lockMode)
      Re-read the state of the given instance from the underlying database, requesting the given LockMode.
      Parameters:
      entity - a managed persistent entity instance
      lockMode - the requested lock mode
      See Also:

    • refresh

      default io.smallrye.mutiny.Uni<Void> refresh(Object entity, jakarta.persistence.LockModeType lockModeType)
      Re-read the state of the given instance from the underlying database, requesting the given LockModeType.
      Parameters:
      entity - a managed persistent entity instance
      lockModeType - the requested lock mode
      See Also:

    • refreshAll

      io.smallrye.mutiny.Uni<Void> refreshAll(Object... entities)
      Refresh multiple entity instances at once.
      See Also:

    • lock

      io.smallrye.mutiny.Uni<Void> lock(Object entity, org.hibernate.LockMode lockMode)
      Obtain the specified lock level upon the given object. For example, this operation may be used to:
      • perform a version check with LockMode.PESSIMISTIC_READ,
      • upgrade to a pessimistic lock with LockMode.PESSIMISTIC_WRITE,
      • force a version increment with LockMode.PESSIMISTIC_FORCE_INCREMENT,
      • schedule a version check just before the end of the transaction with LockMode.OPTIMISTIC, or
      • schedule a version increment just before the end of the transaction with LockMode.OPTIMISTIC_FORCE_INCREMENT.

      This operation cascades to associated instances if the association is mapped with CascadeType.LOCK.

      Parameters:
      entity - a managed persistent instance
      lockMode - the lock level
      Throws:
      IllegalArgumentException - if the given instance is not managed

    • lock

      default io.smallrye.mutiny.Uni<Void> lock(Object entity, jakarta.persistence.LockModeType lockModeType)
      Obtain the specified lock level upon the given object. For example, this operation may be used to:
      • perform a version check with LockModeType.PESSIMISTIC_READ,
      • upgrade to a pessimistic lock with LockModeType.PESSIMISTIC_WRITE,
      • force a version increment with LockModeType.PESSIMISTIC_FORCE_INCREMENT,
      • schedule a version check just before the end of the transaction with LockModeType.OPTIMISTIC, or
      • schedule a version increment just before the end of the transaction with LockModeType.OPTIMISTIC_FORCE_INCREMENT.

      This operation cascades to associated instances if the association is mapped with CascadeType.LOCK.

      Parameters:
      entity - a managed persistent instance
      lockModeType - the lock level
      Throws:
      IllegalArgumentException - if the given instance is not managed

    • flush

      io.smallrye.mutiny.Uni<Void> flush()
      Force this session to flush asynchronously. Must be called at the end of a unit of work, before committing the transaction and closing the session. Flushing is the process of synchronizing the underlying persistent store with state held in memory. 
       session.flush().thenAccept(v -> print("done saving changes"));
      See Also:
      • EntityManager.flush()

    • fetch

      <T> io.smallrye.mutiny.Uni<T> fetch(T association)
      Asynchronously fetch an association configured for lazy loading. 

       session.fetch(author.getBook()).thenAccept(book -> print(book.getTitle()));

      This operation may be even be used to initialize a reference returned by getReference(Class, Object). 

       session.fetch(session.getReference(Author.class, authorId))

      Parameters:
      association - a lazy-loaded association, or a proxy
      Returns:
      the fetched association, via a Uni
      See Also:

    • fetch

      <E, T> io.smallrye.mutiny.Uni<T> fetch(E entity, jakarta.persistence.metamodel.Attribute<E,T> field)
      Fetch a lazy property of the given entity, identified by a JPA attribute metamodel. Note that this feature is only supported in conjunction with the Hibernate bytecode enhancer. 
       session.fetch(book, Book_.isbn).thenAccept(isbn -> print(isbn))

    • unproxy

      <T> io.smallrye.mutiny.Uni<T> unproxy(T association)
      Asynchronously fetch an association that's configured for lazy loading, and unwrap the underlying entity implementation from any proxy. 
       session.unproxy(author.getBook()).thenAccept(book -> print(book.getTitle()));
      Parameters:
      association - a lazy-loaded association
      Returns:
      the fetched association, via a Uni
      See Also:
      • Hibernate.unproxy(Object)

    • getLockMode

      org.hibernate.LockMode getLockMode(Object entity)
      Determine the current lock mode of the given entity.

    • contains

      boolean contains(Object entity)
      Determine if the given instance belongs to this persistence context.

    • setFlushMode

      Mutiny.Session setFlushMode(org.hibernate.FlushMode flushMode)
      Set the flush mode 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 is reasonable to set the session's flush mode to FlushMode.MANUAL at the start of the session (in order to achieve some extra performance).

      Parameters:
      flushMode - the new flush mode

    • setFlushMode

      default Mutiny.Session setFlushMode(jakarta.persistence.FlushModeType flushModeType)
      Set the flush mode 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.

      Parameters:
      flushModeType - the new flush mode

    • getFlushMode

      org.hibernate.FlushMode getFlushMode()
      Get the current flush mode for this session.
      Returns:
      the flush mode

    • detach

      Mutiny.Session detach(Object entity)
      Remove this instance from the session cache. Changes to the instance will not be synchronized with the database.

      This operation cascades to associated instances if the association is mapped with CascadeType.DETACH.

      Parameters:
      entity - The entity to evict
      Throws:
      NullPointerException - if the passed object is null
      IllegalArgumentException - if the passed object is not defined as an entity
      See Also:
      • EntityManager.detach(Object)

    • clear

      Mutiny.Session clear()
      Completely clear the session. Detach all persistent instances and cancel all pending insertions, updates and deletions.
      See Also:
      • EntityManager.clear()

    • enableFetchProfile

      Mutiny.Session enableFetchProfile(String name)
      Enable a particular fetch profile on this session, or do nothing if requested fetch profile is already enabled.
      Parameters:
      name - The name of the fetch profile to be enabled.
      Throws:
      org.hibernate.UnknownProfileException - Indicates that the given name does not match any known profile names
      See Also:
      • for discussion of this feature

    • disableFetchProfile

      Mutiny.Session disableFetchProfile(String name)
      Disable a particular fetch profile on this session, or do nothing if the requested fetch profile is not enabled.
      Parameters:
      name - The name of the fetch profile to be disabled.
      Throws:
      org.hibernate.UnknownProfileException - Indicates that the given name does not match any known profile names
      See Also:
      • for discussion of this feature

    • isFetchProfileEnabled

      boolean isFetchProfileEnabled(String name)
      Determine if the fetch profile with the given name is enabled for this session.
      Parameters:
      name - The name of the profile to be checked.
      Returns:
      True if fetch profile is enabled; false if not.
      Throws:
      org.hibernate.UnknownProfileException - Indicates that the given name does not match any known profile names
      See Also:
      • for discussion of this feature

    • setDefaultReadOnly

      Mutiny.Session setDefaultReadOnly(boolean readOnly)
      Change the default for entities and proxies loaded into this session from modifiable to read-only mode, or from modifiable to read-only mode.

      Read-only entities are not dirty-checked and snapshots of persistent state are not maintained. Read-only entities can be modified, but changes are not persisted.

      See Also:
      • Session.setDefaultReadOnly(boolean)

    • isDefaultReadOnly

      boolean isDefaultReadOnly()
      Returns:
      the default read-only mode for entities and proxies loaded in this session

    • setReadOnly

      Mutiny.Session setReadOnly(Object entityOrProxy, boolean readOnly)
      Set an unmodified persistent object to read-only mode, or a read-only object to modifiable mode. In read-only mode, no snapshot is maintained, the instance is never dirty checked, and changes are not persisted.
      See Also:
      • Session.setReadOnly(Object, boolean)

    • isReadOnly

      boolean isReadOnly(Object entityOrProxy)
      Is the specified entity or proxy read-only?
      See Also:
      • Session.isReadOnly(Object)

    • setCacheMode

      Mutiny.Session setCacheMode(org.hibernate.CacheMode cacheMode)
      Set the cache mode for this session.

      The cache mode determines the manner in which this session interacts with the second level cache.

      Parameters:
      cacheMode - The new cache mode.

    • setCacheStoreMode

      default Mutiny.Session setCacheStoreMode(jakarta.persistence.CacheStoreMode cacheStoreMode)
      Set the CacheStoreMode for this session.
      Parameters:
      cacheStoreMode - The new cache store mode.

    • setCacheRetrieveMode

      default Mutiny.Session setCacheRetrieveMode(jakarta.persistence.CacheRetrieveMode cacheRetrieveMode)
      Set the CacheRetrieveMode for this session.
      Parameters:
      cacheRetrieveMode - The new cache retrieve mode.

    • getCacheMode

      org.hibernate.CacheMode getCacheMode()
      Get the current cache mode.
      Returns:
      The current cache mode.

    • setBatchSize

      Mutiny.Session setBatchSize(Integer batchSize)
      Set the session-level batch size, overriding the batch size set by the configuration property hibernate.jdbc.batch_size.

    • getBatchSize

      Integer getBatchSize()
      The session-level batch size, or null if it has not been overridden.

    • enableFilter

      org.hibernate.Filter enableFilter(String filterName)
      Enable the named filter for this session.
      Parameters:
      filterName - The name of the filter to be enabled.
      Returns:
      The Filter instance representing the enabled filter.

    • disableFilter

      void disableFilter(String filterName)
      Disable the named filter for this session.
      Parameters:
      filterName - The name of the filter to be disabled.

    • getEnabledFilter

      org.hibernate.Filter getEnabledFilter(String filterName)
      Retrieve a currently enabled filter by name.
      Parameters:
      filterName - The name of the filter to be retrieved.
      Returns:
      The Filter instance representing the enabled filter.

    • getFetchBatchSize

      int getFetchBatchSize()
      Get the maximum batch size for batch fetching associations by id in this session.
      Since:
      2.1

    • setFetchBatchSize

      Mutiny.Session setFetchBatchSize(int batchSize)
      Set the maximum batch size for batch fetching associations by id in this session. Override the default controlled by the configuration property hibernate.default_batch_fetch_size.

      • If batchSize>1, then batch fetching is enabled.
      • If batchSize<0, the batch size is inherited from the factory-level setting.
      • Otherwise, batch fetching is disabled.
      Parameters:
      batchSize - the maximum batch size for batch fetching
      Since:
      2.1

    • isSubselectFetchingEnabled

      boolean isSubselectFetchingEnabled()
      Determine if subselect fetching is enabled in this session.
      Returns:
      true if subselect fetching is enabled
      Since:
      2.1

    • setSubselectFetchingEnabled

      Mutiny.Session setSubselectFetchingEnabled(boolean enabled)
      Enable or disable subselect fetching in this session. Override the default controlled by the configuration property hibernate.use_subselect_fetch.
      Parameters:
      enabled - true to enable subselect fetching
      Since:
      2.1

    • withTransaction

      <T> io.smallrye.mutiny.Uni<T> withTransaction(Function<Mutiny.Transaction,io.smallrye.mutiny.Uni<T>> work)
      Performs the given work within the scope of a database transaction, automatically flushing the session. The transaction will be rolled back if the work completes with an uncaught exception, or if Mutiny.Transaction.markForRollback() is called.

      The resulting Mutiny.Transaction object may also be obtained via currentTransaction().

    • If there is already a transaction associated with this session, the work is executed in the context of the existing transaction, and no new transaction is initiated.
    • If there is no transaction associated with this session, a new transaction is started, and the work is executed in the context of the new transaction.
      • Parameters:
      work - a function which accepts Mutiny.Transaction and returns the result of the work as a Uni.
      See Also:

    • currentTransaction

      Mutiny.Transaction currentTransaction()
      Obtain the transaction currently associated with this session, if any.
      Returns:
      the Mutiny.Transaction, or null if no transaction was started using withTransaction(Function).
      See Also:

    • isOpen

      boolean isOpen()
      Returns:
      false if Mutiny.Closeable.close() has been called

    • getFactory

      Mutiny.SessionFactory getFactory()
      The Mutiny.SessionFactory which created this session.