UniversalConnectionPool (Oracle AI Database Universal Connection Pool Java API Reference, Release 26ai)

All Superinterfaces:

Diagnosable
```
public interface UniversalConnectionPool
extends Diagnosable
```
A connection pool that pools any type of connection (called a physical connection).
There are several key objects that make up the connection pool:
- The physical pool itself
- The connection factory adapter
- The pooled connection
- The connection retrieval info object
Physical Pool The physical pool maintains pooled connections that can be borrowed from the pool, returned to the pool, or closed and not returned to the pool. The pool keeps track of the connections that are available (so that they can be borrowed) and connections that are in use (so they can be reaped if it is determined that they are no longer valid).
Connection Factory Adapter The connection pool must rely on another entity to create and close connections because connection pools can pool any type of connection. This is the responsibility of the connection factory adapter. A connection factory adapter is tied to a specific resource (JDBC, JCA, LDAP, and so forth). When the connection pool needs to create a new connection, it asks the connection factory adapter to do so. The returned connection is placed inside a UniversalPooledConnection object that is then placed into the connection pool. When the connection pool closes a connection, it hands the connection to the connection factory adapter which then closes the connection.
Pooled Connections Each pooled connection in the connection pool is an instance of UniversalPooledConnection. The pooled connection decorates a physical connection (created by the connection factory adapter) which can be borrowed.
Connection Retrieval Info The connection retrieval info object is used by the connection factory adapter to create connections. It contains resource-specific information that the connection factory adapter uses to create connections. For example, the JDBC connection retrieval info object maintains the user and password that are used to create a connection from a JDBC resource. The JCA connection retrieval info object maintains the Subject and JCA ConnectionRequestInfo object.
Pool Properties The pool provides some properties for users to customize the pool's behavior, such as:
- minPoolSize The minimum number of connections that the pool maintains.
- maxPoolSize The maximum number of connections that the pool maintains.
- initialPoolSize The initial number of connections in the pool.
Statistics The pool maintains some statistics such as:
- The number of connections that are in use (borrowed) at any given time.
- The number of connections that are available (not in use) at any given time.
- The number of physical connections created by the resource.
- The number of physical connections closed by the resource.
Lifecycle A connection pool has a lifecycle. See UniversalConnectionPoolLifeCycleState for details. A connection pool is started by calling the start() method and stopped by calling the stop() method. Connections may not be borrowed until the connection pool has been started or after the pool has been stopped (unless the pool has been started again).
See Also:

