Define modes for withTransaction, rename withPropagatedTransaction, adhere to code style guidelines

Author: technical-debt-collector

vertx-sql-client/src/main/java/io/vertx/sqlclient/Pool.java

@@ -140,7 +140,7 @@ default <T> void withTransaction(Function<SqlConnection, Future<@Nullable T>> fu
   }
 
   /**
-   * Like {@link #withTransaction(Function, Handler)} but returns a {@code Future} of the asynchronous result
+   * Like {@link #withTransaction(Function, Handler)} but returns a {@code Future} of the asynchronous result.
    */
   default <T> Future<@Nullable T> withTransaction(Function<SqlConnection, Future<@Nullable T>> function) {
     return getConnection()
@@ -165,10 +165,10 @@ default <T> void withTransaction(Function<SqlConnection, Future<@Nullable T>> fu
   }
 
   /**
-   * Like {@link #withTransaction(Function, Handler)} but keeps the connection accessible via the context
-   * for the duration of the given {@code function}
+   * Like {@link #withTransaction(Function, Handler)} but allows for setting the mode, defining how the acquired
+   * connection is managed during the execution of the function.
    */
-  <T> Future<@Nullable T> withPropagatedTransaction(Function<SqlConnection, Future<@Nullable T>> function);
+  <T> Future<@Nullable T> withTransaction(TransactionMode mode, Function<SqlConnection, Future<@Nullable T>> function);
 
   /**
    * Get a connection from the pool and execute the given {@code function}.

vertx-sql-client/src/main/java/io/vertx/sqlclient/TransactionMode.java

@@ -0,0 +1,25 @@
+package io.vertx.sqlclient;
+
+import java.util.function.Function;
+
+/**
+ * Defines how the acquired connection will be managed during the execution of the function provided in
+ * {@link Pool#withTransaction(TransactionMode, Function)}.
+ */
+public enum TransactionMode {
+
+  /**
+   * The acquired connection is not stored anywhere, making it local to the provided function execution and to
+   * whereever it is passed.
+   */
+  DEFAULT,
+
+  /**
+   * Keeps the acquired connection stored in the local context for as long as the given function executes.
+   * Any subsequent calls to {@link Pool#withTransaction} with this mode during the function execution
+   * will retrieve this connection from the context instead of creating another.
+   * The connection is removed from the local context when the function block has completed.
+   */
+  PROPAGATABLE
+
+}

vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/PoolBase.java

@@ -24,14 +24,7 @@
 import io.vertx.core.impl.ContextInternal;
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.impl.future.PromiseInternal;
-import io.vertx.sqlclient.Pool;
-import io.vertx.sqlclient.PrepareOptions;
-import io.vertx.sqlclient.PreparedQuery;
-import io.vertx.sqlclient.Query;
-import io.vertx.sqlclient.Row;
-import io.vertx.sqlclient.RowSet;
-import io.vertx.sqlclient.SqlClient;
-import io.vertx.sqlclient.SqlConnection;
+import io.vertx.sqlclient.*;
 import io.vertx.sqlclient.spi.Driver;
 
 import java.util.function.Function;
@@ -79,8 +72,9 @@ public PreparedQuery<RowSet<Row>> preparedQuery(String sql) {
   }
 
   @Override
-  public <T> Future<@Nullable T> withPropagatedTransaction(Function<SqlConnection, Future<@Nullable T>> function) {
-    return delegate.withPropagatedTransaction(function);
+  public <T> Future<@Nullable T> withTransaction(TransactionMode mode,
+                                                 Function<SqlConnection, Future<@Nullable T>> function) {
+    return delegate.withTransaction(mode, function);
   }
 
   @Override

vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/PoolImpl.java

@@ -24,10 +24,7 @@
 import io.vertx.core.impl.VertxInternal;
 import io.vertx.core.impl.future.PromiseInternal;
 import io.vertx.core.spi.metrics.ClientMetrics;
-import io.vertx.sqlclient.Pool;
-import io.vertx.sqlclient.PoolOptions;
-import io.vertx.sqlclient.SqlConnection;
-import io.vertx.sqlclient.TransactionRollbackException;
+import io.vertx.sqlclient.*;
 import io.vertx.sqlclient.impl.command.CommandBase;
 import io.vertx.sqlclient.impl.pool.SqlConnectionPool;
 import io.vertx.sqlclient.impl.tracing.QueryTracer;
@@ -158,22 +155,26 @@ public Future<SqlConnection> getConnection() {
     });
   }
 
