#124 - Remove deprecated DatabaseClient.execute().sql(…) and TransactionalDatabaseClient.

Author: mp911de

src/main/asciidoc/reference/r2dbc-core.adoc

@@ -139,7 +139,7 @@ public class R2dbcApp {
 
     DatabaseClient client = DatabaseClient.create(connectionFactory);
 
-    client.sql("CREATE TABLE person" +
+    client.execute("CREATE TABLE person" +
         "(id VARCHAR(255) PRIMARY KEY," +
         "name VARCHAR(255)," +
         "age INT)")

src/main/asciidoc/reference/r2dbc-sql.adoc

@@ -6,15 +6,15 @@ The following example shows what you need to include for minimal but fully funct
 
 [source,java]
 ----
-Mono<Void> completion = client.sql("CREATE TABLE person (id VARCHAR(255) PRIMARY KEY, name VARCHAR(255), age INTEGER);")
+Mono<Void> completion = client.execute("CREATE TABLE person (id VARCHAR(255) PRIMARY KEY, name VARCHAR(255), age INTEGER);")
         .then();
 ----
 
 `DatabaseClient` is designed for a convenient fluent usage.
 It exposes intermediate, continuation, and terminal methods at each stage of the execution specification.
 The example above uses `then()` to return a completion `Publisher` that completes as soon as the query (or queries, if the SQL query contains multiple statements) completes.
 
-NOTE: `sql(…)` accepts either the SQL query string or a query `Supplier<String>` to defer the actual query creation until execution.
+NOTE: `execute(…)` accepts either the SQL query string or a query `Supplier<String>` to defer the actual query creation until execution.
 
 [[r2dbc.datbaseclient.queries]]
 == Running Queries
@@ -26,7 +26,7 @@ The following example shows an `UPDATE` statement that returns the number of upd
 
 [source,java]
 ----
-Mono<Integer> affectedRows = client.sql("UPDATE person SET name = 'Joe'")
+Mono<Integer> affectedRows = client.execute("UPDATE person SET name = 'Joe'")
         .fetch().rowsUpdated();
 ----
 
@@ -36,7 +36,7 @@ You might have noticed the use of `fetch()` in the previous example.
 
 [source,java]
 ----
-Mono<Map<String, Object>> first = client.sql("SELECT id, name FROM person")
+Mono<Map<String, Object>> first = client.execute("SELECT id, name FROM person")
         .fetch().first();
 ----
 
@@ -52,7 +52,7 @@ You can consume data with the following operators:
 
 [source,java]
 ----
-Flux<Person> all = client.sql("SELECT id, name FROM mytable")
+Flux<Person> all = client.execute("SELECT id, name FROM mytable")
         .as(Person.class)
         .fetch().all();
 ----
@@ -69,7 +69,7 @@ The following example extracts the `id` column and emits its value:
 
 [source,java]
 ----
-Flux<String> names = client.sql("SELECT name FROM person")
+Flux<String> names = client.execute("SELECT name FROM person")
         .map((row, rowMetadata) -> row.get("id", String.class))
         .all();
 ----
@@ -90,7 +90,7 @@ A typical application requires parameterized SQL statements to select or update
 These are typically `SELECT` statements  constrained by a `WHERE` clause or `INSERT`/`UPDATE` statements accepting input parameters.
 Parameterized statements bear the risk of SQL injection if parameters are not escaped properly.
 `DatabaseClient` leverages R2DBC's Bind API to eliminate the risk of SQL injection for query parameters.
-You can provide a parameterized SQL statement with the `sql(…)` operator and bind parameters to the actual `Statement`.
+You can provide a parameterized SQL statement with the `execute(…)` operator and bind parameters to the actual `Statement`.
 Your R2DBC driver then executes the statement using prepared statements and parameter substitution.
 
 Parameter binding supports various binding strategies:
@@ -102,7 +102,7 @@ The following example shows parameter binding for a query:
 
 [source,java]
 ----
-db.sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
+db.execute("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
     .bind("id", "joe")
     .bind("name", "Joe")
     .bind("age", 34);
@@ -140,7 +140,7 @@ List<Object[]> tuples = new ArrayList<>();
 tuples.add(new Object[] {"John", 35});
 tuples.add(new Object[] {"Ann",  50});
 
-db.sql("SELECT id, name, state FROM table WHERE (name, age) IN (:tuples)")
+db.execute("SELECT id, name, state FROM table WHERE (name, age) IN (:tuples)")
     .bind("tuples", tuples);
 ----
 
@@ -150,6 +150,6 @@ A simpler variant using `IN` predicates:
 
 [source,java]
 ----
-db.sql("SELECT id, name, state FROM table WHERE age IN (:ages)")
+db.execute("SELECT id, name, state FROM table WHERE age IN (:ages)")
     .bind("ages", Arrays.asList(35, 50));
 ----

src/main/asciidoc/reference/r2dbc-transactions.adoc

@@ -18,12 +18,12 @@ TransactionalOperator operator = TransactionalOperator.create(tm); <1>
 
 DatabaseClient client = DatabaseClient.create(connectionFactory);
 
-Mono<Void> atomicOperation = client.sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
+Mono<Void> atomicOperation = client.execute("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
   .bind("id", "joe")
   .bind("name", "Joe")
   .bind("age", 34)
   .fetch().rowsUpdated()
-  .then(client.sql("INSERT INTO contacts (id, name) VALUES(:id, :name)")
+  .then(client.execute("INSERT INTO contacts (id, name) VALUES(:id, :name)")
     .bind("id", "joe")
     .bind("name", "Joe")
     .fetch().rowsUpdated())
@@ -69,12 +69,12 @@ class MyService {
   @Transactional
   public Mono<Void> insertPerson() {
 
-    return client.sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
+    return client.execute("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
       .bind("id", "joe")
       .bind("name", "Joe")
       .bind("age", 34)
       .fetch().rowsUpdated()
-      .then(client.sql("INSERT INTO contacts (id, name) VALUES(:id, :name)")
+      .then(client.execute("INSERT INTO contacts (id, name) VALUES(:id, :name)")
         .bind("id", "joe")
         .bind("name", "Joe")
         .fetch().rowsUpdated())

src/main/java/org/springframework/data/r2dbc/connectionfactory/ConnectionFactoryUtils.java

@@ -23,7 +23,6 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.reactivestreams.Publisher;
 
 import org.springframework.core.Ordered;
 import org.springframework.dao.DataAccessResourceFailureException;
@@ -67,7 +66,7 @@ private ConnectionFactoryUtils() {}
 	 * @throws DataAccessResourceFailureException if the attempt to get a {@link io.r2dbc.spi.Connection} failed
 	 * @see #releaseConnection
 	 */
-	public static Mono<Tuple2<Connection, ConnectionFactory>> getConnection(ConnectionFactory connectionFactory) {
+	public static Mono<Connection> getConnection(ConnectionFactory connectionFactory) {
 		return doGetConnection(connectionFactory)
 				.onErrorMap(e -> new DataAccessResourceFailureException("Failed to obtain R2DBC Connection", e));
 	}
@@ -82,7 +81,7 @@ public static Mono<Tuple2<Connection, ConnectionFactory>> getConnection(Connecti
 	 * @param connectionFactory the {@link ConnectionFactory} to obtain Connections from.
 	 * @return a R2DBC {@link io.r2dbc.spi.Connection} from the given {@link ConnectionFactory}.
 	 */
-	public static Mono<Tuple2<Connection, ConnectionFactory>> doGetConnection(ConnectionFactory connectionFactory) {
+	public static Mono<Connection> doGetConnection(ConnectionFactory connectionFactory) {
 
 		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
 
@@ -138,56 +137,11 @@ public static Mono<Tuple2<Connection, ConnectionFactory>> doGetConnection(Connec
 
 			return con;
 		}) //
-				.map(conn -> Tuples.of(conn, connectionFactory)) //
 				.onErrorResume(NoTransactionException.class, e -> {
-
-					return Mono.subscriberContext().flatMap(it -> {
-
-						if (it.hasKey(ReactiveTransactionSynchronization.class)) {
-
-							ReactiveTransactionSynchronization synchronization = it.get(ReactiveTransactionSynchronization.class);
-
-							return obtainConnection(synchronization, connectionFactory);
-						}
-						return Mono.empty();
-					}).switchIfEmpty(Mono.defer(() -> {
-						return Mono.from(connectionFactory.create()).map(it -> Tuples.of(it, connectionFactory));
-					}));
+					return Mono.from(connectionFactory.create());
 				});
 	}
 
-	private static Mono<Tuple2<Connection, ConnectionFactory>> obtainConnection(
-			ReactiveTransactionSynchronization synchronization, ConnectionFactory connectionFactory) {
-
-		if (synchronization.isSynchronizationActive()) {
-
-			if (logger.isDebugEnabled()) {
-				logger.debug("Registering transaction synchronization for R2DBC Connection");
-			}
-
-			TransactionResources txContext = synchronization.getCurrentTransaction();
-			ConnectionFactory resource = txContext.getResource(ConnectionFactory.class);
-
-			Mono<Tuple2<Connection, ConnectionFactory>> attachNewConnection = Mono
-					.defer(() -> Mono.from(connectionFactory.create()).map(it -> {
-
-						if (logger.isDebugEnabled()) {
-							logger.debug("Fetching new R2DBC Connection from ConnectionFactory");
-						}
-
-						SingletonConnectionFactory s = new SingletonConnectionFactory(connectionFactory.getMetadata(), it);
-						txContext.registerResource(ConnectionFactory.class, s);
-
-						return Tuples.of(it, connectionFactory);
-					}));
-
-			return Mono.justOrEmpty(resource).flatMap(ConnectionFactoryUtils::createConnection)
-					.switchIfEmpty(attachNewConnection);
-		}
-
-		return Mono.empty();
-	}
-
 	/**
 	 * Actually fetch a {@link Connection} from the given {@link ConnectionFactory}, defensively turning an unexpected
 	 * {@code null} return value from {@link ConnectionFactory#create()} into an {@link IllegalStateException}.
@@ -198,12 +152,7 @@ private static Mono<Tuple2<Connection, ConnectionFactory>> obtainConnection(
 	 * @see ConnectionFactory#create()
 	 */
 	private static Mono<Connection> fetchConnection(ConnectionFactory connectionFactory) {
-
-		Publisher<? extends Connection> con = connectionFactory.create();
-		if (con == null) { // TODO: seriously why would it do that?
-			throw new IllegalStateException("ConnectionFactory returned null from getConnection(): " + connectionFactory);
-		}
-		return Mono.from(con);
+		return Mono.from(connectionFactory.create());
 	}
 
 	/**
@@ -226,40 +175,24 @@ public static Mono<Void> releaseConnection(@Nullable io.r2dbc.spi.Connection con
 	 * Actually close the given {@link io.r2dbc.spi.Connection}, obtained from the given {@link ConnectionFactory}. Same
 	 * as {@link #releaseConnection}, but preserving the original exception.
 	 *
-	 * @param con the {@link io.r2dbc.spi.Connection} to close if necessary.
+	 * @param connection the {@link io.r2dbc.spi.Connection} to close if necessary.
 	 * @param connectionFactory the {@link ConnectionFactory} that the Connection was obtained from (may be
 	 *          {@literal null}).
 	 * @see #doGetConnection
 	 */
-	public static Mono<Void> doReleaseConnection(@Nullable io.r2dbc.spi.Connection con,
+	public static Mono<Void> doReleaseConnection(@Nullable io.r2dbc.spi.Connection connection,
 			@Nullable ConnectionFactory connectionFactory) {
 
 		return TransactionSynchronizationManager.forCurrentTransaction().flatMap(it -> {
 
 			ConnectionHolder conHolder = (ConnectionHolder) it.getResource(connectionFactory);
-			if (conHolder != null && connectionEquals(conHolder, con)) {
+			if (conHolder != null && connectionEquals(conHolder, connection)) {
 				// It's the transactional Connection: Don't close it.
 				conHolder.released();
 			}
-			return Mono.from(con.close());
+			return Mono.from(connection.close());
 		}).onErrorResume(NoTransactionException.class, e -> {
-
-			if (connectionFactory instanceof SingletonConnectionFactory) {
-
-				SingletonConnectionFactory factory = (SingletonConnectionFactory) connectionFactory;
-
-				if (logger.isDebugEnabled()) {
-					logger.debug("Releasing R2DBC Connection");
-				}
-
-				return factory.close(con);
-			}
-
-			if (logger.isDebugEnabled()) {
-				logger.debug("Closing R2DBC Connection");
-			}
-
-			return Mono.from(con.close());
+			return doCloseConnection(connection, connectionFactory);
 		});
 	}
 
@@ -287,55 +220,23 @@ public static Mono<Void> closeConnection(Connection connection, ConnectionFactor
 	 */
 	public static Mono<Void> doCloseConnection(Connection connection, @Nullable ConnectionFactory connectionFactory) {
 
-		if (!(connectionFactory instanceof SingletonConnectionFactory)
-				|| ((SingletonConnectionFactory) connectionFactory).shouldClose(connection)) {
+		if (!(connectionFactory instanceof SmartConnectionFactory)
+				|| ((SmartConnectionFactory) connectionFactory).shouldClose(connection)) {
 
-			SingletonConnectionFactory factory = (SingletonConnectionFactory) connectionFactory;
-			return factory.close(connection).then(Mono.from(connection.close()));
+			if (logger.isDebugEnabled()) {
+				logger.debug("Closing R2DBC Connection");
+			}
+
+			return Mono.from(connection.close());
 		}
 
 		return Mono.empty();
 	}
 
-	/**
-	 * Obtain the currently {@link ReactiveTransactionSynchronization} from the current subscriber
-	 * {@link reactor.util.context.Context}.
-	 *
-	 * @throws NoTransactionException if no active {@link ReactiveTransactionSynchronization} is associated with the
-	 *           current subscription.
-	 * @see Mono#subscriberContext()
-	 * @see ReactiveTransactionSynchronization
-	 */
-	public static Mono<ReactiveTransactionSynchronization> currentReactiveTransactionSynchronization() {
-
-		return Mono.subscriberContext().filter(it -> it.hasKey(ReactiveTransactionSynchronization.class)) //
-				.switchIfEmpty(Mono.error(new NoTransactionException(
-						"Transaction management is not enabled. Make sure to register ReactiveTransactionSynchronization in the subscriber Context!"))) //
-				.map(it -> it.get(ReactiveTransactionSynchronization.class));
-	}
-
-	/**
-	 * Obtain the currently active {@link ReactiveTransactionSynchronization} from the current subscriber
-	 * {@link reactor.util.context.Context}.
-	 *
-	 * @throws NoTransactionException if no active {@link ReactiveTransactionSynchronization} is associated with the
-	 *           current subscription.
-	 * @see Mono#subscriberContext()
-	 * @see ReactiveTransactionSynchronization
-	 */
-	public static Mono<ReactiveTransactionSynchronization> currentActiveReactiveTransactionSynchronization() {
-
-		return currentReactiveTransactionSynchronization()
-				.filter(ReactiveTransactionSynchronization::isSynchronizationActive) //
-				.switchIfEmpty(Mono.error(new NoTransactionException("ReactiveTransactionSynchronization not active!")));
-	}
-
 	/**
 	 * Obtain the {@link io.r2dbc.spi.ConnectionFactory} from the current subscriber {@link reactor.util.context.Context}.
 	 *
-	 * @see Mono#subscriberContext()
-	 * @see ReactiveTransactionSynchronization
-	 * @see TransactionResources
+	 * @see TransactionSynchronizationManager
 	 */
 	public static Mono<ConnectionFactory> currentConnectionFactory(ConnectionFactory connectionFactory) {
 
@@ -347,8 +248,7 @@ public static Mono<ConnectionFactory> currentConnectionFactory(ConnectionFactory
 						return true;
 					}
 					return false;
-				}).map(it -> connectionFactory) //
-				.onErrorResume(NoTransactionException.class, ConnectionFactoryUtils::obtainDefaultConnectionFactory);
+				}).map(it -> connectionFactory);
 	}
 
 	/**
@@ -410,20 +310,6 @@ private static int getConnectionSynchronizationOrder(ConnectionFactory connectio
 		return order;
 	}
 
-	/**
-	 * @param e
-	 * @return an {@link Mono#error(Throwable) error} if not transaction present.
-	 */
-	private static Mono<? extends ConnectionFactory> obtainDefaultConnectionFactory(NoTransactionException e) {
-
-		return currentActiveReactiveTransactionSynchronization().map(synchronization -> {
-
-			TransactionResources currentSynchronization = synchronization.getCurrentTransaction();
-			return currentSynchronization.getResource(ConnectionFactory.class);
-		}).switchIfEmpty(Mono.error(
-				new DataAccessResourceFailureException("Cannot extract ConnectionFactory from current TransactionContext!")));
-	}
-
 	/**
 	 * Create a {@link Connection} via the given {@link ConnectionFactory#create() factory} and return a {@link Tuple2}
 	 * associating the {@link Connection} with its creating {@link ConnectionFactory}.