JDBCConnectionPoolParamsBean (Java API Reference for Oracle WebLogic Server)

All Superinterfaces:

SettableBean
```
public interface JDBCConnectionPoolParamsBean
extends SettableBean
```
Contains the connection pool parameters of a data source.

Configuration parameters for a data source's connection pool are specified using the connection pool parameters bean.

Access limited to the following security roles:

Deployer

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method	Description
`int`	`getCapacityIncrement()`	Deprecated. 10.3.6.0
`int`	`getConnectionCreationRetryFrequencySeconds()`	The number of seconds between attempts to establish connections to the database.
`int`	`getConnectionHarvestMaxCount()`	The maximum number of connections that may be harvested when the connection harvesting occurs.
`int`	`getConnectionHarvestTriggerCount()`	Specifies the number of available connections (trigger value) used to determine when connection harvesting occurs.
`java.lang.String`	`getConnectionLabelingCallback()`	The class name of the connection labeling callback.
`int`	`getConnectionReserveTimeoutSeconds()`	The number of seconds after which a call to reserve a connection from the connection pool will timeout.
`int`	`getCountOfRefreshFailuresTillDisable()`	Specifies the number of reconnect failures allowed before WebLogic Server disables a connection pool to minimize the delay in handling the connection request caused by a database failure.
`int`	`getCountOfTestFailuresTillFlush()`	Specifies the number of test failures allowed before WebLogic Server closes all unused connections in a connection pool to minimize the delay caused by further database testing.
`java.lang.String`	`getDriverInterceptor()`	Specifies the absolute name of the application class used to intercept method calls to the JDBC driver.
`java.lang.String`	`getFatalErrorCodes()`	Specifies a comma-separated list of error codes that are treated as fatal errors.
`int`	`getHighestNumWaiters()`	The maximum number of connection requests that can concurrently block threads while waiting to reserve a connection from the data source's connection pool.
`int`	`getInactiveConnectionTimeoutSeconds()`	The number of inactive seconds on a reserved connection before WebLogic Server reclaims the connection and releases it back into the connection pool.
`int`	`getInitialCapacity()`	The number of physical connections to create when creating the connection pool in the data source.
`java.lang.String`	`getInitSql()`	SQL statement to execute that will initialize newly created physical database connections.
`int`	`getJDBCXADebugLevel()`	Specifies level of JDBC debugging for XA drivers, where larger values in the range provide more debugging information.
`int`	`getLoginDelaySeconds()`	The number of seconds to delay before creating each physical database connection.
`int`	`getMaxCapacity()`	The maximum number of physical connections that this connection pool can contain.
`int`	`getMinCapacity()`	The minimum number of physical connections that this connection pool can contain after it is initialized.
`int`	`getProfileConnectionLeakTimeoutSeconds()`	The number of seconds that an inactive JDBC connection needs to be held by an application before triggering a connection leak diagnostic profiling record.
`int`	`getProfileHarvestFrequencySeconds()`	The number of seconds between when WebLogic Server harvests profile data.
`int`	`getProfileType()`	Specifies the type of profile data to be collected for the JDBC subsystem.
`int`	`getSecondsToTrustAnIdlePoolConnection()`	The number of seconds within a connection use that WebLogic Server trusts that the connection is still viable and will skip the connection test, either before delivering it to an application or during the periodic connection testing process.
`int`	`getShrinkFrequencySeconds()`	The number of seconds to wait before shrinking a connection pool that has incrementally increased to meet demand.
`int`	`getStatementCacheSize()`	The number of prepared and callable statements stored in the cache.
`java.lang.String`	`getStatementCacheType()`	The algorithm used for maintaining the prepared statements stored in the statement cache.
`int`	`getStatementTimeout()`	The time after which a statement currently being executed will time out.
`int`	`getTestFrequencySeconds()`	The number of seconds a WebLogic Server instance waits between attempts when testing unused connections.
`java.lang.String`	`getTestTableName()`	The name of the database table to use when testing physical database connections.
`boolean`	`isCredentialMappingEnabled()`	Enables Set Client ID on connection for the data source.
`boolean`	`isIdentityBasedConnectionPoolingEnabled()`	Enables identity-based-connection-pooling for the data source.
`boolean`	`isIgnoreInUseConnectionsEnabled()`	Enables the data source to be shutdown even if connections obtained from the pool are still in use.
`boolean`	`isInvokeBeginEndRequest()`	When true, and when a JDBC 4.3 compatible driver is used, the connection pool will invoke Connection.beginRequest() prior to returning the connection to the application, and will invoke Connection.endRequest() before the connection is released to the pool.
`boolean`	`isPinnedToThread()`	Enables an option to improve performance by enabling execute threads to keep a pooled database connection even after the application closes the logical connection.
`boolean`	`isRemoveInfectedConnections()`	Specifies whether a connection will be removed from the connection pool after the application uses the underlying vendor connection object.
`boolean`	`isTestConnectionsOnReserve()`	Enables WebLogic Server to test a connection before giving it to a client.
`boolean`	`isWrapJdbc()`	By default, SQL objects for `CallableStatement`, `PreparedStatement`, `ResultSet`, `Statement`, and `DatabaseMetaData` are wrapped with a WebLogic wrapper.
`boolean`	`isWrapTypes()`	By default, data type objects for Array, Blob, Clob, NClob, Ref, SQLXML, and Struct, plus ParameterMetaData and ResultSetMetaData objects are wrapped with a WebLogic wrapper.
`void`	`setCapacityIncrement(int capacityIncrement)`	Deprecated. 10.3.6.0
`void`	`setConnectionCreationRetryFrequencySeconds(int connectionCreationRetryFrequencySeconds)`
`void`	`setConnectionHarvestMaxCount(int connectionHarvestMaxCount)`
`void`	`setConnectionHarvestTriggerCount(int connectionHarvestTriggerCount)`
`void`	`setConnectionLabelingCallback(java.lang.String className)`
`void`	`setConnectionReserveTimeoutSeconds(int connectionReserveTimeoutSeconds)`
`void`	`setCountOfRefreshFailuresTillDisable(int countOfRefreshFailuresTillDisable)`
`void`	`setCountOfTestFailuresTillFlush(int countOfTestFailuresTillFlush)`
`void`	`setCredentialMappingEnabled(boolean credentialMappingEnabled)`
`void`	`setDriverInterceptor(java.lang.String driverInterceptor)`
`void`	`setFatalErrorCodes(java.lang.String fatalErrorCodes)`
`void`	`setHighestNumWaiters(int highestNumWaiters)`
`void`	`setIdentityBasedConnectionPoolingEnabled(boolean identityBasedConnectionPoolingEnabled)`
`void`	`setIgnoreInUseConnectionsEnabled(boolean ignoreInUseConnectionsEnabled)`
`void`	`setInactiveConnectionTimeoutSeconds(int inactiveConnectionTimeoutSeconds)`
`void`	`setInitialCapacity(int initialCapacity)`
`void`	`setInitSql(java.lang.String initSql)`
`void`	`setInvokeBeginEndRequest(boolean invokeBeginEndRequest)`
`void`	`setJDBCXADebugLevel(int jdbcXaDebugLevel)`
`void`	`setLoginDelaySeconds(int loginDelaySeconds)`
`void`	`setMaxCapacity(int maxCapacity)`
`void`	`setMinCapacity(int minCapacity)`
`void`	`setPinnedToThread(boolean pinnedToThread)`
`void`	`setProfileConnectionLeakTimeoutSeconds(int seconds)`
`void`	`setProfileHarvestFrequencySeconds(int profileHarvestFrequencySeconds)`
`void`	`setProfileType(int profileType)`
`void`	`setRemoveInfectedConnections(boolean removeInfectedConnections)`
`void`	`setSecondsToTrustAnIdlePoolConnection(int secondsToTrustAnIdlePoolConnection)`
`void`	`setShrinkFrequencySeconds(int shrinkFrequencySeconds)`
`void`	`setStatementCacheSize(int statementCacheSize)`
`void`	`setStatementCacheType(java.lang.String statementCacheType)`
`void`	`setStatementTimeout(int statementTimeout)`
`void`	`setTestConnectionsOnReserve(boolean testConnectionsOnReserve)`
`void`	`setTestFrequencySeconds(int testFrequencySeconds)`
`void`	`setTestTableName(java.lang.String testTableName)`
`void`	`setWrapJdbc(boolean wrapJdbc)`
`void`	`setWrapTypes(boolean wrapTypes)`

