add API support for CacheRetrieveMode, CacheStoreMode, LockModeType, FlushModeType

fixes #600

Author: gavinking

hibernate-reactive-core/src/main/java/org/hibernate/reactive/mutiny/Mutiny.java

@@ -10,7 +10,11 @@
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import javax.persistence.CacheRetrieveMode;
+import javax.persistence.CacheStoreMode;
 import javax.persistence.EntityGraph;
+import javax.persistence.FlushModeType;
+import javax.persistence.LockModeType;
 import javax.persistence.Parameter;
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaDelete;
@@ -31,6 +35,7 @@
 import org.hibernate.engine.spi.PersistentAttributeInterceptable;
 import org.hibernate.engine.spi.PersistentAttributeInterceptor;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
+import org.hibernate.jpa.internal.util.FlushModeTypeHelper;
 import org.hibernate.proxy.HibernateProxy;
 import org.hibernate.reactive.common.AffectedEntities;
 import org.hibernate.reactive.common.Identifier;
@@ -42,6 +47,11 @@
 import io.smallrye.mutiny.Uni;
 import org.hibernate.stat.Statistics;
 
+import static org.hibernate.internal.util.LockModeConverter.convertToLockMode;
+import static org.hibernate.jpa.internal.util.CacheModeHelper.interpretCacheMode;
+import static org.hibernate.jpa.internal.util.CacheModeHelper.interpretCacheRetrieveMode;
+import static org.hibernate.jpa.internal.util.CacheModeHelper.interpretCacheStoreMode;
+
 /**
  * An API for Hibernate Reactive where non-blocking operations are
  * represented by a Mutiny {@link Uni}.
@@ -243,6 +253,22 @@ interface Query<R> {
 		 */
 		Query<R> setCacheMode(CacheMode cacheMode);
 
+		/**
+		 * Set the current {@link CacheStoreMode} in effect while this query
+		 * is being executed.
+		 */
+		default Query<R> setCacheStoreMode(CacheStoreMode cacheStoreMode) {
+			return setCacheMode( interpretCacheMode( cacheStoreMode, interpretCacheRetrieveMode(getCacheMode()) ) );
+		}
+
+		/**
+		 * Set the current {@link CacheRetrieveMode} in effect while this query
+		 * is being executed.
+		 */
+		default Query<R> setCacheRetrieveMode(CacheRetrieveMode cacheRetrieveMode) {
+			return setCacheMode( interpretCacheMode( interpretCacheStoreMode(getCacheMode()), cacheRetrieveMode ) );
+		}
+
 		/**
 		 * Obtain the {@link CacheMode} in effect for this query. By default,
 		 * the query inherits the {@code CacheMode} of the {@link Session}
@@ -258,6 +284,14 @@ interface Query<R> {
 		 */
 		Query<R> setFlushMode(FlushMode flushMode);
 
+
+		/**
+		 * Set the current {@link FlushModeType} in effect while this query is
+		 * being executed.
+		 */
+		default Query<R> setFlushMode(FlushModeType flushModeType) {
+			return setFlushMode( FlushModeTypeHelper.getFlushMode(flushModeType) );
+		}
 		/**
 		 * Obtain the {@link FlushMode} in effect for this query. By default,
 		 * the query inherits the {@code FlushMode} of the {@link Session}
@@ -272,6 +306,13 @@ interface Query<R> {
 		 */
 		Query<R> setLockMode(LockMode lockMode);
 
+		/**
+		 * Set the {@link LockModeType} to use for the whole query.
+		 */
+		default Query<R> setLockMode(LockModeType lockModeType) {
+			return setLockMode( convertToLockMode(lockModeType) );
+		}
+
 		/**
 		 * Set the {@link LockMode} to use for specified alias (as defined in
 		 * the query's {@code from} clause).
@@ -283,6 +324,19 @@ interface Query<R> {
 		 */
 		Query<R> setLockMode(String alias, LockMode lockMode);
 
+		/**
+		 * Set the {@link LockModeType} to use for specified alias (as defined in
+		 * the query's {@code from} clause).
+		 *
+		 * @param alias the from clause alias
+		 * @param lockModeType the requested {@link LockModeType}
+		 *
+		 * @see org.hibernate.query.Query#setLockMode(String,LockMode)
+		 */
+		default Query<R> setLockMode(String alias, LockModeType lockModeType) {
+			return setLockMode( alias, convertToLockMode(lockModeType) );
+		}
+
 //		/**
 //		 * Set the {@link LockOptions} to use for the whole query.
 //		 *
