Package org.hibernate.reactive.mutiny

Interface Mutiny.StatelessSession

  • All Superinterfaces:
    Mutiny.Closeable
    Enclosing interface:
    Mutiny
    public static interface Mutiny.StatelessSession
extends Mutiny.Closeable
    A non-blocking counterpart to the Hibernate StatelessSession interface, which provides a command-oriented API for performing bulk operations against a database.

    A stateless session does not implement a first-level cache nor interact with any second-level cache, nor does it implement transactional write-behind or automatic dirty checking, nor do operations cascade to associated instances. Changes to many to many associations and element collections may not be made persistent in a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors.

    For certain kinds of work, a stateless session may perform slightly better than a stateful session.

    In particular, for a session which loads many entities, use of a StatelessSession alleviates the need to call:

    Stateless sessions are vulnerable to data aliasing effects, due to the lack of a first-level cache.

    See Also:
    StatelessSession

    • Method Detail

      • get

        <T> io.smallrye.mutiny.Uni<T> get​(Class<T> entityClass,
                                  Object id)
        Retrieve a row.
        Parameters:
        entityClass - The class of the entity to retrieve
        id - The id of the entity to retrieve
        Returns:
        a detached entity instance, via a Uni
        See Also:
        StatelessSession.get(Class, Object)

      • get

        <T> io.smallrye.mutiny.Uni<T> get​(Class<T> entityClass,
                                  Object id,
                                  LockMode lockMode)
        Retrieve a row, obtaining the specified lock mode.
        Parameters:
        entityClass - The class of the entity to retrieve
        id - The id of the entity to retrieve
        lockMode - The lock mode to apply to the entity
        Returns:
        a detached entity instance, via a Uni
        See Also:
        StatelessSession.get(Class, Object, LockMode)

      • get

        default <T> io.smallrye.mutiny.Uni<T> get​(Class<T> entityClass,
                                          Object id,
                                          jakarta.persistence.LockModeType lockModeType)
        Retrieve a row, obtaining the specified lock mode.
        Parameters:
        entityClass - The class of the entity to retrieve
        id - The id of the entity to retrieve
        lockModeType - The lock mode to apply to the entity
        Returns:
        a detached entity instance, via a Uni
        See Also:
        StatelessSession.get(Class, Object, LockMode)

      • get

        <T> io.smallrye.mutiny.Uni<T> get​(jakarta.persistence.EntityGraph<T> entityGraph,
                                  Object id)
        Retrieve a row, using the given EntityGraph as a fetch plan.
        Parameters:
        entityGraph - an EntityGraph specifying the entity and associations to be fetched
        id - The id of the entity to retrieve
        Returns:
        a detached entity instance, via a Uni

      • createSelectionQuery

        <R> Mutiny.SelectionQuery<R> createSelectionQuery​(String queryString,
                                                  Class<R> resultType)
        Create an instance of Mutiny.SelectionQuery for the given HQL/JPQL query string.
        Parameters:
        queryString - The HQL/JPQL query
        Returns:
        The Mutiny.SelectionQuery instance for manipulation and execution
        See Also:
        EntityManager.createQuery(String, Class)

      • createMutationQuery

        Mutiny.MutationQuery createMutationQuery​(String queryString)
        Create an instance of Mutiny.MutationQuery for the given HQL/JPQL update or delete statement.
        Parameters:
        queryString - The HQL/JPQL query, update or delete statement
        Returns:
        The Mutiny.MutationQuery instance for manipulation and execution
        See Also:
        EntityManager.createQuery(String)

      • createNamedQuery

        <R> Mutiny.Query<R> createNamedQuery​(String queryName)
        Create an instance of Mutiny.Query for the named query.
        Parameters:
        queryName - The name of the query
        Returns:
        The Mutiny.Query instance for manipulation and execution
        See Also:
        EntityManager.createQuery(String)

      • createNamedQuery

        <R> Mutiny.SelectionQuery<R> createNamedQuery​(String queryName,
                                              Class<R> resultType)
        Create an instance of Mutiny.SelectionQuery for the named query.
        Parameters:
        queryName - The name of the query
        resultType - the Java type returned in each row of query results
        Returns:
        The Mutiny.SelectionQuery instance for manipulation and execution
        See Also:
        EntityManager.createQuery(String, Class)

      • createQuery

        <R> Mutiny.SelectionQuery<R> createQuery​(jakarta.persistence.criteria.CriteriaQuery<R> criteriaQuery)
        Create an instance of Mutiny.SelectionQuery for the given criteria query.
        Parameters:
        criteriaQuery - The CriteriaQuery
        Returns:
        The Mutiny.SelectionQuery instance for manipulation and execution
        See Also:
        EntityManager.createQuery(String)

      • insertAll

        io.smallrye.mutiny.Uni<Void> insertAll​(int batchSize,
                                       Object... entities)
        Insert multiple rows using the specified batch size.
        Parameters:
        batchSize - the batch size
        entities - new transient instances
        See Also:
        StatelessSession.insert(Object)

      • deleteAll

        io.smallrye.mutiny.Uni<Void> deleteAll​(int batchSize,
                                       Object... entities)
        Delete multiple rows.
        Parameters:
        batchSize - the batch size
        entities - detached entity instances
        See Also:
        StatelessSession.delete(Object)

      • updateAll

        io.smallrye.mutiny.Uni<Void> updateAll​(int batchSize,
                                       Object... entities)
        Update multiple rows.
        Parameters:
        batchSize - the batch size
        entities - detached entity instances
        See Also:
        StatelessSession.update(Object)

      • refresh

        io.smallrye.mutiny.Uni<Void> refresh​(Object entity)
        Refresh the entity instance state from the database.
        Parameters:
        entity - The entity to be refreshed.
        See Also:
        StatelessSession.refresh(Object)

      • refreshAll

        io.smallrye.mutiny.Uni<Void> refreshAll​(Object... entities)
        Refresh the entity instance state from the database.
        Parameters:
        entities - The entities to be refreshed.
        See Also:
        StatelessSession.refresh(Object)

      • refreshAll

        io.smallrye.mutiny.Uni<Void> refreshAll​(int batchSize,
                                        Object... entities)
        Refresh the entity instance state from the database using the selected batch size.
        Parameters:
        batchSize - the batch size
        entities - The entities to be refreshed.
        See Also:
        StatelessSession.refresh(Object)

      • refresh

        default io.smallrye.mutiny.Uni<Void> refresh​(Object entity,
                                             jakarta.persistence.LockModeType lockModeType)
        Refresh the entity instance state from the database.
        Parameters:
        entity - The entity to be refreshed.
        lockModeType - The LockMode to be applied.
        See Also:
        StatelessSession.refresh(Object, LockMode)

      • fetch

        <T> io.smallrye.mutiny.Uni<T> fetch​(T association)
        Asynchronously fetch an association that's configured for lazy loading. 
         session.fetch(author.getBook()).thenAccept(book -> print(book.getTitle()))

        Warning: this operation in a stateless session is quite sensitive to data aliasing effects and should be used with great care.

        Parameters:
        association - a lazy-loaded association
        Returns:
        the fetched association, via a Uni
        See Also:
        Hibernate.initialize(Object)

      • getResultSetMapping

        <T> ResultSetMapping<T> getResultSetMapping​(Class<T> resultType,
                                            String mappingName)
        Obtain a native SQL result set mapping defined via the annotation SqlResultSetMapping.

      • getEntityGraph

        <T> jakarta.persistence.EntityGraph<T> getEntityGraph​(Class<T> rootType,
                                                      String graphName)
        Obtain a named EntityGraph

      • createEntityGraph

        <T> jakarta.persistence.EntityGraph<T> createEntityGraph​(Class<T> rootType)
        Create a new mutable EntityGraph

      • createEntityGraph

        <T> jakarta.persistence.EntityGraph<T> createEntityGraph​(Class<T> rootType,
                                                         String graphName)
        Create a new mutable copy of a named EntityGraph

      • 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.
      • 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:
Mutiny.SessionFactory.withTransaction(BiFunction)