- Method Detail
  - getInitialCapacity
```
int getInitialCapacity()
```
    The number of physical connections to create when creating the connection pool in the data source. If unable to create this number of connections, creation of the data source will fail.
    
    Default Value:
    
    1
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setInitialCapacity
```
void setInitialCapacity(int initialCapacity)
```
  - getMaxCapacity
```
int getMaxCapacity()
```
    The maximum number of physical connections that this connection pool can contain.
    
    Default Value:
    
    15
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    1
  - setMaxCapacity
```
void setMaxCapacity(int maxCapacity)
```
  - getMinCapacity
```
int getMinCapacity()
```
    The minimum number of physical connections that this connection pool can contain after it is initialized.
    - Default: InitialCapacity
    - Used only for connection pool shrinking calculations.
    - For compatibility, InitialCapacity is used if MinCapacity is not configured.
    - Once a data source has gone through a suspend/resume, the larger value of either MinCapacity or InitialCapacity is used.
    Default Value:
    
    1
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setMinCapacity
```
void setMinCapacity(int minCapacity)
```
  - getCapacityIncrement
```
@Deprecated
int getCapacityIncrement()
```
    Deprecated.
    10.3.6.0
    
    The increment by which this JDBC connection pool's capacity is expanded. In WebLogic Server 10.3.1 and higher releases, the capacityIncrement is no longer configurable and is set to a value of 1.
    
    When there are no more available physical connections to service requests, the connection pool will create this number of additional physical database connections and add them to the connection pool. The connection pool will ensure that it does not exceed the maximum number of physical connections.
    
    Default Value:
    
    1
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    1
  - setCapacityIncrement
