/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.vertx.reactivex.pgclient;

import io.vertx.reactivex.RxHelper;
import io.vertx.reactivex.ObservableHelper;
import io.vertx.reactivex.FlowableHelper;
import io.vertx.reactivex.impl.AsyncResultMaybe;
import io.vertx.reactivex.impl.AsyncResultSingle;
import io.vertx.reactivex.impl.AsyncResultCompletable;
import io.vertx.reactivex.WriteStreamObserver;
import io.vertx.reactivex.WriteStreamSubscriber;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.lang.rx.RxGen;
import io.vertx.lang.rx.TypeArg;
import io.vertx.lang.rx.MappingIterator;

A connection to Postgres.

The connection object supports all the operations defined in the interface, it also provides additional support:

  • Notification
  • Request Cancellation

NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.
/** * A connection to Postgres. * <P> * The connection object supports all the operations defined in the interface, * it also provides additional support: * <ul> * <li>Notification</li> * <li>Request Cancellation</li> * </ul> * </P> * * <p/> * NOTE: This class has been automatically generated from the {@link io.vertx.pgclient.PgConnection original} non RX-ified interface using Vert.x codegen. */
@RxGen(io.vertx.pgclient.PgConnection.class) public class PgConnection extends io.vertx.reactivex.sqlclient.SqlConnection { @Override public String toString() { return delegate.toString(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; PgConnection that = (PgConnection) o; return delegate.equals(that.delegate); } @Override public int hashCode() { return delegate.hashCode(); } public static final TypeArg<PgConnection> __TYPE_ARG = new TypeArg<>( obj -> new PgConnection((io.vertx.pgclient.PgConnection) obj), PgConnection::getDelegate ); private final io.vertx.pgclient.PgConnection delegate; public PgConnection(io.vertx.pgclient.PgConnection delegate) { super(delegate); this.delegate = delegate; } public PgConnection(Object delegate) { super((io.vertx.pgclient.PgConnection)delegate); this.delegate = (io.vertx.pgclient.PgConnection)delegate; } public io.vertx.pgclient.PgConnection getDelegate() { return delegate; }
Connects to the database and returns the connection if that succeeds.

The connection interracts directly with the database is not a proxy, so closing the connection will close the underlying connection to the database.
Params:
  • vertx – the vertx instance
  • options – the connect options
  • handler – the handler called with the connection or the failure
/** * Connects to the database and returns the connection if that succeeds. * <p/> * The connection interracts directly with the database is not a proxy, so closing the * connection will close the underlying connection to the database. * @param vertx the vertx instance * @param options the connect options * @param handler the handler called with the connection or the failure */
public static void connect(io.vertx.reactivex.core.Vertx vertx, io.vertx.pgclient.PgConnectOptions options, Handler<AsyncResult<io.vertx.reactivex.pgclient.PgConnection>> handler) { io.vertx.pgclient.PgConnection.connect(vertx.getDelegate(), options, new Handler<AsyncResult<io.vertx.pgclient.PgConnection>>() { public void handle(AsyncResult<io.vertx.pgclient.PgConnection> ar) { if (ar.succeeded()) { handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.reactivex.pgclient.PgConnection.newInstance((io.vertx.pgclient.PgConnection)ar.result()))); } else { handler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } }); }
Connects to the database and returns the connection if that succeeds.

The connection interracts directly with the database is not a proxy, so closing the connection will close the underlying connection to the database.
Params:
  • vertx – the vertx instance
  • options – the connect options
/** * Connects to the database and returns the connection if that succeeds. * <p/> * The connection interracts directly with the database is not a proxy, so closing the * connection will close the underlying connection to the database. * @param vertx the vertx instance * @param options the connect options */
public static void connect(io.vertx.reactivex.core.Vertx vertx, io.vertx.pgclient.PgConnectOptions options) { connect(vertx, options, ar -> { }); }
Connects to the database and returns the connection if that succeeds.

The connection interracts directly with the database is not a proxy, so closing the connection will close the underlying connection to the database.
Params:
  • vertx – the vertx instance
  • options – the connect options
Returns:
/** * Connects to the database and returns the connection if that succeeds. * <p/> * The connection interracts directly with the database is not a proxy, so closing the * connection will close the underlying connection to the database. * @param vertx the vertx instance * @param options the connect options * @return */
public static io.reactivex.Single<io.vertx.reactivex.pgclient.PgConnection> rxConnect(io.vertx.reactivex.core.Vertx vertx, io.vertx.pgclient.PgConnectOptions options) { return AsyncResultSingle.toSingle($handler -> { connect(vertx, options, $handler); }); }
Like connect with options build from the environment variables.
Params:
  • vertx –
  • handler –
/** * Like {@link io.vertx.reactivex.pgclient.PgConnection#connect} with options build from the environment variables. * @param vertx * @param handler */
public static void connect(io.vertx.reactivex.core.Vertx vertx, Handler<AsyncResult<io.vertx.reactivex.pgclient.PgConnection>> handler) { io.vertx.pgclient.PgConnection.connect(vertx.getDelegate(), new Handler<AsyncResult<io.vertx.pgclient.PgConnection>>() { public void handle(AsyncResult<io.vertx.pgclient.PgConnection> ar) { if (ar.succeeded()) { handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.reactivex.pgclient.PgConnection.newInstance((io.vertx.pgclient.PgConnection)ar.result()))); } else { handler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } }); }
Like connect with options build from the environment variables.
Params:
  • vertx –
/** * Like {@link io.vertx.reactivex.pgclient.PgConnection#connect} with options build from the environment variables. * @param vertx */
public static void connect(io.vertx.reactivex.core.Vertx vertx) { connect(vertx, ar -> { }); }
Like connect with options build from the environment variables.
Params:
  • vertx –
