ManagedConnection (Tentackle Persistence 2.0.7 API)

java.lang.Object
- org.tentackle.persist.ManagedConnection

```
public class ManagedConnection
extends Object
```
A jdbc connection managed by the ConnectionManager.
The connection provides some additional features such as a prepared statement cache and translates SQLExceptions to DbRuntimeExceptions. The ConnectionManager is responsible to attach and detach the connection to a session.

Author:

harald

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`checkStatementResultSetParameters` Optionally enable statement checks for resultSetType and resultSetConcurrency.
`static boolean`	`collectStatistics` Flag to turn on statement statistics.
`static long`	`logMinAttachMillis` Minimum milliseconds a connection remains attached before being logged. 0 to disable, -1 to log every detach.
`static long`	`logStatisticsMillis` Optional periodical log of statistics in milliseconds.
`static Pattern`	`mdcFilter` Optional filter to log only statements for certain MappedDiagnosticContexts. If set, statements are only collected for logging if the MDC is valid and the pattern matches the toString-value of the MDC.

Constructor Summary

Constructors
Constructor and Description
`ManagedConnection(ConnectionManager manager, Backend backend, Connection connection)` Creates a managed connection.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addResultSet(ResultSetWrapper rs)` Adds a pending result set.
`void`	`addRunningStatement(StatementWrapper statement)` Remembers a statement as running.
`void`	`attachSession(Db db)` Attaches a connection to a session.
`void`	`cancelRunningStatements()` Cancels the(all) currently running statement(s). May be invoked from any thread.
`void`	`close()` Closes the connection. Closing an already closed connection is allowed.
`void`	`closePreparedStatements(boolean onlyMarkedReady)` Closes prepared statements.
`void`	`commit()` Performs a commit.
`void`	`countForClearWarnings()` Increments a counter and empties the warnings on the connection and all prepared statements if a trigger value is reached.
`PreparedStatementWrapper`	`createPreparedStatement(StatementKey statementKey, String sql, int resultSetType, int resultSetConcurrency)` Creates a prepared statement.
`StatementWrapper`	`createStatement(int resultSetType, int resultSetConcurrency)` Creates a non-prepared statement. One-shot statements (i.e.
`void`	`detachSession(Db db)` Detaches a session from a connection.
`protected void`	`finalize()`
`long`	`getAttachedSince()` Gets the epochal time when this connection was attached.
`boolean`	`getAutoCommit()` Gets the autocommit value.
`String`	`getBackendId()` Gets the backend id.
`Connection`	`getConnection()` Gets the low level connection.
`long`	`getDetachedSince()` Gets the epochal time when this connection was detached.
`long`	`getEstablishedSince()` Gets the epochal time when this connection was established.
`long`	`getExpireAt()` Gets the epochal time when this connection should be closed, if unused.
`int`	`getIndex()` Gets the connection index.
`long`	`getInstanceNumber()` Gets the unique instance number.
`static Collection<ManagedConnection>`	`getManagedConnections()` Gets a list of all managed open connections.
`ConnectionManager`	`getManager()` Gets the connection manager
`int`	`getMaxCountForClearWarnings()` Gets the current setting for clearWarnings() trigger.
`String`	`getName()` Gets the connection name.
`Collection<ResultSetWrapper>`	`getOpenResultSets()` Gets all open result sets for this connection.
`PreparedStatementWrapper`	`getPreparedStatement(StatementKey statementKey, boolean alwaysPrepare, int resultSetType, int resultSetConcurrency, Supplier<String> sqlSupplier)` Gets a prepared statement. The statement will be reused if already prepared.
`Db`	`getSession()` Gets tha attached session.
`List<StatementHistory>`	`getStatementHistory()` Gets the statement history.
`boolean`	`isAttached()` Checks whether a Db is attached to this connection.
`boolean`	`isClosed()` Gets the connection's closed state.
`boolean`	`isDead()` Returns whether connection is marked dead
`protected boolean`	`isMDCValid()` Checks whether the mapped diagnostic context is valid for statistics logging.
`boolean`	`isTxRunning()` Returns whether a transaction is running.
`void`	`logAndClearWarnings()` Reads all warnings, logs and clears them.
`void`	`removePreparedStatement(PreparedStatementWrapper st)` Removes a closed prepared statement.
`void`	`removeResultSet(ResultSetWrapper rs)` Removes a pending result set.
`void`	`removeRunningStatement(StatementWrapper statement)` Removes a statement from the running statements.
`void`	`rollback(boolean withLog)` Performs a rollback.
`void`	`setAutoCommit(boolean autoCommit)` Sets the autocommit feature.
`void`	`setDead(boolean dead)` Marks a connection being dead.
`void`	`setExpireAt(long expireAt)` Sets the epochal time when this connection should be closed, if unused.
`void`	`setIndex(int index)` Sets the connection index.
`void`	`setMaxCountForClearWarnings(int max)` Sets the countForClearWarnings trigger.
`String`	`toDiagnosticString()` Creates a diagnostic string.
`String`	`toString()`
`void`	`unmarkPreparedStatements()` Unmark all prepared statements that are marked ready.
`boolean`	`verifyConnection()` Checks whether connection is still valid.

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

- Field Detail
  - logMinAttachMillis
```
public static long logMinAttachMillis
```
    Minimum milliseconds a connection remains attached before being logged.
    0 to disable, -1 to log every detach.
    For analysis and debugging purposes only.
  - collectStatistics
```
public static boolean collectStatistics
```
    Flag to turn on statement statistics. (default is turned off)
  - logStatisticsMillis
```
public static long logStatisticsMillis
```
    Optional periodical log of statistics in milliseconds. (default is off)
    If turned on, the statistics will be logged and cleared every logStatisticsMillis milliseconds.
  - mdcFilter
```
public static Pattern mdcFilter
```
    Optional filter to log only statements for certain MappedDiagnosticContexts.
    If set, statements are only collected for logging if the MDC is valid and the pattern matches the toString-value of the MDC.
  - checkStatementResultSetParameters
```
public static boolean checkStatementResultSetParameters
```
    Optionally enable statement checks for resultSetType and resultSetConcurrency.
- Constructor Detail
  - ManagedConnection
```
public ManagedConnection(ConnectionManager manager,
                         Backend backend,
                         Connection connection)