```
@Deprecated
void setCapacityIncrement(int capacityIncrement)
```
    Deprecated.
    10.3.6.0
  - getShrinkFrequencySeconds
```
int getShrinkFrequencySeconds()
```
    The number of seconds to wait before shrinking a connection pool that has incrementally increased to meet demand.
    
    When set to 0, shrinking is disabled.
    
    Default Value:
    
    weblogic.jdbc.common.internal.JDBCConstants.SHRINK_FREQUENCY_SECONDS_DEFAULT
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setShrinkFrequencySeconds
```
void setShrinkFrequencySeconds(int shrinkFrequencySeconds)
```
  - getHighestNumWaiters
```
int getHighestNumWaiters()
```
    The maximum number of connection requests that can concurrently block threads while waiting to reserve a connection from the data source's connection pool.
    
    Default Value:
    
    java.lang.Integer.MAX_VALUE
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setHighestNumWaiters
```
void setHighestNumWaiters(int highestNumWaiters)
```
  - getConnectionCreationRetryFrequencySeconds
```
int getConnectionCreationRetryFrequencySeconds()
```
    The number of seconds between attempts to establish connections to the database.
    
    If you do not set this value, data source creation fails if the database is unavailable. If set and if the database is unavailable when the data source is created, WebLogic Server will attempt to create connections in the pool again after the number of seconds you specify, and will continue to attempt to create the connections until it succeeds.
    
    When set to 0, connection retry is disabled.
    
    Default Value:
    
    0
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setConnectionCreationRetryFrequencySeconds
```
void setConnectionCreationRetryFrequencySeconds(int connectionCreationRetryFrequencySeconds)
```
  - getConnectionReserveTimeoutSeconds
```
int getConnectionReserveTimeoutSeconds()
```
    The number of seconds after which a call to reserve a connection from the connection pool will timeout.
    
    When set to 0, a call will never timeout.
    
    When set to -1, a call will timeout immediately.
    
    Default Value:
    
    10
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    -1
  - setConnectionReserveTimeoutSeconds
```
void setConnectionReserveTimeoutSeconds(int connectionReserveTimeoutSeconds)
```
  - getTestFrequencySeconds
```
int getTestFrequencySeconds()
```
    The number of seconds a WebLogic Server instance waits between attempts when testing unused connections. (Requires that you specify a Test Table Name.) Connections that fail the test are closed and reopened to re-establish a valid physical connection. If the test fails again, the connection is closed.
    
    In the context of multi data sources, this attribute controls the frequency at which WebLogic Server checks the health of data sources it had previously marked as unhealthy.
    
    When set to 0, the feature is disabled.
    
    Default Value:
    
    120
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setTestFrequencySeconds
```
void setTestFrequencySeconds(int testFrequencySeconds)
```
  - isTestConnectionsOnReserve
