Package org.postgresql.jdbc

# Class PgStatement

java.lang.Object
org.postgresql.jdbc.PgStatement

All Implemented Interfaces:
  `AutoCloseable`, `Statement`, `Wrapper`, `BaseStatement`, `PGStatement`

public class PgStatement extends Object implements Statement, BaseStatement

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `class`
  `PgStatement.StatementResultHandler`
  ResultHandler implementations for updates, queries, and either-or.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected boolean`
  `adaptiveFetch`
  `protected @Nullable ArrayList<@Nullable ParameterList>`
  `batchParameters`
  `protected @Nullable ArrayList<Query>`
  `batchStatements`
  `protected final int`
  `concurrency`
  `protected final PgConnection`
  `connection`
  `protected int`
  `fetchdirection`
  `protected int`
  `fetchSize`
  Number of rows to get in a batch.
  `protected @Nullable @GuardedBy("<self>") ResultWrapper`
  `firstUnclosedResult`
  The first unclosed result.
  `protected @Nullable ResultWrapper`
  `generatedKeys`
  Results returned by a statement that wants generated keys.
  `protected final ResourceLock`
  `lock`
  `protected int`
  `maxFieldSize`
  `protected int`
  `maxrows`
  Maximum number of rows to return, 0 = unlimited.
  `protected int`
  `mPrepareThreshold`
  `protected boolean`
  `replaceProcessingEnabled`
  `protected @Nullable ResultWrapper`
  `result`
  The current results.
  `protected final int`
  `resultsettype`
  `protected long`
  `timeout`
  Timeout (in milliseconds) for a query.
  `boolean`
  `wantsGeneratedKeysAlways`
  Was this PreparedStatement created to return generated keys for every execution? This is set at creation time and never cleared by execution.
  `protected boolean`
  `wantsGeneratedKeysOnce`
  Does the caller of execute/executeUpdate want generated keys for this execution? This is set by Statement methods that have generated keys arguments and cleared after execution is complete.
  `protected @Nullable org.postgresql.jdbc.PSQLWarningWrapper`
  `warnings`
  The warnings chain.

  ### Fields inherited from interface org.postgresql.PGStatement

  `DATE_NEGATIVE_INFINITY, DATE_NEGATIVE_SMALLER_INFINITY, DATE_POSITIVE_INFINITY, DATE_POSITIVE_SMALLER_INFINITY`

  ### Fields inherited from interface java.sql.Statement

  `CLOSE_ALL_RESULTS, CLOSE_CURRENT_RESULT, EXECUTE_FAILED, KEEP_CURRENT_RESULT, NO_GENERATED_KEYS, RETURN_GENERATED_KEYS, SUCCESS_NO_INFO`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addBatch(String sql)`
  `void`
  `addWarning(SQLWarning warn)`
  Either initializes new warning wrapper, or adds warning onto the chain.
  `void`
  `cancel()`
  `protected void`
  `checkClosed()`
  `protected void`
  `checkCompletion()`
  `protected final void`
  `checkNoResultUpdate()`
  `void`
  `clearBatch()`
  `void`
  `clearWarnings()`
  Clears the warning chain.
  `final void`
  `close()`
  Note: even though `Statement` is automatically closed when it is garbage collected, it is better to close it explicitly to lower resource consumption.
  `protected void`
  `closeForNextExecution()`
  `protected void`
  `closeImpl()`
  This is guaranteed to be called exactly once even in case of concurrent `close()` calls.
  `void`
  `closeOnCompletion()`
  `protected BatchResultHandler`
  `createBatchHandler(Query[] queries, @Nullable ParameterList[] parameterLists)`
  `ResultSet`
  `createDriverResultSet(Field[] fields, List<Tuple> tuples)`
  Create a synthetic resultset from data provided by the driver.
  `ResultSet`
  `createResultSet(@Nullable Query originalQuery, Field[] fields, List<Tuple> tuples, @Nullable ResultCursor cursor)`
  Create a resultset from data retrieved from the server.
  `boolean`
  `execute(String sql)`
  `boolean`
  `execute(String sql, int autoGeneratedKeys)`
  `boolean`
  `execute(String sql, int @Nullable [] columnIndexes)`
  `boolean`
  `execute(String sql, String @Nullable [] columnNames)`
  `protected final void`
  `execute(CachedQuery cachedQuery, @Nullable ParameterList queryParameters, int flags)`
  `int[]`
  `executeBatch()`
  `long[]`
  `executeLargeBatch()`
  `long`
  `executeLargeUpdate(String sql)`
  `long`
  `executeLargeUpdate(String sql, int autoGeneratedKeys)`
  `long`
  `executeLargeUpdate(String sql, int[] columnIndexes)`
  `long`
  `executeLargeUpdate(String sql, String @Nullable [] columnNames)`
  `ResultSet`
  `executeQuery(String sql)`
  `int`
  `executeUpdate(String sql)`
  `int`
  `executeUpdate(String sql, int autoGeneratedKeys)`
  `int`
  `executeUpdate(String sql, int[] columnIndexes)`
  `int`
  `executeUpdate(String sql, String @Nullable [] columnNames)`
  `boolean`
  `executeWithFlags(int flags)`
  Execute a prepared query, passing additional query flags.
  `boolean`
  `executeWithFlags(String sql, int flags)`
  Execute a query, passing additional query flags.
  `boolean`
  `executeWithFlags(CachedQuery simpleQuery, int flags)`
  Execute a query, passing additional query flags.
  `boolean`
  `getAdaptiveFetch()`
  Get state of adaptive fetch for statement.
  `Connection`
  `getConnection()`
  `int`
  `getFetchDirection()`
  `@Nullable String`
  `getFetchingCursorName()`
  `@org.checkerframework.checker.index.qual.NonNegative int`
  `getFetchSize()`
  `protected boolean`
  `getForceBinaryTransfer()`
  `ResultSet`
  `getGeneratedKeys()`
  `long`
  `getLargeMaxRows()`
  `long`
  `getLargeUpdateCount()`
  `long`
  `getLastOID()`
  Returns the Last inserted/updated oid.
  `int`
  `getMaxFieldSize()`
  `int`
  `getMaxRows()`
  `boolean`
  `getMoreResults()`
  `boolean`
  `getMoreResults(int current)`
  `BaseConnection`
  `getPGConnection()`
  `int`
  `getPrepareThreshold()`
  Gets the server-side prepare reuse threshold in use for this statement.
  `int`
  `getQueryTimeout()`
  `long`
  `getQueryTimeoutMs()`
  The queryTimeout limit is the number of milliseconds the driver will wait for a Statement to execute.
  `@Nullable ResultSet`
  `getResultSet()`
  `int`
  `getResultSetConcurrency()`
  `int`
  `getResultSetHoldability()`
  `int`
  `getResultSetType()`
  `protected ResultSet`
  `getSingleResultSet()`
  `protected TimestampUtils`
  `getTimestampUtils()`
  `int`
  `getUpdateCount()`
  `@Nullable SQLWarning`
  `getWarnings()`
  `boolean`
  `isClosed()`
  `boolean`
  `isCloseOnCompletion()`
  `protected boolean`
  `isOneShotQuery(@Nullable CachedQuery cachedQuery)`
  Returns true if query is unlikely to be reused.
  `boolean`
  `isPoolable()`
  `boolean`
  `isUseServerPrepare()`
  Checks if this statement will be executed as a server-prepared statement.
  `boolean`
  `isWrapperFor(Class<?> iface)`
  `void`
  `setAdaptiveFetch(boolean adaptiveFetch)`
  Turn on/off adaptive fetch for statement.
  `void`
  `setCursorName(String name)`
  `void`
  `setEscapeProcessing(boolean enable)`
  `void`
  `setFetchDirection(int direction)`
  `void`
  `setFetchSize(@org.checkerframework.checker.index.qual.NonNegative int rows)`
  `void`
  `setLargeMaxRows(long max)`
  `void`
  `setMaxFieldSize(int max)`
  `void`
  `setMaxRows(int max)`
  `void`
  `setPoolable(boolean poolable)`
  `void`
  `setPrepareThreshold(int newThreshold)`
  Sets the reuse threshold for using server-prepared statements.
  `void`
  `setQueryTimeout(int seconds)`
  `void`
  `setQueryTimeoutMs(long millis)`
  Sets the queryTimeout limit.
  `void`
  `setUseServerPrepare(boolean flag)`
  Turn on the use of prepared statements in the server (server side prepared statements are unrelated to jdbc PreparedStatements) As of build 302, this method is equivalent to `setPrepareThreshold(1)`.
  `protected void`
  `transformQueriesAndParameters()`
  `<T> T`
  `unwrap(Class<T> iface)`
  `protected boolean`
  `wantsHoldableResultSet()`
  `protected boolean`
  `wantsScrollableResultSet()`

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

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

  ### Methods inherited from interface java.sql.Statement

  `enquoteIdentifier, enquoteLiteral, enquoteNCharLiteral, isSimpleIdentifier`

