Mutiny.Session (Hibernate Reactive Core 1.0.0.Alpha10 API)

All Superinterfaces:
AutoCloseable
All Known Implementing Classes:
MutinySessionImpl
Enclosing interface:
Mutiny
```
public static interface Mutiny.Session
extends AutoCloseable
```
A non-blocking counterpart to the Hibernate org.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:
- enabling a fetch profile,
- using an EntityGraph, or
- writing a join fetch clause in a HQL query.
See Also:
org.hibernate.Session

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`Mutiny.Session`	`clear()` Completely clear the session.
`void`	`close()` Close the reactive session and release the underlying database connection.
`boolean`	`contains(Object entity)` Determine if the given instance belongs to this persistence context.
`<T> <any>`	`createEntityGraph(Class<T> rootType)` Create a new mutable `EntityGraph`
`<T> <any>`	`createEntityGraph(Class<T> rootType, String graphName)` Create a new mutable copy of a named `EntityGraph`
`<R> Mutiny.Query<R>`	`createNamedQuery(String queryName)` Create an instance of `Mutiny.Query` for the named query.
`<R> Mutiny.Query<R>`	`createNamedQuery(String queryName, Class<R> resultType)` Create an instance of `Mutiny.Query` for the named query.
`<R> Mutiny.Query<R>`	`createNativeQuery(String queryString)` Create an instance of `Mutiny.Query` for the given SQL query string, or SQL update, insert, or delete statement.
`<R> Mutiny.Query<R>`	`createNativeQuery(String queryString, Class<R> resultType)` Create an instance of `Mutiny.Query` for the given SQL query string, using the given `resultType` to interpret the results.
`<R> Mutiny.Query<R>`	`createNativeQuery(String queryString, ResultSetMapping<R> resultSetMapping)` Create an instance of `Mutiny.Query` for the given SQL query string, using the given `ResultSetMapping` to interpret the result set.
`<R> Mutiny.Query<R>`	`createQuery(<any> criteriaQuery)` Create an instance of `Mutiny.Query` for the given criteria query.
`<R> Mutiny.Query<R>`	`createQuery(<any> criteriaUpdate)` Create an instance of `Mutiny.Query` for the given criteria update.
`<R> Mutiny.Query<R>`	`createQuery(<any> criteriaDelete)` Create an instance of `Mutiny.Query` for the given criteria delete.
`<R> Mutiny.Query<R>`	`createQuery(String queryString)` Create an instance of `Mutiny.Query` for the given HQL/JPQL query string or HQL/JPQL update or delete statement.
`<R> Mutiny.Query<R>`	`createQuery(String queryString, Class<R> resultType)` Create an instance of `Mutiny.Query` for the given HQL/JPQL query string.
`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.
`Filter`	`enableFilter(String filterName)` Enable the named filter for this session.
`<E,T> <any>`	`fetch(E entity, <any> field)` Fetch a lazy property of the given entity, identified by a JPA `attribute metamodel`.
`<T> <any>`	`fetch(T association)` Asynchronously fetch an association that's configured for lazy loading.
`<T> <any>`	`find(<any> 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> <any>`	`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.
`<T> <any>`	`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> <any>`	`find(Class<T> entityClass, Object id, LockMode lockMode)` Asynchronously return the persistent instance of the given entity class with the given identifier, requesting the given `LockMode`.
`<any>`	`flush()` Force this session to flush asynchronously.
`Integer`	`getBatchSize()` The session-level JDBC batch size, or `null` if it has not been overridden.
`CacheMode`	`getCacheMode()` Get the current cache mode.
`Filter`	`getEnabledFilter(String filterName)` Retrieve a currently enabled filter by name.
`<T> <any>`	`getEntityGraph(Class<T> rootType, String graphName)` Obtain a named `EntityGraph`
`FlushMode`	`getFlushMode()` Get the current flush mode for this session.
`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 of with the same identity as the given instance, which might be detached, assuming that the instance is still persistent in the database.
`<T> ResultSetMapping<T>`	`getResultSetMapping(Class<T> resultType, String mappingName)` Obtain a native SQL result set mapping defined via the annotation `javax.persistence.SqlResultSetMapping`.
`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?
`<any>`	`lock(Object entity, LockMode lockMode)` Obtain the specified lock level upon the given object.
`<T> <any>`	`merge(T entity)` Copy the state of the given object onto the persistent instance with the same identifier.
`<T> <any>`	`mergeAll(T... entities)` Merge multiple entity instances at once.
`<any>`	`persist(Object entity)` Asynchronously persist the given transient instance, first assigning a generated identifier.
`<any>`	`persistAll(Object... entities)` Persist multiple transient entity instances at once.
`<any>`	`refresh(Object entity)` Re-read the state of the given instance from the underlying database.
`<any>`	`refresh(Object entity, LockMode lockMode)` Re-read the state of the given instance from the underlying database, requesting the given `LockMode`.
`<any>`	`refreshAll(Object... entities)` Refresh multiple entity instances at once.
`<any>`	`remove(Object entity)` Asynchronously remove a persistent instance from the datastore.
`<any>`	`removeAll(Object... entities)` Remove multiple entity instances at once.
`Mutiny.Session`	`setBatchSize(Integer batchSize)` Set the session-level JDBC batch size, overriding the batch size set by the configuration property `hibernate.jdbc.batch_size`.
`Mutiny.Session`	`setCacheMode(CacheMode cacheMode)` Set the `cache mode` 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`	`setFlushMode(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.
`<T> <any>`	`unproxy(T association)` Asynchronously fetch an association that's configured for lazy loading, and unwrap the underlying entity implementation from any proxy.
`<T> <any>`	`withTransaction(Function<Mutiny.Transaction,<any>> work)` Performs the given work within the scope of a database transaction, automatically flushing the session.

- Method Detail
  - find
```
<T> <any> 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:
    javax.persistence.EntityManager#find(Class, Object)
  - find
```
<T> <any> find(Class<T> entityClass,
               Object id,
               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(Class,Object), this discussion of lock modes
  - find
```
<T> <any> find(<any> 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(Class,Object)
  - find
```
<T> <any> 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
  - 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:
    javax.persistence.EntityManager#getReference(Class, Object)
  - getReference
```
<T> T getReference(T entity)
```
    Return the persistent instance of 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
```
<any> persist(Object entity)
```
    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 javax.persistence.CascadeType#PERSIST.
```
  session.persist(newBook).map(v -> session.flush());
 
```
    Parameters:
    entity - a transient instance of a persistent class
    See Also:
    javax.persistence.EntityManager#persist(Object)
  - persistAll
```
<any> persistAll(Object... entities)
```
    Persist multiple transient entity instances at once.
    See Also:
    persist(Object)
  - remove
```
<any> 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 javax.persistence.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:
    javax.persistence.EntityManager#remove(Object)
  - removeAll
```
<any> removeAll(Object... entities)
```
    Remove multiple entity instances at once.
    See Also:
    remove(Object)
  - merge
```
<T> <any> 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 javax.persistence.CascadeType#MERGE.
    Parameters:
    entity - a detached instance with state to be copied
    Returns:
    an updated persistent instance
    See Also:
    javax.persistence.EntityManager#merge(Object)
  - mergeAll
```
<T> <any> mergeAll(T... entities)
```
    Merge multiple entity instances at once.
    See Also:
    merge(Object)
  - refresh
```
<any> 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:
    javax.persistence.EntityManager#refresh(Object)
  - refresh
```
<any> refresh(Object entity,
              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(Object)
  - refreshAll
```
<any> refreshAll(Object... entities)
```
    Refresh multiple entity instances at once.
    See Also:
    refresh(Object)
  - lock
```
<any> lock(Object entity,
           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 org.hibernate.annotations.CascadeType#LOCK.
    Parameters:
    entity - a managed persistent instance
    lockMode - the lock level
    Throws:
    IllegalArgumentException - if the given instance is not managed
  - flush
```
<any> 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:
    javax.persistence.EntityManager#flush()
  - fetch
```
<T> <any> fetch(T association)
```
    Asynchronously fetch an association that's configured for lazy loading.
```
  session.fetch(author.getBook()).thenAccept(book -> print(book.getTitle()));
 
```
    Parameters:
    association - a lazy-loaded association
    Returns:
    the fetched association, via a Uni
    See Also:
    Mutiny.fetch(Object), org.hibernate.Hibernate#initialize(Object)
  - fetch
```
<E,T> <any> fetch(E entity,
                  <any> 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> <any> 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:
    org.hibernate.Hibernate#unproxy(Object)
  - getLockMode
```
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.
  - createQuery
```
<R> Mutiny.Query<R> createQuery(String queryString)
```
    Create an instance of Mutiny.Query for the given HQL/JPQL query string or HQL/JPQL update or delete statement. In the case of an update or delete, the returned Mutiny.Query must be executed using Mutiny.Query.executeUpdate() which returns an affected row count.
    Parameters:
    queryString - The HQL/JPQL query, update or delete statement
    Returns:
    The Mutiny.Query instance for manipulation and execution
    See Also:
    javax.persistence.EntityManager#createQuery(String)
  - createQuery
```
<R> Mutiny.Query<R> createQuery(String queryString,
                                Class<R> resultType)
```
    Create an instance of Mutiny.Query for the given HQL/JPQL query string.
    Parameters:
    queryString - The HQL/JPQL query
    resultType - the Java type returned in each row of query results
    Returns:
    The Mutiny.Query instance for manipulation and execution
    See Also:
    javax.persistence.EntityManager#createQuery(String, Class)
  - 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:
    javax.persistence.EntityManager#createQuery(String)
  - createNamedQuery
```
<R> Mutiny.Query<R> createNamedQuery(String queryName,
                                     Class<R> resultType)
```
    Create an instance of Mutiny.Query 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.Query instance for manipulation and execution
    See Also:
    javax.persistence.EntityManager#createQuery(String, Class)
  - createNativeQuery
```
<R> Mutiny.Query<R> createNativeQuery(String queryString,
                                      Class<R> resultType)
```
    Create an instance of Mutiny.Query for the given SQL query string, using the given resultType to interpret the results.
    - If the given result type is Object, or a built-in type such as String or Integer, the result set must have a single column, which will be returned as a scalar.
    - If the given result type is Object[], then the result set must have multiple columns, which will be returned in arrays.
    - Otherwise, the given result type must be an entity class, in which case the result set column aliases must map to the fields of the entity, and the query will return instances of the entity.
    Parameters:
    queryString - The SQL query
    resultType - the Java type returned in each row of query results
    Returns:
    The Mutiny.Query instance for manipulation and execution
    See Also:
    javax.persistence.EntityManager#createNativeQuery(String, Class)
  - createNativeQuery
```
<R> Mutiny.Query<R> createNativeQuery(String queryString,
                                      ResultSetMapping<R> resultSetMapping)
```
    Create an instance of Mutiny.Query for the given SQL query string, using the given ResultSetMapping to interpret the result set.
    Parameters:
    queryString - The SQL query
    resultSetMapping - the result set mapping
    Returns:
    The Mutiny.Query instance for manipulation and execution
    See Also:
    getResultSetMapping(Class, String), javax.persistence.EntityManager#createNativeQuery(String, String)
  - createNativeQuery
```
<R> Mutiny.Query<R> createNativeQuery(String queryString)
```
    Create an instance of Mutiny.Query for the given SQL query string, or SQL update, insert, or delete statement. In the case of an update, insert or delete, the returned Mutiny.Query must be executed using Mutiny.Query.executeUpdate() which returns an affected row count. In the case of a query:
    - If the result set has a single column, the results will be returned as scalars.
    - Otherwise, if the result set has multiple columns, the results will be returned as elements of arrays of type Object[].
    Parameters:
    queryString - The SQL select, update, insert, or delete statement
  - createQuery
```
<R> Mutiny.Query<R> createQuery(<any> criteriaQuery)
```
    Create an instance of Mutiny.Query for the given criteria query.
    Parameters:
    criteriaQuery - The CriteriaQuery
    Returns:
    The Mutiny.Query instance for manipulation and execution
    See Also:
    javax.persistence.EntityManager#createQuery(String)
  - createQuery
```
<R> Mutiny.Query<R> createQuery(<any> criteriaUpdate)
```
    Create an instance of Mutiny.Query for the given criteria update.
    Parameters:
    criteriaUpdate - The CriteriaUpdate
    Returns:
    The Mutiny.Query instance for manipulation and execution
    See Also:
    javax.persistence.EntityManager#createQuery(String)
  - createQuery
```
<R> Mutiny.Query<R> createQuery(<any> criteriaDelete)
```
    Create an instance of Mutiny.Query for the given criteria delete.
    Parameters:
    criteriaDelete - The CriteriaDelete
    Returns:
    The Mutiny.Query instance for manipulation and execution
    See Also:
    javax.persistence.EntityManager#createQuery(String)
  - setFlushMode
```
Mutiny.Session setFlushMode(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
  - getFlushMode
```
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 javax.persistence.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:
    javax.persistence.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:
    javax.persistence.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
  - getResultSetMapping
```
<T> ResultSetMapping<T> getResultSetMapping(Class<T> resultType,
                                            String mappingName)
```
    Obtain a native SQL result set mapping defined via the annotation javax.persistence.SqlResultSetMapping.
  - getEntityGraph
```
<T> <any> getEntityGraph(Class<T> rootType,
                         String graphName)
```
    Obtain a named EntityGraph
  - createEntityGraph
```
<T> <any> createEntityGraph(Class<T> rootType)
```
    Create a new mutable EntityGraph
  - createEntityGraph
```
<T> <any> createEntityGraph(Class<T> rootType,
                            String graphName)
```
    Create a new mutable copy of a named EntityGraph
  - 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:
    org.hibernate.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:
    org.hibernate.Session#setReadOnly(Object, boolean)
  - isReadOnly
```
boolean isReadOnly(Object entityOrProxy)
```
    Is the specified entity or proxy read-only?
    See Also:
    org.hibernate.Session#isReadOnly(Object)
  - setCacheMode
```
Mutiny.Session setCacheMode(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.
  - getCacheMode
```
CacheMode getCacheMode()
```
    Get the current cache mode.
    Returns:
    The current cache mode.
  - setBatchSize
```
Mutiny.Session setBatchSize(Integer batchSize)
```
    Set the session-level JDBC batch size, overriding the batch size set by the configuration property hibernate.jdbc.batch_size.
  - getBatchSize
```
Integer getBatchSize()
```
    The session-level JDBC batch size, or null if it has not been overridden.
  - enableFilter
```
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
```
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.
  - withTransaction
```
<T> <any> withTransaction(Function<Mutiny.Transaction,<any>> 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.
    Parameters:
    work - a function which accepts Mutiny.Transaction and returns the result of the work as a Uni.
  - close
```
void close()
```
    Close the reactive session and release the underlying database connection.
    Specified by:
    close in interface AutoCloseable
  - isOpen
```
boolean isOpen()
```
    Returns:
    false if close() has been called

Interface Mutiny.Session

Method Summary

Method Detail

find

find

find

find

getReference

getReference

persist

persistAll

remove

removeAll

merge

mergeAll

refresh

refresh

refreshAll

lock

flush

fetch

fetch

unproxy

getLockMode

contains

createQuery

createQuery

createNamedQuery

createNamedQuery

createNativeQuery

createNativeQuery

createNativeQuery

createQuery

createQuery

createQuery

setFlushMode

getFlushMode

detach

clear

enableFetchProfile

getResultSetMapping

getEntityGraph

createEntityGraph

createEntityGraph

disableFetchProfile

isFetchProfileEnabled

setDefaultReadOnly

isDefaultReadOnly

setReadOnly

isReadOnly

setCacheMode

getCacheMode

setBatchSize

getBatchSize

enableFilter

disableFilter

getEnabledFilter

withTransaction

close

isOpen