```
boolean isTestConnectionsOnReserve()
```
    Enables WebLogic Server to test a connection before giving it to a client. (Requires that you specify a Test Table Name.)
    
    The test adds a small delay in serving the client's request for a connection from the pool, but ensures that the client receives a viable connection.
    
    Default Value:
    
    false
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
  - setTestConnectionsOnReserve
```
void setTestConnectionsOnReserve(boolean testConnectionsOnReserve)
```
  - getProfileHarvestFrequencySeconds
```
int getProfileHarvestFrequencySeconds()
```
    The number of seconds between when WebLogic Server harvests profile data.
    
    When set to 0, harvesting of data is disabled.
    
    Default Value:
    
    300
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setProfileHarvestFrequencySeconds
```
void setProfileHarvestFrequencySeconds(int profileHarvestFrequencySeconds)
```
  - isIgnoreInUseConnectionsEnabled
```
boolean isIgnoreInUseConnectionsEnabled()
```
    Enables the data source to be shutdown even if connections obtained from the pool are still in use.
    
    Default Value:
    
    true
  - setIgnoreInUseConnectionsEnabled
```
void setIgnoreInUseConnectionsEnabled(boolean ignoreInUseConnectionsEnabled)
```
  - getInactiveConnectionTimeoutSeconds
```
int getInactiveConnectionTimeoutSeconds()
```
    The number of inactive seconds on a reserved connection before WebLogic Server reclaims the connection and releases it back into the connection pool.
    
    You can use the Inactive Connection Timeout feature to reclaim leaked connections - connections that were not explicitly closed by the application. Note that this feature is not intended to be used in place of properly closing connections.
    
    When set to 0, the feature is disabled.
    
    Default Value:
    
    0
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setInactiveConnectionTimeoutSeconds
```
void setInactiveConnectionTimeoutSeconds(int inactiveConnectionTimeoutSeconds)
```
  - getTestTableName
```
java.lang.String getTestTableName()
```
    The name of the database table to use when testing physical database connections. This name is required when you specify a Test Frequency and enable Test Reserved Connections.
    
    The default SQL code used to test a connection is select count(*) from TestTableName
    
    Most database servers optimize this SQL to avoid a table scan, but it is still a good idea to set the Test Table Name to the name of a table that is known to have few rows, or even no rows.
    
    If the Test Table Name begins with SQL, then the rest of the string following that leading token will be taken as a literal SQL statement that will be used to test connections instead of the standard query. For example: SQL BEGIN; Null; END;
    
    For an Oracle database, you can reduce the overhead of connection testing by setting Test Table Name to SQL PINGDATABASE which uses the pingDatabase() method to test the Oracle connection. For any JDBC 4.0 database, it is possible to use "SQL ISVALID" to use the isValid() method on the connection.
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
  - setTestTableName
```
void setTestTableName(java.lang.String testTableName)
```
  - getLoginDelaySeconds
```
int getLoginDelaySeconds()
```
    The number of seconds to delay before creating each physical database connection. This delay supports database servers that cannot handle multiple connection requests in rapid succession.
    
    The delay takes place both during initial data source creation and during the lifetime of the data source whenever a physical database connection is created.
    
    Default Value:
    
    0
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setLoginDelaySeconds
```
void setLoginDelaySeconds(int loginDelaySeconds)
```
  - getInitSql
```
java.lang.String getInitSql()
```
    SQL statement to execute that will initialize newly created physical database connections. Start the statement with SQL followed by a space.
    
    If the Init SQL value begins with "SQL ", then the rest of the string following that leading token will be taken as a literal SQL statement that will be used to initialize database connections. If the Init SQL value does not begin with "SQL ", the value will be treated as the name of a table and the following SQL statement will be used to initialize connections:
    
    "select count(*) from InitSQL"
    
    The table InitSQL must exist and be accessible to the database user for the connection. Most database servers optimize this SQL to avoid a table scan, but it is still a good idea to set InitSQL to the name of a table that is known to have few rows, or even no rows.
  - setInitSql
```
void setInitSql(java.lang.String initSql)
```
  - getStatementCacheSize
