HHH-19708 allow regular ConnectionProvider to handle schema/read-only

as requested by @beikov

Author: gavinking

hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/ConnectionProvider.java

@@ -7,6 +7,7 @@
 import java.sql.Connection;
 import java.sql.SQLException;
 
+import org.hibernate.Incubating;
 import org.hibernate.dialect.Dialect;
 import org.hibernate.engine.jdbc.connections.internal.DatabaseConnectionInfoImpl;
 import org.hibernate.engine.jdbc.env.spi.ExtractedDatabaseMetaData;
@@ -40,20 +41,62 @@ public interface ConnectionProvider extends Service, Wrapped {
 	 * @return The obtained JDBC connection
 	 *
 	 * @throws SQLException Indicates a problem opening a connection
-	 * @throws org.hibernate.HibernateException Indicates a problem otherwise obtaining a connection.
+	 * @throws org.hibernate.HibernateException Indicates a problem obtaining a connection.
 	 */
 	Connection getConnection() throws SQLException;
 
+	/**
+	 * Obtains a connection to a read-only replica for use according to the underlying
+	 * strategy of this provider.
+	 *
+	 * @return The obtained JDBC connection
+	 *
+	 * @throws SQLException Indicates a problem opening a connection
+	 * @throws org.hibernate.HibernateException Indicates a problem obtaining a connection.
+	 *
+	 * @implNote This default implementation simply calls {@link #getConnection()},
+	 * which returns a connection to a writable replica. If this operation is overridden
+	 * to return a connection to a distinct read-only replica, the matching operation
+	 * {@link #closeReadOnlyConnection(Connection)} must also be overridden.
+	 *
+	 * @since 7.2
+	 */
+	@Incubating
+	default Connection getReadOnlyConnection() throws SQLException {
+		return getConnection();
+	}
+
 	/**
 	 * Release a connection from Hibernate use.
 	 *
 	 * @param connection The JDBC connection to release
 	 *
 	 * @throws SQLException Indicates a problem closing the connection
-	 * @throws org.hibernate.HibernateException Indicates a problem otherwise releasing a connection.
+	 * @throws org.hibernate.HibernateException Indicates a problem releasing a connection.
 	 */
 	void closeConnection(Connection connection) throws SQLException;
 
+	/**
+	 * Release a connection to a read-only replica from Hibernate use.
+	 *
+	 * @param connection The JDBC connection to release
+	 *
+	 * @throws SQLException Indicates a problem closing the connection
+	 * @throws org.hibernate.HibernateException Indicates a problem otherwise releasing a connection.
+	 *
+	 * @implNote This default implementation simply calls
+	 *           {@link #closeConnection(Connection)}. If
+	 *           {@link #getReadOnlyConnection()} is overridden to return a
+	 *           connection to a distinct read-only replica, this operation must also
+	 *           be overridden.
+	 *
+	 * @since 7.2
+	 */
+	@Incubating
+	default void closeReadOnlyConnection(Connection connection) throws SQLException {
+		closeConnection( connection );
+	}
+
 	/**
 	 * Does this connection provider support aggressive release of JDBC connections and later
 	 * re-acquisition of those connections if needed?
@@ -72,6 +115,34 @@ public interface ConnectionProvider extends Service, Wrapped {
 	 */
 	boolean supportsAggressiveRelease();
 
+	/**
+	 * Does this connection provider correctly set the
+	 * {@linkplain java.sql.Connection#setSchema schema}
+	 * of the returned JDBC connections?
+	 * @return {@code true} if the connection provider handles this;
+	 *         {@code false} if the client should set the schema
+	 *
+	 * @implNote If necessary, a {@code ConnectionProvider} may
+	 * call {@link org.hibernate.context.spi.MultiTenancy#getTenantSchemaMapper}
+	 * to obtain the {@link org.hibernate.context.spi.TenantSchemaMapper}.
+	 */
+	@Incubating
+	default boolean handlesConnectionSchema() {
+		return false;
+	}
+
+	/**
+	 * Does this connection provider correctly set the
+	 * {@linkplain java.sql.Connection#setReadOnly read-only mode}
+	 * of the returned JDBC connections?
+	 * @return {@code true} if the connection provider handles this;
+	 *         {@code false} if the client should set the read-only mode
+	 */
+	@Incubating
+	default boolean handlesConnectionReadOnly() {
+		return false;
+	}
+
 	/**
 	 * @return an informative instance of {@link DatabaseConnectionInfo} for logging.
 	 *

hibernate-core/src/main/java/org/hibernate/engine/jdbc/connections/spi/MultiTenantConnectionProvider.java

@@ -77,8 +77,8 @@ public interface MultiTenantConnectionProvider<T> extends Service, Wrapped {
 	 * @throws org.hibernate.HibernateException Indicates a problem obtaining a connection
 	 *
 	 * @implNote This default implementation simply calls {@link #getConnection(Object)},
-	 * which returns a connection a writable replica. If this operation is overridden to
-	 * return a connection to a distinct read-only replica, the matching operation
+	 * which returns a connection to a writable replica. If this operation is overridden
+	 * to return a connection to a distinct read-only replica, the matching operation
 	 * {@link #releaseReadOnlyConnection(Object, Connection)} must also be overridden.
 	 *
 	 * @since 7.2
@@ -147,7 +147,12 @@ default void releaseReadOnlyConnection(T tenantIdentifier, Connection connection
 	 * of the returned JDBC connections?
 	 * @return {@code true} if the connection provider handles this;
 	 *         {@code false} if the client should set the schema
+	 *
+	 * @implNote If necessary, a {@code ConnectionProvider} may
+	 * call {@link org.hibernate.context.spi.MultiTenancy#getTenantSchemaMapper}
+	 * to obtain the {@link org.hibernate.context.spi.TenantSchemaMapper}.
 	 */
+	@Incubating
 	default boolean handlesConnectionSchema() {
 		return false;
 	}
@@ -159,6 +164,7 @@ default boolean handlesConnectionSchema() {
 	 * @return {@code true} if the connection provider handles this;
 	 *         {@code false} if the client should set the read-only mode
 	 */
+	@Incubating
 	default boolean handlesConnectionReadOnly() {
 		return false;
 	}

hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java

@@ -693,6 +693,7 @@ public JdbcConnectionAccess getJdbcConnectionAccess() {
 			if ( !factoryOptions.isMultiTenancyEnabled() ) {
 				// we might still be using schema-based multitenancy
 				jdbcConnectionAccess = new NonContextualJdbcConnectionAccess(
+						readOnly,
 						sessionEventsManager,
 						factory.connectionProvider,
 						this
@@ -713,13 +714,11 @@ public JdbcConnectionAccess getJdbcConnectionAccess() {
 	}
 
 	private boolean manageReadOnly() {
-		return factory.multiTenantConnectionProvider == null
-			|| !factory.multiTenantConnectionProvider.handlesConnectionReadOnly();
+		return !factory.connectionProviderHandlesConnectionReadOnly();
 	}
 
 	private boolean manageSchema() {
-		return factory.multiTenantConnectionProvider == null
-			|| !factory.multiTenantConnectionProvider.handlesConnectionSchema();
+		return !factory.connectionProviderHandlesConnectionSchema();
 	}
 
 	private boolean useSchemaBasedMultiTenancy() {

hibernate-core/src/main/java/org/hibernate/internal/NonContextualJdbcConnectionAccess.java

@@ -18,16 +18,19 @@
  * @author Steve Ebersole
  */
 public class NonContextualJdbcConnectionAccess implements JdbcConnectionAccess, Serializable {
+	private final boolean readOnly;
 	private final SessionEventListener listener;
 	private final ConnectionProvider connectionProvider;
 	private final SharedSessionContractImplementor session;
 
 	public NonContextualJdbcConnectionAccess(
+			boolean readOnly,
 			SessionEventListener listener,
 			ConnectionProvider connectionProvider,
 			SharedSessionContractImplementor session) {
 		Objects.requireNonNull( listener );
 		Objects.requireNonNull( connectionProvider );
+		this.readOnly = readOnly;
 		this.listener = listener;
 		this.connectionProvider = connectionProvider;
 		this.session = session;
@@ -39,7 +42,9 @@ public Connection obtainConnection() throws SQLException {
 		final var connectionAcquisitionEvent = eventMonitor.beginJdbcConnectionAcquisitionEvent();
 		try {
 			listener.jdbcConnectionAcquisitionStart();
-			return connectionProvider.getConnection();
+			return readOnly
+					? connectionProvider.getReadOnlyConnection()
+					: connectionProvider.getConnection();
 		}
 		finally {
 			eventMonitor.completeJdbcConnectionAcquisitionEvent( connectionAcquisitionEvent, session, null );
@@ -53,7 +58,12 @@ public void releaseConnection(Connection connection) throws SQLException {
 		final var connectionReleaseEvent = eventMonitor.beginJdbcConnectionReleaseEvent();
 		try {
 			listener.jdbcConnectionReleaseStart();
-			connectionProvider.closeConnection( connection );
+			if ( readOnly ) {
+				connectionProvider.closeReadOnlyConnection( connection );
+			}
+			else {
+				connectionProvider.closeConnection( connection );
+			}
 		}
 		finally {
 			eventMonitor.completeJdbcConnectionReleaseEvent( connectionReleaseEvent, session, null );

hibernate-core/src/main/java/org/hibernate/internal/SessionFactoryImpl.java

@@ -1581,6 +1581,17 @@ public JavaType<Object> getTenantIdentifierJavaType() {
 		return tenantIdentifierJavaType;
 	}
 
+	boolean connectionProviderHandlesConnectionReadOnly() {
+		return multiTenantConnectionProvider != null
+				? multiTenantConnectionProvider.handlesConnectionReadOnly()
+				: connectionProvider.handlesConnectionReadOnly();
+	}
+
+	boolean connectionProviderHandlesConnectionSchema() {
+		return multiTenantConnectionProvider != null
+				? multiTenantConnectionProvider.handlesConnectionSchema()
+				: connectionProvider.handlesConnectionSchema();
+	}
 
 	// Serialization handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~