UniversalPooledConnection, ConnectionFactoryAdapter, ConnectionRetrievalInfo, UniversalConnectionPoolStatistics, UniversalConnectionPoolLifeCycleState

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`UniversalPooledConnection`	`borrowConnection(ConnectionRetrievalInfo connectionRetrievalInfo)` Gets a connection from the connection pool.
`default java.util.concurrent.CompletionStage<UniversalPooledConnection>`	`borrowConnectionAsync(ConnectionRetrievalInfo cri, java.util.concurrent.Executor executor)` Get a connection from a pool asynchronously
`void`	`closeConnection(UniversalPooledConnection pooledConnection)` Closes the pooled connection.
`default int`	`getAbandonedConnectionTimeout()` Gets the abandoned connection timeout value.
`int`	`getAvailableConnectionsCount()` Gets the number of connections that are available in the connection pool (that is, connections in the pool that are not currently in use by clients).
`int`	`getBorrowedConnectionsCount()` Gets the number of connections that are actively in use by clients.
`default int`	`getConnectionHarvestMaxCount()` Gets the maximum number of connections that may be harvested when the connection harvesting occurs.
`default int`	`getConnectionHarvestTriggerCount()` Gets the number of available connections below which the connection pool's connection harvesting occurs.
`default int`	`getConnectionLabelingHighCost()` Obtains the cost value which identifies a connection as "high-cost" for connection labeling.
`default int`	`getConnectionRepurposeThreshold()` Gets the connection repurpose threshold for the pool.
`ConnectionRetrievalInfo`	`getConnectionRetrievalInfo()` Gets the `ConnectionRetrievalInfo` object which contains user and password information to create the connections.
`default int`	`getConnectionValidationTimeout()` Connection validation timeout getter This property changes the allowed time for a connection validation.
`default java.time.Duration`	`getConnectionWaitDuration()` Gets the maximum time (in java.time.Duration) that any connection borrow request can wait before it returns to the application.
`default java.lang.Long`	`getConnectionWaitDurationInMillis()` Get connection wait duration in milliseconds.
`default int`	`getConnectionWaitTimeout()` Deprecated.
`default java.lang.Long`	`getConnectionWaitTimeoutWhileServiceDown()` Get connection wait timeout that applies while service is down in seconds.
`default boolean`	`getFailFastOnChunkUnavailable()` Return the boolean value of the property fail fast on chunk unavailable.
`default int`	`getHighCostConnectionReuseThreshold()` Obtains the high-cost connection reuse threshold property value for connection labeling.
`default int`	`getInactiveConnectionTimeout()` Gets the inactive connection timeout value.
`default int`	`getInitialPoolSize()` Gets the initial pool size.
`UniversalConnectionPoolLifeCycleState`	`getLifeCycleState()` Gets the life cycle state of the connection pool.
`default int`	`getLoginTimeout()` Gets the default maximum time in seconds that a driver will wait while attempting to connect to a database once the driver has been identified.
`default int`	`getMaxConnectionReuseCount()` Gets the maximum connection reuse count property value.
`default long`	`getMaxConnectionReuseTime()` Gets the maximum connection reuse time property value.
`default int`	`getMaxConnectionsPerService()` Gets the maximum number of connections that can be obtained to a particular service, in a shared pool.
`default int`	`getMaxIdle()` Gets the maximum number of idle connections that the connection pool maintains.
`default int`	`getMaxPoolSize()` Gets the maximum number of connections that the connection pool maintains.
`default int`	`getMinIdle()` Gets the minimum number of idle connections that the connection pool maintains.
`default int`	`getMinPoolSize()` Gets the minimum number of connections that the connection pool maintains.
`java.lang.String`	`getName()` Gets the name of the connection pool.
`oracle.ucp.config.PoolProperties`	`getPoolProperties()` Pool properties backbone getter.
`default java.lang.Object`	`getPoolProperty(oracle.ucp.config.PoolProperty poolProperty)` Get a pool property.
`default int`	`getQueryTimeout()` Gets the number of seconds the driver will wait for a Statement object to execute to the given number of seconds.
`default int`	`getSecondsToTrustIdleConnection()` Gets the seconds To Trust Idle Connection value which determines whether or not connection validation on borrow should be skipped See property description in `setSecondsToTrustIdleConnection()`.
`default boolean`	`getShardingMode()` Returns the mode of UCP when UCP is using a Sharded Database.
`UniversalConnectionPoolStatistics`	`getStatistics()` Gets the statistics of the connection pool.
`default int`	`getTimeoutCheckInterval()` Gets the frequency (in seconds) to enforce the timeout properties.
`default int`	`getTimeToLiveConnectionTimeout()` Gets the maximum time (in seconds) a connection may remain in-use.
`java.lang.String`	`getUCPEventListenerProvider()` Gets the UCP event listener provider name.
`default boolean`	`getValidateConnectionOnBorrow()` Returns whether or not a connection being borrowed should first be validated.
`default boolean`	`isCommitOnConnectionReturn()` Returns the boolean value for the property that controls the behavior of UCP when a connection is released back to the pool with pending uncommitted changes in an active transaction.
`default boolean`	`isCreateConnectionInBorrowThread()` Get flag defining how to create connections on pool grow.
`default boolean`	`isReadOnlyInstanceAllowed()` Returns true if the connection borrow is allowed to a read-only instance, false otherwise.
`default boolean`	`isShareable()` Returns whether the pool is shareable or not.
`void`	`purge()` Removes all connections from the connection pool.
`void`	`reconfigure(java.util.Properties props)` Allows a connection pool to be reconfigured gracefully with a different set of properties that specify the behavior of the connection pool at runtime.
`void`	`recycle()` Allows only invalid available connections in the pool to be replaced with new/fresh connections.
`void`	`refresh()` Allows connections in the pool, both borrowed and available ones, to be replaced with new/fresh connections.
`default void`	`registerConnectionAffinityCallback(ConnectionAffinityCallback cbk)` Registers a `ConnectionAffinityCallback` objet on the connection pool.
`default void`	`registerConnectionLabelingCallback(ConnectionLabelingCallback cbk)` Registers a `ConnectionLabelingCallback` object with this connection pool.
`default void`	`removeConnectionAffinityCallback()` Removes the `ConnectionAffinityCallback` object registered on the connection pool.
`default void`	`removeConnectionLabelingCallback()` Removes the `ConnectionLabelingCallback` object registered with this connection pool, if any.
`void`	`returnConnection(UniversalPooledConnection pooledConnection)` Returns a connection back into the connection pool.
`default void`	`setAbandonedConnectionTimeout(int abandonedConnectionTimeout)` Sets the abandoned connection timeout.
`default void`	`setCommitOnConnectionReturn(boolean commit)` Sets the boolean value for the property that controls the behavior of UCP when a connection is released back to the pool with pending uncommitted changes in an active transaction.
`default void`	`setConnectionHarvestMaxCount(int connectionHarvestMaxCount)` Sets the maximum number of connections that may be harvested when the connection harvesting occurs.
`default void`	`setConnectionHarvestTriggerCount(int connectionHarvestTriggerCount)` Sets the number of available connections below which the connection pool's connection harvesting occurs.
`default void`	`setConnectionLabelingHighCost(int highCost)` Sets the cost value which identifies a connection as "high-cost" for connection labeling.
`default void`	`setConnectionRepurposeThreshold(java.lang.Integer threshold)` Sets the connection repurpose threshold for the pool.
`void`	`setConnectionRetrievalInfo(ConnectionRetrievalInfo cri)` Sets the `ConnectionRetrievalInfo` for creating the initial connections (physical connections) in the pool based on the initialPoolSize property.
`default void`	`setConnectionValidationTimeout(int connectionValidationTimeout)` Connection validation timeout setter This property changes the allowed time for a connection validation.
`default void`	`setConnectionWaitDuration(java.time.Duration waitDuration)` Configures how much time a connection request call may wait before it either successfully returns a connection or throws an exception.
`default void`	`setConnectionWaitDurationInMillis(java.lang.Long durationInMillis)` Set connection wait duration in milliseconds.
`default void`	`setConnectionWaitTimeout(int waitTimeout)` Deprecated.
`default void`	`setConnectionWaitTimeoutWhileServiceDown(java.lang.Long timeoutServiceDown)` Set connection wait timeout that applies while service is down.
`default void`	`setCreateConnectionInBorrowThread(boolean createConnectionInBorrowThread)` Set flag defining how to create connections on pool grow.
`default void`	`setFailFastOnChunkUnavailable(boolean failFastEnabled)` This flag determines if connection requests to unavailable chunks will fail fast or not.
`default void`	`setHighCostConnectionReuseThreshold(int threshold)` Sets the high-cost connection reuse threshold for connection labeling.
`default void`	`setInactiveConnectionTimeout(int inactiveConnectionTimeout)` Sets the inactive connection timeout.
`default void`	`setInitialPoolSize(int initialPoolSize)` Sets the initial pool size.
`default void`	`setLoginTimeout(int seconds)` Sets the default maximum time in seconds that a driver will wait while attempting to connect to a database once the driver has been identified.
`default void`	`setMaxConnectionReuseCount(int maxConnectionReuseCount)` Sets the maximum connection reuse count property.
`default void`	`setMaxConnectionReuseTime(long maxConnectionReuseTime)` Sets the maximum connection reuse time property.
`default void`	`setMaxConnectionsPerService(int maxConnectionsPerService)` Sets the maximum number of connections that can be obtained to a particular service, in a shared pool.
`default void`	`setMaxIdle(int maxIdle)` Sets the maximum number of idle connections.
`default void`	`setMaxPoolSize(int maxPoolSize)` Sets the maximum number of connections.
`default void`	`setMinIdle(int minIdle)` Sets the minimum number of idle connections.
`default void`	`setMinPoolSize(int minPoolSize)` Sets the minimum number of connections.
`void`	`setName(java.lang.String name)` Sets the name of the connection pool.
`default void`	`setPoolProperty(oracle.ucp.config.PoolProperty poolProperty, java.lang.Object value, int code)` Set a given pool property.
`default void`	`setQueryTimeout(int queryTimeout)` Sets the number of seconds the driver will wait for a Statement object to execute to the given number of seconds.
`default void`	`setReadOnlyInstanceAllowed(boolean readOnlyInstanceAllowed)` Sets the read-only instance allowed value on the datasource.
`default void`	`setSecondsToTrustIdleConnection(int secondsToTrustIdleConnection)` Sets the time in seconds to trust an idle connection to skip a validation test.
`default void`	`setShardingMode(boolean shardingMode)` This API changes the mode of UCP when UCP is using a Sharded Database.
`default void`	`setTimeoutCheckInterval(int timeoutCheckInterval)` Sets the frequency (in seconds) to enforce the timeout properties.
`default void`	`setTimeToLiveConnectionTimeout(int timeToLiveConnectionTimeout)` Sets the maximum time (in seconds) a connection may remain in-use.
`void`	`setUCPEventListenerProvider(java.lang.String providerName)` Sets the UCP event listener provider by name.
`default void`	`setValidateConnectionOnBorrow(boolean validateConnectionOnBorrow)` Makes the pool validate the connection before returning it to the user by calling the JDBC API "isValid".
`default void`	`start()` if keepMetadataConn is not specified, assume it is "false".
`void`	`start(ConnectionRetrievalInfo connectionRetrievalInfo, boolean keepMetadataConn)` Starts the connection pool.
`void`	`stop()` Stops the connection pool.

