Move connection factory specific methods to GenericDriver.

Motivation:

The Driver interface does not need to declare connection pool related details such as the connection factory and the connection wrapper methods.

Those instead can be on the GenericDriver, so let's move them there.

Author: vietj

vertx-db2-client/src/main/java/io/vertx/db2client/spi/DB2Driver.java

@@ -58,7 +58,7 @@ protected Pool newPool(VertxInternal vertx, Handler<SqlConnection> connectHandle
     boolean pipelinedPool = poolOptions instanceof Db2PoolOptions && ((Db2PoolOptions) poolOptions).isPipelined();
     ConnectionFactory<DB2ConnectOptions> factory = createConnectionFactory(vertx, transportOptions);
     PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, poolOptions, null, null,
-      factory, databases, connectHandler, closeFuture);
+      factory, databases, connectHandler, this::wrapConnection, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
@@ -81,7 +81,7 @@ public ConnectionFactory<DB2ConnectOptions> createConnectionFactory(Vertx vertx,
   }
 
   @Override
-  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<DB2ConnectOptions> factory, Connection conn) {
-    return new DB2ConnectionImpl(context, factory, conn);
+  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<DB2ConnectOptions> factory, Connection connection) {
+    return new DB2ConnectionImpl(context, factory, connection);
   }
 }

vertx-mssql-client/src/main/java/io/vertx/mssqlclient/spi/MSSQLDriver.java

@@ -69,7 +69,7 @@ public int appendQueryPlaceholder(StringBuilder queryBuilder, int index, int cur
   }
 
   @Override
-  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<MSSQLConnectOptions> factory, Connection conn) {
-    return new MSSQLConnectionImpl(context, factory, conn);
+  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<MSSQLConnectOptions> factory, Connection connection) {
+    return new MSSQLConnectionImpl(context, factory, connection);
   }
 }

vertx-mysql-client/src/main/java/io/vertx/mysqlclient/spi/MySQLDriver.java

@@ -58,7 +58,7 @@ protected Pool newPool(VertxInternal vertx, Handler<SqlConnection> connectHandle
     boolean pipelinedPool = poolOptions instanceof MySQLPoolOptions && ((MySQLPoolOptions) poolOptions).isPipelined();
     ConnectionFactory<MySQLConnectOptions> factory = createConnectionFactory(vertx, transportOptions);
     PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, poolOptions, null, null, factory,
-      databases, connectHandler, closeFuture);
+      databases, connectHandler, this::wrapConnection, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
@@ -81,7 +81,7 @@ public ConnectionFactory<MySQLConnectOptions> createConnectionFactory(Vertx vert
   }
 
   @Override
-  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<MySQLConnectOptions> factory, Connection conn) {
-    return new MySQLConnectionImpl(context, factory, conn);
+  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<MySQLConnectOptions> factory, Connection connection) {
+    return new MySQLConnectionImpl(context, factory, connection);
   }
 }

vertx-oracle-client/src/main/java/io/vertx/oracleclient/spi/OracleDriver.java

@@ -66,7 +66,7 @@ public ConnectionFactory<OracleConnectOptions> createConnectionFactory(Vertx ver
   }
 
   @Override
-  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<OracleConnectOptions> factory, Connection conn) {
-    return new OracleConnectionImpl(context, factory, conn);
+  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<OracleConnectOptions> factory, Connection connection) {
+    return new OracleConnectionImpl(context, factory, connection);
   }
 }

vertx-pg-client/src/main/java/io/vertx/pgclient/spi/PgDriver.java

@@ -41,7 +41,7 @@ protected Pool newPool(VertxInternal vertx, Handler<SqlConnection> connectHandle
     boolean pipelinedPool = poolOptions instanceof PgPoolOptions && ((PgPoolOptions) poolOptions).isPipelined();
     ConnectionFactory<PgConnectOptions> factory = createConnectionFactory(vertx, transportOptions);
     PoolImpl pool = new PoolImpl(vertx, this, pipelinedPool, poolOptions, null, null,
-      factory, databases, connectHandler, closeFuture);
+      factory, databases, connectHandler, this::wrapConnection, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;
@@ -75,7 +75,7 @@ public int appendQueryPlaceholder(StringBuilder queryBuilder, int index, int cur
   }
 
   @Override
-  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<PgConnectOptions> factory, Connection conn) {
-    return new PgConnectionImpl((PgConnectionFactory) factory, context, conn);
+  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<PgConnectOptions> factory, Connection connection) {
+    return new PgConnectionImpl((PgConnectionFactory) factory, context, connection);
   }
 }

