HHH-19602 - Adjust JdbcOperation to allow more-than-one statement

HHH-19513 - Follow-on locking does not lock element-collection tables
HHH-19782 - Oracle support for locking across joins

# Conflicts:
#	hibernate-core/src/main/java/org/hibernate/sql/results/jdbc/internal/DeferredResultSetAccess.java
#	hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java

Author: sebersole

hibernate-core/src/main/java/org/hibernate/dialect/function/NumberSeriesGenerateSeriesFunction.java

@@ -48,7 +48,7 @@
 import org.hibernate.sql.ast.tree.predicate.PredicateContainer;
 import org.hibernate.sql.ast.tree.select.QuerySpec;
 import org.hibernate.sql.ast.tree.select.SelectStatement;
-import org.hibernate.sql.exec.spi.JdbcOperationQuerySelect;
+import org.hibernate.sql.exec.internal.JdbcOperationQuerySelect;
 import org.hibernate.sql.results.internal.SqlSelectionImpl;
 import org.hibernate.type.BasicType;
 import org.hibernate.type.SqlTypes;

hibernate-core/src/main/java/org/hibernate/dialect/lock/internal/Helper.java

@@ -15,9 +15,15 @@
 import java.util.function.Function;
 
 /**
+ * Helper for dealing with {@linkplain Connection}-level lock timeouts.
+ *
  * @author Steve Ebersole
  */
 public class Helper {
+	/**
+	 * Use the given {@code sql} statement to query the current lock-timeout for the
+	 * {@linkplain Connection} and use the {@code extractor} to process the value.
+	 */
 	public static Timeout getLockTimeout(
 			String sql,
 			TimeoutExtractor extractor,
@@ -37,15 +43,13 @@ public static Timeout getLockTimeout(
 		}
 	}
 
+	/**
+	 * Set the {@linkplain Connection}-level lock-timeout using the given {@code sql} command.
+	 */
 	public static void setLockTimeout(
-			Timeout timeout,
-			Function<Timeout,Integer> valueStrategy,
-			String sqlFormat,
+			String sql,
 			Connection connection,
 			SessionFactoryImplementor factory) {
-		final int milliseconds = valueStrategy.apply( timeout );
-
-		final String sql = String.format( sqlFormat, milliseconds );
 		try (final java.sql.Statement statement = connection.createStatement()) {
 			factory.getJdbcServices().getSqlStatementLogger().logStatement( sql );
 			statement.execute( sql );
@@ -56,6 +60,39 @@ public static void setLockTimeout(
 		}
 	}
 
+	/**
+	 * Set the {@linkplain Connection}-level lock-timeout using
+	 * the given {@code sqlFormat} (with a single format placeholder
+	 * for the {@code milliseconds} value).
+	 *
+	 * @see #setLockTimeout(String, Connection, SessionFactoryImplementor)
+	 */
+	public static void setLockTimeout(
+			Integer milliseconds,
+			String sqlFormat,
+			Connection connection,
+			SessionFactoryImplementor factory) {
+		final String sql = String.format( sqlFormat, milliseconds );
+		setLockTimeout( sql, connection, factory );
+	}
+
+	/**
+	 * Set the {@linkplain Connection}-level lock-timeout.  The passed
+	 * {@code valueStrategy} is used to interpret the {@code timeout}
+	 * which is then used with {@code sqlFormat} to execute the command.
+	 *
+	 * @see #setLockTimeout(Integer, String, Connection, SessionFactoryImplementor)
+	 */
+	public static void setLockTimeout(
+			Timeout timeout,
+			Function<Timeout,Integer> valueStrategy,
+			String sqlFormat,
+			Connection connection,
+			SessionFactoryImplementor factory) {
+		final int milliseconds = valueStrategy.apply( timeout );
+		setLockTimeout( milliseconds, sqlFormat, connection, factory );
+	}
+
 	@FunctionalInterface
 	public interface TimeoutExtractor {
 		Timeout extractFrom(ResultSet resultSet) throws SQLException;

hibernate-core/src/main/java/org/hibernate/dialect/lock/internal/OracleLockingSupport.java

@@ -61,7 +61,9 @@ public RowLockStrategy getWriteRowLockStrategy() {
 
 	@Override
 	public OuterJoinLockingType getOuterJoinLockingType() {
-		return OuterJoinLockingType.UNSUPPORTED;
+		// Per Loic, as of 23 at least, Oracle does support this.
+		// Let's see what CI says for previous supported versions.
+		return OuterJoinLockingType.IDENTIFIED;
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/dialect/lock/internal/SqlAstBasedLockingStrategy.java

@@ -8,6 +8,7 @@
 import org.hibernate.LockOptions;
 import org.hibernate.Locking;
 import org.hibernate.StaleObjectStateException;
+import org.hibernate.collection.spi.PersistentCollection;
 import org.hibernate.dialect.lock.LockingStrategy;
 import org.hibernate.dialect.lock.LockingStrategyException;
 import org.hibernate.dialect.lock.PessimisticEntityLockException;
@@ -23,6 +24,7 @@
 import org.hibernate.metamodel.mapping.SelectableMapping;
 import org.hibernate.persister.entity.EntityPersister;
 import org.hibernate.query.sqm.ComparisonOperator;
+import org.hibernate.query.sqm.mutation.internal.SqmMutationStrategyHelper;
 import org.hibernate.spi.NavigablePath;
 import org.hibernate.sql.ast.spi.SimpleFromClauseAccessImpl;
 import org.hibernate.sql.ast.spi.SqlAliasBaseManager;
@@ -34,8 +36,9 @@
 import org.hibernate.sql.exec.internal.JdbcParameterBindingImpl;
 import org.hibernate.sql.exec.internal.JdbcParameterBindingsImpl;
 import org.hibernate.sql.exec.internal.JdbcParameterImpl;
-import org.hibernate.sql.exec.spi.JdbcOperationQuerySelect;
+import org.hibernate.sql.exec.internal.lock.LockingHelper;
 import org.hibernate.sql.exec.spi.JdbcParameterBindings;
+import org.hibernate.sql.exec.spi.JdbcSelect;
 import org.hibernate.sql.exec.spi.JdbcSelectExecutor;
 import org.hibernate.sql.results.graph.basic.BasicResult;
 import org.hibernate.sql.results.graph.internal.ImmutableFetchList;
@@ -157,7 +160,7 @@ public void lock(
 		}
 
 		final SelectStatement selectStatement = new SelectStatement( rootQuerySpec, List.of( idResult ) );
-		final JdbcOperationQuerySelect selectOperation = session
+		final JdbcSelect selectOperation = session
 				.getDialect()
 				.getSqlAstTranslatorFactory()
 				.buildSelectTranslator( factory, selectStatement )
@@ -176,6 +179,19 @@ public void lock(
 					1,
 					SingleResultConsumer.instance()
 			);
+
+			if ( lockOptions.getScope() == Locking.Scope.INCLUDE_COLLECTIONS ) {
+				SqmMutationStrategyHelper.visitCollectionTables( entityToLock, (attribute) -> {
+					final PersistentCollection<?> collectionToLock = (PersistentCollection<?>) attribute.getValue( object );
+					LockingHelper.lockCollectionTable(
+							attribute,
+							lockMode,
+							lockOptions.getTimeout(),
+							collectionToLock,
+							lockingExecutionContext
+					);
+				} );
+			}
 		}
 		catch (LockTimeoutException e) {
 			throw new PessimisticEntityLockException(

hibernate-core/src/main/java/org/hibernate/dialect/lock/internal/TransactSQLLockingSupport.java

@@ -41,17 +41,17 @@ public class TransactSQLLockingSupport extends LockingSupportParameterized {
 			LockTimeoutType.NONE,
 			RowLockStrategy.TABLE,
 			OuterJoinLockingType.IDENTIFIED,
-			ConnectionLockTimeoutStrategy.NONE
+			SybaseImpl.IMPL
 	);
 
 	public static final LockingSupport SYBASE_ASE = new TransactSQLLockingSupport(
-			PessimisticLockStyle.NONE,
+			PessimisticLockStyle.TABLE_HINT,
 			LockTimeoutType.CONNECTION,
 			LockTimeoutType.NONE,
 			LockTimeoutType.NONE,
 			RowLockStrategy.TABLE,
 			OuterJoinLockingType.IDENTIFIED,
-			ConnectionLockTimeoutStrategy.NONE
+			SybaseImpl.IMPL
 	);
 
 	public static final LockingSupport SYBASE_LEGACY = new TransactSQLLockingSupport(
@@ -61,7 +61,7 @@ public class TransactSQLLockingSupport extends LockingSupportParameterized {
 			LockTimeoutType.NONE,
 			RowLockStrategy.TABLE,
 			OuterJoinLockingType.IDENTIFIED,
-			ConnectionLockTimeoutStrategy.NONE
+			SybaseImpl.IMPL
 	);
 
 	public static LockingSupport forSybaseAnywhere(DatabaseVersion version) {
@@ -76,7 +76,7 @@ public static LockingSupport forSybaseAnywhere(DatabaseVersion version) {
 						? RowLockStrategy.COLUMN
 						: RowLockStrategy.TABLE,
 				OuterJoinLockingType.IDENTIFIED,
-				ConnectionLockTimeoutStrategy.NONE
+				SybaseImpl.IMPL
 		);
 	}
 
@@ -111,13 +111,13 @@ public static class SQLServerImpl implements ConnectionLockTimeoutStrategy {
 
 		@Override
 		public Level getSupportedLevel() {
-			return ConnectionLockTimeoutStrategy.Level.EXTENDED;
+			return Level.EXTENDED;
 		}
 
 		@Override
 		public Timeout getLockTimeout(Connection connection, SessionFactoryImplementor factory) {
 			return Helper.getLockTimeout(
-					"select @@LOCK_TIMEOUT",
+					"select @@lock_timeout",
 					(resultSet) -> {
 						final int timeoutInMilliseconds = resultSet.getInt( 1 );
 						return switch ( timeoutInMilliseconds ) {
@@ -148,4 +148,56 @@ public void setLockTimeout(Timeout timeout, Connection connection, SessionFactor
 			);
 		}
 	}
+
+	public static class SybaseImpl implements ConnectionLockTimeoutStrategy {
+		public static final SybaseImpl IMPL = new SybaseImpl();
+
+		@Override
+		public Level getSupportedLevel() {
+			return Level.SUPPORTED;
+		}
+
+		@Override
+		public Timeout getLockTimeout(Connection connection, SessionFactoryImplementor factory) {
+			return Helper.getLockTimeout(
+					"select @@lock_timeout",
+					(resultSet) -> {
+						final int timeoutInMilliseconds = resultSet.getInt( 1 );
+						return switch ( timeoutInMilliseconds ) {
+							case -1 -> Timeouts.WAIT_FOREVER;
+							case 0 -> Timeouts.NO_WAIT;
+							default -> Timeout.milliseconds( timeoutInMilliseconds );
+						};
+					},
+					connection,
+					factory
+			);
+		}
+
+		@Override
+		public void setLockTimeout(Timeout timeout, Connection connection, SessionFactoryImplementor factory) {
+			final int milliseconds = timeout.milliseconds();
+
+			if ( milliseconds == Timeouts.SKIP_LOCKED_MILLI ) {
+				throw new HibernateException( "Sybase does not accept skip-locked for lock-timeout" );
+			}
+
+			// Sybase needs a special syntax for NO_WAIT rather than a number
+			if ( milliseconds == Timeouts.NO_WAIT_MILLI ) {
+				// NOTE: The docs say this is supported, and it does not fail when used,
+				// but immediately after the setting value is still -1.  So it seems to
+				// allow the call but ignore it.  Might just be jTDS.
+				Helper.setLockTimeout( "set lock nowait", connection, factory );
+			}
+			else if ( milliseconds == Timeouts.WAIT_FOREVER_MILLI ) {
+				// Even though Sybase's wait-forever (and default) value is -1, it won't accept
+				// -1 as a value because, well, of course it won't.  Need to set max value instead
+				// because, well, of course you do.
+				Helper.setLockTimeout( 2147483647, "set lock wait %s", connection, factory );
+			}
+			else {
+				Helper.setLockTimeout( milliseconds, "set lock wait %s", connection, factory );
+			}
+		}
+	}
 }

hibernate-core/src/main/java/org/hibernate/dialect/sql/ast/OracleSqlAstTranslator.java

@@ -190,7 +190,9 @@ else if ( followOnStrategy == Locking.FollowOn.IGNORE ) {
 			}
 		}
 
-		if ( strategy != LockStrategy.FOLLOW_ON && needsLockingWrapper( querySpec ) && !canApplyLockingWrapper( querySpec ) ) {
+		if ( strategy != LockStrategy.FOLLOW_ON
+				&& needsLockingWrapper( querySpec, followOnStrategy )
+				&& !canApplyLockingWrapper( querySpec ) ) {
 			if ( followOnStrategy == Locking.FollowOn.DISALLOW ) {
 				throw new IllegalQueryOperationException( "Locking with OFFSET/FETCH is not supported" );
 			}
@@ -317,7 +319,11 @@ public void visitQueryGroup(QueryGroup queryGroup) {
 
 	@Override
 	public void visitQuerySpec(QuerySpec querySpec) {
-		final EntityIdentifierMapping identifierMappingForLockingWrapper = identifierMappingForLockingWrapper( querySpec );
+		final LockOptions lockOptions = getLockOptions();
+		final Locking.FollowOn followOnStrategy = lockOptions == null
+				? Locking.FollowOn.ALLOW
+				: lockOptions.getFollowOnStrategy();
+		final EntityIdentifierMapping identifierMappingForLockingWrapper = identifierMappingForLockingWrapper( querySpec, followOnStrategy );
 		final Expression offsetExpression;
 		final Expression fetchExpression;
 		final FetchClauseType fetchClauseType;
@@ -423,13 +429,13 @@ private QuerySpec createLockingWrapper(
 		return lockingWrapper;
 	}
 
-	private EntityIdentifierMapping identifierMappingForLockingWrapper(QuerySpec querySpec) {
+	private EntityIdentifierMapping identifierMappingForLockingWrapper(QuerySpec querySpec, Locking.FollowOn followOnStrategy) {
 		// We only need a locking wrapper for very simple queries
 		if ( canApplyLockingWrapper( querySpec )
 				// There must be the need for locking in this query
 				&& needsLocking( querySpec )
 				// The query uses some sort of pagination which makes the wrapper necessary
-				&& needsLockingWrapper( querySpec )
+				&& needsLockingWrapper( querySpec, followOnStrategy )
 				// The query may not have a group by, having and distinct clause, or use aggregate functions,
 				// as these features will force the use of follow-on locking
 				&& querySpec.getGroupByClauseExpressions().isEmpty()
@@ -450,9 +456,8 @@ private boolean canApplyLockingWrapper(QuerySpec querySpec) {
 				&& fromClause.getRoots().get( 0 ).getModelPart() instanceof EntityMappingType;
 	}
 
-	private boolean needsLockingWrapper(QuerySpec querySpec) {
-		final LockOptions lockOptions = getLockOptions();
-		if ( lockOptions.getFollowOnStrategy() == Locking.FollowOn.FORCE ) {
+	private boolean needsLockingWrapper(QuerySpec querySpec, Locking.FollowOn followOnStrategy) {
+		if ( followOnStrategy == Locking.FollowOn.FORCE ) {
 			// user explicitly asked for follow-on locking
 			return false;
 		}

hibernate-core/src/main/java/org/hibernate/dialect/sql/ast/SybaseASESqlAstTranslator.java

@@ -229,9 +229,6 @@ public static String determineLockHint(LockMode lockMode, int effectiveLockTimeo
 	protected LockStrategy determineLockingStrategy(
 			QuerySpec querySpec,
 			Locking.FollowOn followOnStrategy) {
-		if ( followOnStrategy == Locking.FollowOn.FORCE ) {
-			return LockStrategy.FOLLOW_ON;
-		}
 		// No need for follow on locking
 		return LockStrategy.CLAUSE;
 	}

hibernate-core/src/main/java/org/hibernate/dialect/sql/ast/SybaseSqlAstTranslator.java

@@ -187,9 +187,6 @@ public static String determineLockHint(LockMode lockMode) {
 	protected LockStrategy determineLockingStrategy(
 			QuerySpec querySpec,
 			Locking.FollowOn followOnStrategy) {
-		if ( followOnStrategy == Locking.FollowOn.FORCE ) {
-			return LockStrategy.FOLLOW_ON;
-		}
 		// No need for follow on locking
 		return LockStrategy.CLAUSE;
 	}

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

@@ -17,7 +17,7 @@
 import org.hibernate.sql.exec.internal.StandardJdbcMutationExecutor;
 import org.hibernate.sql.exec.spi.JdbcMutationExecutor;
 import org.hibernate.sql.exec.spi.JdbcOperationQueryMutation;
-import org.hibernate.sql.exec.spi.JdbcOperationQuerySelect;
+import org.hibernate.sql.exec.internal.JdbcOperationQuerySelect;
 import org.hibernate.sql.exec.spi.JdbcSelectExecutor;
 
 /**