Methods inherited from interface oracle.ucp.diagnostics.Diagnosable
beginCurrentSql, debug, debug, endCurrentSql, format, getDiagnosable, isLoggingLevelFinest, resumeLogging, secure, suspendLogging, trace, trace

- Method Detail
  - borrowConnection
```
UniversalPooledConnection borrowConnection(ConnectionRetrievalInfo connectionRetrievalInfo)
                                    throws UniversalConnectionPoolException
```
    Gets a connection from the connection pool.
    
    Parameters:
    
    connectionRetrievalInfo - Info to use to get the connection.
    
    Returns:
    
    A UniversalPooledConnection for the specified connection retrieval info.
    
    Throws:
    
    UniversalConnectionPoolException - if an error occurs getting a connection.
    
    NoAvailableConnectionsException - if all of the connections are in use.
  - borrowConnectionAsync
```
default java.util.concurrent.CompletionStage<UniversalPooledConnection> borrowConnectionAsync(ConnectionRetrievalInfo cri,
                                                                                              java.util.concurrent.Executor executor)
                                                                                       throws java.lang.UnsupportedOperationException
```
    Get a connection from a pool asynchronously
    
    Parameters:
    
    cri - Info to use to get the connection.
    
    executor - executor for asychronous processing
    
    Returns:
    
    completion stage of a connection borrow operation
    
    Throws:
    
    java.lang.UnsupportedOperationException
  - returnConnection
```
void returnConnection(UniversalPooledConnection pooledConnection)
               throws UniversalConnectionPoolException
```
    Returns a connection back into the connection pool. The pool can decide to close the underlying physical connection when necessary.
    
    Parameters:
    
    pooledConnection - The connection to return back into the pool.
    
    Throws:
    
    UniversalConnectionPoolException - in case it is not possible to return connection.
  - closeConnection
```
void closeConnection(UniversalPooledConnection pooledConnection)
              throws UniversalConnectionPoolException
```
    Closes the pooled connection. Do not put it back into the pool.
    
    Parameters:
    
    pooledConnection - The pooled connection to close.
    
    Throws:
    
    UniversalConnectionPoolException - if an error occurs closing the connection.
  - refresh
```
void refresh()
      throws UniversalConnectionPoolException
```
    Allows connections in the pool, both borrowed and available ones, to be replaced with new/fresh connections. All of the available connections are removed before replacing them with new connections. However, a borrowed connection is marked for removal. When such a borrowed connection is returned to the pool, it is closed and replaced with a new connection with the same user credentials.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to refresh.
  - recycle
```
void recycle()
      throws UniversalConnectionPoolException
```
    Allows only invalid available connections in the pool to be replaced with new/fresh connections.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to recycle.
  - purge
```
void purge()
    throws UniversalConnectionPoolException
```
    Removes all connections from the connection pool. The primary difference in behavior between this and refresh() is that the connection pool is left empty with no connections available after calling purge(). Some of the connection pool properties such as minPoolSize or initialPoolSize may not be honored when purging connections from the pool.
    Note that both borrowed and available connections are removed when this API is called. Any borrowed connections incur an exception after this API is called. The user is expected to retry and obtain a new connection from the pool.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to purge.
  - reconfigure
```
void reconfigure(java.util.Properties props)
          throws UniversalConnectionPoolException
```
    Allows a connection pool to be reconfigured gracefully with a different set of properties that specify the behavior of the connection pool at runtime. Reconfiguration of connection pool properties is always non-disruptive. If this operation cannot be completed right away, then the call returns and the enforcement of the properties continue to occur asynchronously.
    
    Parameters:
    
    props - Containing new set of pool properties for reconfiguration.
    
    Throws:
    
    UniversalConnectionPoolException - in case it wat not possible to reconfigure.
  - start
```
void start(ConnectionRetrievalInfo connectionRetrievalInfo,
           boolean keepMetadataConn)
    throws UniversalConnectionPoolException
```
    Starts the connection pool.
    
    Parameters:
    
    connectionRetrievalInfo - retrieval info with data for creation metadata connection.
    
    keepMetadataConn - keep metadata connection in the working set even if init pool size is 0 (because the next operation will be "borrow").
    
    Throws:
    
    UniversalConnectionPoolException - If an error occurs during start.
  - start
```
default void start()
            throws UniversalConnectionPoolException
```
    if keepMetadataConn is not specified, assume it is "false".
    
    Throws:
    
    UniversalConnectionPoolException
  - stop
```
void stop()
   throws UniversalConnectionPoolException
```
    Stops the connection pool.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to stop.
  - getName
```
java.lang.String getName()
```
    Gets the name of the connection pool.
    
    Returns:
    
    The name of the connection pool.
  - setName
```
void setName(java.lang.String name)
```
    Sets the name of the connection pool.
    
    Parameters:
    
    name - The name of the connection pool.
  - getInitialPoolSize
```
default int getInitialPoolSize()
```
    Gets the initial pool size.
    
    Returns:
    
    the initial pool size.
  - setInitialPoolSize
```
default void setInitialPoolSize(int initialPoolSize)
                         throws UniversalConnectionPoolException
```
    Sets the initial pool size. This is the number of connections that are created and placed in the pool upon initialization.
    
    Parameters:
    
    initialPoolSize - the initial pool size.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set initial pool size.
  - getMinPoolSize
```
default int getMinPoolSize()
```
    Gets the minimum number of connections that the connection pool maintains.
    
    Returns:
    
    The minimum number of connections.
  - setMinPoolSize