Returns:
/** * Like {@link io.vertx.reactivex.pgclient.PgConnection#connect} with options build from the environment variables. * @param vertx * @return */
public static io.reactivex.Single<io.vertx.reactivex.pgclient.PgConnection> rxConnect(io.vertx.reactivex.core.Vertx vertx) { return AsyncResultSingle.toSingle($handler -> { connect(vertx, $handler); }); }
Like connect with options build from connectionUri.
Params:
  • vertx –
  • connectionUri –
  • handler –
/** * Like {@link io.vertx.reactivex.pgclient.PgConnection#connect} with options build from <code>connectionUri</code>. * @param vertx * @param connectionUri * @param handler */
public static void connect(io.vertx.reactivex.core.Vertx vertx, String connectionUri, Handler<AsyncResult<io.vertx.reactivex.pgclient.PgConnection>> handler) { io.vertx.pgclient.PgConnection.connect(vertx.getDelegate(), connectionUri, new Handler<AsyncResult<io.vertx.pgclient.PgConnection>>() { public void handle(AsyncResult<io.vertx.pgclient.PgConnection> ar) { if (ar.succeeded()) { handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.reactivex.pgclient.PgConnection.newInstance((io.vertx.pgclient.PgConnection)ar.result()))); } else { handler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } }); }
Like connect with options build from connectionUri.
Params:
  • vertx –
  • connectionUri –
/** * Like {@link io.vertx.reactivex.pgclient.PgConnection#connect} with options build from <code>connectionUri</code>. * @param vertx * @param connectionUri */
public static void connect(io.vertx.reactivex.core.Vertx vertx, String connectionUri) { connect(vertx, connectionUri, ar -> { }); }
Like connect with options build from connectionUri.
Params:
  • vertx –
  • connectionUri –
Returns:
/** * Like {@link io.vertx.reactivex.pgclient.PgConnection#connect} with options build from <code>connectionUri</code>. * @param vertx * @param connectionUri * @return */
public static io.reactivex.Single<io.vertx.reactivex.pgclient.PgConnection> rxConnect(io.vertx.reactivex.core.Vertx vertx, String connectionUri) { return AsyncResultSingle.toSingle($handler -> { connect(vertx, connectionUri, $handler); }); }
Set an handler called when the connection receives notification on a channel.

The handler is called with the PgNotification and has access to the channel name and the notification payload.
Params:
  • handler – the handler
Returns:the transaction instance
/** * Set an handler called when the connection receives notification on a channel. * <p/> * The handler is called with the {@link io.vertx.pgclient.PgNotification} and has access to the channel name * and the notification payload. * @param handler the handler * @return the transaction instance */
public io.vertx.reactivex.pgclient.PgConnection notificationHandler(Handler<io.vertx.pgclient.PgNotification> handler) { delegate.notificationHandler(handler); return this; }
Send a request cancellation message to tell the server to cancel processing request in this connection.
Note: Use this with caution because the cancellation signal may or may not have any effect.
Params:
  • handler – the handler notified if cancelling request is sent
Returns:a reference to this, so the API can be used fluently
/** * Send a request cancellation message to tell the server to cancel processing request in this connection. * <br>Note: Use this with caution because the cancellation signal may or may not have any effect. * @param handler the handler notified if cancelling request is sent * @return a reference to this, so the API can be used fluently */
public io.vertx.reactivex.pgclient.PgConnection cancelRequest(Handler<AsyncResult<Void>> handler) { io.vertx.reactivex.pgclient.PgConnection ret = io.vertx.reactivex.pgclient.PgConnection.newInstance((io.vertx.pgclient.PgConnection)delegate.cancelRequest(handler)); return ret; }
Returns:The process ID of the target backend
/** * @return The process ID of the target backend */
public int processId() { int ret = delegate.processId(); return ret; }
Returns:The secret key for the target backend
/** * @return The secret key for the target backend */
public int secretKey() { int ret = delegate.secretKey(); return ret; }
Params:
  • sql –
  • handler –
Returns:
/** * * @param sql * @param handler * @return */
public io.vertx.reactivex.pgclient.PgConnection prepare(String sql, Handler<AsyncResult<io.vertx.reactivex.sqlclient.PreparedStatement>> handler) { delegate.prepare(sql, new Handler<AsyncResult<io.vertx.sqlclient.PreparedStatement>>() { public void handle(AsyncResult<io.vertx.sqlclient.PreparedStatement> ar) { if (ar.succeeded()) { handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.reactivex.sqlclient.PreparedStatement.newInstance((io.vertx.sqlclient.PreparedStatement)ar.result()))); } else { handler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } }); return this; }
Params:
  • sql –
Returns:
/** * * @param sql * @return */
public io.vertx.reactivex.pgclient.PgConnection prepare(String sql) { return prepare(sql, ar -> { }); }
Params:
  • sql –
Returns:
/** * * @param sql * @return */
public io.reactivex.Single<io.vertx.reactivex.sqlclient.PreparedStatement> rxPrepare(String sql) { return AsyncResultSingle.toSingle($handler -> { prepare(sql, $handler); }); }
Params:
  • handler –
Returns:
/** * * @param handler * @return */
public io.vertx.reactivex.pgclient.PgConnection exceptionHandler(Handler<java.lang.Throwable> handler) { delegate.exceptionHandler(handler); return this; }
Params:
  • handler –
Returns:
/** * * @param handler * @return */
public io.vertx.reactivex.pgclient.PgConnection closeHandler(Handler<Void> handler) { delegate.closeHandler(handler); return this; } public static PgConnection newInstance(io.vertx.pgclient.PgConnection arg) { return arg != null ? new PgConnection(arg) : null; } }