vertx-sql-client-templates/src/test/java/io/vertx/tests/sqlclient/templates/TemplateBuilderTest.java

@@ -42,10 +42,6 @@ public Pool newPool(Vertx vertx, Supplier<Future<SqlConnectOptions>> databases,
           throw new UnsupportedOperationException();
         }
         @Override
-        public ConnectionFactory<SqlConnectOptions> createConnectionFactory(Vertx vertx, NetClientOptions transportOptions) {
-          throw new UnsupportedOperationException();
-        }
-        @Override
         public boolean acceptsOptions(SqlConnectOptions connectOptions) {
           throw new UnsupportedOperationException();
         }

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

@@ -0,0 +1,12 @@
+package io.vertx.sqlclient.impl.pool;
+
+import io.vertx.core.internal.ContextInternal;
+import io.vertx.sqlclient.SqlConnectOptions;
+import io.vertx.sqlclient.internal.Connection;
+import io.vertx.sqlclient.internal.SqlConnectionInternal;
+import io.vertx.sqlclient.spi.ConnectionFactory;
+
+public interface ConnectionWrapper<O extends SqlConnectOptions> {
+
+  SqlConnectionInternal wrap(ContextInternal context, ConnectionFactory<O> factory, Connection conn);
+}

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

@@ -54,6 +54,7 @@ public class PoolImpl extends SqlClientBase implements Pool, Closeable {
   private final long cleanerPeriod;
   private final boolean pipelined;
   private final Handler<SqlConnection> connectionInitializer;
+  private final ConnectionWrapper<?> connectionWrapper;
   private long timerID;
 
   public <O extends SqlConnectOptions> PoolImpl(VertxInternal vertx,
@@ -65,6 +66,7 @@ public <O extends SqlConnectOptions> PoolImpl(VertxInternal vertx,
                   ConnectionFactory<O> connectionFactory,
                   Supplier<Future<O>> connectionProvider,
                   Handler<SqlConnection> connectionInitializer,
+                  ConnectionWrapper connectionWrapper,
                   CloseFuture closeFuture) {
     super(driver);
 
@@ -78,6 +80,7 @@ public <O extends SqlConnectOptions> PoolImpl(VertxInternal vertx,
       poolMetrics = null;
     }
 
+    this.connectionWrapper = connectionWrapper;
     this.idleTimeout = MILLISECONDS.convert(poolOptions.getIdleTimeout(), poolOptions.getIdleTimeoutUnit());
     this.connectionTimeout = MILLISECONDS.convert(poolOptions.getConnectionTimeout(), poolOptions.getConnectionTimeoutUnit());
     this.maxLifetime = MILLISECONDS.convert(poolOptions.getMaxLifetime(), poolOptions.getMaxLifetimeUnit());
@@ -95,7 +98,7 @@ public <O extends SqlConnectOptions> PoolImpl(VertxInternal vertx,
   private void initializeConnection(SqlConnectionPool.PooledConnection conn) {
     if (connectionInitializer != null) {
       ContextInternal current = vertx.getContext();
-      SqlConnectionInternal wrapper = driver.wrapConnection(current, conn.factory(), conn);
+      SqlConnectionInternal wrapper = connectionWrapper.wrap(current, conn.factory(), conn);
       conn.init((Connection.Holder) wrapper);
       current.dispatch(wrapper, connectionInitializer);
     }
@@ -144,7 +147,7 @@ public Future<SqlConnection> getConnection() {
     Promise<SqlConnectionPool.PooledConnection> promise = current.promise();
     acquire(current, connectionTimeout, promise);
     return promise.future().map(conn -> {
-      SqlConnectionInternal wrapper = driver.wrapConnection(current, conn.factory(), conn);
+      SqlConnectionInternal wrapper = connectionWrapper.wrap(current, conn.factory(), conn);
       conn.init((Connection.Holder) wrapper);
       return wrapper;
     });

vertx-sql-client/src/main/java/io/vertx/sqlclient/spi/Driver.java

@@ -101,15 +101,6 @@ default Pool createPool(Vertx vertx, Supplier<Future<C>> databases, PoolOptions
    */
   Pool newPool(Vertx vertx, Supplier<Future<C>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, CloseFuture closeFuture);
 
-  /**
-   * Create a connection factory to the given {@code database}.
-   *
-   * @param vertx            the Vertx instance
-   * @param transportOptions the options to configure the TCP client
-   * @return the connection factory
-   */
-  ConnectionFactory<C> createConnectionFactory(Vertx vertx, NetClientOptions transportOptions);
-
   /**
    * @return {@code true} if the driver accepts the {@code connectOptions}, {@code false} otherwise
    */
@@ -149,8 +140,4 @@ default int appendQueryPlaceholder(StringBuilder queryBuilder, int index, int cu
     queryBuilder.append("?");
     return current;
   }
-
-  default SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<C> factory, Connection conn) {
-    return new SqlConnectionBase<>(context, factory, conn, this);
-  }
 }

vertx-sql-client/src/main/java/io/vertx/sqlclient/spi/GenericDriver.java

@@ -4,6 +4,7 @@
 import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
 import io.vertx.core.internal.CloseFuture;
+import io.vertx.core.internal.ContextInternal;
 import io.vertx.core.internal.VertxInternal;
 import io.vertx.core.net.NetClientOptions;
 import io.vertx.sqlclient.Pool;
@@ -13,6 +14,8 @@
 import io.vertx.sqlclient.internal.Connection;
 import io.vertx.sqlclient.impl.pool.CloseablePool;
 import io.vertx.sqlclient.impl.pool.PoolImpl;
+import io.vertx.sqlclient.internal.SqlConnectionBase;
+import io.vertx.sqlclient.internal.SqlConnectionInternal;
 
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -38,6 +41,28 @@ public GenericDriver(Function<Connection, Future<Void>> afterAcquire, Function<C
     this.beforeRecycle = beforeRecycle;
   }
 
+  /**
+   * Create a connection factory to the given {@code database}.
+   *
+   * @param vertx            the Vertx instance
+   * @param transportOptions the options to configure the TCP client
+   * @return the connection factory
+   */
+  public abstract ConnectionFactory<O> createConnectionFactory(Vertx vertx, NetClientOptions transportOptions);
+
+  /**
+   * Wrap a given {@code connection} into a {@link SqlConnectionInternal}. The default implementation
+   * wraps with a generic {@link SqlConnectionBase}.
+   *
+   * @param context the connection context
+   * @param factory the connection factory
+   * @param connection the connection to wrap
+   * @return the wrapped connection
+   */
+  public SqlConnectionInternal wrapConnection(ContextInternal context, ConnectionFactory<O> factory, Connection connection) {
+    return new SqlConnectionBase<>(context, factory, connection, this);
+  }
+
   @Override
   public Pool newPool(Vertx vertx, Supplier<Future<O>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, CloseFuture closeFuture) {
     VertxInternal vx = (VertxInternal) vertx;
@@ -53,7 +78,7 @@ public Pool newPool(Vertx vertx, Supplier<Future<O>> databases, PoolOptions opti
   protected Pool newPool(VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<O>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, CloseFuture closeFuture) {
     ConnectionFactory<O> factory = createConnectionFactory(vertx, transportOptions);
     PoolImpl pool = new PoolImpl(vertx, this, false, poolOptions, afterAcquire, beforeRecycle,
-      factory, databases, connectHandler, closeFuture);
+      factory, databases, connectHandler, this::wrapConnection, closeFuture);
     pool.init();
     closeFuture.add(factory);
     return pool;