Align with R2DBC 0.9 API changes

Adopt to R2DBC Parameter type, deprecate our own one in favor of the R2DBC type.
Add support for extensible transaction definitions and support to consume Readable and result segments.
Return Long instead of Integer in DatabaseClient update in preparation for R2DBC 1.0 changes.

Author: mp911de

build.gradle

@@ -346,7 +346,7 @@ configure([rootProject] + javaProjects) { project ->
 			// "https://junit.org/junit5/docs/5.8.2/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
-			"https://r2dbc.io/spec/0.8.5.RELEASE/api/",
+			"https://r2dbc.io/spec/0.9.1.RELEASE/api/",
 			// The external Javadoc link for JSR 305 must come last to ensure that types from
 			// JSR 250 (such as @PostConstruct) are still supported. This is due to the fact
 			// that JSR 250 and JSR 305 both define types in javax.annotation, which results

spring-r2dbc/src/main/java/org/springframework/r2dbc/connection/R2dbcTransactionManager.java

@@ -21,8 +21,10 @@
 import io.r2dbc.spi.Connection;
 import io.r2dbc.spi.ConnectionFactory;
 import io.r2dbc.spi.IsolationLevel;
+import io.r2dbc.spi.Option;
 import io.r2dbc.spi.R2dbcException;
 import io.r2dbc.spi.Result;
+import org.reactivestreams.Publisher;
 import reactor.core.publisher.Mono;
 
 import org.springframework.beans.factory.InitializingBean;
@@ -47,7 +49,7 @@
  * <p><b>Note: The {@code ConnectionFactory} that this transaction manager
  * operates on needs to return independent {@code Connection}s.</b>
  * The {@code Connection}s may come from a pool (the typical case), but the
- * {@code ConnectionFactory} must not return scoped scoped {@code Connection}s
+ * {@code ConnectionFactory} must not return scoped {@code Connection}s
  * or the like. This transaction manager will associate {@code Connection}
  * with context-bound transactions itself, according to the specified propagation
  * behavior. It assumes that a separate, independent {@code Connection} can
@@ -72,6 +74,11 @@
  * synchronizations (if synchronization is generally active), assuming resources
  * operating on the underlying R2DBC {@code Connection}.
  *
+ * <p>Spring's {@code TransactionDefinition} attributes are carried forward to R2DBC drivers
+ * using extensible R2DBC {@link io.r2dbc.spi.TransactionDefinition}. Subclasses may
+ * override {@link #createTransactionDefinition(TransactionDefinition)} to customize
+ * transaction definitions for vendor-specific attributes.
+ *
  * @author Mark Paluch
  * @since 5.3
  * @see ConnectionFactoryUtils#getConnection(ConnectionFactory)
@@ -203,7 +210,8 @@ protected Mono<Void> doBegin(TransactionSynchronizationManager synchronizationMa
 			}
 
 			return connectionMono.flatMap(con -> {
-				return prepareTransactionalConnection(con, definition, transaction).then(Mono.from(con.beginTransaction()))
+				return prepareTransactionalConnection(con, definition, transaction)
+						.then(Mono.from(doBegin(definition, con)))
 						.doOnSuccess(v -> {
 							txObject.getConnectionHolder().setTransactionActive(true);
 							Duration timeout = determineTimeout(definition);
@@ -230,6 +238,31 @@ protected Mono<Void> doBegin(TransactionSynchronizationManager synchronizationMa
 		}).then();
 	}
 
+	private Publisher<Void> doBegin(TransactionDefinition definition, Connection con) {
+		io.r2dbc.spi.TransactionDefinition transactionDefinition = createTransactionDefinition(definition);
+		if (logger.isDebugEnabled()) {
+			logger.debug("Starting R2DBC transaction on Connection [" + con + "] using [" + transactionDefinition + "]");
+		}
+		return con.beginTransaction(transactionDefinition);
+	}
+
+	/**
+	 * Determine the transaction definition from our {@code TransactionDefinition}.
+	 * Can be overridden to wrap the R2DBC {@code TransactionDefinition} to adjust or
+	 * enhance transaction attributes.
+	 * @param definition the transaction definition
+	 * @return the actual transaction definition to use
+	 * @since 6.0
+	 * @see io.r2dbc.spi.TransactionDefinition
+	 */
+	protected io.r2dbc.spi.TransactionDefinition createTransactionDefinition(TransactionDefinition definition) {
+		// Apply specific isolation level, if any.
+		IsolationLevel isolationLevelToUse = resolveIsolationLevel(definition.getIsolationLevel());
+		return new ExtendedTransactionDefinition(definition.getName(), definition.isReadOnly(),
+				definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ? isolationLevelToUse : null,
+				determineTimeout(definition));
+	}
+
 	/**
 	 * Determine the actual timeout to use for the given definition.
 	 * Will fall back to this manager's default timeout if the
@@ -375,21 +408,6 @@ protected Mono<Void> prepareTransactionalConnection(
 					.then();
 		}
 
-		// Apply specific isolation level, if any.
-		IsolationLevel isolationLevelToUse = resolveIsolationLevel(definition.getIsolationLevel());
-		if (isolationLevelToUse != null && definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
-
-			if (logger.isDebugEnabled()) {
-				logger.debug("Changing isolation level of R2DBC Connection [" + con + "] to " + isolationLevelToUse.asSql());
-			}
-			IsolationLevel currentIsolation = con.getTransactionIsolationLevel();
-			if (!currentIsolation.asSql().equalsIgnoreCase(isolationLevelToUse.asSql())) {
-
-				txObject.setPreviousIsolationLevel(currentIsolation);
-				prepare = prepare.then(Mono.from(con.setTransactionIsolationLevel(isolationLevelToUse)));
-			}
-		}
-
 		// Switch to manual commit if necessary. This is very expensive in some R2DBC drivers,
 		// so we don't want to do it unnecessarily (for example if we've explicitly
 		// configured the connection pool to set it already).
@@ -436,6 +454,62 @@ protected RuntimeException translateException(String task, R2dbcException ex) {
 	}
 
 
+	/**
+	 * Extended R2DBC transaction definition object providing transaction attributes
+	 * to R2DBC drivers when starting a transaction.
+	 */
+	private record ExtendedTransactionDefinition(@Nullable String transactionName,
+												boolean readOnly,
+												@Nullable IsolationLevel isolationLevel,
+												Duration lockWaitTimeout) implements io.r2dbc.spi.TransactionDefinition {
+
+		private ExtendedTransactionDefinition(@Nullable String transactionName, boolean readOnly,
+				@Nullable IsolationLevel isolationLevel, Duration lockWaitTimeout) {
+			this.transactionName = transactionName;
+			this.readOnly = readOnly;
+			this.isolationLevel = isolationLevel;
+			this.lockWaitTimeout = lockWaitTimeout;
+		}
+
+
+		@Override
+		@SuppressWarnings("unchecked")
+		public <T> T getAttribute(Option<T> option) {
+			return (T) doGetValue(option);
+		}
+
+		@Nullable
+		private Object doGetValue(Option<?> option) {
+			if (io.r2dbc.spi.TransactionDefinition.ISOLATION_LEVEL.equals(option)) {
+				return this.isolationLevel;
+			}
+			if (io.r2dbc.spi.TransactionDefinition.NAME.equals(option)) {
+				return this.transactionName;
+			}
+			if (io.r2dbc.spi.TransactionDefinition.READ_ONLY.equals(option)) {
+				return this.readOnly;
+			}
+			if (io.r2dbc.spi.TransactionDefinition.LOCK_WAIT_TIMEOUT.equals(option)
+				&& !this.lockWaitTimeout.isZero()) {
+				return this.lockWaitTimeout;
+			}
+			return null;
+		}
+
+		@Override
+		public String toString() {
+			StringBuilder sb = new StringBuilder();
+			sb.append(getClass().getSimpleName());
+			sb.append(" [transactionName='").append(this.transactionName).append('\'');
+			sb.append(", readOnly=").append(this.readOnly);
+			sb.append(", isolationLevel=").append(this.isolationLevel);
+			sb.append(", lockWaitTimeout=").append(this.lockWaitTimeout);
+			sb.append(']');
+			return sb.toString();
+		}
+	}
+
+
 	/**
 	 * ConnectionFactory transaction object, representing a ConnectionHolder.
 	 * Used as transaction object by R2dbcTransactionManager.

spring-r2dbc/src/main/java/org/springframework/r2dbc/core/BindParameterSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2020 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 package org.springframework.r2dbc.core;
 
-import org.springframework.lang.Nullable;
+import io.r2dbc.spi.Parameter;
 
 /**
  * Interface that defines common functionality for objects
@@ -44,24 +44,13 @@ interface BindParameterSource {
 	boolean hasValue(String paramName);
 
 	/**
-	 * Return the parameter value for the requested named parameter.
+	 * Return the parameter for the requested named parameter.
 	 * @param paramName the name of the parameter
-	 * @return the value of the specified parameter (can be {@code null})
+	 * @return the specified parameter
 	 * @throws IllegalArgumentException if there is no value
 	 * for the requested parameter
 	 */
-	@Nullable
-	Object getValue(String paramName) throws IllegalArgumentException;
-
-	/**
-	 * Determine the type for the specified named parameter.
-	 * @param paramName the name of the parameter
-	 * @return the type of the specified parameter, or
-	 * {@link Object#getClass()} if not known.
-	 */
-	default Class<?> getType(String paramName) {
-		return Object.class;
-	}
+	Parameter getValue(String paramName) throws IllegalArgumentException;
 
 	/**
 	 * Return the parameter names of the underlying parameter source.

spring-r2dbc/src/main/java/org/springframework/r2dbc/core/ColumnMapRowMapper.java

@@ -16,7 +16,7 @@
 
 package org.springframework.r2dbc.core;
 
-import java.util.Collection;
+import java.util.List;
 import java.util.Map;
 import java.util.function.BiFunction;
 
@@ -55,12 +55,12 @@ public class ColumnMapRowMapper implements BiFunction<Row, RowMetadata, Map<Stri
 	@SuppressWarnings("deprecation")  // getColumnNames() is deprecated as of R2DBC 0.9
 	@Override
 	public Map<String, Object> apply(Row row, RowMetadata rowMetadata) {
-		Collection<String> columns = rowMetadata.getColumnNames();
+		List<? extends ColumnMetadata> columns = rowMetadata.getColumnMetadatas();
 		int columnCount = columns.size();
 		Map<String, Object> mapOfColValues = createColumnMap(columnCount);
 		int index = 0;
-		for (String column : columns) {
-			String key = getColumnKey(column);
+		for (ColumnMetadata column : columns) {
+			String key = getColumnKey(column.getName());
 			Object obj = getColumnValue(row, index++);
 			mapOfColValues.put(key, obj);
 		}

spring-r2dbc/src/main/java/org/springframework/r2dbc/core/DatabaseClient.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2020 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,12 +20,17 @@
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 import io.r2dbc.spi.ConnectionFactory;
+import io.r2dbc.spi.Readable;
+import io.r2dbc.spi.Result;
 import io.r2dbc.spi.Row;
 import io.r2dbc.spi.RowMetadata;
 import io.r2dbc.spi.Statement;
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import org.springframework.r2dbc.core.binding.BindMarkersFactory;
@@ -157,9 +162,9 @@ interface GenericExecuteSpec {
 
 		/**
 		 * Bind a non-{@code null} value to a parameter identified by its
-		 * {@code index}. {@code value} can be either a scalar value or {@link Parameter}.
+		 * {@code index}. {@code value} can be either a scalar value or {@link io.r2dbc.spi.Parameter}.
 		 * @param index zero based index to bind the parameter to
-		 * @param value either a scalar value or {@link Parameter}
+		 * @param value either a scalar value or {@link io.r2dbc.spi.Parameter}
 		 */
 		GenericExecuteSpec bind(int index, Object value);
 
@@ -213,14 +218,12 @@ default GenericExecuteSpec filter(Function<? super Statement, ? extends Statemen
 
 		/**
 		 * Configure a result mapping {@link Function function} and enter the execution stage.
-		 * @param mappingFunction a function that maps from {@link Row} to the result type
+		 * @param mappingFunction a function that maps from {@link Readable} to the result type
 		 * @param <R> the result type
 		 * @return a {@link FetchSpec} for configuration what to fetch
+		 * @since 6.0
 		 */
-		default <R> RowsFetchSpec<R> map(Function<Row, R> mappingFunction) {
-			Assert.notNull(mappingFunction, "Mapping function must not be null");
-			return map((row, rowMetadata) -> mappingFunction.apply(row));
-		}
+		<R> RowsFetchSpec<R> map(Function<? super Readable, R> mappingFunction);
 
 		/**
 		 * Configure a result mapping {@link BiFunction function} and enter the execution stage.
@@ -231,6 +234,17 @@ default <R> RowsFetchSpec<R> map(Function<Row, R> mappingFunction) {
 		 */
 		<R> RowsFetchSpec<R> map(BiFunction<Row, RowMetadata, R> mappingFunction);
 
+		/**
+		 * Perform the SQL call and apply {@link BiFunction function} to the {@link  Result}.
+		 * @param mappingFunction a function that maps from {@link Result} into a result publisher
+		 * @param <R> the result type
+		 * @return a {@link Flux} emitting mapped elements
+		 * @since 6.0
+		 * @see Result#filter(Predicate)
+		 * @see Result#flatMap(Function)
+		 */
+		<R> Flux<R> flatMap(Function<Result, Publisher<R>> mappingFunction);
+
 		/**
 		 * Perform the SQL call and retrieve the result by entering the execution stage.
 		 */