```
default void setMinPoolSize(int minPoolSize)
                     throws UniversalConnectionPoolException
```
    Sets the minimum number of connections. If the number of available connections PLUS the number of connections in use IS LESS THAN the minimum, then the connection is returned to the pool. Otherwise, the connection is closed. The default is 1 connection.
    
    Parameters:
    
    minPoolSize - The minimum number of connections.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set min pool size.
  - getMinIdle
```
default int getMinIdle()
```
    Gets the minimum number of idle connections that the connection pool maintains.
    
    Returns:
    
    The minimum number of idle connections.
  - setMinIdle
```
default void setMinIdle(int minIdle)
                 throws UniversalConnectionPoolException
```
    Sets the minimum number of idle connections. If the number of available connections IS LESS THAN the minimum, then new connections are created and made available in pool. The default is 0.
    
    Parameters:
    
    minIdle - The minimum number of idle connections.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set min idle.
  - getMaxIdle
```
default int getMaxIdle()
```
    Gets the maximum number of idle connections that the connection pool maintains.
    
    Returns:
    
    The maximum number of idle connections.
  - setMaxIdle
```
default void setMaxIdle(int maxIdle)
                 throws UniversalConnectionPoolException
```
    Sets the maximum number of idle connections. If the number of available connections is greater than the "maximum idle", then when a connection is returned it will be closed. The default value is Integer.MAX_VALUE.
    
    Parameters:
    
    maxIdle - The maximum number of idle connections.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set max idle.
  - getMaxPoolSize
```
default int getMaxPoolSize()
```
    Gets the maximum number of connections that the connection pool maintains.
    
    Returns:
    
    The maximum number of connections.
  - setMaxPoolSize
```
default void setMaxPoolSize(int maxPoolSize)
                     throws UniversalConnectionPoolException
```
    Sets the maximum number of connections. The maximum number of connections includes the number of connections that are in use as well as the number of available connections. The default value is Integer.MAX_VALUE.
    
    Parameters:
    
    maxPoolSize - The maximum number of connections.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set max pool size.
  - getInactiveConnectionTimeout
```
default int getInactiveConnectionTimeout()
```
    Gets the inactive connection timeout value.
    
    Returns:
    
    The inactive connection timeout.
  - setInactiveConnectionTimeout
```
default void setInactiveConnectionTimeout(int inactiveConnectionTimeout)
                                   throws UniversalConnectionPoolException
```
    Sets the inactive connection timeout. This timeout determines how long an available connection remains in the connection pool before it is removed from the pool.
    This property's behaviour is affected by the system property oracle.ucp.timersAffectAllConnections. For more details go to - PoolDataSource.SYSTEM_PROPERTY_TIMERS_AFFECT_ALL_CONNECTIONS.
    
    Parameters:
    
    inactiveConnectionTimeout - The inactive connection timeout (in seconds).
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - getAbandonedConnectionTimeout
```
default int getAbandonedConnectionTimeout()
```
    Gets the abandoned connection timeout value.
    
    Returns:
    
    The abandoned connection timeout.
  - setAbandonedConnectionTimeout
```
default void setAbandonedConnectionTimeout(int abandonedConnectionTimeout)
                                    throws UniversalConnectionPoolException
```
    Sets the abandoned connection timeout. This timeout determines how long a borrowed connection can remain unused before it is considered abandoned and reclaimed by the connection pool.
    
    Parameters:
    
    abandonedConnectionTimeout - The value of how long a connection has not been used before it is abandoned (in seconds).
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - getConnectionWaitTimeout
```
@Deprecated
default int getConnectionWaitTimeout()
```
    Deprecated.
    
    Gets the maximum time (in seconds) that any connection borrow request can wait before it returns to the application.
    This method is deprecated. Use getConnectionWaitDuration() instead.
    
    Returns:
    
    The connection wait timeout.
    
    See Also:
    
    setConnectionWaitTimeout
  - getConnectionWaitDuration
```
default java.time.Duration getConnectionWaitDuration()
```
    Gets the maximum time (in java.time.Duration) that any connection borrow request can wait before it returns to the application.
    
    Returns:
    
    The connection wait duration.
    
    See Also:
    
    setConnectionWaitDuration
  - setConnectionWaitTimeout
```
@Deprecated
default void setConnectionWaitTimeout(int waitTimeout)
                                           throws UniversalConnectionPoolException
```
    Deprecated.
    
    Configures how much time a connection request call may wait before it either successfully returns a connection or throws an exception.
    
    The wait timeout starts from the point when a connection borrow request is submitted to the pool.
    
    During this time, UCP may either return a connection that's currently available in the pool (ideal scenario) or create a new connection if the pool hasn't reached its maximum size. Otherwise, UCP waits for a connection to be returned to the pool.
    
    By default, the connection wait timeout is set to 3 seconds.
    
    Setting the timeout to 0 makes UCP throw an exception immediately if there is no connection available and no room to grow the pool. Note that it still allows UCP to create a new connection if the maximum size hasn't been reached, and that may take some time.
    
    This method is deprecated. Use setConnectionWaitDuration(java.time.Duration) instead.
    
    Parameters:
    
    waitTimeout - The amount of time for a connection request to wait.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - setConnectionWaitDuration
```
default void setConnectionWaitDuration(java.time.Duration waitDuration)
                                throws UniversalConnectionPoolException
```
    Configures how much time a connection request call may wait before it either successfully returns a connection or throws an exception.
    
    The wait duration starts from the point when a connection borrow request is submitted to the pool.
    
    During this time, UCP may either return a connection that's currently available in the pool (ideal scenario) or create a new connection if the pool hasn't reached its maximum size. Otherwise, UCP waits for a connection to be returned to the pool.
    
    By default, the connection wait timeout is set to 3 seconds.
    
    Setting the connection wait timeout to Duration.ZERO makes UCP throw an exception immediately if there is no connection available and no room to grow the pool. Note that it still allows UCP to create a new connection if the maximum size hasn't been reached, and that may take some time.
    
    Parameters:
    
    waitDuration - The duration for a connection request to wait.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - getConnectionWaitDurationInMillis
```
default java.lang.Long getConnectionWaitDurationInMillis()
```
    Get connection wait duration in milliseconds.
    
    Returns:
    
    connection wait duration in milliseconds.
  - setConnectionWaitDurationInMillis
```
default void setConnectionWaitDurationInMillis(java.lang.Long durationInMillis)
                                        throws UniversalConnectionPoolException
```
    Set connection wait duration in milliseconds.
    
    Parameters:
    
    durationInMillis - long value of duration in milliseconds.
    
    Throws:
    
    UniversalConnectionPoolException - if not able to set for some reason.
  - getConnectionWaitTimeoutWhileServiceDown