@@ -358,6 +412,23 @@ interface Session extends Closeable {
 		 */
 		<T> Uni<T> 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 {@link LockModeType}.
+		 *
+		 * @param entityClass The entity type
+		 * @param id an identifier
+		 * @param lockModeType the requested {@link LockModeType}
+		 *
+		 * @return a persistent instance or null via a {@code Uni}
+		 *
+		 * @see #find(Class,Object)
+		 * @see #lock(Object, LockMode) this discussion of lock modes
+		 */
+		default <T> Uni<T> find(Class<T> entityClass, Object id, LockModeType lockModeType) {
+			return find( entityClass, id, convertToLockMode(lockModeType) );
+		}
+
 //		/**
 //		 * Asynchronously return the persistent instance of the given entity
 //		 * class with the given identifier, requesting the given {@link LockOptions}.
@@ -555,6 +626,19 @@ interface Session extends Closeable {
 		 */
 		Uni<Void> refresh(Object entity, LockMode lockMode);
 
+		/**
+		 * Re-read the state of the given instance from the underlying database,
+		 * requesting the given {@link LockModeType}.
+		 *
+		 * @param entity a managed persistent entity instance
+		 * @param lockModeType the requested lock mode
+		 *
+		 * @see #refresh(Object)
+		 */
+		default Uni<Void> refresh(Object entity, LockModeType lockModeType) {
+			return refresh( entity, convertToLockMode(lockModeType) );
+		}
+
 //		/**
 //		 * Re-read the state of the given instance from the underlying database,
 //		 * requesting the given {@link LockOptions}.
@@ -597,6 +681,32 @@ interface Session extends Closeable {
 		 */
 		Uni<Void> lock(Object entity, LockMode lockMode);
 
+		/**
+		 * Obtain the specified lock level upon the given object. For example,
+		 * this operation may be used to:
+		 *
+		 * <ul>
+		 * <li>perform a version check with {@link LockModeType#PESSIMISTIC_READ},
+		 * <li>upgrade to a pessimistic lock with {@link LockModeType#PESSIMISTIC_WRITE},
+		 * <li>force a version increment with {@link LockModeType#PESSIMISTIC_FORCE_INCREMENT},
+		 * <li>schedule a version check just before the end of the transaction with
+		 * {@link LockModeType#OPTIMISTIC}, or
+		 * <li>schedule a version increment just before the end of the transaction
+		 * with {@link LockModeType#OPTIMISTIC_FORCE_INCREMENT}.
+		 * </ul>
+		 *
+		 * This operation cascades to associated instances if the association is
+		 * mapped with {@link org.hibernate.annotations.CascadeType#LOCK}.
+		 *
+		 * @param entity a managed persistent instance
+		 * @param lockModeType the lock level
+		 *
+		 * @throws IllegalArgumentException if the given instance is not managed
+		 */
+		default Uni<Void> lock(Object entity, LockModeType lockModeType) {
+			return lock( entity, convertToLockMode(lockModeType) );
+		}
+
 //		/**
 //		 * Obtain the specified lock level upon the given object, with the given
 //		 * {@link LockOptions}.
@@ -900,6 +1010,19 @@ <R> Query<R> createNativeQuery(String queryString, ResultSetMapping<R> resultSet
 		 */
 		Session setFlushMode(FlushMode flushMode);
 
+		/**
+		 * Set the {@link FlushModeType flush mode} for this session.
+		 * <p>
+		 * The flush mode determines the points at which the session is flushed.
+		 * <i>Flushing</i> is the process of synchronizing the underlying persistent
+		 * store with persistable state held in memory.
+		 *
+		 * @param flushModeType the new flush mode
+		 */
+		default Session setFlushMode(FlushModeType flushModeType) {
+			return setFlushMode( FlushModeTypeHelper.getFlushMode(flushModeType) );
+		}
+
 		/**
 		 * Get the current flush mode for this session.
 		 *
@@ -1032,6 +1155,24 @@ <R> Query<R> createNativeQuery(String queryString, ResultSetMapping<R> resultSet
 		 */
 		Session setCacheMode(CacheMode cacheMode);
 
+		/**
+		 * Set the {@link CacheStoreMode} for this session.
+		 *
+		 * @param cacheStoreMode The new cache store mode.
+		 */
+		default Session setCacheStoreMode(CacheStoreMode cacheStoreMode) {
+			return setCacheMode( interpretCacheMode( cacheStoreMode, interpretCacheRetrieveMode(getCacheMode()) ) );
+		}
+
+		/**
+		 * Set the {@link CacheRetrieveMode} for this session.
+		 *
+		 * @param cacheRetrieveMode The new cache retrieve mode.
+		 */
+		default Session setCacheRetrieveMode(CacheRetrieveMode cacheRetrieveMode) {
+			return setCacheMode( interpretCacheMode( interpretCacheStoreMode(getCacheMode()), cacheRetrieveMode ) );
+		}
+
 		/**
 		 * Get the current cache mode.
 		 *
@@ -1176,6 +1317,21 @@ interface StatelessSession extends Closeable {
 		 */
 		<T> Uni<T> get(Class<T> entityClass, Object id, LockMode lockMode);
 
+		/**
+		 * Retrieve a row, obtaining the specified lock mode.
+		 *
+		 * @param entityClass The class of the entity to retrieve
+		 * @param id The id of the entity to retrieve
+		 * @param lockModeType The lock mode to apply to the entity
+		 *
+		 * @return a detached entity instance, via a {@code Uni}
+		 *
+		 * @see org.hibernate.StatelessSession#get(Class, Serializable, LockMode)
+		 */
+		default <T> Uni<T> get(Class<T> entityClass, Object id, LockModeType lockModeType) {
+			return get( entityClass, id, convertToLockMode(lockModeType) );
+		}
+
 		/**
 		 * Retrieve a row, using the given {@link EntityGraph} as a fetch plan.
 		 *
@@ -1431,6 +1587,18 @@ interface StatelessSession extends Closeable {
 		 */
 		Uni<Void> refresh(Object entity, LockMode lockMode);
 
+		/**
+		 * Refresh the entity instance state from the database.
+		 *
+		 * @param entity The entity to be refreshed.
+		 * @param lockModeType The LockMode to be applied.
+		 *
+		 * @see org.hibernate.StatelessSession#refresh(Object, LockMode)
+		 */
+		default Uni<Void> refresh(Object entity, LockModeType lockModeType) {
+			return refresh( entity, convertToLockMode(lockModeType) );
+		}
+
 		/**
 		 * Asynchronously fetch an association that's configured for lazy loading.
 		 *