```
int getStatementCacheSize()
```
    The number of prepared and callable statements stored in the cache. (This may increase server performance.)
    
    WebLogic Server can reuse statements in the cache without reloading the statements, which can increase server performance. Each connection in the connection pool has its own cache of statements.
    
    Setting the size of the statement cache to 0 turns off statement caching.
    
    Default Value:
    
    weblogic.jdbc.common.internal.JDBCConstants.DEFAULT_CACHE_STATEMENTS_SIZE
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    weblogic.jdbc.common.internal.JDBCConstants.MAX_CACHE_STATEMENTS_SIZE
    
    Minimum Value:
    
    weblogic.jdbc.common.internal.JDBCConstants.MIN_CACHE_STATEMENTS_SIZE
  - setStatementCacheSize
```
void setStatementCacheSize(int statementCacheSize)
```
  - getStatementCacheType
```
java.lang.String getStatementCacheType()
```
    The algorithm used for maintaining the prepared statements stored in the statement cache.
    
    Options are:
    - LRU - when a new prepared or callable statement is used, the least recently used statement is replaced in the cache.
    - FIXED - the first fixed number of prepared and callable statements are cached.
    Default Value:
    
    weblogic.jdbc.common.internal.JDBCConstants.STATEMENT_CACHE_TYPE_LRU
    
    Valid Values:
    
    weblogic.jdbc.common.internal.JDBCConstants.STATEMENT_CACHE_TYPE_LRU, weblogic.jdbc.common.internal.JDBCConstants.STATEMENT_CACHE_TYPE_FIXED
  - setStatementCacheType
```
void setStatementCacheType(java.lang.String statementCacheType)
```
  - isRemoveInfectedConnections
```
boolean isRemoveInfectedConnections()
```
    Specifies whether a connection will be removed from the connection pool after the application uses the underlying vendor connection object.
    
    If you disable removing infected connections, you must make sure that the database connection is suitable for reuse by other applications.
    
    When set to true (the default), the physical connection is not returned to the connection pool after the application closes the logical connection. Instead, the physical connection is closed and recreated.
    
    When set to false, when the application closes the logical connection, the physical connection is returned to the connection pool and can be reused by the application or by another application.
    
    Default Value:
    
    true
  - setRemoveInfectedConnections
```
void setRemoveInfectedConnections(boolean removeInfectedConnections)
```
  - getSecondsToTrustAnIdlePoolConnection
```
int getSecondsToTrustAnIdlePoolConnection()
```
    The number of seconds within a connection use that WebLogic Server trusts that the connection is still viable and will skip the connection test, either before delivering it to an application or during the periodic connection testing process.
    
    This option is an optimization that minimizes the performance impact of connection testing, especially during heavy traffic.
    
    Default Value:
    
    10
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setSecondsToTrustAnIdlePoolConnection
```
void setSecondsToTrustAnIdlePoolConnection(int secondsToTrustAnIdlePoolConnection)
```
  - getStatementTimeout
```
int getStatementTimeout()
```
    The time after which a statement currently being executed will time out.
    
    StatementTimeout relies on underlying JDBC driver support. WebLogic Server passes the time specified to the JDBC driver using the java.sql.Statement.setQueryTimeout() method. If your JDBC driver does not support this method, it may throw an exception and the timeout value is ignored.
    
    A value of -1 disables this feature.
    
    A value of 0 means that statements will not time out.
    
    Default Value:
    
    -1
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    -1
  - setStatementTimeout
```
void setStatementTimeout(int statementTimeout)
```
  - getProfileType
```
int getProfileType()
```
    Specifies the type of profile data to be collected for the JDBC subsystem. To enable a multiple profiling options, the value should be set to the sum of each option's numeric value. For example, to enable the Connection Usage, Connection Leak and Connection Unwrap Usage options the value would be set to 261 (1 + 4 + 256) or 0x105 (0x001 + 0x004 + 0x100).
    
    You can specify combinations of the following profile types:
    - None (0/0x000): Disable profiling for the data source.
    - Connection Usage (1/0x001): Profile threads currently using connections from the pool of connections in the data source.
    - Connection Reserve Wait (2/0x002): Profile threads currently waiting to reserve a connection from the data source.
    - Connection Leak (4/0x004): Profile threads that have reserved a connection from the data source and the connection leaked (was not properly returned to the pool of connections).
    - Connection Reserve Fail (8/0x008): Profile threads that attempt to reserve a connection from the data source but fail.
    - Statement Cache Entry (16/0x010): Profile prepared and callable statements added to the statement cache, and profile the threads that originated the cached statements.
    - Statement Usage (32/0x020): Profile threads currently executing SQL statements from the statement cache.
    - Connection Last Usage (64/0x040): Profile the previous thread that last used the connection. This information is useful when debugging problems with connections infected with pending transactions that cause subsequent XA operations on the connections to fail.
    - Connection Multi-thread Usage (128/0x080): Profile threads that erroneously use a connection previously obtained by a different thread.
    - Connection Unwrap Usage (256/0x100): Profile threads that have obtained the JDBC delegate object by invoking unwrap or weblogic.common.wrapper.Wrapper.getVendorObj on the connection.
    - Connection Local Transaction Leak (512/0x200): Profile threads that close JDBC connections that have an active local database transaction.
    - Closed Usage (1024/0x400): Profile threads that attempt to use a closed connection, statement or result set.
    Default Value:
    
    weblogic.jdbc.common.internal.JDBCConstants.PROFILE_TYPE_NONE
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
  - setProfileType