```
default java.lang.Long getConnectionWaitTimeoutWhileServiceDown()
```
    Get connection wait timeout that applies while service is down in seconds.
    
    Returns:
    
    connection wait timeout while service is down in seconds.
  - setConnectionWaitTimeoutWhileServiceDown
```
default void setConnectionWaitTimeoutWhileServiceDown(java.lang.Long timeoutServiceDown)
                                               throws UniversalConnectionPoolException
```
    Set connection wait timeout that applies while service is down.
    
    Parameters:
    
    timeoutServiceDown - value of timeout while service is down in seconds.
    
    Throws:
    
    UniversalConnectionPoolException - if not able to set for some reason.
  - getFailFastOnChunkUnavailable
```
default boolean getFailFastOnChunkUnavailable()
```
    Return the boolean value of the property fail fast on chunk unavailable.
    The default value is true.
    
    Returns:
    
    true if fail fast on shard unavailable is enabled, false otherwise
  - setFailFastOnChunkUnavailable
```
default void setFailFastOnChunkUnavailable(boolean failFastEnabled)
                                    throws UniversalConnectionPoolException
```
    This flag determines if connection requests to unavailable chunks will fail fast or not. If this is enabled, requests will fail as soon as we find the chunk is unavailable at the moment, otherwise, the connection request will turn to the listener to look for the appropriate connection, which would increase the wait time.
    
    Parameters:
    
    failFastEnabled - true if this property is to be set to enabled, false otherwise.
    
    Throws:
    
    UniversalConnectionPoolException
  - getTimeToLiveConnectionTimeout
```
default int getTimeToLiveConnectionTimeout()
```
    Gets the maximum time (in seconds) a connection may remain in-use. The used connection is unconditionally returned to the connection pool when this timeout expires. A value of 0 means that the feature is not enabled.
    
    Returns:
    
    The maximum time (in seconds) a used connection may be active.
  - setTimeToLiveConnectionTimeout
```
default void setTimeToLiveConnectionTimeout(int timeToLiveConnectionTimeout)
                                     throws UniversalConnectionPoolException
```
    Sets the maximum time (in seconds) a connection may remain in-use.
    
    Parameters:
    
    timeToLiveConnectionTimeout - The maximum time (in seconds) a used connection may be active.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - getTimeoutCheckInterval
```
default int getTimeoutCheckInterval()
```
    Gets the frequency (in seconds) to enforce the timeout properties. It applies to all of the connection pool timeouts including abandonedConnectionTimeout, inactiveConnectionTimeout, and timeToLiveConnectionTimeout.
    
    Returns:
    
    The frequency (in seconds) to enforce the timeout properties.
  - setTimeoutCheckInterval
```
default void setTimeoutCheckInterval(int timeoutCheckInterval)
                              throws UniversalConnectionPoolException
```
    Sets the frequency (in seconds) to enforce the timeout properties.
    
    Parameters:
    
    timeoutCheckInterval - The frequency (in seconds) to enforce the timeout properties.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - getValidateConnectionOnBorrow
```
default boolean getValidateConnectionOnBorrow()
```
    Returns whether or not a connection being borrowed should first be validated. When this property is set to true, connection validity is performed before returning the connection to the user.
    
    Returns:
    
    Whether or not a connection being borrowed should first be validated.
  - setValidateConnectionOnBorrow
```
default void setValidateConnectionOnBorrow(boolean validateConnectionOnBorrow)
```
    Makes the pool validate the connection before returning it to the user by calling the JDBC API "isValid".
    
    Validating the connection each time it's borrowed from the pool has a performance cost because it typically requires a full roundtrip to the database. You can tune how the Oracle JDBC thin driver validates connections using the "oracle.jdbc.defaultConnectionValidation" property (please refer to the JDBC driver javadoc). You may also configure "secondsToTrustIdleConnection" to avoid validating connections that are often active.
    
    Please note that by default, OracleConnection.ConnectionValidation isn't enabled, but UCP performs the lightweight INBAND_DOWN validation to know if a connection needs to be drained.
    
    Parameters:
    
    validateConnectionOnBorrow - Whether or not a connection being borrowed should first be validated.
    
    See Also:
    
    setSecondsToTrustIdleConnection
  - getConnectionHarvestTriggerCount
```
default int getConnectionHarvestTriggerCount()
```
    Gets the number of available connections below which the connection pool's connection harvesting occurs. For example, if the value is set to 10, then connection harvesting occurs when the number of available connections drops to 10.
    
    Returns:
    
    The number of available connections below which the connection pool's connection harvesting occurs.
  - setConnectionHarvestTriggerCount
```
default void setConnectionHarvestTriggerCount(int connectionHarvestTriggerCount)
                                       throws UniversalConnectionPoolException
```
    Sets the number of available connections below which the connection pool's connection harvesting occurs.
    
    Parameters:
    
    connectionHarvestTriggerCount - The number of available connections below which the connection pool's connection harvesting occurs.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set count.
  - getConnectionHarvestMaxCount
```
default int getConnectionHarvestMaxCount()
```
    Gets the maximum number of connections that may be harvested when the connection harvesting occurs. Note that it is possible that the number of connections that are harvested may be anywhere from 0 to the connectionHarvestMaxCount.
    
    Returns:
    
    The maximum number of connections that may be harvested when the connection harvesting occurs.
  - setConnectionHarvestMaxCount
```
default void setConnectionHarvestMaxCount(int connectionHarvestMaxCount)
                                   throws UniversalConnectionPoolException
```
    Sets the maximum number of connections that may be harvested when the connection harvesting occurs.
    
    Parameters:
    
    connectionHarvestMaxCount - the maximum number of connections that may be harvested when the connection harvesting occurs.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - getAvailableConnectionsCount
```
int getAvailableConnectionsCount()
```
    Gets the number of connections that are available in the connection pool (that is, connections in the pool that are not currently in use by clients).
    
    Returns:
    
    The number of connections that are available in the connection pool.
  - getBorrowedConnectionsCount
```
int getBorrowedConnectionsCount()
```
    Gets the number of connections that are actively in use by clients.
    
    Returns:
    
    The number of connections that are actively in use by clients.
  - getStatistics
```
UniversalConnectionPoolStatistics getStatistics()
```
    Gets the statistics of the connection pool.
    
    Returns:
    
    The statistics of the connection pool.
  - getLifeCycleState
```
UniversalConnectionPoolLifeCycleState getLifeCycleState()
```
    Gets the life cycle state of the connection pool.
    
    Returns:
    
    The life cycle state of the connection pool.
  - getConnectionRetrievalInfo