- ## Field Details

  - ### lock

    protected final ResourceLock lock

  - ### batchStatements

    protected @Nullable ArrayList<Query> batchStatements

  - ### batchParameters

    protected @Nullable ArrayList<@Nullable ParameterList> batchParameters

  - ### resultsettype

    protected final int resultsettype

  - ### concurrency

    protected final int concurrency

  - ### fetchdirection

    protected int fetchdirection

  - ### wantsGeneratedKeysOnce

    protected boolean wantsGeneratedKeysOnce
    Does the caller of execute/executeUpdate want generated keys for this execution? This is set by Statement methods that have generated keys arguments and cleared after execution is complete.

  - ### wantsGeneratedKeysAlways

    public boolean wantsGeneratedKeysAlways
    Was this PreparedStatement created to return generated keys for every execution? This is set at creation time and never cleared by execution.

  - ### connection

    protected final PgConnection connection

  - ### warnings

    protected volatile @Nullable org.postgresql.jdbc.PSQLWarningWrapper warnings
    The warnings chain.

  - ### maxrows

    protected int maxrows
    Maximum number of rows to return, 0 = unlimited.

  - ### fetchSize

    protected int fetchSize
    Number of rows to get in a batch.

  - ### timeout

    protected long timeout
    Timeout (in milliseconds) for a query.

  - ### replaceProcessingEnabled

    protected boolean replaceProcessingEnabled

  - ### result

    protected @Nullable ResultWrapper result
    The current results.

  - ### firstUnclosedResult

    protected @Nullable @GuardedBy("<self>") ResultWrapper firstUnclosedResult
    The first unclosed result.

  - ### generatedKeys

    protected @Nullable ResultWrapper generatedKeys
    Results returned by a statement that wants generated keys.

  - ### mPrepareThreshold

    protected int mPrepareThreshold

  - ### maxFieldSize

    protected int maxFieldSize

  - ### adaptiveFetch

    protected boolean adaptiveFetch