```
void setProfileType(int profileType)
```
  - getJDBCXADebugLevel
```
int getJDBCXADebugLevel()
```
    Specifies level of JDBC debugging for XA drivers, where larger values in the range provide more debugging information.
    
    Default Value:
    
    10
    
    Maximum Value:
    
    100
    
    Minimum Value:
    
    0
  - setJDBCXADebugLevel
```
void setJDBCXADebugLevel(int jdbcXaDebugLevel)
```
  - isCredentialMappingEnabled
```
boolean isCredentialMappingEnabled()
```
    Enables Set Client ID on connection for the data source. When an application requests a database connection, WebLogic Server sets a light-weight client ID on the database connection.
    
    By default, it uses the credential mapping to map WebLogic Server user IDs to database user IDs. However, if use-database-credentials is set to true, then the credential mapping is not done and the ID is used directly as a database user ID.
    
    It is currently supported for IBM DB2 driver and Oracle thin driver. Support for this feature will be dropped in a future Oracle thin driver release. Oracle recommends using proxy authentication instead of this feature.
    
    Default Value:
    
    false
  - setCredentialMappingEnabled
```
void setCredentialMappingEnabled(boolean credentialMappingEnabled)
```
  - getDriverInterceptor
```
java.lang.String getDriverInterceptor()
```
    Specifies the absolute name of the application class used to intercept method calls to the JDBC driver. The application specified must implement the weblogic.jdbc.extensions.DriverInterceptor interface.
    
    Weblogic Server will invoke the preInvokeCallback(), postInvokeExceptionCallback(), and postInvokeCallback() methods of the registered application before and after invoking any method inside the JDBC driver. You can use this feature to profile JDBC driver usage and monitor:
    - Methods being executed
    - Any exceptions thrown
    - Time spent inside the driver executing methods
  - setDriverInterceptor
```
void setDriverInterceptor(java.lang.String driverInterceptor)
```
  - isPinnedToThread
```
boolean isPinnedToThread()
```
    Enables an option to improve performance by enabling execute threads to keep a pooled database connection even after the application closes the logical connection.
    
    When enabled:
    - WebLogic Server pins a database connection from the connection pool to an execution thread the first time an application uses the thread to reserve a connection. When the application finishes using the connection and calls connection.close(), WebLogic Server keeps the connection with the execute thread and does not return it to the connection pool. When an application subsequently requests a connection using the same execute thread, WebLogic Server provides the connection already reserved by the thread.
    - There is no locking contention on the connection pool that occurs when multiple threads attempt to reserve a connection at the same time. There is no contention for threads that attempt to reserve the same connection from a limited number of database connections.
    - If an application concurrently reserves more than one connection from the connection pool using the same execute thread, WebLogic Server creates additional database connections and pins them to the thread.
    - The maximum capacity of the connection pool (maximum number of database connections created in the connection pool) becomes the number of execute threads used to request a connection multiplied by the number of concurrent connections each thread reserves. This may exceed the Maximum Capacity specified for the connection pool. You may need to consider this larger number of connections in your system design and ensure that your database allows for additional associated resources. If your system cannot handle the additional resource requirements or if you see database resource errors after enabling PinnedToThread, Oracle recommends not using PinnedToThread. See Using Pinned-To-Thread Property to Increase Performance .
    Default Value:
    
    false
  - setPinnedToThread
```
void setPinnedToThread(boolean pinnedToThread)
```
  - isIdentityBasedConnectionPoolingEnabled