```
ConnectionRetrievalInfo getConnectionRetrievalInfo()
```
    Gets the ConnectionRetrievalInfo object which contains user and password information to create the connections.
    
    Returns:
    
    ConnectionRetrievalInfo object which contains user and password information to create the connections.
  - setConnectionRetrievalInfo
```
void setConnectionRetrievalInfo(ConnectionRetrievalInfo cri)
```
    Sets the ConnectionRetrievalInfo for creating the initial connections (physical connections) in the pool based on the initialPoolSize property.
    
    Parameters:
    
    cri - The ConnectionRetrievalInfo with user and password for creating the initial connections in the pool.
  - registerConnectionAffinityCallback
```
default void registerConnectionAffinityCallback(ConnectionAffinityCallback cbk)
                                         throws UniversalConnectionPoolException
```
    Registers a ConnectionAffinityCallback objet on the connection pool.
    
    Parameters:
    
    cbk - The affinity callback object to be registered
    
    Throws:
    
    UniversalConnectionPoolException - If callback registration fails.
  - removeConnectionAffinityCallback
```
default void removeConnectionAffinityCallback()
                                       throws UniversalConnectionPoolException
```
    Removes the ConnectionAffinityCallback object registered on the connection pool.
    
    Throws:
    
    UniversalConnectionPoolException - If callback removal fails.
  - registerConnectionLabelingCallback
```
default void registerConnectionLabelingCallback(ConnectionLabelingCallback cbk)
                                         throws UniversalConnectionPoolException
```
    Registers a ConnectionLabelingCallback object with this connection pool.
    
    Parameters:
    
    cbk - The ConnectionLabelingCallback object to be registered.
    
    Throws:
    
    UniversalConnectionPoolException - If there is a callback already registered with this pool.
  - removeConnectionLabelingCallback
```
default void removeConnectionLabelingCallback()
                                       throws UniversalConnectionPoolException
```
    Removes the ConnectionLabelingCallback object registered with this connection pool, if any.
    
    Throws:
    
    UniversalConnectionPoolException - If callback removal fails.
  - getMaxConnectionReuseTime
```
default long getMaxConnectionReuseTime()
```
    Gets the maximum connection reuse time property value. See property description in setMaxConnectionReuseTime().
    
    Returns:
    
    Maximum connection reuse time (in seconds)
  - setMaxConnectionReuseTime
```
default void setMaxConnectionReuseTime(long maxConnectionReuseTime)
                                throws UniversalConnectionPoolException
```
    Sets the maximum connection reuse time property. This property specifies the maximum time any connection can potentially be reused after which the pool removes and closes a connection. The value is specified in seconds and must be greater than 0. For example, if the specified value is 3600 seconds, then when a connection is in existence for more than 3600 seconds, the connection is closed and removed from the pool. Connections are closed gracefully after they are returned to the pool and the specified property value has been exceeded. Default is 0, which means this feature is not enabled.
    This property's behaviour is affected by the system property oracle.ucp.timersAffectAllConnections. For more details go to - PoolDataSource.SYSTEM_PROPERTY_TIMERS_AFFECT_ALL_CONNECTIONS.
    
    Parameters:
    
    maxConnectionReuseTime - Maximum connection reuse time (in seconds).
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set timeout.
  - getMaxConnectionReuseCount
```
default int getMaxConnectionReuseCount()
```
    Gets the maximum connection reuse count property value. See property description in setMaxConnectionReuseCount().
    
    Returns:
    
    Maximum connection reuse count.
  - setMaxConnectionReuseCount
```
default void setMaxConnectionReuseCount(int maxConnectionReuseCount)
                                 throws UniversalConnectionPoolException
```
    Sets the maximum connection reuse count property. This property specifies the maximum number of times any connection can be reused after which the pool removes and closes a connection. The value must be greater than 0 for this feature to be enabled. For example, if the specified value is 100, then when a connection is reused or borrowed 100 times from the pool, it is closed and removed from the pool. Connections are closed gracefully after they are returned to the pool and the property value has been exceeded. Default is 0, which means this feature is not enabled.
    
    Parameters:
    
    maxConnectionReuseCount - Maximum connection reuse count.
    
    Throws:
    
    UniversalConnectionPoolException - in case it was not possible to set count.
  - getSecondsToTrustIdleConnection
```
default int getSecondsToTrustIdleConnection()
```
    Gets the seconds To Trust Idle Connection value which determines whether or not connection validation on borrow should be skipped See property description in setSecondsToTrustIdleConnection().
    
    Returns:
    
    Seconds To Trust Idle Connection value.
  - setSecondsToTrustIdleConnection
```
default void setSecondsToTrustIdleConnection(int secondsToTrustIdleConnection)
                                      throws UniversalConnectionPoolException
```
    Sets the time in seconds to trust an idle connection to skip a validation test. It works in conjunction with setValidateConnectionOnBorrow(boolean). When set to any positive value, a connection validation during the checkout is skipped if the connection was successfully used and returned to the pool within the time specified for secondsToTrustIdleConnection. Default value is set to 0 seconds which means that the feature is disabled.
    With this mode enabled, UCP will do a SOCKET validation on every connection borrow and default driver validation type (can be changed with the "oracle.jdbc.defaultConnectionValidation" system property) after designated seconds to trust idle connection has passed
    
    Parameters:
    
    secondsToTrustIdleConnection - The value of how long a connection can be trusted to skip connectionValidationOnBorrow
    
    Throws:
    
    UniversalConnectionPoolException - in case setter was failed.
  - getConnectionLabelingHighCost
```
default int getConnectionLabelingHighCost()
```
    Obtains the cost value which identifies a connection as "high-cost" for connection labeling.
    
    Returns:
    
    The cost value that identifies a connection as "high-cost" for connection labeling.
    
    See Also:
    
    setConnectionLabelingHighCost
  - setConnectionLabelingHighCost
```
default void setConnectionLabelingHighCost(int highCost)
                                    throws UniversalConnectionPoolException
```
    Sets the cost value which identifies a connection as "high-cost" for connection labeling. Connection labeling uses the cost(Properties, Properties) method in ConnectionLabelingCallback to find a connection in the pool for a request. When this property is set, connections with a cost value equal to or greater than the property value are considered "high-cost" connections. The default value is Integer.MAX_VALUE.
    
    Parameters:
    
    highCost - The cost value that identifies a connection as "high-cost" for connection labeling.
    
    Throws:
    
    UniversalConnectionPoolException - If an exception occurs while setting the cost.
  - getHighCostConnectionReuseThreshold
