Configure Oracle client from URI (#1075)

* Fixes on OracleConnectOptions

Missing copy constructor
Broken JsonObject constructor

Removed duplicated options

Signed-off-by: Thomas Segismont <tsegismont@gmail.com>

* Add OracleConnectionUriParser

Parses Oracle thin client URIs for now.
'jdbc:' prefix omitted to avoid confusions.

Signed-off-by: Thomas Segismont <tsegismont@gmail.com>

* Add method to create OracleConnectOptions from uri

Signed-off-by: Thomas Segismont <tsegismont@gmail.com>

* Add methods to create OraclePool from uri

Signed-off-by: Thomas Segismont <tsegismont@gmail.com>

* Document pool setup with connection uri

Signed-off-by: Thomas Segismont <tsegismont@gmail.com>

Author: tsegismont

vertx-oracle-client/src/main/asciidoc/index.adoc

@@ -86,13 +86,22 @@ There are several alternatives for you to configure the client.
 
 === Data Object
 
-A simple way to configure the client is to specify a `OracleConnectOptions` data object.
+A simple way to configure the client is to specify a {@link io.vertx.oracleclient.OracleConnectOptions} data object.
 
 [source,$lang]
 ----
 {@link examples.OracleClientExamples#configureFromDataObject(io.vertx.core.Vertx)}
 ----
 
+=== Connection URI
+
+Apart from configuring with a {@link io.vertx.oracleclient.OracleConnectOptions} data object, ww also provide you with an alternative way to connect when you want to configure with a connection URI:
+
+[source,$lang]
+----
+{@link examples.OracleClientExamples#configureFromUri(io.vertx.core.Vertx)}
+----
+
 == Connect retries
 
 You can configure the client to retry when a connection fails to be established.

vertx-oracle-client/src/main/java/examples/OracleClientExamples.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2019 Contributors to the Eclipse Foundation
+ * Copyright (c) 2011-2021 Contributors to the Eclipse Foundation
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License 2.0 which is available at
@@ -17,13 +17,7 @@
 import io.vertx.docgen.Source;
 import io.vertx.oracleclient.OracleConnectOptions;
 import io.vertx.oracleclient.OraclePool;
-import io.vertx.sqlclient.Pool;
-import io.vertx.sqlclient.PoolOptions;
-import io.vertx.sqlclient.Row;
-import io.vertx.sqlclient.RowSet;
-import io.vertx.sqlclient.SqlClient;
-import io.vertx.sqlclient.SqlResult;
-import io.vertx.sqlclient.Tuple;
+import io.vertx.sqlclient.*;
 import io.vertx.sqlclient.data.Numeric;
 
 import java.math.BigDecimal;
@@ -33,7 +27,9 @@
 import java.util.stream.Collectors;
 
 @Source
+@SuppressWarnings("unused")
 public class OracleClientExamples {
+
   public void gettingStarted() {
 
     // Connect options
@@ -88,6 +84,18 @@ public void configureFromDataObject(Vertx vertx) {
     });
   }
 
+  public void configureFromUri(Vertx vertx) {
+
+    // Connection URI
+    String connectionUri = "oracle:thin:scott/tiger@myhost:1521:orcl";
+
+    // Pool Options
+    PoolOptions poolOptions = new PoolOptions().setMaxSize(5);
+
+    // Create the pool from the connection URI
+    OraclePool pool = OraclePool.pool(connectionUri, poolOptions);
+  }
+
   public void connecting01() {
 
     // Connect options

vertx-oracle-client/src/main/java/io/vertx/oracleclient/OracleConnectOptions.java

@@ -11,58 +11,51 @@
 package io.vertx.oracleclient;
 
 import io.vertx.codegen.annotations.DataObject;
-import io.vertx.core.json.JsonArray;
 import io.vertx.core.json.JsonObject;
+import io.vertx.core.net.SocketAddress;
 import io.vertx.core.tracing.TracingPolicy;
+import io.vertx.oracleclient.impl.OracleConnectionUriParser;
 import io.vertx.sqlclient.SqlConnectOptions;
 
+import java.util.Map;
+import java.util.function.Predicate;
+
 @DataObject(generateConverter = true)
 public class OracleConnectOptions extends SqlConnectOptions {
 
   // Support TNS_ADMIN (tnsnames.ora, ojdbc.properties).
   private String tnsAdmin;
 
-  private int connectTimeout;
-  private int idleTimeout;
-
-
-  private TracingPolicy tracingPolicy;
-
-  public OracleConnectOptions(JsonObject toJson) {
-    super(toJson);
-    // TODO Copy
-  }
-
   public OracleConnectOptions() {
+  }
 
+  public OracleConnectOptions(OracleConnectOptions other) {
+    super(other);
+    this.tnsAdmin = other.tnsAdmin;
   }
 
   public OracleConnectOptions(SqlConnectOptions options) {
     super(options);
-    // TODO Copy
   }
 
-  // TODO...
-
-  /**
-   * @return the tracing policy
-   */
-  public TracingPolicy getTracingPolicy() {
-    return tracingPolicy;
+  public OracleConnectOptions(JsonObject json) {
+    super(json);
+    OracleConnectOptionsConverter.fromJson(json, this);
   }
 
   /**
-   * Set the tracing policy for the client behavior when Vert.x has tracing enabled.
+   * Provide a {@link OracleConnectOptions} configured from a connection URI.
    *
-   * @param tracingPolicy the tracing policy
-   * @return a reference to this, so the API can be used fluently
+   * @param connectionUri the connection URI to configure from
+   * @return a {@link OracleConnectOptions} parsed from the connection URI
+   * @throws IllegalArgumentException when the {@code connectionUri} is in an invalid format
    */
-  public OracleConnectOptions setTracingPolicy(TracingPolicy tracingPolicy) {
-    this.tracingPolicy = tracingPolicy;
-    return this;
+  public static OracleConnectOptions fromUri(String connectionUri) throws IllegalArgumentException {
+    JsonObject parsedConfiguration = OracleConnectionUriParser.parse(connectionUri);
+    return new OracleConnectOptions(parsedConfiguration);
   }
 
-  // Oracle specifics
+  // Oracle-specific options
 
   public String getTnsAdmin() {
     return tnsAdmin;
@@ -73,51 +66,127 @@ public OracleConnectOptions setTnsAdmin(String tnsAdmin) {
     return this;
   }
 
+  // Non-specific options
+
   @Override
-  public OracleConnectOptions setPort(int port) {
-    super.setPort(port);
-    return this;
+  public String getHost() {
+    return super.getHost();
   }
 
   @Override
   public OracleConnectOptions setHost(String host) {
-    super.setHost(host);
-    return this;
+    return (OracleConnectOptions) super.setHost(host);
   }
 
   @Override
-  public OracleConnectOptions setDatabase(String db) {
-    super.setDatabase(db);
-    return this;
+  public int getPort() {
+    return super.getPort();
+  }
+
+  @Override
+  public OracleConnectOptions setPort(int port) {
+    return (OracleConnectOptions) super.setPort(port);
+  }
+
+  @Override
+  public String getUser() {
+    return super.getUser();
   }
 
   @Override
   public OracleConnectOptions setUser(String user) {
-    super.setUser(user);
-    return this;
+    return (OracleConnectOptions) super.setUser(user);
   }
 
   @Override
-  public OracleConnectOptions setPassword(String pwd) {
-    super.setPassword(pwd);
-    return this;
+  public String getPassword() {
+    return super.getPassword();
+  }
+
+  @Override
+  public OracleConnectOptions setPassword(String password) {
+    return (OracleConnectOptions) super.setPassword(password);
   }
 
-  public int getConnectTimeout() {
-    return connectTimeout;
+  @Override
+  public String getDatabase() {
+    return super.getDatabase();
   }
 
-  public OracleConnectOptions setConnectTimeout(int connectTimeout) {
-    this.connectTimeout = connectTimeout;
-    return this;
+  @Override
+  public OracleConnectOptions setDatabase(String database) {
+    return (OracleConnectOptions) super.setDatabase(database);
   }
 
-  public int getIdleTimeout() {
-    return idleTimeout;
+  @Override
+  public boolean getCachePreparedStatements() {
+    return super.getCachePreparedStatements();
   }
 
-  public OracleConnectOptions setIdleTimeout(int idleTimeout) {
-    this.idleTimeout = idleTimeout;
-    return this;
+  @Override
+  public OracleConnectOptions setCachePreparedStatements(boolean cachePreparedStatements) {
+    return (OracleConnectOptions) super.setCachePreparedStatements(cachePreparedStatements);
+  }
+
+  @Override
+  public int getPreparedStatementCacheMaxSize() {
+    return super.getPreparedStatementCacheMaxSize();
+  }
+
+  @Override
+  public OracleConnectOptions setPreparedStatementCacheMaxSize(int preparedStatementCacheMaxSize) {
+    return (OracleConnectOptions) super.setPreparedStatementCacheMaxSize(preparedStatementCacheMaxSize);
+  }
+
+  @Override
+  public Predicate<String> getPreparedStatementCacheSqlFilter() {
+    return super.getPreparedStatementCacheSqlFilter();
+  }
+
+  @Override
+  public OracleConnectOptions setPreparedStatementCacheSqlFilter(Predicate<String> predicate) {
+    return (OracleConnectOptions) super.setPreparedStatementCacheSqlFilter(predicate);
+  }
+
+  @Override
+  public OracleConnectOptions setPreparedStatementCacheSqlLimit(int preparedStatementCacheSqlLimit) {
+    return (OracleConnectOptions) super.setPreparedStatementCacheSqlLimit(preparedStatementCacheSqlLimit);
+  }
+
+  @Override
+  public Map<String, String> getProperties() {
+    return super.getProperties();
+  }
+
+  @Override
+  public OracleConnectOptions setProperties(Map<String, String> properties) {
+    return (OracleConnectOptions) super.setProperties(properties);
+  }
+
+  @Override
+  public OracleConnectOptions addProperty(String key, String value) {
+    return (OracleConnectOptions) super.addProperty(key, value);
+  }
+
+  @Override
+  public SocketAddress getSocketAddress() {
+    return super.getSocketAddress();
+  }
+
+  @Override
+  public TracingPolicy getTracingPolicy() {
+    return super.getTracingPolicy();
+  }
+
+  @Override
+  public OracleConnectOptions setTracingPolicy(TracingPolicy tracingPolicy) {
+    return (OracleConnectOptions) super.setTracingPolicy(tracingPolicy);
+  }
+
+  @Override
+  public JsonObject toJson() {
+    JsonObject json = super.toJson();
+    OracleConnectOptionsConverter.toJson(this, json);
+    return json;
   }
 }

vertx-oracle-client/src/main/java/io/vertx/oracleclient/OraclePool.java

@@ -38,7 +38,6 @@ public interface OraclePool extends Pool {
    */
   PropertyKind<Boolean> OUTPUT = PropertyKind.create("callable-statement-output", Boolean.class);
 
-
   static OraclePool pool(OracleConnectOptions connectOptions, PoolOptions poolOptions) {
     if (Vertx.currentContext() != null) {
       throw new IllegalStateException(
@@ -60,6 +59,17 @@ static OraclePool pool(Vertx vertx, OracleConnectOptions connectOptions, PoolOpt
     return OraclePoolImpl.create((VertxInternal) vertx, false, connectOptions, poolOptions, tracer);
   }
 
-  // TODO No option version
+  /**
+   * Like {@link #pool(OracleConnectOptions, PoolOptions)} but connection options are created from the provided {@code connectionUri}.
+   */
+  static OraclePool pool(String connectionUri, PoolOptions poolOptions) {
+    return pool(OracleConnectOptions.fromUri(connectionUri), poolOptions);
+  }
 
+  /**
+   * Like {@link #pool(String, PoolOptions)} with a specific {@link Vertx} instance.
+   */
+  static OraclePool pool(Vertx vertx, String connectionUri, PoolOptions poolOptions) {
+    return pool(vertx, OracleConnectOptions.fromUri(connectionUri), poolOptions);
+  }
 }