@Override public SQLClient getConnection(Handler<AsyncResult<SQLConnection>> handler) { return client.getConnection(handler); } }
@Override public void shutdown(Handler<AsyncResult<Void>> resultHandler) { sqlClient.close(resultHandler); }
/** * 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 * @param handler the result handler * @return self */ public io.vertx.rxjava.ext.sql.SQLOperations querySingle(String sql, Handler<AsyncResult<JsonArray>> handler) { delegate.querySingle(sql, handler); return this; }
/** * 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 * @param handler the result handler * @return self */ public io.vertx.rxjava.ext.sql.SQLOperations querySingleWithParams(String sql, JsonArray arguments, Handler<AsyncResult<JsonArray>> handler) { delegate.querySingleWithParams(sql, arguments, handler); return this; }
public static io.vertx.ext.sql.SQLOperations querySingleWithParams(io.vertx.ext.asyncsql.AsyncSQLClient j_receiver, java.lang.String sql, java.util.List<Object> arguments, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<Object>>> handler) { io.vertx.core.impl.ConversionHelper.fromObject(j_receiver.querySingleWithParams(sql, arguments != null ? io.vertx.core.impl.ConversionHelper.toJsonArray(arguments) : null, handler != null ? new io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray>>() { public void handle(io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray> ar) { handler.handle(ar.map(event -> io.vertx.core.impl.ConversionHelper.fromJsonArray(event))); } } : null)); return j_receiver; } }
@Override public SQLClient getConnection(Handler<AsyncResult<SQLConnection>> handler) { return client.getConnection(handler); } }
synchronized void close(Handler<AsyncResult<Void>> whenDone) { if (--refCount == 0) { if (client != null) { client.close(whenDone); } if (closeRunner != null) { closeRunner.run(); } } } }
public static io.vertx.ext.sql.SQLOperations querySingle(io.vertx.ext.asyncsql.AsyncSQLClient j_receiver, java.lang.String sql, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<Object>>> handler) { io.vertx.core.impl.ConversionHelper.fromObject(j_receiver.querySingle(sql, handler != null ? new io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray>>() { public void handle(io.vertx.core.AsyncResult<io.vertx.core.json.JsonArray> ar) { handler.handle(ar.map(event -> io.vertx.core.impl.ConversionHelper.fromJsonArray(event))); } } : null)); return j_receiver; } public static io.vertx.ext.sql.SQLOperations querySingleWithParams(io.vertx.ext.asyncsql.AsyncSQLClient j_receiver, java.lang.String sql, java.util.List<Object> arguments, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<Object>>> handler) {
@Override public SQLClient getConnection(Handler<AsyncResult<SQLConnection>> handler) { return client.getConnection(handler); } }
synchronized void close(Handler<AsyncResult<Void>> whenDone) { if (--refCount == 0) { if (client != null) { client.close(whenDone); } if (closeRunner != null) { closeRunner.run(); } } } }
/** * @return a Future that returns a SQLConnection or an Exception. */ private Future<SQLConnection> getConnection(){ Future<SQLConnection> future = Future.future(); delegate.getConnection(future); return future; }
synchronized void close(Handler<AsyncResult<Void>> whenDone) { if (--refCount == 0) { if (client != null) { client.close(whenDone); } if (closeRunner != null) { closeRunner.run(); } } } }
/** * @return a Future that returns a SQLConnection or an Exception. */ protected Future<SQLConnection> getConnection(){ Future<SQLConnection> future = Future.future(); delegate.getConnection(future); return future; }
/** * @return a Future that returns a SQLConnection or an Exception. */ protected Future<SQLConnection> getConnection(){ Future<SQLConnection> future = Future.future(); delegate.getConnection(future); return future; }
/** * @return a Future that returns a SQLConnection or an Exception. */ private Future<SQLConnection> getConnection(){ Future<SQLConnection> future = Future.future(); delegate.getConnection(future); return future; }
/** * @return a CompletableFuture that returns a SQLConnection or an Exception. */ protected CompletableFuture<SQLConnection> getConnection(){ CompletableFuture<SQLConnection> cf = new VertxCompletableFuture<>(vertx); delegate.getConnection(h -> { if (h.succeeded()) { cf.complete(h.result()); } else { cf.completeExceptionally(h.cause()); } }); return cf; }
public void getConnection(Handler<ExtendedAsyncResult<SQLConnection>> fut) { cli.getConnection(res -> { if (res.failed()) { fut.handle(new Failure<>(INTERNAL, res.cause())); } else { SQLConnection con = res.result(); fut.handle(new Success<>(con)); } }); }
/** * @return a CompletableFuture that returns a SQLConnection or an Exception. */ private CompletableFuture<SQLConnection> getConnection(){ CompletableFuture<SQLConnection> cf = new VertxCompletableFuture<>(vertx); delegate.getConnection(h -> { if (h.succeeded()) { cf.complete(h.result()); } else { cf.completeExceptionally(h.cause()); } }); return cf; }
/** * @return a CompletableFuture that returns a SQLConnection or an Exception. */ private CompletableFuture<SQLConnection> getConnection(){ CompletableFuture<SQLConnection> cf = new VertxCompletableFuture<>(vertx); delegate.getConnection(h -> { if (h.succeeded()) { cf.complete(h.result()); } else { cf.completeExceptionally(h.cause()); } }); return cf; }
/** * Executes the given query and returns the {@link ResultSet} to the {@link Handler} * * @param sqlClient * the sqlClient to obtain the connection from * @param command * the command to be executed * @param resultHandler * a resulthandler to be informed */ public static void queryWithParams(AsyncSQLClient sqlClient, String command, JsonArray params, Handler<AsyncResult<ResultSet>> resultHandler) { LOGGER.debug("queryWithParams: " + command + " | " + params); sqlClient.getConnection(cr -> { if (cr.failed()) { Exception sqlEx = new SqlException(ERROR_GAINING_CONNECTION, cr.cause()); LOGGER.error("", sqlEx); resultHandler.handle(Future.failedFuture(sqlEx)); return; } SQLConnection connection = cr.result(); LOGGER.debug(GAINED_SUCCESSFULLY_A_CONNECTION); doQueryWithParams(command, params, resultHandler, connection); }); }