```
default int getHighCostConnectionReuseThreshold()
```
    Obtains the high-cost connection reuse threshold property value for connection labeling.
    
    Returns:
    
    The high-cost connection reuse threshold property value currently set.
    
    See Also:
    
    setConnectionLabelingHighCost, setHighCostConnectionReuseThreshold
  - setHighCostConnectionReuseThreshold
```
default void setHighCostConnectionReuseThreshold(int threshold)
                                          throws UniversalConnectionPoolException
```
    Sets the high-cost connection reuse threshold for connection labeling. This property works together with the ConnectionLabelingHighCost property to determine when high-cost connections are reused for connection labeling. This property specifies a threshold of the number of total connections in the pool. If Connection Labeling finds all available connections are high-cost connections (i.e., the lowest cost value exceeds the ConnectionLabelingHighCost value), it checks this threshold to determine whether to reuse those connections. Only when this threshold is reached, Connection Labeling will try to reuse the high-cost connections in the pool to serve a labeled connection request. Otherwise, Connection Labeling picks a low-cost connection, a no-label connection available in the pool, or creates a brand-new physical connection to serve a labeled request. For example, if the property value is set to 10, Connection Labeling reuses high-cost connections when there are no low-cost connections available and the total connections reach 10. Note that any labeled connection with cost Integer.MAX_VALUE will not be reused. This is consistent with connection labeling behavior when this property and ConnectionLabelingHighCost are not set. A Connection Labeling callback must be registered at the same time for this property to take effect. The default value is 0, which is treated the same way as MinPoolSize.
    
    Parameters:
    
    threshold - The high-cost connection reuse threshold to set.
    
    Throws:
    
    UniversalConnectionPoolException - If any exception occurs while setting the threshold.
  - getMaxConnectionsPerService
```
default int getMaxConnectionsPerService()
```
    Gets the maximum number of connections that can be obtained to a particular service, in a shared pool.
    
    Returns:
    
    The maximum number of connections that can be obtained to a particular service.
  - setMaxConnectionsPerService
```
default void setMaxConnectionsPerService(int maxConnectionsPerService)
                                  throws UniversalConnectionPoolException
```
    Sets the maximum number of connections that can be obtained to a particular service, in a shared pool. An exception is thrown when setting a different maxConnectionsPerService value on a running pool instance.
    
    Parameters:
    
    maxConnectionsPerService - The maximum number of connections that can be obtained to a particular service.
    
    Throws:
    
    UniversalConnectionPoolException - If any exception occurs while setting the maxConnectionsPerService value.
  - getConnectionRepurposeThreshold
```
default int getConnectionRepurposeThreshold()
```
    Gets the connection repurpose threshold for the pool. This property is used in cases when the connection pool is shared by multiple datasources connecting to the same database but using different services.Only when this threshold is reached the pool will try to repurpose connections between different services before trying to create new connections. This property is applicable only for multi-tenant databases.
    
    Returns:
    
    connection repurpose threshold property value currently set.
  - setConnectionRepurposeThreshold
```
default void setConnectionRepurposeThreshold(java.lang.Integer threshold)
                                      throws UniversalConnectionPoolException
```
    Sets the connection repurpose threshold for the pool. This property is applicable only for multi-tenant databases.
    
    Parameters:
    
    threshold - connection repurpose threshold to set.
    
    Throws:
    
    UniversalConnectionPoolException - If any exception occurs while setting the threshold.
    
    See Also:
    
    getConnectionRepurposeThreshold
  - getLoginTimeout
```
default int getLoginTimeout()
```
    Gets the default maximum time in seconds that a driver will wait while attempting to connect to a database once the driver has been identified.
    
    Returns:
    
    timeout in seconds
  - setLoginTimeout
```
default void setLoginTimeout(int seconds)
                      throws UniversalConnectionPoolException
```
    Sets the default maximum time in seconds that a driver will wait while attempting to connect to a database once the driver has been identified.
    
    Parameters:
    
    seconds - timeout
    
    Throws:
    
    UniversalConnectionPoolException - in case of negative value
  - isShareable
```
default boolean isShareable()
```
    Returns whether the pool is shareable or not.
    
    Returns:
    
    Whether or not pool is shareable.
  - setShardingMode
```
default void setShardingMode(boolean shardingMode)
```
    This API changes the mode of UCP when UCP is using a Sharded Database. By default UCP requires the caller to provide a sharding key for every connection request. When switching off the sharding mode, UCP behaves like a regular connection pool and all the sharding features are disabled so that a caller can request a connection without providing any sharding key.
    
    Parameters:
    
    shardingMode - Mode of UCP when using a Sharded Database.
  - getShardingMode
```
default boolean getShardingMode()
```
    Returns the mode of UCP when UCP is using a Sharded Database. By default sharding mode is ON which means UCP requires the caller to provide a sharding key for every connection request.
    
    Returns:
    
    Mode of UCP when using a Sharded Database.
  - setConnectionValidationTimeout
```
default void setConnectionValidationTimeout(int connectionValidationTimeout)
                                     throws UniversalConnectionPoolException
```
    Connection validation timeout setter This property changes the allowed time for a connection validation. If a connection validation operation lasts longer than this timeout, it is interrupted and a connection is considered to be invalid.
    
    Parameters:
    
    connectionValidationTimeout - validation timeout in seconds
    
    Throws:
    
    UniversalConnectionPoolException - gets thrown in case of negation timeout submitted
  - getConnectionValidationTimeout
```
default int getConnectionValidationTimeout()
```
    Connection validation timeout getter This property changes the allowed time for a connection validation. If a connection validation operation lasts longer than this timeout, it is interrupted and a connection is considered to be invalid.
    
    Returns:
    
    connection validation timeout in seconds
  - isReadOnlyInstanceAllowed
```
default boolean isReadOnlyInstanceAllowed()
```
    Returns true if the connection borrow is allowed to a read-only instance, false otherwise. This property is applicable to sharded database only. A shard instance can be in read-only mode for a chunk if chunk move/split operation is in progress.
    
    Returns:
    
    true if the connection borrow is allowed to a read-only instance, false otherwise.
  - setReadOnlyInstanceAllowed
```
default void setReadOnlyInstanceAllowed(boolean readOnlyInstanceAllowed)
```
    Sets the read-only instance allowed value on the datasource. This property is applicable to sharded database only. When the property value is set to true, UCP allows connection borrow to read-only instances as well otherwise not. A shard instance goes into read-only mode for a chunk if the chunk move/split operation is in progress on that instance. The default value is false which means by default connection borrow is not allowed to a read-only instance.
    
    Parameters:
    
    readOnlyInstanceAllowed - whether to allow connection borrow to a read-only instance or not
  - isCreateConnectionInBorrowThread