```
    Creates a managed connection.
    
    Parameters:
    
    manager - the connection manager
    
    backend - the backend
    
    connection - the low level JDBC connection
- Method Detail
  - getManagedConnections
```
public static Collection<ManagedConnection> getManagedConnections()
```
    Gets a list of all managed open connections.
    
    Returns:
    
    the set of connections
  - getManager
```
public ConnectionManager getManager()
```
    Gets the connection manager
    
    Returns:
    
    the manager
  - getConnection
```
public Connection getConnection()
```
    Gets the low level connection.
    
    Returns:
    
    the physical connection
  - getEstablishedSince
```
public long getEstablishedSince()
```
    Gets the epochal time when this connection was established.
    
    Returns:
    
    the time establishedSince in ms
  - setExpireAt
```
public void setExpireAt(long expireAt)
```
    Sets the epochal time when this connection should be closed, if unused.
    
    Parameters:
    
    expireAt - the time in [ms], 0 = forever
  - getExpireAt
```
public long getExpireAt()
```
    Gets the epochal time when this connection should be closed, if unused.
    
    Returns:
    
    the time in [ms], 0 = forever
  - getAttachedSince
```
public long getAttachedSince()
```
    Gets the epochal time when this connection was attached.
    
    Returns:
    
    the epochal time of last attach, 0 if not attached
  - getDetachedSince
```
public long getDetachedSince()
```
    Gets the epochal time when this connection was detached.
    Note that newly created conntections get their detach time initialized from the current system time.
    
    Returns:
    
    the epochal time of last detach, 0 if attached
  - setIndex
```
public void setIndex(int index)
```
    Sets the connection index. Connection managers use that to manage connection lists.
    
    Parameters:
    
    index - the connection index
  - getIndex
```
public int getIndex()
```
    Gets the connection index.
    
    Returns:
    
    the connection index.
  - setDead
```
public void setDead(boolean dead)
```
    Marks a connection being dead.
    Marking connections dead allows connection managers like MpxConnectionManager to re-open connections before being attached next time. Notice that not all connection managers honour the dead-flag (makes only sense in servers, anyway).
    
    Parameters:
    
    dead - true if marked dead, false not dead
  - isDead
```
public boolean isDead()
```
    Returns whether connection is marked dead
    
    Returns:
    
    true if dead
  - verifyConnection
```
public boolean verifyConnection()
```
    Checks whether connection is still valid.
    Implemented via a "SELECT 1" query. If the check fails the connection is marked dead.
    
    Returns:
    
    true if connection still valid, false if invalid
  - attachSession
```
public void attachSession(Db db)
```
    Attaches a connection to a session. Connections must be attached before it can be used by statements or starting a tx. The method must only be invoked by a connection manager!
    
    Parameters:
    
    db - the logical Db to attach
  - isAttached
```
public boolean isAttached()
```
    Checks whether a Db is attached to this connection.
    
    Returns:
    
    true if attached, else false.
  - isTxRunning
```
public boolean isTxRunning()
```
    Returns whether a transaction is running.
    
    Returns:
    
    true if connection is attached to a Db in transaction
  - detachSession
```
public void detachSession(Db db)
```
    Detaches a session from a connection. Connections must be detached before they can be used by another Db. The method must only be invoked by a connection manager!
    
    Parameters:
    
    db - the db to detach
  - getSession
```
public Db getSession()
```
    Gets tha attached session.
    
    Returns:
    
    the session, null if not attached
  - getInstanceNumber
```
public long getInstanceNumber()
```
    Gets the unique instance number.
    
    Returns:
    
    the instance number
  - getBackendId
```
public String getBackendId()
```
    Gets the backend id.
    
    Returns:
    
    the unique id
  - getName
```
public String getName()
```
    Gets the connection name.
    
    Returns:
    
    the unique name
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - isMDCValid
```
protected boolean isMDCValid()
```
    Checks whether the mapped diagnostic context is valid for statistics logging.
    
    Returns:
    
    true if loggable
    
    See Also:
    
    mdcFilter
  - getStatementHistory
```
public List<StatementHistory> getStatementHistory()
```
    Gets the statement history.
    
    Returns:
    
    the statements executed during last attachment
  - addResultSet
```
public void addResultSet(ResultSetWrapper rs)
```
    Adds a pending result set.
    
    Parameters:
    
    rs - the result set
  - removeResultSet
```
public void removeResultSet(ResultSetWrapper rs)
```
    Removes a pending result set.
    
    Parameters:
    
    rs - the result set
  - getOpenResultSets
```
public Collection<ResultSetWrapper> getOpenResultSets()
```
    Gets all open result sets for this connection.
    
    Returns:
    
    the result sets, never null
  - toDiagnosticString
```
public String toDiagnosticString()
```
    Creates a diagnostic string.
    
    Returns:
    
    the connection's status info
  - setAutoCommit
```
public void setAutoCommit(boolean autoCommit)
```
    Sets the autocommit feature.
    
    Parameters:
    
    autoCommit - true to enable autocomit, false to disable.
  - getAutoCommit
```
public boolean getAutoCommit()
```
    Gets the autocommit value.
    
    Returns:
    
    the autocommit value.
  - commit
```
public void commit()
```
    Performs a commit.
  - rollback
```
public void rollback(boolean withLog)
```
    Performs a rollback.
    
    Parameters:
    
    withLog - true if log via INFO
  - addRunningStatement
```
public void addRunningStatement(StatementWrapper statement)
```
    Remembers a statement as running.
    
    Parameters:
    
    statement - the statement
  - removeRunningStatement
```
public void removeRunningStatement(StatementWrapper statement)
```
    Removes a statement from the running statements.
    
    Parameters:
    
    statement - the statement
  - cancelRunningStatements
```
public void cancelRunningStatements()
```
    Cancels the(all) currently running statement(s).
    May be invoked from any thread.
  - unmarkPreparedStatements
```
public void unmarkPreparedStatements()
```
    Unmark all prepared statements that are marked ready.
  - logAndClearWarnings
```
public void logAndClearWarnings()
```
    Reads all warnings, logs and clears them.
  - setMaxCountForClearWarnings
```
public void setMaxCountForClearWarnings(int max)
```
    Sets the countForClearWarnings trigger.
    
    Parameters:
    
    max - the maxcount, 0 = app must eat the warnings
  - getMaxCountForClearWarnings
```
public int getMaxCountForClearWarnings()
```
    Gets the current setting for clearWarnings() trigger.
    
    Returns:
    
    the maxcount, 0 = app must eat the warnings
  - countForClearWarnings
```
public void countForClearWarnings()
```
    Increments a counter and empties the warnings on the connection and all prepared statements if a trigger value is reached. This is necessary for apps that don't clearWarnings() on their own, otherwise filling up memory might occur.
  - close
```
public void close()
```
    Closes the connection.
    Closing an already closed connection is allowed.
  - isClosed
```
public boolean isClosed()
```
    Gets the connection's closed state.
    
    Returns:
    
    true if connection is closed
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - closePreparedStatements
```
public void closePreparedStatements(boolean onlyMarkedReady)
```
    Closes prepared statements.
    
    Parameters:
    
    onlyMarkedReady - true if close only pending statements, false if all
  - removePreparedStatement
```
public void removePreparedStatement(PreparedStatementWrapper st)
```
    Removes a closed prepared statement.
    
    Parameters:
    
    st - the statement
  - createStatement
```
public StatementWrapper createStatement(int resultSetType,
                                        int resultSetConcurrency)