- ## Method Details

  - ### createResultSet

    public ResultSet createResultSet(@Nullable Query originalQuery, Field[] fields, List<Tuple> tuples, @Nullable ResultCursor cursor) throws SQLException
    Description copied from interface: `BaseStatement`
    Create a resultset from data retrieved from the server.
    Specified by:
      `createResultSet` in interface `BaseStatement`
    Parameters:
      `originalQuery` - the query that generated this resultset; used when dealing with updateable resultsets
      `fields` - the column metadata for the resultset
      `tuples` - the resultset data
      `cursor` - the cursor to use to retrieve more data from the server; if null, no additional data is present.
    Returns:
      the new ResultSet
    Throws:
      `SQLException` - if something goes wrong

  - ### getPGConnection

    public BaseConnection getPGConnection()

  - ### getFetchingCursorName

    public @Nullable String getFetchingCursorName()

  - ### getFetchSize

    public @org.checkerframework.checker.index.qual.NonNegative int getFetchSize()
    Specified by:
      `getFetchSize` in interface `Statement`

  - ### wantsScrollableResultSet

    protected boolean wantsScrollableResultSet()

  - ### wantsHoldableResultSet

    protected boolean wantsHoldableResultSet()

  - ### executeQuery

    public ResultSet executeQuery(String sql) throws SQLException
    Specified by:
      `executeQuery` in interface `Statement`
    Throws:
      `SQLException`

  - ### getSingleResultSet

    protected ResultSet getSingleResultSet() throws SQLException
    Throws:
      `SQLException`

  - ### executeUpdate

    public int executeUpdate(String sql) throws SQLException
    Specified by:
      `executeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### checkNoResultUpdate

    protected final void checkNoResultUpdate() throws SQLException
    Throws:
      `SQLException`

  - ### execute

    public boolean execute(String sql) throws SQLException
    Specified by:
      `execute` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeWithFlags

    public boolean executeWithFlags(String sql, int flags) throws SQLException
    Description copied from interface: `BaseStatement`
    Execute a query, passing additional query flags.
    Specified by:
      `executeWithFlags` in interface `BaseStatement`
    Parameters:
      `sql` - the query to execute (JDBC-style query)
      `flags` - additional `QueryExecutor` flags for execution; these are bitwise-ORed into the default flags.
    Returns:
      true if there is a result set
    Throws:
      `SQLException` - if something goes wrong.

  - ### executeWithFlags

    public boolean executeWithFlags(CachedQuery simpleQuery, int flags) throws SQLException
    Description copied from interface: `BaseStatement`
    Execute a query, passing additional query flags.
    Specified by:
      `executeWithFlags` in interface `BaseStatement`
    Parameters:
      `simpleQuery` - the query to execute (native to PostgreSQL)
      `flags` - additional `QueryExecutor` flags for execution; these are bitwise-ORed into the default flags.
    Returns:
      true if there is a result set
    Throws:
      `SQLException` - if something goes wrong.

  - ### executeWithFlags

    public boolean executeWithFlags(int flags) throws SQLException
    Description copied from interface: `BaseStatement`
    Execute a prepared query, passing additional query flags.
    Specified by:
      `executeWithFlags` in interface `BaseStatement`
    Parameters:
      `flags` - additional `QueryExecutor` flags for execution; these are bitwise-ORed into the default flags.
    Returns:
      true if there is a result set
    Throws:
      `SQLException` - if something goes wrong.

  - ### closeForNextExecution

    protected void closeForNextExecution() throws SQLException
    Throws:
      `SQLException`

  - ### isOneShotQuery

    protected boolean isOneShotQuery(@Nullable CachedQuery cachedQuery)
    Returns true if query is unlikely to be reused.
    Parameters:
      `cachedQuery` - to check (null if current query)
    Returns:
      true if query is unlikely to be reused

  - ### execute

    protected final void execute(CachedQuery cachedQuery, @Nullable ParameterList queryParameters, int flags) throws SQLException
    Throws:
      `SQLException`

  - ### setCursorName

    public void setCursorName(String name) throws SQLException
    Specified by:
      `setCursorName` in interface `Statement`
    Throws:
      `SQLException`

  - ### getUpdateCount

    public int getUpdateCount() throws SQLException
    Specified by:
      `getUpdateCount` in interface `Statement`
    Throws:
      `SQLException`

  - ### getMoreResults

    public boolean getMoreResults() throws SQLException
    Specified by:
      `getMoreResults` in interface `Statement`
    Throws:
      `SQLException`

  - ### getMaxRows

    public int getMaxRows() throws SQLException
    Specified by:
      `getMaxRows` in interface `Statement`
    Throws:
      `SQLException`

  - ### setMaxRows

    public void setMaxRows(int max) throws SQLException
    Specified by:
      `setMaxRows` in interface `Statement`
    Throws:
      `SQLException`

  - ### setEscapeProcessing

    public void setEscapeProcessing(boolean enable) throws SQLException
    Specified by:
      `setEscapeProcessing` in interface `Statement`
    Throws:
      `SQLException`

  - ### getQueryTimeout

    public int getQueryTimeout() throws SQLException
    Specified by:
      `getQueryTimeout` in interface `Statement`
    Throws:
      `SQLException`

  - ### setQueryTimeout

    public void setQueryTimeout(int seconds) throws SQLException
    Specified by:
      `setQueryTimeout` in interface `Statement`
    Throws:
      `SQLException`

  - ### getQueryTimeoutMs

    public long getQueryTimeoutMs() throws SQLException
    The queryTimeout limit is the number of milliseconds the driver will wait for a Statement to execute. If the limit is exceeded, a SQLException is thrown.
    Returns:
      the current query timeout limit in milliseconds; 0 = unlimited
    Throws:
      `SQLException` - if a database access error occurs

  - ### setQueryTimeoutMs

    public void setQueryTimeoutMs(long millis) throws SQLException
    Sets the queryTimeout limit.
    Parameters:
      `millis` - - the new query timeout limit in milliseconds
    Throws:
      `SQLException` - if a database access error occurs

  - ### addWarning

    public void addWarning(SQLWarning warn)
    Either initializes new warning wrapper, or adds warning onto the chain.

    Although warnings are expected to be added sequentially, the warnings chain may be cleared concurrently at any time via `clearWarnings()`, therefore it is possible that a warning added via this method is placed onto the end of the previous warning chain

    Parameters:
      `warn` - warning to add

  - ### getWarnings

    public @Nullable SQLWarning getWarnings() throws SQLException
    Specified by:
      `getWarnings` in interface `Statement`
    Throws:
      `SQLException`

  - ### getMaxFieldSize

    public int getMaxFieldSize() throws SQLException
    Specified by:
      `getMaxFieldSize` in interface `Statement`
    Throws:
      `SQLException`

  - ### setMaxFieldSize

    public void setMaxFieldSize(int max) throws SQLException
    Specified by:
      `setMaxFieldSize` in interface `Statement`
    Throws:
      `SQLException`

  - ### clearWarnings

    public void clearWarnings() throws SQLException
    Clears the warning chain.

    Note that while it is safe to clear warnings while the query is executing, warnings that are added between calls to `getWarnings()` and #clearWarnings() may be missed. Therefore you should hold a reference to the tail of the previous warning chain and verify if its `SQLWarning.getNextWarning()` value is holds any new value.

    Specified by:
      `clearWarnings` in interface `Statement`
    Throws:
      `SQLException`

  - ### getResultSet

    public @Nullable ResultSet getResultSet() throws SQLException
    Specified by:
      `getResultSet` in interface `Statement`
    Throws:
      `SQLException`

  - ### close

    public final void close() throws SQLException
    Note: even though `Statement` is automatically closed when it is garbage collected, it is better to close it explicitly to lower resource consumption.
    Specified by:
      `close` in interface `AutoCloseable`
    Specified by:
      `close` in interface `Statement`
    Throws:
      `SQLException`

  - ### closeImpl

    protected void closeImpl() throws SQLException
    This is guaranteed to be called exactly once even in case of concurrent `close()` calls.
    Throws:
      `SQLException` - in case of error

  - ### getLastOID

    public long getLastOID() throws SQLException
    Description copied from interface: `PGStatement`
    Returns the Last inserted/updated oid.
    Specified by:
      `getLastOID` in interface `PGStatement`
    Returns:
      OID of last insert
    Throws:
      `SQLException` - if something goes wrong

  - ### setPrepareThreshold

    public void setPrepareThreshold(int newThreshold) throws SQLException
    Description copied from interface: `PGStatement`
    Sets the reuse threshold for using server-prepared statements.

    If `threshold` is a non-zero value N, the Nth and subsequent reuses of a PreparedStatement will use server-side prepare.

    If `threshold` is zero, server-side prepare will not be used.

    The reuse threshold is only used by PreparedStatement and CallableStatement objects; it is ignored for plain Statements.

    Specified by:
      `setPrepareThreshold` in interface `PGStatement`
    Parameters:
      `newThreshold` - the new threshold for this statement
    Throws:
      `SQLException` - if an exception occurs while changing the threshold

  - ### getPrepareThreshold

    public int getPrepareThreshold()
    Description copied from interface: `PGStatement`
    Gets the server-side prepare reuse threshold in use for this statement.
    Specified by:
      `getPrepareThreshold` in interface `PGStatement`
    Returns:
      the current threshold
    See Also:
      - `PGStatement.setPrepareThreshold(int)`

  - ### setUseServerPrepare

    public void setUseServerPrepare(boolean flag) throws SQLException
    Description copied from interface: `PGStatement`
    Turn on the use of prepared statements in the server (server side prepared statements are unrelated to jdbc PreparedStatements) As of build 302, this method is equivalent to `setPrepareThreshold(1)`.
    Specified by:
      `setUseServerPrepare` in interface `PGStatement`
    Parameters:
      `flag` - use server prepare
    Throws:
      `SQLException` - if something goes wrong

  - ### isUseServerPrepare

    public boolean isUseServerPrepare()
    Description copied from interface: `PGStatement`
    Checks if this statement will be executed as a server-prepared statement. A return value of `true` indicates that the next execution of the statement will be done as a server-prepared statement, assuming the underlying protocol supports it.
    Specified by:
      `isUseServerPrepare` in interface `PGStatement`
    Returns:
      true if the next reuse of this statement will use a server-prepared statement

  - ### checkClosed

    protected void checkClosed() throws SQLException
    Throws:
      `SQLException`

  - ### addBatch

    public void addBatch(String sql) throws SQLException
    Specified by:
      `addBatch` in interface `Statement`
    Throws:
      `SQLException`

  - ### clearBatch

    public void clearBatch() throws SQLException
    Specified by:
      `clearBatch` in interface `Statement`
    Throws:
      `SQLException`

  - ### createBatchHandler

    protected BatchResultHandler createBatchHandler(Query[] queries, @Nullable ParameterList[] parameterLists)

  - ### executeBatch

    public int[] executeBatch() throws SQLException
    Specified by:
      `executeBatch` in interface `Statement`
    Throws:
      `SQLException`

  - ### cancel

    public void cancel() throws SQLException
    Specified by:
      `cancel` in interface `Statement`
    Throws:
      `SQLException`

  - ### getConnection

    public Connection getConnection() throws SQLException
    Specified by:
      `getConnection` in interface `Statement`
    Throws:
      `SQLException`

  - ### getFetchDirection

    public int getFetchDirection()
    Specified by:
      `getFetchDirection` in interface `Statement`

  - ### getResultSetConcurrency

    public int getResultSetConcurrency()
    Specified by:
      `getResultSetConcurrency` in interface `Statement`

  - ### getResultSetType

    public int getResultSetType()
    Specified by:
      `getResultSetType` in interface `Statement`

  - ### setFetchDirection

    public void setFetchDirection(int direction) throws SQLException
    Specified by:
      `setFetchDirection` in interface `Statement`
    Throws:
      `SQLException`

  - ### setFetchSize

    public void setFetchSize(@org.checkerframework.checker.index.qual.NonNegative int rows) throws SQLException
    Specified by:
      `setFetchSize` in interface `Statement`
    Throws:
      `SQLException`

  - ### getForceBinaryTransfer

    protected boolean getForceBinaryTransfer()

  - ### getLargeUpdateCount

    public long getLargeUpdateCount() throws SQLException
    Specified by:
      `getLargeUpdateCount` in interface `Statement`
    Throws:
      `SQLException`

  - ### setLargeMaxRows

    public void setLargeMaxRows(long max) throws SQLException
    Specified by:
      `setLargeMaxRows` in interface `Statement`
    Throws:
      `SQLException`

  - ### getLargeMaxRows

    public long getLargeMaxRows() throws SQLException
    Specified by:
      `getLargeMaxRows` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeLargeBatch

    public long[] executeLargeBatch() throws SQLException
    Specified by:
      `executeLargeBatch` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeLargeUpdate

    public long executeLargeUpdate(String sql) throws SQLException
    Specified by:
      `executeLargeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeLargeUpdate

    public long executeLargeUpdate(String sql, int autoGeneratedKeys) throws SQLException
    Specified by:
      `executeLargeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeLargeUpdate

    public long executeLargeUpdate(String sql, int[] columnIndexes) throws SQLException
    Specified by:
      `executeLargeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeLargeUpdate

    public long executeLargeUpdate(String sql, String @Nullable [] columnNames) throws SQLException
    Specified by:
      `executeLargeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### isClosed

    public boolean isClosed() throws SQLException
    Specified by:
      `isClosed` in interface `Statement`
    Throws:
      `SQLException`

  - ### setPoolable

    public void setPoolable(boolean poolable) throws SQLException
    Specified by:
      `setPoolable` in interface `Statement`
    Throws:
      `SQLException`

  - ### isPoolable

    public boolean isPoolable() throws SQLException
    Specified by:
      `isPoolable` in interface `Statement`
    Throws:
      `SQLException`

  - ### isWrapperFor

    public boolean isWrapperFor(Class<?> iface) throws SQLException
    Specified by:
      `isWrapperFor` in interface `Wrapper`
    Throws:
      `SQLException`

  - ### unwrap

    public <T> T unwrap(Class<T> iface) throws SQLException
    Specified by:
      `unwrap` in interface `Wrapper`
    Throws:
      `SQLException`

  - ### closeOnCompletion

    public void closeOnCompletion() throws SQLException
    Specified by:
      `closeOnCompletion` in interface `Statement`
    Throws:
      `SQLException`

  - ### isCloseOnCompletion

    public boolean isCloseOnCompletion() throws SQLException
    Specified by:
      `isCloseOnCompletion` in interface `Statement`
    Throws:
      `SQLException`

  - ### checkCompletion

    protected void checkCompletion() throws SQLException
    Throws:
      `SQLException`

  - ### getMoreResults

    public boolean getMoreResults(int current) throws SQLException
    Specified by:
      `getMoreResults` in interface `Statement`
    Throws:
      `SQLException`

  - ### getGeneratedKeys

    public ResultSet getGeneratedKeys() throws SQLException
    Specified by:
      `getGeneratedKeys` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeUpdate

    public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException
    Specified by:
      `executeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeUpdate

    public int executeUpdate(String sql, int[] columnIndexes) throws SQLException
    Specified by:
      `executeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### executeUpdate

    public int executeUpdate(String sql, String @Nullable [] columnNames) throws SQLException
    Specified by:
      `executeUpdate` in interface `Statement`
    Throws:
      `SQLException`

  - ### execute

    public boolean execute(String sql, int autoGeneratedKeys) throws SQLException
    Specified by:
      `execute` in interface `Statement`
    Throws:
      `SQLException`

  - ### execute

    public boolean execute(String sql, int @Nullable [] columnIndexes) throws SQLException
    Specified by:
      `execute` in interface `Statement`
    Throws:
      `SQLException`

  - ### execute

    public boolean execute(String sql, String @Nullable [] columnNames) throws SQLException
    Specified by:
      `execute` in interface `Statement`
    Throws:
      `SQLException`

  - ### getResultSetHoldability

    public int getResultSetHoldability() throws SQLException
    Specified by:
      `getResultSetHoldability` in interface `Statement`
    Throws:
      `SQLException`

  - ### createDriverResultSet

    public ResultSet createDriverResultSet(Field[] fields, List<Tuple> tuples) throws SQLException
    Description copied from interface: `BaseStatement`
    Create a synthetic resultset from data provided by the driver.
    Specified by:
      `createDriverResultSet` in interface `BaseStatement`
    Parameters:
      `fields` - the column metadata for the resultset
      `tuples` - the resultset data
    Returns:
      the new ResultSet
    Throws:
      `SQLException` - if something goes wrong

  - ### transformQueriesAndParameters

    protected void transformQueriesAndParameters() throws SQLException
    Throws:
      `SQLException`

  - ### setAdaptiveFetch

    public void setAdaptiveFetch(boolean adaptiveFetch)
    Description copied from interface: `PGStatement`
    Turn on/off adaptive fetch for statement. Existing resultSets won't be affected by change here.
    Specified by:
      `setAdaptiveFetch` in interface `PGStatement`
    Parameters:
      `adaptiveFetch` - desired state of adaptive fetch.

  - ### getAdaptiveFetch

    public boolean getAdaptiveFetch()
    Description copied from interface: `PGStatement`
    Get state of adaptive fetch for statement.
    Specified by:
      `getAdaptiveFetch` in interface `PGStatement`
    Returns:
      state of adaptive fetch (turned on or off)

  - ### getTimestampUtils

    protected TimestampUtils getTimestampUtils()