Pool (Vert.x Stack - Docs 4.2.7 API)

java.lang.Object
- io.vertx.reactivex.sqlclient.SqlClient
- - io.vertx.reactivex.sqlclient.Pool

Direct Known Subclasses:

DB2Pool, JDBCPool, MSSQLPool, MySQLPool, PgPool
```
public class Pool
extends SqlClient
```
A connection pool which reuses a number of SQL connections.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field and Description

static io.vertx.lang.rx.TypeArg<Pool> __TYPE_ARG

Fields
Modifier and Type	Field and Description
`static io.vertx.lang.rx.TypeArg<Pool>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

Pool(Object delegate)

Pool(Pool delegate)

Constructors
Constructor and Description
`Pool(Object delegate)`
`Pool(Pool delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`close()` Close the pool and release the associated resources.
`void`	`close(Handler<AsyncResult<Void>> handler)` Close the pool and release the associated resources.
`Pool`	`connectHandler(Handler<SqlConnection> handler)` Set an handler called when the pool has established a connection to the database.
`Pool`	`connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)` Replace the default pool connection provider, the new `provider` returns a future connection for a given .
`Pool`	`connectionProvider(Function<Context,Single<SqlConnection>> provider)` Replace the default pool connection provider, the new `provider` returns a future connection for a given .
`boolean`	`equals(Object o)`
`void`	`getConnection()` Get a connection from the pool.
`void`	`getConnection(Handler<AsyncResult<SqlConnection>> handler)` Get a connection from the pool.
`Pool`	`getDelegate()`
`int`	`hashCode()`
`static Pool`	`newInstance(Pool arg)`
`static Pool`	`pool(SqlConnectOptions connectOptions)` Like `pool(io.vertx.sqlclient.SqlConnectOptions)` with default options.
`static Pool`	`pool(SqlConnectOptions database, PoolOptions options)` Like `pool(io.vertx.sqlclient.SqlConnectOptions)` with a Vert.x instance created automatically.
`static Pool`	`pool(Vertx vertx, SqlConnectOptions database, PoolOptions options)` Create a connection pool to the `database` with the given `options`.
`PreparedQuery<RowSet<Row>>`	`preparedQuery(String sql)` A connection is borrowed from the connection pool when the query is executed and then immediately returned to the pool after it completes.
`Query<RowSet<Row>>`	`query(String sql)` A connection is borrowed from the connection pool when the query is executed and then immediately returned to the pool after it completes.
`Completable`	`rxClose()` Close the pool and release the associated resources.
`Single<SqlConnection>`	`rxGetConnection()` Get a connection from the pool.
`<T> Maybe<T>`	`rxWithConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Get a connection from the pool and execute the given `function`.
`<T> Maybe<T>`	`rxWithConnection(Function<SqlConnection,Maybe<T>> function)` Get a connection from the pool and execute the given `function`.
`<T> Maybe<T>`	`rxWithTransaction(java.util.function.Function<SqlConnection,Future<T>> function)` Execute the given `function` within a transaction.
`<T> Maybe<T>`	`rxWithTransaction(Function<SqlConnection,Maybe<T>> function)` Execute the given `function` within a transaction.
`int`	`size()`
`String`	`toString()`
`<T> void`	`withConnection(java.util.function.Function<SqlConnection,Future<T>> function)` Get a connection from the pool and execute the given `function`.
`<T> void`	`withConnection(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Get a connection from the pool and execute the given `function`.
`<T> void`	`withConnection(Function<SqlConnection,Maybe<T>> function)` Get a connection from the pool and execute the given `function`.
`<T> void`	`withConnection(Function<SqlConnection,Maybe<T>> function, Handler<AsyncResult<T>> handler)` Get a connection from the pool and execute the given `function`.
`<T> void`	`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function)` Execute the given `function` within a transaction.
`<T> void`	`withTransaction(java.util.function.Function<SqlConnection,Future<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.
`<T> void`	`withTransaction(Function<SqlConnection,Maybe<T>> function)` Execute the given `function` within a transaction.
`<T> void`	`withTransaction(Function<SqlConnection,Maybe<T>> function, Handler<AsyncResult<T>> handler)` Execute the given `function` within a transaction.

Methods inherited from class io.vertx.reactivex.sqlclient.SqlClient
newInstance, preparedQuery

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __TYPE_ARG
```
public static final io.vertx.lang.rx.TypeArg<Pool> __TYPE_ARG
```
- Constructor Detail
  - Pool
```
public Pool(Pool delegate)
```
  - Pool
```
public Pool(Object delegate)
```
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class SqlClient
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class SqlClient
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class SqlClient
  - getDelegate
```
public Pool getDelegate()
```
    Overrides:
    
    getDelegate in class SqlClient
  - pool
```
public static Pool pool(SqlConnectOptions connectOptions)
```
    Like pool(io.vertx.sqlclient.SqlConnectOptions) with default options.
    
    Parameters:
    
    connectOptions -
    
    Returns:
  - pool
```
public static Pool pool(SqlConnectOptions database,
                        PoolOptions options)
```
    Like pool(io.vertx.sqlclient.SqlConnectOptions) with a Vert.x instance created automatically.
    
    Parameters:
    
    database -
    
    options -
    
    Returns:
  - pool
```
public static Pool pool(Vertx vertx,
                        SqlConnectOptions database,
                        PoolOptions options)
```
    Create a connection pool to the database with the given options.
    A will be selected among the drivers found on the classpath returning true when applied to the first options of the list.
    
    Parameters:
    
    vertx - the Vertx instance to be used with the connection pool
    
    database - the options used to create the connection pool, such as database hostname
    
    options - the options for creating the pool
    
    Returns:
    
    the connection pool
  - getConnection
```
public void getConnection(Handler<AsyncResult<SqlConnection>> handler)
```
    Get a connection from the pool.
    
    Parameters:
    
    handler - the handler that will get the connection result
  - getConnection
```
public void getConnection()
```
    Get a connection from the pool.
  - rxGetConnection
```
public Single<SqlConnection> rxGetConnection()
```
    Get a connection from the pool.
    
    Returns:
  - query
```
public Query<RowSet<Row>> query(String sql)
```
    A connection is borrowed from the connection pool when the query is executed and then immediately returned to the pool after it completes.
    
    Overrides:
    
    query in class SqlClient
    
    Parameters:
    
    sql -
    
    Returns:
  - preparedQuery
```
public PreparedQuery<RowSet<Row>> preparedQuery(String sql)
```
    A connection is borrowed from the connection pool when the query is executed and then immediately returned to the pool after it completes.
    
    Overrides:
    
    preparedQuery in class SqlClient
    
    Parameters:
    
    sql -
    
    Returns:
  - withTransaction
```
public <T> void withTransaction(java.util.function.Function<SqlConnection,Future<T>> function,
                                Handler<AsyncResult<T>> handler)
```
    Execute the given function within a transaction.
    The function is passed a client executing all operations within a transaction. When the future returned by the function
    - succeeds the transaction commits
    - fails the transaction rollbacks
    The handler is given a success result when the function returns a succeeded futures and the transaction commits. Otherwise it is given a failure result.
    Parameters:
    
    function - the code to execute
    
    handler - the result handler
  - withTransaction
```
public <T> void withTransaction(java.util.function.Function<SqlConnection,Future<T>> function)
```
    Execute the given function within a transaction.
    The function is passed a client executing all operations within a transaction. When the future returned by the function
    - succeeds the transaction commits
    - fails the transaction rollbacks
    The handler is given a success result when the function returns a succeeded futures and the transaction commits. Otherwise it is given a failure result.
    Parameters:
    
    function - the code to execute
  - rxWithTransaction
```
public <T> Maybe<T> rxWithTransaction(java.util.function.Function<SqlConnection,Future<T>> function)
```
    Execute the given function within a transaction.
    The function is passed a client executing all operations within a transaction. When the future returned by the function
    - succeeds the transaction commits
    - fails the transaction rollbacks
    The handler is given a success result when the function returns a succeeded futures and the transaction commits. Otherwise it is given a failure result.
    Parameters:
    
    function - the code to execute
    
    Returns:
  - withTransaction
```
public <T> void withTransaction(Function<SqlConnection,Maybe<T>> function,
                                Handler<AsyncResult<T>> handler)
```
    Execute the given function within a transaction.
    The function is passed a client executing all operations within a transaction. When the future returned by the function
    - succeeds the transaction commits
    - fails the transaction rollbacks
    The handler is given a success result when the function returns a succeeded futures and the transaction commits. Otherwise it is given a failure result.
    Parameters:
    
    function - the code to execute
    
    handler - the result handler
  - withTransaction
```
public <T> void withTransaction(Function<SqlConnection,Maybe<T>> function)
```
    Execute the given function within a transaction.
    The function is passed a client executing all operations within a transaction. When the future returned by the function
    - succeeds the transaction commits
    - fails the transaction rollbacks
    The handler is given a success result when the function returns a succeeded futures and the transaction commits. Otherwise it is given a failure result.
    Parameters:
    
    function - the code to execute
  - rxWithTransaction
```
public <T> Maybe<T> rxWithTransaction(Function<SqlConnection,Maybe<T>> function)
```
    Execute the given function within a transaction.
    The function is passed a client executing all operations within a transaction. When the future returned by the function
    - succeeds the transaction commits
    - fails the transaction rollbacks
    The handler is given a success result when the function returns a succeeded futures and the transaction commits. Otherwise it is given a failure result.
    Parameters:
    
    function - the code to execute
    
    Returns:
  - withConnection
```
public <T> void withConnection(java.util.function.Function<SqlConnection,Future<T>> function,
                               Handler<AsyncResult<T>> handler)
```
    Get a connection from the pool and execute the given function.
    When the future returned by the function completes, the connection is returned to the pool.
    The handler is given a success result when the function returns a succeeded futures. Otherwise it is given a failure result.
    
    Parameters:
    
    function - the code to execute
    
    handler - the result handler
  - withConnection
```
public <T> void withConnection(java.util.function.Function<SqlConnection,Future<T>> function)
```
    Get a connection from the pool and execute the given function.
    When the future returned by the function completes, the connection is returned to the pool.
    The handler is given a success result when the function returns a succeeded futures. Otherwise it is given a failure result.
    
    Parameters:
    
    function - the code to execute
  - rxWithConnection
```
public <T> Maybe<T> rxWithConnection(java.util.function.Function<SqlConnection,Future<T>> function)
```
    Get a connection from the pool and execute the given function.
    When the future returned by the function completes, the connection is returned to the pool.
    The handler is given a success result when the function returns a succeeded futures. Otherwise it is given a failure result.
    
    Parameters:
    
    function - the code to execute
    
    Returns:
  - withConnection
```
public <T> void withConnection(Function<SqlConnection,Maybe<T>> function,
                               Handler<AsyncResult<T>> handler)
```
    Get a connection from the pool and execute the given function.
    When the future returned by the function completes, the connection is returned to the pool.
    The handler is given a success result when the function returns a succeeded futures. Otherwise it is given a failure result.
    
    Parameters:
    
    function - the code to execute
    
    handler - the result handler
  - withConnection
```
public <T> void withConnection(Function<SqlConnection,Maybe<T>> function)
```
    Get a connection from the pool and execute the given function.
    When the future returned by the function completes, the connection is returned to the pool.
    The handler is given a success result when the function returns a succeeded futures. Otherwise it is given a failure result.
    
    Parameters:
    
    function - the code to execute
  - rxWithConnection
```
public <T> Maybe<T> rxWithConnection(Function<SqlConnection,Maybe<T>> function)
```
    Get a connection from the pool and execute the given function.
    When the future returned by the function completes, the connection is returned to the pool.
    The handler is given a success result when the function returns a succeeded futures. Otherwise it is given a failure result.
    
    Parameters:
    
    function - the code to execute
    
    Returns:
  - close
```
public void close(Handler<AsyncResult<Void>> handler)
```
    Close the pool and release the associated resources.
    
    Overrides:
    
    close in class SqlClient
    
    Parameters:
    
    handler - the completion handler
  - close
```
public void close()
```
    Close the pool and release the associated resources.
    
    Overrides:
    
    close in class SqlClient
  - rxClose
```
public Completable rxClose()
```
    Close the pool and release the associated resources.
    
    Overrides:
    
    rxClose in class SqlClient
    
    Returns:
  - connectHandler
```
public Pool connectHandler(Handler<SqlConnection> handler)
```
    Set an handler called when the pool has established a connection to the database.
    This handler allows interactions with the database before the connection is added to the pool.
    When the handler has finished, it must call SqlClient.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) to release the connection to the pool.
    
    Parameters:
    
    handler - the handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - connectionProvider
```
public Pool connectionProvider(java.util.function.Function<Context,Future<SqlConnection>> provider)
```
    Replace the default pool connection provider, the new provider returns a future connection for a given .
    A ConnectionFactory can be used as connection provider.
    
    Parameters:
    
    provider - the new connection provider
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - connectionProvider
```
public Pool connectionProvider(Function<Context,Single<SqlConnection>> provider)
```
    Replace the default pool connection provider, the new provider returns a future connection for a given .
    A ConnectionFactory can be used as connection provider.
    
    Parameters:
    
    provider - the new connection provider
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - size
```
public int size()
```
    Returns:
    
    the current pool size approximation
  - newInstance
```
public static Pool newInstance(Pool arg)
```

Class Pool

Field Summary

Constructor Summary

Method Summary

Methods inherited from class io.vertx.reactivex.sqlclient.SqlClient

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

Pool

Pool

Method Detail

toString

equals

hashCode

getDelegate

pool

pool

pool

getConnection

getConnection

rxGetConnection

query

preparedQuery

withTransaction

withTransaction

rxWithTransaction

withTransaction

withTransaction

rxWithTransaction

withConnection

withConnection

rxWithConnection

withConnection

withConnection

rxWithConnection

close

close

rxClose

connectHandler

connectionProvider

connectionProvider

size

newInstance