```
    Creates a non-prepared statement.
    One-shot statements (i.e. non-prepared statements) must attach the db as soon as they are instantiated. The db is detached after executeUpdate or after executeQuery when its result set is closed.
    
    Parameters:
    
    resultSetType - a result set type; one of ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or ResultSet.TYPE_SCROLL_SENSITIVE
    
    resultSetConcurrency - a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
    
    Returns:
    
    a new Statement object that will generate ResultSet objects with the given type and concurrency
  - createPreparedStatement
```
public PreparedStatementWrapper createPreparedStatement(StatementKey statementKey,
                                                        String sql,
                                                        int resultSetType,
                                                        int resultSetConcurrency)
```
    Creates a prepared statement.
    
    Parameters:
    
    statementKey - the statement key, null if one-shot
    
    sql - the sql code
    
    resultSetType - the result set type
    
    resultSetConcurrency - the result set concurrency
    
    Returns:
    
    the statement
  - getPreparedStatement
```
public PreparedStatementWrapper getPreparedStatement(StatementKey statementKey,
                                                     boolean alwaysPrepare,
                                                     int resultSetType,
                                                     int resultSetConcurrency,
                                                     Supplier<String> sqlSupplier)
```
    Gets a prepared statement.
    The statement will be reused if already prepared. Else it will be prepared according to the statement definition in BackendStatement.
    Notice: this method will be invoked from within a synchronized block from a Db-instance, so there's no need for special multi-threading handling.
    
    Parameters:
    
    statementKey - the unique statement key
    
    alwaysPrepare - true if always do a physical prepare
    
    resultSetType - one of ResultSet.TYPE_...
    
    resultSetConcurrency - one of ResultSet.CONCUR_...
    
    sqlSupplier - the SQL supplier
    
    Returns:
    
    the prepared statement for this connection

Class ManagedConnection

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logMinAttachMillis

collectStatistics

logStatisticsMillis

mdcFilter

checkStatementResultSetParameters

Constructor Detail

ManagedConnection

Method Detail

getManagedConnections

getManager

getConnection

getEstablishedSince

setExpireAt

getExpireAt

getAttachedSince

getDetachedSince

setIndex

getIndex

setDead

isDead

verifyConnection

attachSession

isAttached

isTxRunning

detachSession

getSession

getInstanceNumber

getBackendId

getName

toString

isMDCValid

getStatementHistory

addResultSet

removeResultSet

getOpenResultSets

toDiagnosticString

setAutoCommit

getAutoCommit

commit

rollback

addRunningStatement

removeRunningStatement

cancelRunningStatements

unmarkPreparedStatements

logAndClearWarnings

setMaxCountForClearWarnings

getMaxCountForClearWarnings

countForClearWarnings

close

isClosed

finalize

closePreparedStatements

removePreparedStatement

createStatement

createPreparedStatement

getPreparedStatement