-  public <T> Future<@Nullable T> withPropagatedTransaction(Function<SqlConnection, Future<@Nullable T>> function) {
-    ContextInternal context = (ContextInternal) Vertx.currentContext();
-    SqlConnection sqlConnection = context.getLocal(PROPAGATABLE_CONNECTION);
-    if (sqlConnection == null) {
-      return initializePropagatedConnectionAndTransaction(function);
+  public <T> Future<@Nullable T> withTransaction(TransactionMode mode,
+                                                 Function<SqlConnection, Future<@Nullable T>> function) {
+    if (mode == TransactionMode.PROPAGATABLE) {
+      ContextInternal context = (ContextInternal) Vertx.currentContext();
+      SqlConnection sqlConnection = context.getLocal(PROPAGATABLE_CONNECTION);
+      if (sqlConnection == null) {
+        return startPropagatableConnection(function);
+      }
+      return context.succeededFuture(sqlConnection)
+        .flatMap(conn -> function.apply(conn)
+          .onFailure(err -> {
+            if (!(err instanceof TransactionRollbackException)) {
+              conn.getTransaction().rollback();
+            }
+          }));
     }
-    return context.succeededFuture(sqlConnection)
-      .flatMap(conn -> function.apply(conn)
-        .onFailure(err -> {
-          if (!(err instanceof TransactionRollbackException)) {
-            conn.getTransaction().rollback();
-          }
-        }));
+    return withTransaction(function);
   }
 
-  private <T> Future<@Nullable T> initializePropagatedConnectionAndTransaction(Function<SqlConnection, Future<@Nullable T>> function) {
+  private <T> Future<@Nullable T> startPropagatableConnection(Function<SqlConnection, Future<@Nullable T>> function) {
     ContextInternal context = (ContextInternal) Vertx.currentContext();
     return getConnection().onComplete(handler -> context.putLocal(PROPAGATABLE_CONNECTION, handler.result()))
       .flatMap(conn -> conn

vertx-sql-client/src/test/java/io/vertx/sqlclient/tck/TransactionTestBase.java

@@ -310,13 +310,15 @@ public void testWithTransactionImplicitRollback(TestContext ctx) {
   }
 
   @Test
-  public void testWithPropagatedConnectionTransactionCommit(TestContext ctx) {
+  public void testWithPropagatableConnectionTransactionCommit(TestContext ctx) {
     Async async = ctx.async();
     Pool pool = createPool();
     vertx.runOnContext(handler -> {
-    pool.withPropagatedTransaction(c ->
-      pool.withPropagatedTransaction(conn -> conn.query("INSERT INTO mutable (id, val) VALUES (1, 'hello-1')").execute().mapEmpty()).flatMap(v ->
-        pool.withPropagatedTransaction(conn -> conn.query("INSERT INTO mutable (id, val) VALUES (2, 'hello-2')").execute().mapEmpty())).flatMap(v2 ->
+    pool.withTransaction(TransactionMode.PROPAGATABLE, c ->
+      pool.withTransaction(TransactionMode.PROPAGATABLE, conn ->
+        conn.query("INSERT INTO mutable (id, val) VALUES (1, 'hello-1')").execute().mapEmpty()).flatMap(v ->
+        pool.withTransaction(TransactionMode.PROPAGATABLE, conn ->
+          conn.query("INSERT INTO mutable (id, val) VALUES (2, 'hello-2')").execute().mapEmpty())).flatMap(v2 ->
         c.query("INSERT INTO mutable (id, val) VALUES (3, 'hello-3')").execute().mapEmpty())
     ).onComplete(ctx.asyncAssertSuccess(v -> pool
       .query("SELECT id, val FROM mutable")
@@ -329,13 +331,15 @@ public void testWithPropagatedConnectionTransactionCommit(TestContext ctx) {
   }
 
   @Test
-  public void testWithPropagatedConnectionTransactionRollback(TestContext ctx) {
+  public void testWithPropagatableConnectionTransactionRollback(TestContext ctx) {
     Async async = ctx.async();
     Pool pool = createPool();
     Throwable failure = new Throwable();
     vertx.runOnContext(handler -> {
-      pool.withPropagatedTransaction(c ->
-        pool.withPropagatedTransaction(conn -> conn.query("INSERT INTO mutable (id, val) VALUES (1, 'hello-1')").execute().mapEmpty().flatMap(v -> Future.failedFuture(failure)))
+      pool.withTransaction(TransactionMode.PROPAGATABLE, c ->
+        pool.withTransaction(TransactionMode.PROPAGATABLE, conn ->
+          conn.query("INSERT INTO mutable (id, val) VALUES (1, 'hello-1')").execute().mapEmpty().flatMap(
+            v -> Future.failedFuture(failure)))
       ).onComplete(ctx.asyncAssertFailure(v -> pool
         .query("SELECT id, val FROM mutable")
         .execute(ctx.asyncAssertSuccess(rows -> {