@Override public void start() throws Exception { JsonObject config = new JsonObject().put("url", "jdbc:hsqldb:mem:test?shutdown=true") .put("driver_class", "org.hsqldb.jdbcDriver"); JDBCClient jdbc = JDBCClient.createShared(vertx, config); // Connect to the database jdbc.rxGetConnection().flatMap(conn -> { // Now chain some statements using flatmap composition Single<ResultSet> resa = conn.rxUpdate("CREATE TABLE test(col VARCHAR(20))") .flatMap(result -> conn.rxUpdate("INSERT INTO test (col) VALUES ('val1')")) .flatMap(result -> conn.rxUpdate("INSERT INTO test (col) VALUES ('val2')")) .flatMap(result -> conn.rxQuery("SELECT * FROM test")); return resa.doAfterTerminate(conn::close); }).subscribe(resultSet -> { // Subscribe to the final result System.out.println("Results : " + resultSet.getRows()); }, err -> { System.out.println("Database problem"); err.printStackTrace(); }); } }
@Test public void testStreamRX() { JDBCClient client = new JDBCClient(io.vertx.ext.jdbc.JDBCClient.createNonShared(vertx, config)); try { client.getConnection(onSuccess(conn -> { await(); } finally { client.close();
public CartEventDataSourceImpl(io.vertx.core.Vertx vertx, JsonObject json) { this.client = JDBCClient.createNonShared(Vertx.newInstance(vertx), json); // TODO: Should not init the table here. client.rxGetConnection() .flatMap(connection -> connection.rxExecute(INIT_STATEMENT) .doAfterTerminate(connection::close) ) .subscribe(); }
public void handle(AsyncResult<io.vertx.ext.jdbc.JDBCClient> ar) { if (ar.succeeded()) { resultHandler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.ext.jdbc.JDBCClient.newInstance(ar.result()))); } else { resultHandler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } });
@Override public Single<Optional<CartEvent>> retrieveOne(Long id) { return client.rxGetConnection() .flatMap(conn -> conn.rxQueryWithParams(RETRIEVE_STATEMENT, new JsonArray().add(id)) .map(ResultSet::getRows) .map(list -> { if (list.isEmpty()) { return Optional.<CartEvent>empty(); } else { return Optional.of(list.get(0)) .map(this::wrapCartEvent); } }) .doAfterTerminate(conn::close) ); }
public static JDBCClient newInstance(io.vertx.ext.jdbc.JDBCClient arg) { return arg != null ? new JDBCClient(arg) : null; } }
/** * Execute a one shot SQL statement that returns a single SQL row. This method will reduce the boilerplate code by * getting a connection from the pool (this object) and return it back after the execution. Only the first result * from the result set is returned. * @param sql the statement to execute * @return self */ public Single<JsonArray> rxQuerySingle(String sql) { return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> { querySingle(sql, fut); })); }
/** * Execute a one shot SQL statement with arguments that returns a single SQL row. This method will reduce the * boilerplate code by getting a connection from the pool (this object) and return it back after the execution. * Only the first result from the result set is returned. * @param sql the statement to execute * @param arguments the arguments * @return self * @deprecated use {@link #rxQuerySingleWithParams} instead */ @Deprecated() public Observable<JsonArray> querySingleWithParamsObservable(String sql, JsonArray arguments) { io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture(); querySingleWithParams(sql, arguments, handler.toHandler()); return handler; }
/** * Create a JDBC auth provider implementation * @param vertx * @param client the JDBC client instance * @return the auth provider */ public static io.vertx.rxjava.ext.auth.jdbc.JDBCAuth create(io.vertx.rxjava.core.Vertx vertx, io.vertx.rxjava.ext.jdbc.JDBCClient client) { io.vertx.rxjava.ext.auth.jdbc.JDBCAuth ret = io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.newInstance(io.vertx.ext.auth.jdbc.JDBCAuth.create(vertx.getDelegate(), client.getDelegate())); return ret; }
public void handle(AsyncResult<io.vertx.ext.jdbc.JDBCClient> ar) { if (ar.succeeded()) { resultHandler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.ext.jdbc.JDBCClient.newInstance(ar.result()))); } else { resultHandler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } });
@Override public Observable<CartEvent> streamByUser(String userId) { JsonArray params = new JsonArray().add(userId).add(userId); return client.rxGetConnection() .flatMapObservable(conn -> conn.rxQueryWithParams(STREAM_STATEMENT, params) .map(ResultSet::getRows) .flatMapObservable(Observable::from) .map(this::wrapCartEvent) .doOnTerminate(conn::close) ); }
public static JDBCClient newInstance(io.vertx.ext.jdbc.JDBCClient arg) { return arg != null ? new JDBCClient(arg) : null; } }
/** * Execute a one shot SQL statement that returns a single SQL row. This method will reduce the boilerplate code by * getting a connection from the pool (this object) and return it back after the execution. Only the first result * from the result set is returned. * @param sql the statement to execute * @return self * @deprecated use {@link #rxQuerySingle} instead */ @Deprecated() public Observable<JsonArray> querySingleObservable(String sql) { io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture(); querySingle(sql, handler.toHandler()); return handler; }
/** * Execute a one shot SQL statement with arguments that returns a single SQL row. This method will reduce the * boilerplate code by getting a connection from the pool (this object) and return it back after the execution. * Only the first result from the result set is returned. * @param sql the statement to execute * @param arguments the arguments * @return self */ public Single<JsonArray> rxQuerySingleWithParams(String sql, JsonArray arguments) { return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> { querySingleWithParams(sql, arguments, fut); })); }
/** * Create a JDBC auth provider implementation * @param vertx * @param client the JDBC client instance * @return the auth provider */ public static io.vertx.rxjava.ext.auth.jdbc.JDBCAuth create(io.vertx.rxjava.core.Vertx vertx, io.vertx.rxjava.ext.jdbc.JDBCClient client) { io.vertx.rxjava.ext.auth.jdbc.JDBCAuth ret = io.vertx.rxjava.ext.auth.jdbc.JDBCAuth.newInstance(io.vertx.ext.auth.jdbc.JDBCAuth.create(vertx.getDelegate(), client.getDelegate())); return ret; }
@Override public void start() throws Exception { JsonObject config = new JsonObject().put("url", "jdbc:hsqldb:mem:test?shutdown=true") .put("driver_class", "org.hsqldb.jdbcDriver"); JDBCClient jdbc = JDBCClient.createShared(vertx, config); jdbc .rxGetConnection() // Connect to the database .flatMapObservable(conn -> { // With the connection... return conn.rxUpdate("CREATE TABLE test(col VARCHAR(20))") // ...create test table .flatMap(result -> conn.rxUpdate("INSERT INTO test (col) VALUES ('val1')")) // ...insert a row .flatMap(result -> conn.rxUpdate("INSERT INTO test (col) VALUES ('val2')")) // ...another one .flatMap(result -> conn.rxQueryStream("SELECT * FROM test")) // ...get values stream .flatMapObservable(sqlRowStream -> { return sqlRowStream.toObservable() // Transform the stream into an Observable... .doOnTerminate(conn::close); // ...and close the connection when the stream is fully read or an error occurs }); }).subscribe(row -> System.out.println("Row : " + row.encode())); } }
public void handle(AsyncResult<io.vertx.ext.jdbc.JDBCClient> ar) { if (ar.succeeded()) { resultHandler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.ext.jdbc.JDBCClient.newInstance(ar.result()))); } else { resultHandler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } });
@Override public Single<Void> save(CartEvent cartEvent) { JsonArray params = new JsonArray().add(cartEvent.getCartEventType().name()) .add(cartEvent.getUserId()) .add(cartEvent.getProductId()) .add(cartEvent.getAmount()) .add(cartEvent.getCreatedAt() > 0 ? cartEvent.getCreatedAt() : System.currentTimeMillis()); return client.rxGetConnection() .flatMap(conn -> conn.rxUpdateWithParams(SAVE_STATEMENT, params) .map(r -> (Void) null) .doAfterTerminate(conn::close) ); }
@Override public void setUp() throws Exception { super.setUp(); client = new JDBCClient(io.vertx.ext.jdbc.JDBCClient.createNonShared(vertx, config)); client.rxGetConnection().flatMapCompletable(conn -> { Completable setup = conn.rxExecute("drop table folks if exists").toCompletable() .andThen(conn.rxExecute("create table folks (firstname varchar(255) not null)").toCompletable()); for (String name : NAMES) { setup = setup.andThen(conn.rxExecute(String.format(INSERT_FOLK_SQL, name)).toCompletable()); } return setup.doAfterTerminate(conn::close); }).await(); }
/** * Execute a one shot SQL statement that returns a single SQL row. This method will reduce the boilerplate code by * getting a connection from the pool (this object) and return it back after the execution. Only the first result * from the result set is returned. * @param sql the statement to execute * @return self */ public Single<JsonArray> rxQuerySingle(String sql) { return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> { querySingle(sql, fut); })); }