The new withTransaction method should be a default method so the JDBC implementation does not need to implement it

Author: vietj

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

@@ -31,10 +31,14 @@
 import io.vertx.core.Future;
 import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
+import io.vertx.core.impl.ContextInternal;
+import io.vertx.sqlclient.impl.PoolImpl;
 import io.vertx.sqlclient.spi.Driver;
 
 import java.util.function.Function;
 
+import static io.vertx.sqlclient.impl.PoolImpl.startPropagatableConnection;
+
 /**
  * A connection pool which reuses a number of SQL connections.
  *
@@ -168,7 +172,23 @@ default <T> void withTransaction(Function<SqlConnection, Future<@Nullable T>> fu
    * 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> withTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Future<@Nullable T>> function);
+  default <T> Future<@Nullable T> withTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Future<@Nullable T>> function) {
+    if (txPropagation == TransactionPropagation.CONTEXT) {
+      ContextInternal context = (ContextInternal) Vertx.currentContext();
+      SqlConnection sqlConnection = context.getLocal(PoolImpl.PROPAGATABLE_CONNECTION);
+      if (sqlConnection == null) {
+        return startPropagatableConnection(this, function);
+      }
+      return context.succeededFuture(sqlConnection)
+        .flatMap(conn -> function.apply(conn)
+          .onFailure(err -> {
+            if (!(err instanceof TransactionRollbackException)) {
+              conn.transaction().rollback();
+            }
+          }));
+    }
+    return withTransaction(function);
+  }
 
   /**
    * Get a connection from the pool and execute the given {@code function}.

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

@@ -51,7 +51,7 @@ public class PoolImpl extends SqlClientBase implements Pool, Closeable {
   private long timerID;
   private volatile Function<Context, Future<SqlConnection>> connectionProvider;
 
-  private static final String PROPAGATABLE_CONNECTION = "propagatable_connection";
+  public static final String PROPAGATABLE_CONNECTION = "propagatable_connection";
 
   public PoolImpl(VertxInternal vertx,
                   Driver driver,
@@ -155,28 +155,9 @@ public Future<SqlConnection> getConnection() {
     });
   }
 
-  public <T> Future<@Nullable T> withTransaction(TransactionPropagation txPropagation,
-                                                 Function<SqlConnection, Future<@Nullable T>> function) {
-    if (txPropagation == TransactionPropagation.CONTEXT) {
-      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.transaction().rollback();
-            }
-          }));
-    }
-    return withTransaction(function);
-  }
-
-  private <T> Future<@Nullable T> startPropagatableConnection(Function<SqlConnection, Future<@Nullable T>> function) {
+  public static <T> Future<@Nullable T> startPropagatableConnection(Pool pool, Function<SqlConnection, Future<@Nullable T>> function) {
     ContextInternal context = (ContextInternal) Vertx.currentContext();
-    return getConnection().onComplete(handler -> context.putLocal(PROPAGATABLE_CONNECTION, handler.result()))
+    return pool.getConnection().onComplete(handler -> context.putLocal(PROPAGATABLE_CONNECTION, handler.result()))
       .flatMap(conn -> conn
         .begin()
         .flatMap(tx -> function