```
boolean isIdentityBasedConnectionPoolingEnabled()
```
    Enables identity-based-connection-pooling for the data source. When an application requests a database connection, WebLogic Server picks or creates a physical connection with requested DBMS identity based on a map of WebLogic user IDs and database IDs.
    
    You must also specify the map of WebLogic Server user IDs to database user IDs (credential mapping).
    
    Default Value:
    
    false
  - setIdentityBasedConnectionPoolingEnabled
```
void setIdentityBasedConnectionPoolingEnabled(boolean identityBasedConnectionPoolingEnabled)
```
  - isWrapTypes
```
boolean isWrapTypes()
```
    By default, data type objects for Array, Blob, Clob, NClob, Ref, SQLXML, and Struct, plus ParameterMetaData and ResultSetMetaData objects are wrapped with a WebLogic wrapper. This allows for features like debugging and connection usage to be done by the server.
    
    The wrapping can be turned off by setting this value to false. This improves performance, in some cases significantly, and allows for the application to use the native driver objects directly.
    
    Default Value:
    
    true
  - setWrapTypes
```
void setWrapTypes(boolean wrapTypes)
```
  - getFatalErrorCodes
```
java.lang.String getFatalErrorCodes()
```
    Specifies a comma-separated list of error codes that are treated as fatal errors. These errors include deployment errors that cause a server to fail to boot and connection errors that prevent a connection from being put back in the connection pool.
    
    This optional attribute is used to define fatal error codes, that when specified as the exception code within a SQLException (retrieved by sqlException.getErrorCode()), indicate that a fatal error has occurred and the connection is no longer usable. For Oracle databases the following fatal error codes are predefined within WLS and do not need to be placed in the configuration file:
    - 3113: "end-of-file on communication channel"
    - 3114: "not connected to ORACLE"
    - 1033: "ORACLE initialization or shutdown in progress"
    - 1034: "ORACLE not available"
    - 1089: "immediate shutdown in progress - no operations are permitted"
    - 1090: "shutdown in progress - connection is not permitted"
    - 17002: "I/O exception"
  - setFatalErrorCodes
```
void setFatalErrorCodes(java.lang.String fatalErrorCodes)
```
  - getConnectionLabelingCallback
```
java.lang.String getConnectionLabelingCallback()
```
    The class name of the connection labeling callback. This is automatically passed to registerConnectionLabelingCallback when the datasource is created. The class must implement oracle.ucp.ConnectionLabelingCallback.
  - setConnectionLabelingCallback
```
void setConnectionLabelingCallback(java.lang.String className)
```
  - getConnectionHarvestMaxCount
```
int getConnectionHarvestMaxCount()
```
    The maximum number of connections that may be harvested when the connection harvesting occurs. The range of valid values is 1 to MaxCapacity.
    
    Default Value:
    
    1
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Minimum Value:
    
    1
  - setConnectionHarvestMaxCount
```
void setConnectionHarvestMaxCount(int connectionHarvestMaxCount)
```
  - getConnectionHarvestTriggerCount
```
int getConnectionHarvestTriggerCount()
```
    Specifies the number of available connections (trigger value) used to determine when connection harvesting occurs.
    - Harvesting occurs when the number of available connections is below the trigger value for a connection pool.
    - The range of valid values is -1 to MaxCapacity.
    - Default value is -1.
    - Setting the value to -1 disables connection harvesting.
    Default Value:
    
    -1
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Minimum Value:
    
    -1
  - setConnectionHarvestTriggerCount
```
void setConnectionHarvestTriggerCount(int connectionHarvestTriggerCount)
```
  - getCountOfTestFailuresTillFlush
```
int getCountOfTestFailuresTillFlush()
```
    Specifies the number of test failures allowed before WebLogic Server closes all unused connections in a connection pool to minimize the delay caused by further database testing. Zero means it is disabled.
    
    Default Value:
    
    2
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Minimum Value:
    
    0
  - setCountOfTestFailuresTillFlush
```
void setCountOfTestFailuresTillFlush(int countOfTestFailuresTillFlush)
```
  - getCountOfRefreshFailuresTillDisable
```
int getCountOfRefreshFailuresTillDisable()
```
    Specifies the number of reconnect failures allowed before WebLogic Server disables a connection pool to minimize the delay in handling the connection request caused by a database failure. Zero means it is disabled.
    
    Default Value:
    
    2
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Minimum Value:
    
    0
  - setCountOfRefreshFailuresTillDisable
