HHH-19737 - Support Envers with StatelessSession

# Conflicts:
#	hibernate-core/src/main/java/org/hibernate/engine/spi/AbstractDelegatingSharedSessionBuilder.java
#	hibernate-core/src/main/java/org/hibernate/event/internal/DefaultLockEventListener.java
#	hibernate-core/src/main/java/org/hibernate/internal/StatelessSessionImpl.java

# Conflicts:
#	hibernate-core/src/main/java/org/hibernate/cache/internal/CollectionCacheInvalidator.java

# Conflicts:
#	hibernate-core/src/main/java/org/hibernate/engine/spi/ActionQueue.java
#	hibernate-core/src/main/java/org/hibernate/event/internal/DefaultRefreshEventListener.java
#	hibernate-core/src/main/java/org/hibernate/event/internal/PostUpdateEventListenerStandardImpl.java
#	hibernate-core/src/main/java/org/hibernate/internal/SessionImpl.java
#	hibernate-core/src/main/java/org/hibernate/internal/StatelessSessionImpl.java

Author: sebersole

hibernate-core/src/main/java/org/hibernate/CommonSessionBuilderOptions.java

@@ -0,0 +1,56 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate;
+
+import java.util.function.UnaryOperator;
+
+/**
+ * Common options builders of {@linkplain Session} and {@linkplain StatelessSession}.
+ *
+ * @author Steve Ebersole
+ */
+public interface CommonSessionBuilderOptions {
+	/**
+	 * Adds a specific interceptor to the session options.
+	 *
+	 * @param interceptor The interceptor to use.
+	 *
+	 * @return {@code this}, for method chaining
+	 */
+	CommonSessionBuilderOptions interceptor(Interceptor interceptor);
+
+	/**
+	 * Signifies that no {@link Interceptor} should be used.
+	 * <p>
+	 * By default, if no {@code Interceptor} is explicitly specified, the
+	 * {@code Interceptor} associated with the {@link SessionFactory} is
+	 * inherited by the new session.
+	 * <p>
+	 * Calling {@link #interceptor(Interceptor)} with null has the same effect.
+	 *
+	 * @return {@code this}, for method chaining
+	 */
+	CommonSessionBuilderOptions noInterceptor();
+
+	/**
+	 * Applies the given statement inspection function to the session.
+	 *
+	 * @param operator An operator which accepts a SQL string, returning
+	 * a processed SQL string to be used by Hibernate instead of the given
+	 * original SQL. The operator may simply return the original SQL.
+	 *
+	 * @return {@code this}, for method chaining
+	 */
+	CommonSessionBuilderOptions statementInspector(UnaryOperator<String> operator);
+
+	/**
+	 * Define the tenant identifier to be associated with the opened session.
+	 *
+	 * @param tenantIdentifier The tenant identifier.
+	 *
+	 * @return {@code this}, for method chaining
+	 */
+	CommonSessionBuilderOptions tenantIdentifier(Object tenantIdentifier);
+}

hibernate-core/src/main/java/org/hibernate/CommonSharedSessionBuilderOptions.java

@@ -0,0 +1,54 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate;
+
+import java.util.function.UnaryOperator;
+
+/**
+ * Common options for builders of {@linkplain Session} and {@linkplain StatelessSession}
+ * which share state from an underlying {@linkplain Session} or {@linkplain StatelessSession}.
+ *
+ * @author Steve Ebersole
+ */
+public interface CommonSharedSessionBuilderOptions extends CommonSessionBuilderOptions {
+
+	/**
+	 * Signifies that the connection from the original session should be used to create the new session.
+	 *
+	 * @return {@code this}, for method chaining
+	 */
+	CommonSharedSessionBuilderOptions connection();
+
+	/**
+	 * Signifies the interceptor from the original session should be used to create the new session.
+	 *
+	 * @return {@code this}, for method chaining
+	 */
+	CommonSharedSessionBuilderOptions interceptor();
+
+	/**
+	 * Signifies that the SQL {@linkplain org.hibernate.resource.jdbc.spi.StatementInspector statement inspector}
+	 * from the original session should be used.
+	 */
+	CommonSharedSessionBuilderOptions statementInspector();
+
+	/**
+	 * Signifies that no SQL {@linkplain org.hibernate.resource.jdbc.spi.StatementInspector statement inspector}
+	 * should be used.
+	 */
+	CommonSharedSessionBuilderOptions noStatementInspector();
+
+	@Override
+	CommonSharedSessionBuilderOptions interceptor(Interceptor interceptor);
+
+	@Override
+	CommonSharedSessionBuilderOptions noInterceptor();
+
+	@Override
+	CommonSharedSessionBuilderOptions statementInspector(UnaryOperator<String> operator);
+
+	@Override
+	CommonSharedSessionBuilderOptions tenantIdentifier(Object tenantIdentifier);
+}

