use of io.vertx.pgclient.PgPool in project raml-module-builder by folio-org.
the class PostgresClientTransactionsIT method postgresClientMonitor.
private PostgresClient postgresClientMonitor(AtomicInteger open, AtomicInteger active) {
try {
PostgresClient postgresClient = new PostgresClient(vertx, tenant);
PgPool ePool = postgresClient.getClient();
PgPool client = new PgPoolBase() {
@Override
public Future<SqlConnection> getConnection() {
return ePool.getConnection().map(conn -> new MonitorPgConnection((PgConnection) conn, open, active));
}
@Override
public Query<RowSet<Row>> query(String s) {
return ePool.query(s);
}
@Override
public PreparedQuery<RowSet<Row>> preparedQuery(String s) {
return ePool.preparedQuery(s);
}
@Override
public Future<Void> close() {
return ePool.close();
}
};
postgresClient.setClient(client);
return postgresClient;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
use of io.vertx.pgclient.PgPool in project raml-module-builder by folio-org.
the class PostgresClientIT method postgresClientQueryFails.
/**
* @return a PostgresClient where invoking SQLConnection::update, SQLConnection::updateWithParams or
* SQLConnection::queryWithParams will report a failure via the resultHandler.
*/
private PostgresClient postgresClientQueryFails() {
PgConnection pgConnection = new PgConnection() {
@Override
public PgConnection notificationHandler(Handler<PgNotification> handler) {
return this;
}
@Override
public PgConnection cancelRequest(Handler<AsyncResult<Void>> handler) {
handler.handle(Future.failedFuture("cancelRequestFails"));
return this;
}
@Override
public int processId() {
return 0;
}
@Override
public int secretKey() {
return 0;
}
@Override
public PgConnection prepare(String s, Handler<AsyncResult<PreparedStatement>> handler) {
prepare(s).onComplete(handler);
return null;
}
@Override
public Future<PreparedStatement> prepare(String s) {
return Future.failedFuture("preparedFails");
}
@Override
public SqlConnection prepare(String sql, PrepareOptions options, Handler<AsyncResult<PreparedStatement>> handler) {
prepare(sql, options).onComplete(handler);
return null;
}
@Override
public Future<PreparedStatement> prepare(String sql, PrepareOptions options) {
return prepare(sql);
}
@Override
public PgConnection exceptionHandler(Handler<Throwable> handler) {
return null;
}
@Override
public PgConnection closeHandler(Handler<Void> handler) {
return null;
}
@Override
public void begin(Handler<AsyncResult<Transaction>> handler) {
}
@Override
public Future<Transaction> begin() {
return null;
}
@Override
public boolean isSSL() {
return false;
}
@Override
public void close(Handler<AsyncResult<Void>> handler) {
}
@Override
public Query<RowSet<Row>> query(String s) {
return new Query<RowSet<Row>>() {
@Override
public void execute(Handler<AsyncResult<RowSet<Row>>> handler) {
handler.handle(execute());
}
@Override
public Future<RowSet<Row>> execute() {
return Future.failedFuture("queryFails");
}
@Override
public <R> Query<SqlResult<R>> collecting(Collector<Row, ?, R> collector) {
return null;
}
@Override
public <U> Query<RowSet<U>> mapping(Function<Row, U> function) {
return null;
}
};
}
@Override
public PreparedQuery<RowSet<Row>> preparedQuery(String sql, PrepareOptions options) {
return preparedQuery(sql);
}
@Override
public PreparedQuery<RowSet<Row>> preparedQuery(String s) {
throw new RuntimeException("queryFails");
}
@Override
public Future<Void> close() {
return null;
}
@Override
public DatabaseMetadata databaseMetadata() {
return null;
}
};
PgPool client = new PgPoolBase() {
@Override
public Future<SqlConnection> getConnection() {
return Future.succeededFuture(pgConnection);
}
};
try {
PostgresClient postgresClient = new PostgresClient(vertx, TENANT);
postgresClient.setClient(client);
return postgresClient;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
use of io.vertx.pgclient.PgPool in project raml-module-builder by folio-org.
the class PostgresClient method closeClient.
/**
* Close the SQL client of this PostgresClient instance.
* This is idempotent: additional close invocations are always successful.
*/
public Future<Void> closeClient() {
if (client == null) {
return Future.succeededFuture();
}
PgPool clientToClose = client;
client = null;
// remove (vertx, tenantId, this) entry
CONNECTION_POOL.removeMultiKey(vertx, tenantId);
if (sharedPgPool) {
return Future.succeededFuture();
}
return clientToClose.close();
}
Aggregations