```
void setCountOfRefreshFailuresTillDisable(int countOfRefreshFailuresTillDisable)
```
  - isWrapJdbc
```
boolean isWrapJdbc()
```
    By default, SQL objects for CallableStatement, PreparedStatement, ResultSet, Statement, and DatabaseMetaData are wrapped with a WebLogic wrapper. Wrapping allows features like debugging and connection usage to be performed by the server.
    
    When false, wrapping is disabled. This improves performance, in some cases significantly, and allows for the application to use the native driver objects directly. A value of false also disables data type wrapping.
    
    Default Value:
    
    true
  - setWrapJdbc
```
void setWrapJdbc(boolean wrapJdbc)
```
  - getProfileConnectionLeakTimeoutSeconds
```
int getProfileConnectionLeakTimeoutSeconds()
```
    The number of seconds that an inactive JDBC connection needs to be held by an application before triggering a connection leak diagnostic profiling record.
    
    When set to 0, the timeout is disabled. This attribute only applies when the connection leak diagnostic profiling option is enabled.
    
    Default Value:
    
    0
    
    Changes to this property are dynamic and thus take effect immediately without restarting the server or partition.
    
    Maximum Value:
    
    java.lang.Integer.MAX_VALUE
    
    Minimum Value:
    
    0
  - setProfileConnectionLeakTimeoutSeconds
```
void setProfileConnectionLeakTimeoutSeconds(int seconds)
```
  - isInvokeBeginEndRequest
```
boolean isInvokeBeginEndRequest()
```
    When true, and when a JDBC 4.3 compatible driver is used, the connection pool will invoke Connection.beginRequest() prior to returning the connection to the application, and will invoke Connection.endRequest() before the connection is released to the pool.
  - setInvokeBeginEndRequest
```
void setInvokeBeginEndRequest(boolean invokeBeginEndRequest)
```

Interface JDBCConnectionPoolParamsBean

Method Summary

Method Detail

getInitialCapacity

setInitialCapacity

getMaxCapacity

setMaxCapacity

getMinCapacity

setMinCapacity

getCapacityIncrement

setCapacityIncrement

getShrinkFrequencySeconds

setShrinkFrequencySeconds

getHighestNumWaiters

setHighestNumWaiters

getConnectionCreationRetryFrequencySeconds

setConnectionCreationRetryFrequencySeconds

getConnectionReserveTimeoutSeconds

setConnectionReserveTimeoutSeconds

getTestFrequencySeconds

setTestFrequencySeconds

isTestConnectionsOnReserve

setTestConnectionsOnReserve

getProfileHarvestFrequencySeconds

setProfileHarvestFrequencySeconds

isIgnoreInUseConnectionsEnabled

setIgnoreInUseConnectionsEnabled

getInactiveConnectionTimeoutSeconds

setInactiveConnectionTimeoutSeconds

getTestTableName

setTestTableName

getLoginDelaySeconds

setLoginDelaySeconds

getInitSql

setInitSql

getStatementCacheSize

setStatementCacheSize

getStatementCacheType

setStatementCacheType

isRemoveInfectedConnections

setRemoveInfectedConnections

getSecondsToTrustAnIdlePoolConnection

setSecondsToTrustAnIdlePoolConnection

getStatementTimeout

setStatementTimeout

getProfileType

setProfileType

getJDBCXADebugLevel

setJDBCXADebugLevel

isCredentialMappingEnabled

setCredentialMappingEnabled

getDriverInterceptor

setDriverInterceptor

isPinnedToThread

setPinnedToThread

isIdentityBasedConnectionPoolingEnabled

setIdentityBasedConnectionPoolingEnabled

isWrapTypes

setWrapTypes

getFatalErrorCodes

setFatalErrorCodes

getConnectionLabelingCallback

setConnectionLabelingCallback

getConnectionHarvestMaxCount

setConnectionHarvestMaxCount

getConnectionHarvestTriggerCount

setConnectionHarvestTriggerCount

getCountOfTestFailuresTillFlush

setCountOfTestFailuresTillFlush

getCountOfRefreshFailuresTillDisable

setCountOfRefreshFailuresTillDisable

isWrapJdbc

setWrapJdbc

getProfileConnectionLeakTimeoutSeconds

setProfileConnectionLeakTimeoutSeconds

isInvokeBeginEndRequest

setInvokeBeginEndRequest