hibernate-core/src/main/java/org/hibernate/SessionBuilder.java

@@ -18,49 +18,21 @@
  *
  * @see SessionFactory#withOptions()
  */
-public interface SessionBuilder {
+public interface SessionBuilder extends CommonSessionBuilderOptions {
 	/**
 	 * Opens a session with the specified options.
 	 *
 	 * @return The session
 	 */
 	Session openSession();
 
-	/**
-	 * Adds a specific interceptor to the session options.
-	 *
-	 * @param interceptor The interceptor to use.
-	 *
-	 * @return {@code this}, for method chaining
-	 */
+	@Override
 	SessionBuilder interceptor(Interceptor interceptor);
 
-	/**
-	 * Signifies that no {@link Interceptor} should be used.
-	 * <p>
-	 * By default, if no {@code Interceptor} is explicitly specified, the
-	 * {@code Interceptor} associated with the {@link SessionFactory} is
-	 * inherited by the new {@link Session}.
-	 * <p>
-	 * Calling {@link #interceptor(Interceptor)} with null has the same effect.
-	 *
-	 * @return {@code this}, for method chaining
-	 */
+	@Override
 	SessionBuilder noInterceptor();
 
-	/**
-	 * Applies the given statement inspection function to the session.
-	 *
-	 * @param operator An operator which accepts a SQL string, returning
-	 *                 a processed SQL string to be used by Hibernate
-	 *                 instead of the given original SQL. Alternatively.
-	 *                 the operator may work by side effect, and simply
-	 *                 return the original SQL.
-	 *
-	 * @return {@code this}, for method chaining
-	 *
-	 * @since 7.0
-	 */
+	@Override
 	SessionBuilder statementInspector(UnaryOperator<String> operator);
 
 	/**

hibernate-core/src/main/java/org/hibernate/SharedSessionBuilder.java

@@ -18,20 +18,12 @@
  *
  * @see Session#sessionWithOptions()
  */
-public interface SharedSessionBuilder extends SessionBuilder {
+public interface SharedSessionBuilder extends SessionBuilder, CommonSharedSessionBuilderOptions {
 
-	/**
-	 * Signifies that the connection from the original session should be used to create the new session.
-	 *
-	 * @return {@code this}, for method chaining
-	 */
+	@Override
 	SharedSessionBuilder connection();
 
-	/**
-	 * Signifies the interceptor from the original session should be used to create the new session.
-	 *
-	 * @return {@code this}, for method chaining
-	 */
+	@Override
 	SharedSessionBuilder interceptor();
 
 	/**
@@ -76,7 +68,7 @@ public interface SharedSessionBuilder extends SessionBuilder {
 	SharedSessionBuilder statementInspector(StatementInspector statementInspector);
 
 	@Override
-	SessionBuilder statementInspector(UnaryOperator<String> operator);
+	SharedSessionBuilder statementInspector(UnaryOperator<String> operator);
 
 	@Override @Deprecated
 	SharedSessionBuilder connectionHandlingMode(PhysicalConnectionHandlingMode mode);

hibernate-core/src/main/java/org/hibernate/SharedSessionContract.java

@@ -26,6 +26,18 @@
  * @author Steve Ebersole
  */
 public interface SharedSessionContract extends QueryProducer, AutoCloseable, Serializable {
+
+	/**
+	 * Obtain a {@link StatelessSession} builder with the ability to copy certain
+	 * information from this session.
+	 *
+	 * @return the session builder
+	 *
+	 * @since 7.2
+	 */
+	@Incubating
+	SharedStatelessSessionBuilder statelessWithOptions();
+
 	/**
 	 * Obtain the tenant identifier associated with this session, as a string.
 	 *

hibernate-core/src/main/java/org/hibernate/SharedStatelessSessionBuilder.java

@@ -0,0 +1,50 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate;
+
+import java.util.function.UnaryOperator;
+
+/**
+ * Allows for creation of a {@linkplain StatelessSession stateless session} sharing the
+ * underpinnings of another {@linkplain Session stateful} or {@linkplain StatelessSession stateless}
+ * session.
+ *
+ * @see Session#statelessWithOptions()
+ * @see StatelessSession#statelessWithOptions()
+ *
+ * @since 7.2
+ *
+ * @author Steve Ebersole
+ */
+@Incubating
+public interface SharedStatelessSessionBuilder extends CommonSharedSessionBuilderOptions {
+	/**
+	 * Open the stateless session.
+	 */
+	StatelessSession open();
+
+	@Override
+	SharedStatelessSessionBuilder connection();
+
+	@Override
+	SharedStatelessSessionBuilder interceptor();
+
+	@Override
+	SharedStatelessSessionBuilder interceptor(Interceptor interceptor);
+
+	@Override
+	SharedStatelessSessionBuilder noInterceptor();
+
+	SharedStatelessSessionBuilder statementInspector(UnaryOperator<String> operator);
+
+	@Override
+	SharedStatelessSessionBuilder statementInspector();
+
+	@Override
+	SharedStatelessSessionBuilder noStatementInspector();
+
+	@Override
+	SharedStatelessSessionBuilder tenantIdentifier(Object tenantIdentifier);
+}

hibernate-core/src/main/java/org/hibernate/action/internal/EntityIncrementVersionProcess.java

@@ -5,7 +5,7 @@
 package org.hibernate.action.internal;
 
 import org.hibernate.action.spi.BeforeTransactionCompletionProcess;
-import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.internal.OptimisticLockHelper;
 
 /**
@@ -33,9 +33,9 @@ public EntityIncrementVersionProcess(Object object) {
 	 * @param session The session on which the transaction is preparing to complete.
 	 */
 	@Override
-	public void doBeforeTransactionCompletion(SessionImplementor session) {
+	public void doBeforeTransactionCompletion(SharedSessionContractImplementor session) {
 		final var entry = session.getPersistenceContext().getEntry( object );
-		// Don't increment version for an entity that is not in the PersistenceContext;
+		// Don't increment the version for an entity that is not in the PersistenceContext;
 		if ( entry != null ) {
 			OptimisticLockHelper.forceVersionIncrement( object, entry, session.asEventSource() );
 		}

hibernate-core/src/main/java/org/hibernate/action/internal/EntityVerifyVersionProcess.java

@@ -6,7 +6,7 @@
 
 import org.hibernate.action.spi.BeforeTransactionCompletionProcess;
 import org.hibernate.dialect.lock.OptimisticEntityLockException;
-import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.pretty.MessageHelper;
 
 /**
@@ -29,9 +29,9 @@ public EntityVerifyVersionProcess(Object object) {
 	}
 
 	@Override
-	public void doBeforeTransactionCompletion(SessionImplementor session) {
+	public void doBeforeTransactionCompletion(SharedSessionContractImplementor session) {
 		final var entry = session.getPersistenceContext().getEntry( object );
-		// Don't check version for an entity that is not in the PersistenceContext
+		// Don't check the version for an entity that is not in the PersistenceContext
 		if ( entry != null ) {
 			final Object latestVersion = entry.getPersister().getCurrentVersion( entry.getId(), session );
 			if ( !entry.getVersion().equals( latestVersion ) ) {

hibernate-core/src/main/java/org/hibernate/action/spi/AfterTransactionCompletionProcess.java

@@ -4,19 +4,12 @@
  */
 package org.hibernate.action.spi;
 
-import org.hibernate.engine.spi.SharedSessionContractImplementor;
+import org.hibernate.engine.spi.TransactionCompletionCallbacks;
 
 /**
  * Contract representing some process that needs to occur during after transaction completion.
  *
  * @author Steve Ebersole
  */
-public interface AfterTransactionCompletionProcess {
-	/**
-	 * Perform whatever processing is encapsulated here after completion of the transaction.
-	 *
-	 * @param success Did the transaction complete successfully?  True means it did.
-	 * @param session The session on which the transaction is completing.
-	 */
-	void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor session);
+public interface AfterTransactionCompletionProcess extends TransactionCompletionCallbacks.AfterCompletionCallback {
 }

hibernate-core/src/main/java/org/hibernate/action/spi/BeforeTransactionCompletionProcess.java

@@ -5,17 +5,23 @@
 package org.hibernate.action.spi;
 
 import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
+import org.hibernate.engine.spi.TransactionCompletionCallbacks;
 
 /**
  * Contract representing some process that needs to occur during before transaction completion.
  *
  * @author Steve Ebersole
  */
-public interface BeforeTransactionCompletionProcess {
+public interface BeforeTransactionCompletionProcess extends TransactionCompletionCallbacks.BeforeCompletionCallback {
 	/**
 	 * Perform whatever processing is encapsulated here before completion of the transaction.
 	 *
 	 * @param session The session on which the transaction is preparing to complete.
+	 * @deprecated Use {@linkplain #doBeforeTransactionCompletion(SharedSessionContractImplementor)} instead.
 	 */
-	void doBeforeTransactionCompletion(SessionImplementor session);
+	@Deprecated(since = "7.2", forRemoval = true)
+	default void doBeforeTransactionCompletion(SessionImplementor session) {
+		doBeforeTransactionCompletion( (SharedSessionContractImplementor) session );
+	}
 }