io.vertx.pgclient.spi

## Class PgDriver

- java.lang.Object
- - io.vertx.pgclient.spi.PgDriver

- All Implemented Interfaces:
    Driver

      public class PgDriver
      extends Object
      implements Driver

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static PgDriver` | `INSTANCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PgDriver()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `acceptsOptions(SqlConnectOptions options)`
    `int` | `appendQueryPlaceholder(StringBuilder queryBuilder, int index, int current)` Append a parameter placeholder in the `query`.
    `ConnectionFactory` | `createConnectionFactory(Vertx vertx, SqlConnectOptions database)` Create a connection factory to the given `database`.
    `ConnectionFactory` | `createConnectionFactory(Vertx vertx, java.util.function.Supplier<? extends Future<? extends SqlConnectOptions>> database)` Create a connection factory to the given `database`.
    `Pool` | `newPool(Vertx vertx, java.util.function.Supplier<? extends Future<? extends SqlConnectOptions>> databases, PoolOptions options, io.vertx.core.impl.CloseFuture closeFuture)` Create a connection pool to the database configured with the given `connectOptions` and `poolOptions`.
    `PgConnectOptions` | `parseConnectionUri(String uri)`
    `io.vertx.sqlclient.impl.SqlConnectionInternal` | `wrapConnection(io.vertx.core.impl.ContextInternal context, ConnectionFactory factory, io.vertx.sqlclient.impl.Connection conn)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface io.vertx.sqlclient.spi.Driver

      `createPool, createPool, newPool`

- - ### Field Detail

    - #### INSTANCE

          public static final PgDriver INSTANCE

  - ### Constructor Detail

    - #### PgDriver

          public PgDriver()

  - ### Method Detail

    - #### newPool

          public Pool newPool(Vertx vertx,
                              java.util.function.Supplier<? extends Future<? extends SqlConnectOptions>> databases,
                              PoolOptions options,
                              io.vertx.core.impl.CloseFuture closeFuture)

      Description copied from interface: `Driver`
      Create a connection pool to the database configured with the given `connectOptions` and `poolOptions`. This method is not meant to be used directly by users, instead they should use `Driver.createPool(Vertx, List, PoolOptions)`.
      Specified by:
        `newPool` in interface `Driver`
      Parameters:
        `vertx` - the Vertx instance to be used with the connection pool
        `databases` - the list of databases
        `options` - the options for creating the pool
        `closeFuture` - the close future
      Returns:
        the connection pool

    - #### parseConnectionUri

          public PgConnectOptions parseConnectionUri(String uri)

      Specified by:
        `parseConnectionUri` in interface `Driver`
      Returns:
        `true` if the driver accepts the `connectOptions`, `false` otherwise

    - #### acceptsOptions

          public boolean acceptsOptions(SqlConnectOptions options)

      Specified by:
        `acceptsOptions` in interface `Driver`
      Returns:
        true if the driver accepts the `connectOptions`, false otherwise

    - #### createConnectionFactory

          public ConnectionFactory createConnectionFactory(Vertx vertx,
                                                           SqlConnectOptions database)

      Description copied from interface: `Driver`
      Create a connection factory to the given `database`.
      Specified by:
        `createConnectionFactory` in interface `Driver`
      Parameters:
        `vertx` - the Vertx instance t
        `database` - the database to connect to
      Returns:
        the connection factory

    - #### createConnectionFactory

          public ConnectionFactory createConnectionFactory(Vertx vertx,
                                                           java.util.function.Supplier<? extends Future<? extends SqlConnectOptions>> database)

      Description copied from interface: `Driver`
      Create a connection factory to the given `database`.
      Specified by:
        `createConnectionFactory` in interface `Driver`
      Parameters:
        `vertx` - the Vertx instance t
        `database` - the database to connect to
      Returns:
        the connection factory

    - #### appendQueryPlaceholder

          public int appendQueryPlaceholder(StringBuilder queryBuilder,
                                            int index,
                                            int current)

      Description copied from interface: `Driver`
      Append a parameter placeholder in the `query`.

      The index starts at `0`.

      - When `index == current` indicates it is a new parameter and therefore the same * value should be returned.
      - When `index < current` indicates the builder wants to reuse a parameter. The implementation can either return the same value to indicate the parameter can be reused or return the next index to use (which is shall be the `current` value
      Specified by:
        `appendQueryPlaceholder` in interface `Driver`
      Parameters:
        `queryBuilder` - the builder to append to
        `index` - the parameter placeholder index
      Returns:
        the index at which the parameter placeholder could be added

    - #### wrapConnection

          public io.vertx.sqlclient.impl.SqlConnectionInternal wrapConnection(io.vertx.core.impl.ContextInternal context,
                                                                              ConnectionFactory factory,
                                                                              io.vertx.sqlclient.impl.Connection conn)

      Specified by:
        `wrapConnection` in interface `Driver`

Copyright © 2024 Eclipse. All rights reserved.