```
default boolean isCreateConnectionInBorrowThread()
```
    Get flag defining how to create connections on pool grow.
    
    Returns:
    
    true, if in a borrow thread, false - if in background.
  - setCreateConnectionInBorrowThread
```
default void setCreateConnectionInBorrowThread(boolean createConnectionInBorrowThread)
```
    Set flag defining how to create connections on pool grow.
    If this property is set to false, a pool waits no longer than a designated connection wait duration no matter how long it takes to create a new connection to grow a pool, if no connection is available at this moment. If this property is set to true, then in this backward compatibility mode a pool waits for a connection to be synchronously created in a borrow thread, and the waiting time can take longer than connectionWaitDuration. For connectionWaitDuration please refer to PoolDataSource.setConnectionWaitDuration(java.time.Duration).
    
    Parameters:
    
    createConnectionInBorrowThread - true, if in a borrow thread, false - if in background.
  - getQueryTimeout
```
default int getQueryTimeout()
```
    Gets the number of seconds the driver will wait for a Statement object to execute to the given number of seconds.
    
    Returns:
    
    The query timeout in seconds
  - setQueryTimeout
```
default void setQueryTimeout(int queryTimeout)
                      throws UniversalConnectionPoolException
```
    Sets the number of seconds the driver will wait for a Statement object to execute to the given number of seconds.
    
    Parameters:
    
    queryTimeout - in seconds
    
    Throws:
    
    UniversalConnectionPoolException - if unable to set.
  - isCommitOnConnectionReturn
```
default boolean isCommitOnConnectionReturn()
```
    Returns the boolean value for the property that controls the behavior of UCP when a connection is released back to the pool with pending uncommitted changes in an active transaction. By default, UCP will commit the changes (default value is "true"). When setting this property to "false" the changes will be rolled back.
    
    Returns:
    
    true to commit, false to rollback.
  - setCommitOnConnectionReturn
```
default void setCommitOnConnectionReturn(boolean commit)
                                  throws UniversalConnectionPoolException
```
    Sets the boolean value for the property that controls the behavior of UCP when a connection is released back to the pool with pending uncommitted changes in an active transaction. By default, UCP will commit the changes (default value is "true"). When setting this property to "false" the changes will be rolled back.
    
    Parameters:
    
    commit - 'true' to commit, 'false' to rollback. The default is 'true'.
    
    Throws:
    
    UniversalConnectionPoolException - if an error occurs while setting the property
  - getUCPEventListenerProvider
```
java.lang.String getUCPEventListenerProvider()
```
    Gets the UCP event listener provider name.
    
    Returns:
    
    The provider name, or null if using the default provider
  - setUCPEventListenerProvider
```
void setUCPEventListenerProvider(java.lang.String providerName)
                          throws UniversalConnectionPoolException
```
    Sets the UCP event listener provider by name.
    
    Parameters:
    
    providerName - The name of the event listener provider (cannot be null, empty, or whitespace)
    
    Throws:
    
    UniversalConnectionPoolException - if providerName is null, empty, or contains only whitespace
  - setPoolProperty
```
default void setPoolProperty(oracle.ucp.config.PoolProperty poolProperty,
                             java.lang.Object value,
                             int code)
                      throws UniversalConnectionPoolException
```
    Set a given pool property.
    
    Parameters:
    
    poolProperty - pool property to set.
    
    value - pool property value to set.
    
    code - error code to throw with UniversalConnectionPoolException.
    
    Throws:
    
    UniversalConnectionPoolException - this error is thrown if unable to set.
  - getPoolProperty
```
default java.lang.Object getPoolProperty(oracle.ucp.config.PoolProperty poolProperty)
```
    Get a pool property.
    
    Parameters:
    
    poolProperty - pool property to get.
    
    Returns:
    
    object containing the current pool property value.
  - getPoolProperties
```
oracle.ucp.config.PoolProperties getPoolProperties()
```
    Pool properties backbone getter.
    This method returns the PoolProperties collection that contains the pool configuration.
    
    Returns:
    
    pool properties collection.

Interface UniversalConnectionPool

Method Summary

Methods inherited from interface oracle.ucp.diagnostics.Diagnosable

Method Detail

borrowConnection

borrowConnectionAsync

returnConnection

closeConnection

refresh

recycle

purge

reconfigure

start

start

stop

getName

setName

getInitialPoolSize

setInitialPoolSize

getMinPoolSize

setMinPoolSize

getMinIdle

setMinIdle

getMaxIdle

setMaxIdle

getMaxPoolSize

setMaxPoolSize

getInactiveConnectionTimeout

setInactiveConnectionTimeout

getAbandonedConnectionTimeout

setAbandonedConnectionTimeout

getConnectionWaitTimeout

getConnectionWaitDuration

setConnectionWaitTimeout

setConnectionWaitDuration

getConnectionWaitDurationInMillis

setConnectionWaitDurationInMillis

getConnectionWaitTimeoutWhileServiceDown

setConnectionWaitTimeoutWhileServiceDown

getFailFastOnChunkUnavailable

setFailFastOnChunkUnavailable

getTimeToLiveConnectionTimeout

setTimeToLiveConnectionTimeout

getTimeoutCheckInterval

setTimeoutCheckInterval

getValidateConnectionOnBorrow

setValidateConnectionOnBorrow

getConnectionHarvestTriggerCount

setConnectionHarvestTriggerCount

getConnectionHarvestMaxCount

setConnectionHarvestMaxCount

getAvailableConnectionsCount

getBorrowedConnectionsCount

getStatistics

getLifeCycleState

getConnectionRetrievalInfo

setConnectionRetrievalInfo

registerConnectionAffinityCallback

removeConnectionAffinityCallback

registerConnectionLabelingCallback

removeConnectionLabelingCallback

getMaxConnectionReuseTime

setMaxConnectionReuseTime

getMaxConnectionReuseCount

setMaxConnectionReuseCount

getSecondsToTrustIdleConnection

setSecondsToTrustIdleConnection

getConnectionLabelingHighCost

setConnectionLabelingHighCost

getHighCostConnectionReuseThreshold

setHighCostConnectionReuseThreshold

getMaxConnectionsPerService

setMaxConnectionsPerService

getConnectionRepurposeThreshold

setConnectionRepurposeThreshold

getLoginTimeout

setLoginTimeout

isShareable

setShardingMode

getShardingMode