Overview | Package | Class | Use | Tree | Deprecated | Index | Help
|  | BEA Systems, Inc.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

WebLogic Server 8.1 API Reference

## weblogic.management.configuration
Interface JDBCConnectionPoolMBean

public interface JDBCConnectionPoolMBean
extends DeploymentMBean

This bean defines a JDBC connection pool.

Author:
  Copyright © 2004 BEA Systems, Inc. All Rights Reserved.

Fields inherited from class weblogic.management.configuration.DeploymentMBean
`CACHING_STUB_SVUID, DEFAULT_ORDER, MAX_ORDER, MIN_ORDER`

Fields inherited from class weblogic.management.configuration.ConfigurationMBean
`CACHING_STUB_SVUID, DEFAULT_EMPTY_BYTE_ARRAY`

Method Summary
`java.lang.String` | `getACLName()` Deprecated.
`int` | `getCapacityIncrement()` Returns the increment by which the connection pool capacity is expanded.
`int` | `getConnectionCreationRetryFrequencySeconds()` Gets the connectionCreationRetryFrequencySeconds attribute of the JDBCConnectionPoolMBean object, which is the number of seconds between attempts to establish connections to the database.
`int` | `getConnectionReserveTimeoutSeconds()` The number of seconds after which a call to reserve a connection from the connection pool will timeout.
`int` | `getCountOfRefreshFailuresTillDisable()` Set the number of consecutive failures to replace dead pool connections before we disable the pool.
`int` | `getCountOfTestFailuresTillFlush()` Get the number of consecutive failed pool connection tests before we close all the connections the pool.
`java.lang.String` | `getDriverName()` Returns the full package name of the JDBC driver class used to create the physical connections between WebLogic Server and the DBMS for this connection pool.
`boolean` | `getEnableResourceHealthMonitoring()` Returns whether JTA resource health monitoring is enabled for this XA connection pool.
`int` | `getHighestNumUnavailable()` Gets the highestNumUnavailable attribute of the JDBCConnectionPoolMBean object, which is the maximum number of connections in the connection pool that can be made unavailable (to an application) for purposes like refreshing the connection, etc.
`int` | `getHighestNumWaiters()` Gets the highestNumWaiters attribute of the JDBCConnectionPoolMBean object, which is the maximum number of connection requests that can concurrently block waiting to reserve a connection from the pool.
`int` | `getInactiveConnectionTimeoutSeconds()` Gets the inactiveConnectionTimeoutSeconds attribute of the JDBCConnectionPoolMBean object, which is the number of seconds of inactivity after which reserved connections will be forcibly returned to the connection pool.
`int` | `getInitialCapacity()` Returns the number of physical database connections to create when creating the connection pool.
`java.lang.String` | `getInitSQL()` Gets the initSQL attribute of the JDBCConnectionPoolMBean object, which is a SQL statement to execute to initialize (or "prime") a physical database connection.
`boolean` | `getKeepLogicalConnOpenOnRelease()` Returns `true` if the logical JDBC connection is kept open when the physical XA connection is returned to the XA connection pool.
`boolean` | `getKeepXAConnTillTxComplete()` Returns `true` if the XA connection pool associates the same XA connection with the distributed transaction until the transaction completes.
`int` | `getLoginDelaySeconds()` Returns the number of seconds to delay before creating each physical database connection.
`int` | `getMaxCapacity()` Returns the maximum number of physical database connections that this connection pool can contain.
`boolean` | `getNeedTxCtxOnClose()` Returns `true` if the XA driver requires a distributed transaction context when closing various JDBC objects, e.g.
`boolean` | `getNewXAConnForCommit()` Returns `true` if a dedicated XA connection is used for commit/rollback processing of a particular distributed transaction.
`java.lang.String` | `getPassword()` The database password as set with `setPassword()`, `setPasswordEncrypted()`, or as a key=value pair in `setProperties()`.
`byte[]` | `getPasswordEncrypted()` The encrypted database password as set with `setPassword()`, `setPasswordEncrypted(byte[] bytes)`, or as a key=value pair in `setProperties()`.
`int` | `getPreparedStatementCacheSize()` Deprecated.
`java.util.Properties` | `getProperties()` Returns the list of properties passed to the the JDBC Driver to use when creating physical database connections.
`int` | `getRefreshMinutes()` Deprecated.
`boolean` | `getRollbackLocalTxUponConnClose()` Whether WLS connection pool will call rollback() on the connection before putting it back in the pool.
`int` | `getSecondsToTrustAnIdlePoolConnection()` The number of seconds within the use of a pooled connection that WebLogic Server trusts that the connection is still viable and will skip connection testing.
`int` | `getShrinkFrequencySeconds()` Returns the number of seconds to wait before shrinking a connection pool that has incrementally increased to meet demand.
`int` | `getShrinkPeriodMinutes()` Deprecated.
`int` | `getStatementCacheSize()` Returns size of the statement cache; The size of the cache is the number of Prepared and Callable statements created from a particular connection and stored in the cache for further use.
`java.lang.String` | `getStatementCacheType()` Returns the algorithm used to maintain the statement cache.
`int` | `getStatementTimeout()` Returns the configured statementTimeout value.
`boolean` | `getSupportsLocalTransaction()` Whether the XA driver used to create physical database connections supports SQL without global transactions.
`boolean` | `getTestConnectionsOnCreate()` Returns the TestConnectionsOnCreate attribute of the JDBCConnectionPoolMBean object; when set to true, WebLogic Server tests a connection after creating it and before adding it to the list of connections available to the client.
`boolean` | `getTestConnectionsOnRelease()` Returns the TestConnectionsOnRelease attribute of the JDBCConnectionPoolMBean object; when set to true, WebLogic Server tests a connection before returning it to the connection pool.
`boolean` | `getTestConnectionsOnReserve()` Returns the TestConnectionsOnReserve attribute of the JDBCConnectionPoolMBean object; when set to true, WebLogic Server tests a connection before giving it to the client.
`int` | `getTestFrequencySeconds()` Returns the number of seconds between database connection tests.
`int` | `getTestStatementTimeout()` Returns the configured testStatementTimeout value.
`java.lang.String` | `getTestTableName()` Returns the name of the table used when testing a physical database connection.
`java.lang.String` | `getURL()` Returns the database URL used to create the connections in this Connection Pool.
`boolean` | `getXAEndOnlyOnce()` Returns `true` if XAResource.end() will be called only once for each pending XAResource.start().
`java.lang.String` | `getXAPassword()` The password that is used to create physical XA database connections.
`byte[]` | `getXAPasswordEncrypted()` The encrypted password that is used to create physical XA database connections.
`int` | `getXAPreparedStatementCacheSize()` Deprecated.
`int` | `getXARetryDurationSeconds()` Determines the duration in seconds during which the transaction manager will retry to perform recover, rollback, and commit operations on the resource.
`int` | `getXARetryIntervalSeconds()` Determines the time in seconds between XA retry operations if the XARetryDurationSeconds attribute is set to a positive value.
`boolean` | `getXASetTransactionTimeout()` When set to true, the WebLogic Server Transaction Manager calls XAResource.setTransactionTimeout() before calling XAResource.start, and passes either the XATransactionTimeout or the global transaction timeout in seconds.
`int` | `getXATransactionTimeout()` Determines the number of seconds to pass as the transaction timeout value in the XAResource.setTransactionTimeout() method.
`boolean` | `isConnLeakProfilingEnabled()` Returns if JDBC Connection leak profiling is enabled.
`boolean` | `isConnProfilingEnabled()` Returns if JDBC Connection usage profiling is enabled.
`boolean` | `isIgnoreInUseConnectionsEnabled()` Returns the configured ignoreInUseConnectionsEnabled value.
`boolean` | `isRemoveInfectedConnectionsEnabled()` Whether a connection will be removed from the connection pool when the application asks for the underlying vendor connection object.
`boolean` | `isShrinkingEnabled()` Indicates whether or not the pool can shrink to the greater of its `InitialCapacity` or the current number of connections in use when it is detected that connections created during increased traffic are not being used.
`boolean` | `isSqlStmtProfilingEnabled()` SQL roundtrip profiling stores SQL statement text, execution time and other metrics.
`void` | `setACLName(java.lang.String name)` Deprecated.
`void` | `setCapacityIncrement(int capacity)` Sets the increment by which the connection pool capacity is expanded.
`void` | `setConnectionCreationRetryFrequencySeconds(int seconds)` The number of seconds between attempts to establish connections to the database.
`void` | `setConnectionReserveTimeoutSeconds(int seconds)` The number of seconds after which a call to reserve a connection from the connection pool will timeout.
`void` | `setConnLeakProfilingEnabled(boolean enable)` This property enables JDBC Connection leak profiling.
`void` | `setConnProfilingEnabled(boolean enable)` This property enables JDBC Connection usage profiling.
`void` | `setCountOfRefreshFailuresTillDisable(int newVal)` Set the number of consecutive failures to replace dead pool connections before we disable the pool.
`void` | `setCountOfTestFailuresTillFlush(int newVal)` Set the number of consecutive failed pool connection tests before we close all the connections the pool.
`void` | `setDriverName(java.lang.String driverClassName)` Sets the full package name of the JDBC driver class used to create the physical connections between the WebLogic Server and the DBMS for this connection pool.
`void` | `setEnableResourceHealthMonitoring(boolean enable)` Determines whether JTA resource health monitoring is enabled for this XA connection pool.
`void` | `setHighestNumUnavailable(int count)` The maximum number of connections in the connection pool that can be made unavailable (to an application) for purposes like refreshing the connection, etc.
`void` | `setHighestNumWaiters(int count)` The maximum number of connection requests that can concurrently block waiting to reserve a connection from the pool.
`void` | `setIgnoreInUseConnectionsEnabled(boolean enable)` Enables pool to be shutdown even if connections are still in use.
`void` | `setInactiveConnectionTimeoutSeconds(int seconds)` The number of seconds of inactivity after which reserved connections will be forcibly returned to the connection pool.
`void` | `setInitialCapacity(int capacity)` Sets the number of physical database connections to create when creating the connection pool.
`void` | `setInitSQL(java.lang.String table)` The SQL statement to execute to initialize (or "prime") a physical database connection.
`void` | `setKeepLogicalConnOpenOnRelease(boolean b)` Determines whether the logical JDBC connection is kept open when the physical XA connection is returned to the XA connection pool.
`void` | `setKeepXAConnTillTxComplete(boolean b)` Set to `true` to force a connection pool to reserve a physical connection and provide the same connection to an application throughout transaction processing until the distributed transaction is complete.
`void` | `setLoginDelaySeconds(int secs)` Sets the number of seconds to delay before creating each physical database connection.
`void` | `setMaxCapacity(int capacity)` Sets the maximum number of physical database connections that this connection pool can contain.
`void` | `setNeedTxCtxOnClose(boolean b)` Set to `true` if the XA driver requires a distributed transaction context when closing various JDBC objects, e.g.
`void` | `setNewXAConnForCommit(boolean b)` Determines whether a dedicated XA connection is used for commit/rollback processing of a particular distributed transaction.
`void` | `setPassword(java.lang.String password)` As of 8.1 sp4, this method does the following:
`void` | `setPasswordEncrypted(byte[] bytes)` Encrypts the password and sets the value of the PasswordEncrypted attribute.
`void` | `setPreparedStatementCacheSize(int cacheSize)` Deprecated.
`void` | `setProperties(java.util.Properties props)` Sets the list of properties passed to the the JDBC Driver to use when creating physical database connections.
`void` | `setRefreshMinutes(int minutes)` Deprecated.
`void` | `setRemoveInfectedConnectionsEnabled(boolean enable)` Controls whether a connection will be removed from the connection pool when the application asks for the underlying vendor connection object.
`void` | `setRollbackLocalTxUponConnClose(boolean enable)` If set to true, WLS connection pool will call rollback() on the connection before putting it back in the pool.
`void` | `setSecondsToTrustAnIdlePoolConnection(int secs)` Sets the SecondsToTrustAnIdlePoolConnection attribute.
`void` | `setShrinkFrequencySeconds(int seconds)` Sets the number of seconds to wait before shrinking a connection pool that has incrementally increased to meet demand.
`void` | `setShrinkingEnabled(boolean enable)` Indicates whether or not the pool can shrink back to its `InitialCapacity` when it is detected that connections created during increased traffic are not being used.
`void` | `setShrinkPeriodMinutes(int minutes)` Deprecated.
`void` | `setSqlStmtProfilingEnabled(boolean enable)` This property enables running of JDBC SQL roundtrip profiling.
`void` | `setStatementCacheSize(int cacheSize)` The number of Prepared and Callable Statements stored in the cache for reuse.
`void` | `setStatementCacheType(java.lang.String type)` Sets the algorithm used to maintain the statement cache: LRU or Fixed.
`void` | `setStatementTimeout(int timeout)` The time after which a statement currently being executed will be timed-out.
`void` | `setSupportsLocalTransaction(boolean support)` Set to true if the XA driver used to create physical database connections supports SQL without global transactions.
`void` | `setTestConnectionsOnCreate(boolean enable)` When set to true, WebLogic Server tests a connection after creating it and before adding it to the list of connections available to the client.
`void` | `setTestConnectionsOnRelease(boolean enable)` When set to true, WebLogic Server tests a connection before returning it to the connection pool.
`void` | `setTestConnectionsOnReserve(boolean enable)` When set to true, WebLogic Server tests a connection before giving it to the client.
`void` | `setTestFrequencySeconds(int seconds)` Returns the number of seconds between database connection tests.
`void` | `setTestStatementTimeout(int timeout)` The time after which the test statement (configured by applications using the pool attribute Test Table Name) or initialization statement (configured by applications using the pool attribute InitSQL) currently being executed will be timed out.
`void` | `setTestTableName(java.lang.String table)` Sets the name of the table used when testing a physical database connection.
`void` | `setURL(java.lang.String url)` The database URL used to create the connections in this connection pool.
`void` | `setXAEndOnlyOnce(boolean b)` Determines whether XAResource.end() will be called only once for each pending XAResource.start().
`void` | `setXAPassword(java.lang.String password)` As of 8.1 sp4, this method does the following:
`void` | `setXAPasswordEncrypted(byte[] bytes)` Encrypts the password and sets the value of the XAPasswordEncrypted attribute.
`void` | `setXAPreparedStatementCacheSize(int size)` Deprecated.
`void` | `setXARetryDurationSeconds(int duration)` Determines the duration in seconds during which the transaction manager will retry to perform recover, rollback, and commit operations on the resource.
`void` | `setXARetryIntervalSeconds(int interval)` Determines the time in seconds between XA retry operations if the XARetryDurationSeconds attribute is set to a positive value.
`void` | `setXASetTransactionTimeout(boolean b)` When set to true, the WebLogic Server Transaction Manager calls XAResource.setTransactionTimeout() before calling XAResource.start, and passes either the XATransactionTimeout or the global transaction timeout in seconds.
`void` | `setXATransactionTimeout(int timeout)` Determines the number of seconds to pass as the transaction timeout value in the XAResource.setTransactionTimeout() method.

Methods inherited from interface weblogic.management.configuration.DeploymentMBean
`addTarget, getDeploymentOrder, getTargets, removeTarget, setDeploymentOrder, setTargets`

Methods inherited from interface weblogic.management.configuration.ConfigurationMBean
`freezeCurrentValue, getNotes, restoreDefaultValue, setComments, setDefaultedMBean, setNotes, setPersistenceEnabled`

Methods inherited from interface weblogic.management.WebLogicMBean
`getMBeanInfo, getName, getObjectName, getParent, getType, isCachingDisabled, isRegistered, setName, setParent`

Methods inherited from interface javax.management.DynamicMBean
`getAttribute, getAttributes, invoke, setAttribute, setAttributes`

Methods inherited from interface javax.management.MBeanRegistration
`postDeregister, postRegister, preRegister`

Methods inherited from interface javax.management.NotificationBroadcaster
`addNotificationListener, getNotificationInfo, removeNotificationListener`

Method Detail

### setConnLeakProfilingEnabled

    public void setConnLeakProfilingEnabled(boolean enable)
                                     throws javax.management.InvalidAttributeValueException

  This property enables JDBC Connection leak profiling.

  A Connection leak occurs when a connection from the pool is not closed explicitly by calling close() on that connection.

  When connection leak profiling is active, the pool will store the stack trace at the time the Connection object is allocated from the pool and given to the client. When a connection leak is detected (when the Connection object is garbage collected), this stack trace is reported.

  This feature uses extra resources and will likely slowdown Connection Pool operations, so it is not recommended for production use.

  A dynamic MBean attribute
  Default Value: false
  Secure Value: false
  Parameters:
    `enable` - The new connLeakProfilingEnabled value
  Throws:
    javax.management.InvalidAttributeValueException -

### isConnLeakProfilingEnabled

    public boolean isConnLeakProfilingEnabled()

  Returns if JDBC Connection leak profiling is enabled.

  Default Value: false
  Returns:
    The connLeakProfilingEnabled value

### setConnProfilingEnabled

    public void setConnProfilingEnabled(boolean enable)
                                 throws javax.management.InvalidAttributeValueException

  This property enables JDBC Connection usage profiling.

  When connection usage profiling is active, the pool will store the stack trace at the time the connection object is released back into the pool by the client. If an expection is thrown during a subsequent operation related to global (XA) transactions, this stack trace is reported.

  Thise feature is used to detect local transaction work left incomplete by application code, which can interfere with subsequent operations related to global (XA) transactions performed using this JDBC Connection.

  This feature uses extra resources and will likely slowdown Connection Pool operations, so it is not recommended for production use.

  A dynamic MBean attribute
  Default Value: false
  Secure Value: false
  Parameters:
    `enable` - The new connProfilingEnabled value
  Throws:
    javax.management.InvalidAttributeValueException -

### isConnProfilingEnabled

    public boolean isConnProfilingEnabled()

  Returns if JDBC Connection usage profiling is enabled.

  Default Value: false
  Returns:
    The connProfilingEnabled value

### isSqlStmtProfilingEnabled

    public boolean isSqlStmtProfilingEnabled()

  SQL roundtrip profiling stores SQL statement text, execution time and other metrics.

  A dynamic MBean attribute
  Default Value: false
  Returns:
    `true` if JDBC SQL roundtrip profiling enabled

### setSqlStmtProfilingEnabled

    public void setSqlStmtProfilingEnabled(boolean enable)
                                    throws javax.management.InvalidAttributeValueException

  This property enables running of JDBC SQL roundtrip profiling. When enabled, SQL statement text, execution time and other metrics are stored externally for further analysis.

  This is a resource-consuming feature, so it's recommended that it's turned off on a production server.

  A dynamic MBean attribute
  Parameters:
    `enable` - The new sqlStmtProfilingEnabled value
  Throws:
    javax.management.InvalidAttributeValueException -

### getACLName

    public java.lang.String getACLName()

  Deprecated.
  Returns the ACL used to control access to this Connection Pool.

  Returns:
    The aCLName value

### setACLName

    public void setACLName(java.lang.String name)
                    throws javax.management.InvalidAttributeValueException

  Deprecated.
  The access control list (ACL) used to control access to this connection pool. Permissions available to this ACL are `reserve` and `admin`.

  `Reserve` permission allows users to get logical connections from this connection pool.

  `Admin` permission allows all other operations on this connection pool, including: reset, shrink, shutdown, disable, and enable.

  Lack of an ACL allows any user open access (provided that the user passes other WLS security controls).

  Secure Value: null
  Parameters:
    `name` - The new aCLName value
  Throws:
    javax.management.InvalidAttributeValueException -

### getURL

    public java.lang.String getURL()

  Returns the database URL used to create the connections in this Connection Pool.

  Old Property: weblogic.jdbc.connectionPool.url
  Returns:
    The uRL value

### setURL

    public void setURL(java.lang.String url)
                throws javax.management.InvalidAttributeValueException

  The database URL used to create the connections in this connection pool. The URL is passed to the JDBC driver to create the physical database connections.

  Parameters:
    `url` - The new uRL value
  Throws:
    javax.management.InvalidAttributeValueException -

### getDriverName

    public java.lang.String getDriverName()

  Returns the full package name of the JDBC driver class used to create the physical connections between WebLogic Server and the DBMS for this connection pool. For example:

  `com.pointbase.jdbc.jdbcUniversalDriver`

  It must be the name of a class that implements the `java.sql.Driver` interface. Check the documentation for the JDBC driver to find the full pathname.

  Old Property: weblogic.jdbc.connectionPool.driver
  Returns:
    The driverName value

### setDriverName

    public void setDriverName(java.lang.String driverClassName)
                       throws javax.management.InvalidAttributeValueException

  Sets the full package name of the JDBC driver class used to create the physical connections between the WebLogic Server and the DBMS for this connection pool. For example:

  `com.pointbase.jdbc.jdbcUniversalDriver`

  It must be the name of a class that implements the `java.sql.Driver` interface. Check the documentation for the JDBC driver to find the full pathname.

  Parameters:
    `driverClassName` - The new driverName value
  Throws:
    javax.management.InvalidAttributeValueException -

### getProperties

    public java.util.Properties getProperties()

  Returns the list of properties passed to the the JDBC Driver to use when creating physical database connections. The list consists of attribute=value tags, separated by semi-colons. For example `user=scott;server=myDB`.

  Old Property: weblogic.jdbc.connectionPool.props
  Returns:
    The properties value

### setProperties

    public void setProperties(java.util.Properties props)
                       throws javax.management.InvalidAttributeValueException

  Sets the list of properties passed to the the JDBC Driver to use when creating physical database connections. The list consists of attribute=value tags, separated by semi-colons. For example `user=scott;server=myDB`.

  Note: BEA recommends that you use `setEncryptedPassword()` to specify the database password so that the value is stored in an encrypted form in `config.xml` and when displayed on the administration console.

  Parameters:
    `props` - The new properties value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `setPasswordEncrypted(byte[] bytes)`

### getLoginDelaySeconds

    public int getLoginDelaySeconds()

  Returns the number of seconds to delay before creating each physical database connection. This delay takes place both during initial pool creation and during the lifetime of the pool whenever a physical database connection is created.

  Default Value: 0
  Old Property: weblogic.jdbc.connectionPool.loginDelaySecs
  Returns:
    The loginDelaySeconds value

### setLoginDelaySeconds

    public void setLoginDelaySeconds(int secs)
                              throws javax.management.InvalidAttributeValueException

  Sets the number of seconds to delay before creating each physical database connection. Some database servers cannot handle multiple requests for connections in rapid succession. This property allows you to specify a small delay for each database connection. This delay takes place both during initial pool creation and whenever a physical database connection is created.

  Default Value: 0
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Secure Value: 0
  Parameters:
    `secs` - The new loginDelaySeconds value
  Throws:
    javax.management.InvalidAttributeValueException -

### getSecondsToTrustAnIdlePoolConnection

    public int getSecondsToTrustAnIdlePoolConnection()

  The number of seconds within the use of a pooled connection that WebLogic Server trusts that the connection is still viable and will skip connection testing.

  If an application requests a connection within the time specified since the connection was tested or successfully used and returned to the connection pool, WebLogic Server skips the connection test before delivering it to an application (if TestConnectionsOnReserve is enabled).

  WebLogic Server also skips the automatic refresh connection test if the connection was successfully used and returned to the connection pool within the time specified (if TestFrequencySeconds is specified).

  SecondsToTrustAnIdlePoolConnection is a tuning feature that can improve application performance by minimizing the delay caused by database connection testing, especially during heavy traffic. However, it can reduce the effectiveness of connection testing, especially if the value is set too high. The appropriate value depends on your environment and the likelihood that a connection will become defunct.

  Default Value: 0
  Returns:
    The secondsToTrustAnIdlePoolConnection value

### setSecondsToTrustAnIdlePoolConnection

    public void setSecondsToTrustAnIdlePoolConnection(int secs)
                                               throws javax.management.InvalidAttributeValueException

  Sets the SecondsToTrustAnIdlePoolConnection attribute.

  Default Value: 0
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Secure Value: 0
  Parameters:
    `secs` - The new secondsToTrustAnIdlePoolConnection value
  Throws:
    javax.management.InvalidAttributeValueException -

### getInitialCapacity

    public int getInitialCapacity()

  Returns the number of physical database connections to create when creating the connection pool.

  Default Value: 1
  Old Property: weblogic.jdbc.connectionPool.initialCapacity
  Returns:
    The initialCapacity value

### setInitialCapacity

    public void setInitialCapacity(int capacity)
                            throws javax.management.InvalidAttributeValueException

  Sets the number of physical database connections to create when creating the connection pool. If unable to create this number of connections, creation of this connection pool will fail. This is also the minimum number of physical connections the connection pool will keep available.

  A dynamic MBean attribute
  Default Value: 1
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `capacity` - The new initialCapacity value
  Throws:
    javax.management.InvalidAttributeValueException -

### getMaxCapacity

    public int getMaxCapacity()

  Returns the maximum number of physical database connections that this connection pool can contain. Different JDBC Drivers and database servers may limit the number of possible physical connections.

  Default Value: ServerLegalHelper.DEFAULT_THREAD_POOL_SIZE
  Production Mode Default Value: ServerLegalHelper.PRODUCTION_MODE_THREAD_POOL_SIZE
  Old Property: weblogic.jdbc.connectionPool.maxCapacity
  Returns:
    The maxCapacity value

### setMaxCapacity

    public void setMaxCapacity(int capacity)
                        throws javax.management.InvalidAttributeValueException

  Sets the maximum number of physical database connections that this connection pool can contain. Different JDBC Drivers and database servers may limit the number of possible physical connections.

  A dynamic MBean attribute
  Default Value: ServerLegalHelper.DEFAULT_THREAD_POOL_SIZE
  Production Mode Default Value: ServerLegalHelper.PRODUCTION_MODE_THREAD_POOL_SIZE
  Legal Minimum Value: 1
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `capacity` - The new maxCapacity value
  Throws:
    javax.management.InvalidAttributeValueException -

### getCapacityIncrement

    public int getCapacityIncrement()

  Returns the increment by which the connection pool capacity is expanded. 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 as set by `MaxCapacity`.

  Default Value: 1
  Old Property: weblogic.jdbc.connectionPool.capacityIncrement
  Returns:
    The capacityIncrement value

### setCapacityIncrement

    public void setCapacityIncrement(int capacity)
                              throws javax.management.InvalidAttributeValueException

  Sets the increment by which the connection pool capacity is expanded. 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 as set by `MaxCapacity`.

  A dynamic MBean attribute
  Default Value: 1
  Legal Minimum Value: 1
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `capacity` - The new capacityIncrement value
  Throws:
    javax.management.InvalidAttributeValueException -

### isShrinkingEnabled

    public boolean isShrinkingEnabled()

  Indicates whether or not the pool can shrink to the greater of its `InitialCapacity` or the current number of connections in use when it is detected that connections created during increased traffic are not being used.

  Default Value: true
  Old Property: weblogic.jdbc.connectionPool.allowShrinking
  Returns:
    The shrinkingEnabled value

### setShrinkingEnabled

    public void setShrinkingEnabled(boolean enable)
                             throws javax.management.InvalidAttributeValueException

  Indicates whether or not the pool can shrink back to its `InitialCapacity` when it is detected that connections created during increased traffic are not being used.

  When shrinking, the number of connections is reduced to the greater of either the initial capacity or the current number of connections in use.

  A dynamic MBean attribute
  Secure Value: true
  Parameters:
    `enable` - The new shrinkingEnabled value
  Throws:
    javax.management.InvalidAttributeValueException -

### getShrinkPeriodMinutes

    public int getShrinkPeriodMinutes()

  Deprecated.
  Returns the number of minutes to wait before shrinking a connection pool that has incrementally increased to meet demand. `ShrinkingEnabled` must be set to true for a connection pool to shrink.

  Default Value: 15
  Old Property: weblogic.jdbc.connectionPool.shrinkPeriodMins
  Returns:
    The shrinkPeriodMinutes value

### setShrinkPeriodMinutes

    public void setShrinkPeriodMinutes(int minutes)
                                throws javax.management.InvalidAttributeValueException

  Deprecated.
  Sets the number of minutes to wait before shrinking a connection pool that has incrementally increased to meet demand. `ShrinkingEnabled` must be set to true for a connection pool to shrink.

  A dynamic MBean attribute
  Default Value: 15
  Legal Minimum Value: 1
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Secure Value: 15
  Parameters:
    `minutes` - The new shrinkPeriodMinutes value
  Throws:
    javax.management.InvalidAttributeValueException -

### getShrinkFrequencySeconds

    public int getShrinkFrequencySeconds()

  Returns the number of seconds to wait before shrinking a connection pool that has incrementally increased to meet demand. `ShrinkingEnabled` must be set to true for a connection pool to shrink.

  Default Value: 900
  Returns:
    The shrinkFrequencySeconds value

### setShrinkFrequencySeconds

    public void setShrinkFrequencySeconds(int seconds)
                                   throws javax.management.InvalidAttributeValueException

  Sets the number of seconds to wait before shrinking a connection pool that has incrementally increased to meet demand. `ShrinkingEnabled` must be set to true for a connection pool to shrink.

  A dynamic MBean attribute
  Default Value: 900
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `seconds` - The new shrinkFrequencySeconds value
  Throws:
    javax.management.InvalidAttributeValueException -

### getRefreshMinutes

    public int getRefreshMinutes()

  Deprecated.
  Returns the number of minutes between database connection tests. After every `RefreshMinutes` interval, unused database connections are tested using `TestTableName`. Connections that do not pass the test will be closed and reopened to re-establish a valid physical database connection. If `TestTableName` is not set, the test will not be performed.

  Default Value: 0
  Old Property: weblogic.jdbc.connectionPool.refreshTestMinutes
  Returns:
    The refreshMinutes value

### setRefreshMinutes

    public void setRefreshMinutes(int minutes)
                           throws javax.management.InvalidAttributeValueException

  Deprecated.
  Sets the number of minutes between database connection tests. After every `RefreshMinutes` interval, unused database connections are tested using `TestTableName`. Connections that do not pass the test will be closed and reopened to re-establish a valid physical database connection. If `TestTableName` is not set, the test will not be performed.

  A dynamic MBean attribute
  Default Value: 0
  Legal Minimum Value: 0
  Legal Maximum Value: 35791394
  Parameters:
    `minutes` - The new refreshMinutes value
  Throws:
    javax.management.InvalidAttributeValueException -

### getTestFrequencySeconds

    public int getTestFrequencySeconds()

  Returns the number of seconds between database connection tests. After every `TestFrequencySeconds` interval, unused database connections are tested using `TestTableName`. Connections that do not pass the test will be closed and reopened to re-establish a valid physical database connection. If `TestTableName` is not set, the test will not be performed.

  When set to `0` (the default), periodic testing is disabled.

  Default Value: 0
  Returns:
    The testFrequencySeconds value
  See Also:
    `setHighestNumUnavailable(int)`, `setTestTableName(java.lang.String)`

### setTestFrequencySeconds

    public void setTestFrequencySeconds(int seconds)
                                 throws javax.management.InvalidAttributeValueException

  Returns the number of seconds between database connection tests. After every `TestFrequencySeconds` interval, unused database connections are tested using `TestTableName`. Connections that do not pass the test will be closed and reopened to re-establish a valid physical database connection. If `TestTableName` is not set, the test will not be performed. Default implies feature is disabled.

  A dynamic MBean attribute
  Default Value: 0
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `seconds` - The new testFrequencySeconds value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `setHighestNumUnavailable(int)`, `setTestTableName(java.lang.String)`

### getTestTableName

    public java.lang.String getTestTableName()

  Returns the name of the table used when testing a physical database connection. The default SQL code used to test a connection is

  `"select count(*) from TestTableName"`

  The `TestTableName` 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 `TestTableName` to the name of a table that is known to have few rows, or even no rows.

  If `TestTableName` 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 a connection.

  Old Property: weblogic.jdbc.connectionPool.testTable
  Returns:
    The testTableName value

### setTestTableName

    public void setTestTableName(java.lang.String table)
                          throws javax.management.InvalidAttributeValueException

  Sets the name of the table used when testing a physical database connection. The default SQL code used to test a connection is

  `"select count(*) from TestTableName"`

  The `TestTableName` 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 `TestTableName` to the name of a table that is known to have few rows, or even no rows.

  If `TestTableName` 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 a connection.

  A dynamic MBean attribute
  Parameters:
    `table` - The new testTableName value
  Throws:
    javax.management.InvalidAttributeValueException -

### setTestConnectionsOnReserve

    public void setTestConnectionsOnReserve(boolean enable)
                                     throws javax.management.InvalidAttributeValueException

  When set to true, WebLogic Server tests a connection before giving it to the client. 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 working connection (assuming that the DBMS is available and accessible).

  The attribute TestTableName must be enabled for TestConnectionsOnReserve to be effective.

  A dynamic MBean attribute
  Default Value: false
  Old Property: weblogic.jdbc.connectionPool.testConnsOnReserve
  Secure Value: false
  Parameters:
    `enable` - The new testConnectionsOnReserve value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `setTestTableName(java.lang.String)`

### getTestConnectionsOnReserve

    public boolean getTestConnectionsOnReserve()

  Returns the TestConnectionsOnReserve attribute of the JDBCConnectionPoolMBean object; when set to true, WebLogic Server tests a connection before giving it to the client.

  Returns:
    The TestConnectionsOnReserve value

### setTestConnectionsOnRelease

    public void setTestConnectionsOnRelease(boolean enable)
                                     throws javax.management.InvalidAttributeValueException

  When set to true, WebLogic Server tests a connection before returning it to the connection pool. If all connections in the pool are already in use and a client is waiting for a connection, the client's wait will be slightly longer while the connection is tested. The attribute TestTableName must be enabled for TestConnectionsOnRelease to be effective.

  A dynamic MBean attribute
  Default Value: false
  Old Property: weblogic.jdbc.connectionPool.testConnsOnRelease
  Secure Value: false
  Parameters:
    `enable` - The new testConnectionsOnRelease value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `setTestTableName(java.lang.String)`

### getTestConnectionsOnRelease

    public boolean getTestConnectionsOnRelease()

  Returns the TestConnectionsOnRelease attribute of the JDBCConnectionPoolMBean object; when set to true, WebLogic Server tests a connection before returning it to the connection pool.

  Returns:
    The TestConnectionsOnRelease value

### setTestConnectionsOnCreate

    public void setTestConnectionsOnCreate(boolean enable)
                                    throws javax.management.InvalidAttributeValueException

  When set to true, WebLogic Server tests a connection after creating it and before adding it to the list of connections available to the client. The test adds a small delay in creating the connection, but ensures that the client receives a working connection (assuming that the DBMS is available and accessible). The attribute TestTableName must be enabled for TestConnectionsOnCreate to be effective.

  A dynamic MBean attribute
  Default Value: false
  Parameters:
    `enable` - The new testConnectionsOnCreate value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `setTestTableName(java.lang.String)`

### getTestConnectionsOnCreate

    public boolean getTestConnectionsOnCreate()

  Returns the TestConnectionsOnCreate attribute of the JDBCConnectionPoolMBean object; when set to true, WebLogic Server tests a connection after creating it and before adding it to the list of connections available to the client.

  Returns:
    The TestConnectionsOnCreate value

### getPassword

    public java.lang.String getPassword()

  The database password as set with `setPassword()`, `setPasswordEncrypted()`, or as a key=value pair in `setProperties()`.

  As of 8.1 sp4, the `getPassword()` method does the following:

  1. Retrieves the value of the `PasswordEncrypted` attribute.
  2. Decrypts the value and returns the unencrypted password as a String.

  Using `getPassword()` is a potential security risk because the String object (which contains the unencrypted password) remains in the JVM's memory until garbage collection removes it. Depending on how memory is allocated in the JVM, a significant amount of time could pass before this unencrypted data is removed from memory.

  Instead of using this method, use `getPasswordEncrypted()` to retrieve the encrypted password. On the same WebLogic Server that encrypted the value of the PasswordEncrypted attribute, use `weblogic.management.EncryptionHelper.encrypt()` to encrypt the user-supplied password. Then compare the encrypted values.

  A non-configurable MBean attribute.
  Returns:
    The password value
  See Also:
    `getPasswordEncrypted()`

### setPassword

    public void setPassword(java.lang.String password)
                     throws javax.management.InvalidAttributeValueException

  As of 8.1 sp4, this method does the following:

  1. Encrypts the parameter value.
  2. Sets the value of the `PasswordEncrypted` attribute to the encrypted parameter value.

  A non-configurable MBean attribute.
  Parameters:
    `password` - The new password value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `setPasswordEncrypted(byte[] bytes)`

### getPasswordEncrypted

    public byte[] getPasswordEncrypted()

  The encrypted database password as set with `setPassword()`, `setPasswordEncrypted(byte[] bytes)`, or as a key=value pair in `setProperties()`.

  Returns:
    The password value as an encrypted byte array
  See Also:
    `EncryptionHelper`

### setPasswordEncrypted

    public void setPasswordEncrypted(byte[] bytes)
                              throws javax.management.InvalidAttributeValueException

  Encrypts the password and sets the value of the PasswordEncrypted attribute.

  Parameters:
    `bytes` - The new password value as a byte array.
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `getPasswordEncrypted()`

### getXAPassword

    public java.lang.String getXAPassword()

  The password that is used to create physical XA database connections.

  As of 8.1 sp4, the `getXAPassword()` method does the following:

  1. Retrieves the value of the `XAPasswordEncrypted` attribute.
  2. Decrypts the value and returns the unencrypted password as a String.

  Using `getXAPassword()` is a potential security risk because the String object (which contains the unencrypted password) remains in the JVM's memory until garbage collection removes it. Depending on how memory is allocated in the JVM, a significant amount of time could pass before this unencrypted data is removed from memory.

  Instead of using this method, use `getXAPasswordEncrypted()` to retrieve the encrypted password. On the same WebLogic Server that encrypted the value of the XAPasswordEncrypted attribute, use `weblogic.management.EncryptionHelper.encrypt()` to encrypt the user-supplied password. Then compare the encrypted values.

  A non-configurable MBean attribute.
  Returns:
    The xAPassword value
  See Also:
    `getXAPasswordEncrypted()`

### setXAPassword

    public void setXAPassword(java.lang.String password)
                       throws javax.management.InvalidAttributeValueException

  As of 8.1 sp4, this method does the following:

  1. Encrypts the parameter value.
  2. Sets the value of the `XAPasswordEncrypted` attribute to the encrypted parameter value.

  A non-configurable MBean attribute.
  Parameters:
    `password` - The new xAPassword value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `setXAPasswordEncrypted(byte[] bytes)`

### getXAPasswordEncrypted

    public byte[] getXAPasswordEncrypted()

  The encrypted password that is used to create physical XA database connections.

  Returns:
    The xAPassword value as encrypted byte array.
  See Also:
    `EncryptionHelper`

### setXAPasswordEncrypted

    public void setXAPasswordEncrypted(byte[] bytes)
                                throws javax.management.InvalidAttributeValueException

  Encrypts the password and sets the value of the XAPasswordEncrypted attribute.

  Parameters:
    `bytes` - The new xAPassword value as a byte array.
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `getXAPasswordEncrypted()`

### getSupportsLocalTransaction

    public boolean getSupportsLocalTransaction()

  Whether the XA driver used to create physical database connections supports SQL without global transactions.

  This property applies to connection pools that use an XA driver only, and is ignored for connection pools that use non-XA drivers.

  Default Value: false
  Returns:
    `true` if XA driver supports SQL with no global transaction.

### setSupportsLocalTransaction

    public void setSupportsLocalTransaction(boolean support)
                                     throws javax.management.InvalidAttributeValueException

  Set to true if the XA driver used to create physical database connections supports SQL without global transactions. Set to false (the default) if the XA driver does not support SQL without global transactions.

  This property applies to connection pools that use an XA driver only, and is ignored for connection pools that use non-XA drivers.

  Parameters:
    `support` - The new supportsLocalTransaction value
  Throws:
    javax.management.InvalidAttributeValueException -

### getKeepXAConnTillTxComplete

    public boolean getKeepXAConnTillTxComplete()

  Returns `true` if the XA connection pool associates the same XA connection with the distributed transaction until the transaction completes. This property applies to XA connection pools only, and is ignored for non-XA driver. Its intention is to workaround specific problems with third party vendor's XA driver.

  Default Value: false

### setKeepXAConnTillTxComplete

    public void setKeepXAConnTillTxComplete(boolean b)
                                     throws javax.management.InvalidAttributeValueException

  Set to `true` to force a connection pool to reserve a physical connection and provide the same connection to an application throughout transaction processing until the distributed transaction is complete.

  This property applies to XA connection pools only, and is ignored for non-XA driver. Its intention is to workaround specific problems with third party vendor's XA driver.

  Parameters:
    `b` - The new keepXAConnTillTxComplete value
  Throws:
    javax.management.InvalidAttributeValueException -

### getNeedTxCtxOnClose

    public boolean getNeedTxCtxOnClose()

  Returns `true` if the XA driver requires a distributed transaction context when closing various JDBC objects, e.g. result sets, statements, connections etc. If it is specified to true, SQL exceptions that are thrown while closing the JDBC objects in no transaction context will be swallowed. This property applies to XA connection pools only, and is ignored for non-XA driver. Its intention is to workaround specific problems with third party vendor's XA driver.

  Default Value: false

### setNeedTxCtxOnClose

    public void setNeedTxCtxOnClose(boolean b)
                             throws javax.management.InvalidAttributeValueException

  Set to `true` if the XA driver requires a distributed transaction context when closing various JDBC objects, e.g. result sets, statements, connections etc. If it is specified to true, SQL exceptions that are thrown while closing the JDBC objects in no transaction context will be swallowed.

  This property applies to XA connection pools only, and is ignored for non-XA drivers. Its intention is to workaround specific problems with third party vendor's XA driver.

  Parameters:
    `b` - The new needTxCtxOnClose value
  Throws:
    javax.management.InvalidAttributeValueException -

### getXAEndOnlyOnce

    public boolean getXAEndOnlyOnce()

  Returns `true` if XAResource.end() will be called only once for each pending XAResource.start(). That is, the XA driver will not be called with XAResource.end(TMSUSPEND), XAResource.end(TMSUCCESS) successively.

  This property applies to XA connection pools only, and is ignored for non-XA drivers. Its intention is to workaround specific problems with third party vendor's XA driver.

  Default Value: false

### setXAEndOnlyOnce

    public void setXAEndOnlyOnce(boolean b)
                          throws javax.management.InvalidAttributeValueException

  Determines whether XAResource.end() will be called only once for each pending XAResource.start(). That is, the XA driver will not be called with XAResource.end(TMSUSPEND), XAResource.end(TMSUCCESS) successively.

  This property applies to XA connection pools only, and is ignored for non-XA driver. Its intention is to workaround specific problems with third party vendor's XA driver.

  Parameters:
    `b` - The new xAEndOnlyOnce value
  Throws:
    javax.management.InvalidAttributeValueException -

### getNewXAConnForCommit

    public boolean getNewXAConnForCommit()

  Returns `true` if a dedicated XA connection is used for commit/rollback processing of a particular distributed transaction.

  This property applies to XA connection pools only, and is ignored for non-XA drivers. Its intention is to workaround specific problems with third party vendor's XA driver.

  Default Value: false

### setNewXAConnForCommit

    public void setNewXAConnForCommit(boolean b)
                               throws javax.management.InvalidAttributeValueException

  Determines whether a dedicated XA connection is used for commit/rollback processing of a particular distributed transaction.

  This property applies to XA connection pools only, and is ignored for non-XA driver. Its intention is to workaround specific problems with third party vendor's XA driver.

  Parameters:
    `b` - The new newXAConnForCommit value
  Throws:
    javax.management.InvalidAttributeValueException -

### getKeepLogicalConnOpenOnRelease

    public boolean getKeepLogicalConnOpenOnRelease()

  Returns `true` if the logical JDBC connection is kept open when the physical XA connection is returned to the XA connection pool.

  This property applies to XA connection pools only, and is ignored for non-XA driver. Its intention is to workaround specific problems with third party vendor's XA driver.

  Default Value: false

### setKeepLogicalConnOpenOnRelease

    public void setKeepLogicalConnOpenOnRelease(boolean b)
                                         throws javax.management.InvalidAttributeValueException

  Determines whether the logical JDBC connection is kept open when the physical XA connection is returned to the XA connection pool.

  This property applies to XA connection pools only, and is ignored for non-XA driver. Its intention is to workaround specific problems with third party vendor's XA driver.

  Parameters:
    `b` - The new keepLogicalConnOpenOnRelease value
  Throws:
    javax.management.InvalidAttributeValueException -

### getXAPreparedStatementCacheSize

    public int getXAPreparedStatementCacheSize()

  Deprecated.
  Returns the maximum number of prepared statements cached by this particular XA connection pool. If the value is 0, caching is turned off. This property applies to XA connection pools only, and is ignored for non-XA driver.

  Default Value: JDBCLegalHelper.UNSPECIFIED_CACHE_STATEMENTS_SIZE
  See Also:
    `setXAPreparedStatementCacheSize(int)`

### setXAPreparedStatementCacheSize

    public void setXAPreparedStatementCacheSize(int size)
                                         throws javax.management.InvalidAttributeValueException

  Deprecated.
  The maximum number of prepared statements cached by this XA connection pool. If the value is 0, caching is turned off. This property applies to XA connection pools only, and is ignored for non-XA driver.

  Legal Value: (value >= weblogic.management.configuration.JDBCLegalHelper.UNSPECIFIED_CACHE_STATEMENTS_SIZE) && (value <= weblogic.management.configuration.JDBCLegalHelper.MAX_CACHE_STATEMENTS_SIZE)
  Parameters:
    `size` - The new xAPreparedStatementCacheSize value
  Throws:
    javax.management.InvalidAttributeValueException -
  See Also:
    `getXAPreparedStatementCacheSize()`

### getEnableResourceHealthMonitoring

    public boolean getEnableResourceHealthMonitoring()

  Returns whether JTA resource health monitoring is enabled for this XA connection pool.

  This property applies to XA connection pools only, and is ignored for connection pools that use a non-XA driver.

  Default Value: true

### setEnableResourceHealthMonitoring

    public void setEnableResourceHealthMonitoring(boolean enable)
                                           throws javax.management.InvalidAttributeValueException

  Determines whether JTA resource health monitoring is enabled for this XA connection pool.

  This property applies to XA connection pools only, and is ignored for connection pools that use a non-XA driver.

  Parameters:
    `enable` - The new enableResourceHealthMonitoring value
  Throws:
    javax.management.InvalidAttributeValueException -

### getXASetTransactionTimeout

    public boolean getXASetTransactionTimeout()

  When set to true, the WebLogic Server Transaction Manager calls XAResource.setTransactionTimeout() before calling XAResource.start, and passes either the XATransactionTimeout or the global transaction timeout in seconds.

  When set to false, the Transaction Manager does not call setTransactionTimeout().

  This property applies to XA connection pools only, and is ignored for connection pools that use a non-XA driver.

  Default Value: false

### setXASetTransactionTimeout

    public void setXASetTransactionTimeout(boolean b)
                                    throws javax.management.InvalidAttributeValueException

  When set to true, the WebLogic Server Transaction Manager calls XAResource.setTransactionTimeout() before calling XAResource.start, and passes either the XATransactionTimeout or the global transaction timeout in seconds.

  When set to false, the Transaction Manager does not call setTransactionTimeout().

  This property applies to XA connection pools only, and is ignored for connection pools that use a non-XA driver.

### getXATransactionTimeout

    public int getXATransactionTimeout()

  Determines the number of seconds to pass as the transaction timeout value in the XAResource.setTransactionTimeout() method. When this property is set to 0, the WebLogic Server Transaction Manager passes the global WebLogic Server transaction timeout in seconds in the method.

  If set, this value should be greater than or equal to the global WebLogic Server transaction timeout.

  XASetTransactionTimeout must be set to "true" or this property is ignored.

  This property applies to XA connection pools only, and is ignored for connection pools that use a non-XA driver.

  Default Value: 0

### setXATransactionTimeout

    public void setXATransactionTimeout(int timeout)
                                 throws javax.management.InvalidAttributeValueException

  Determines the number of seconds to pass as the transaction timeout value in the XAResource.setTransactionTimeout() method. When this property is set to 0, the WebLogic Server Transaction Manager passes the global WebLogic Server transaction timeout in seconds in the method.

  If set, this value should be greater than or equal to the global WebLogic Server transaction timeout.

  XASetTransactionTimeout must be set to "true" or this property is ignored.

  This property applies to XA connection pools only, and is ignored for connection pools that use a non-XA driver.

### getXARetryDurationSeconds

    public int getXARetryDurationSeconds()

  Determines the duration in seconds during which the transaction manager will retry to perform recover, rollback, and commit operations on the resource. A value of zero indicates that no retries will be performed.

  Default Value: 0

### setXARetryDurationSeconds

    public void setXARetryDurationSeconds(int duration)
                                   throws javax.management.InvalidAttributeValueException

  Determines the duration in seconds during which the transaction manager will retry to perform recover, rollback, and commit operations on the resource. A value of zero indicates that no retries will be performed.

### getXARetryIntervalSeconds

    public int getXARetryIntervalSeconds()

  Determines the time in seconds between XA retry operations if the XARetryDurationSeconds attribute is set to a positive value.

  Default Value: 60

### setXARetryIntervalSeconds

    public void setXARetryIntervalSeconds(int interval)
                                   throws javax.management.InvalidAttributeValueException

  Determines the time in seconds between XA retry operations if the XARetryDurationSeconds attribute is set to a positive value.

### setPreparedStatementCacheSize

    public void setPreparedStatementCacheSize(int cacheSize)

  Deprecated.
  The number of prepared statements stored in the cache for further use. WebLogic Server can reuse prepared statements in the cache without reloading them, which can increase server performance. Setting the size of the prepared statement cache to 0 turns it off.

  Legal Value: (value >= weblogic.management.configuration.JDBCLegalHelper.UNSPECIFIED_CACHE_STATEMENTS_SIZE) && (value <= weblogic.management.configuration.JDBCLegalHelper.MAX_CACHE_STATEMENTS_SIZE)
  Parameters:
    `cacheSize` - The new preparedStatementCacheSize value
  See Also:
    `getPreparedStatementCacheSize()`

### getPreparedStatementCacheSize

    public int getPreparedStatementCacheSize()

  Deprecated.
  Returns the size of the prepared statement cache. The size of the cache is a number of prepared statements created from particular connection and stored in the cache for further use.

  Default Value: JDBCLegalHelper.UNSPECIFIED_CACHE_STATEMENTS_SIZE
  Returns:
    The preparedStatementCacheSize value
  See Also:
    `setPreparedStatementCacheSize(int)`

### setConnectionReserveTimeoutSeconds

    public void setConnectionReserveTimeoutSeconds(int seconds)

  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.

  A dynamic MBean attribute
  Default Value: 10
  Legal Minimum Value: -1
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `seconds` - The new connectionReserveTimeoutSeconds value
  See Also:
    `setHighestNumWaiters(int)`

### getConnectionReserveTimeoutSeconds

    public 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.

  Returns:
    The connectionReserveTimeoutSeconds value

### setConnectionCreationRetryFrequencySeconds

    public void setConnectionCreationRetryFrequencySeconds(int seconds)

  The number of seconds between attempts to establish connections to the database. When set to `0` (the default), connection retry is disabled.

  A dynamic MBean attribute
  Default Value: 0
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `seconds` - The new connectionCreationRetryFrequencySeconds value

### getConnectionCreationRetryFrequencySeconds

    public int getConnectionCreationRetryFrequencySeconds()

  Gets the connectionCreationRetryFrequencySeconds attribute of the JDBCConnectionPoolMBean object, which is the number of seconds between attempts to establish connections to the database. When set to `0` (the default), connection retry is disabled.

  Returns:
    The connectionCreationRetryFrequencySeconds value

### setInactiveConnectionTimeoutSeconds

    public void setInactiveConnectionTimeoutSeconds(int seconds)

  The number of seconds of inactivity after which reserved connections will be forcibly returned to the connection pool. When set to `0` (the default), the feature is disabled.

  A dynamic MBean attribute
  Default Value: 0
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `seconds` - The new inactiveConnectionTimeoutSeconds value

### getInactiveConnectionTimeoutSeconds

    public int getInactiveConnectionTimeoutSeconds()

  Gets the inactiveConnectionTimeoutSeconds attribute of the JDBCConnectionPoolMBean object, which is the number of seconds of inactivity after which reserved connections will be forcibly returned to the connection pool. When set to `0` (the default), the feature is disabled.

  Returns:
    The inactiveConnectionTimeoutSeconds value

### setHighestNumWaiters

    public void setHighestNumWaiters(int count)

  The maximum number of connection requests that can concurrently block waiting to reserve a connection from the pool.

  A dynamic MBean attribute
  Default Value: java.lang.Integer.MAX_VALUE
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `count` - The new highestNumWaiters value
  See Also:
    `setConnectionReserveTimeoutSeconds(int)`

### getHighestNumWaiters

    public int getHighestNumWaiters()

  Gets the highestNumWaiters attribute of the JDBCConnectionPoolMBean object, which is the maximum number of connection requests that can concurrently block waiting to reserve a connection from the pool.

  Returns:
    The highestNumWaiters value

### setHighestNumUnavailable

    public void setHighestNumUnavailable(int count)

  The maximum number of connections in the connection pool that can be made unavailable (to an application) for purposes like refreshing the connection, etc. Note that in cases likes the backend system being unavailable, this specified value could be exceeded due to factors outside the pool's control.

  When set to `0` (the default), waiting for a connection is disabled.

  A dynamic MBean attribute
  Default Value: 0
  Legal Minimum Value: 0
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `count` - The new highestNumUnavailable value

### getHighestNumUnavailable

    public int getHighestNumUnavailable()

  Gets the highestNumUnavailable attribute of the JDBCConnectionPoolMBean object, which is the maximum number of connections in the connection pool that can be made unavailable (to an application) for purposes like refreshing the connection, etc.

  Returns:
    The highestNumUnavailable value

### setInitSQL

    public void setInitSQL(java.lang.String table)
                    throws javax.management.InvalidAttributeValueException

  The SQL statement to execute to initialize (or "prime") a physical database connection. If `InitSQL` 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 a connection. Else, `InitSQL` will be treated as the name of a table and the following SQL statement will be used to initialize a connection:

  `"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.

  Parameters:
    `table` - The new initSQL value
  Throws:
    javax.management.InvalidAttributeValueException -

### getInitSQL

    public java.lang.String getInitSQL()

  Gets the initSQL attribute of the JDBCConnectionPoolMBean object, which is a SQL statement to execute to initialize (or "prime") a physical database connection.

  Returns:
    The initSQL value

### setStatementCacheSize

    public void setStatementCacheSize(int cacheSize)

  The number of Prepared and Callable Statements stored in the cache for reuse. WebLogic Server can reuse statements in the cache without reloading them, which can increase server performance. Setting the size of the statement cache to 0 turns it off. Each connection in the pool has its own cache of statements.

  A dynamic MBean attribute
  Legal Value: (value >= JDBCLegalHelper.MIN_CACHE_STATEMENTS_SIZE) && (value <= JDBCLegalHelper.MAX_CACHE_STATEMENTS_SIZE)
  Parameters:
    `cacheSize` - The new statementCacheSize value
  See Also:
    `getStatementCacheSize()`

### getStatementCacheSize

    public int getStatementCacheSize()

  Returns size of the statement cache; The size of the cache is the number of Prepared and Callable statements created from a particular connection and stored in the cache for further use.

  Default Value: JDBCLegalHelper.DEFAULT_CACHE_STATEMENTS_SIZE
  Returns:
    The statementCacheSize value
  See Also:
    `setStatementCacheSize(int)`

### setStatementCacheType

    public void setStatementCacheType(java.lang.String type)

  Sets the algorithm used to maintain the statement cache: LRU or Fixed.
  - LRU - When a new statement is used after the `statementCacheSize` is met, the Least Recently Used statement is removed from the cache.
  - Fixed - The first `statementCacheSize` number of statements is stored and stay fixed in the cache. No new statements are cached unless the cache is manually cleared.

  Legal Values: JDBCLegalHelper.STATEMENT_CACHE_TYPE_LRU, JDBCLegalHelper.STATEMENT_CACHE_TYPE_FIXED
  Parameters:
    `type` - The new statementCacheType value
  See Also:
    `getStatementCacheType()`

### getStatementCacheType

    public java.lang.String getStatementCacheType()

  Returns the algorithm used to maintain the statement cache. With "LRU" algorithm, Least Recently Used entry in cache is ejected to accomodate a new entry. With "Fixed" algorithm, entries stay fixed in the cache.

  Default Value: JDBCLegalHelper.STATEMENT_CACHE_TYPE_DEFAULT
  Returns:
    The statementCacheType value
  See Also:
    `setStatementCacheType(java.lang.String)`

### setRemoveInfectedConnectionsEnabled

    public void setRemoveInfectedConnectionsEnabled(boolean enable)

  Controls whether a connection will be removed from the connection pool when the application asks for the underlying vendor connection object. Enabling this attribute will have an impact on performance as it will essentially disable the pooling of connections (as connections will be removed from the pool and replaced with new connections).

  Default Value: true
  Parameters:
    `enable` - The new removeInfectedConnectionsEnabled value
  See Also:
    `WLConnection.getVendorConnection()`

### isRemoveInfectedConnectionsEnabled

    public boolean isRemoveInfectedConnectionsEnabled()

  Whether a connection will be removed from the connection pool when the application asks for the underlying vendor connection object.

  Returns:
    The removeInfectedConnectionsEnabled value

### setRollbackLocalTxUponConnClose

    public void setRollbackLocalTxUponConnClose(boolean enable)

  If set to true, WLS connection pool will call rollback() on the connection before putting it back in the pool. Enabling this attribute will have a performance impact as the rollback call requires communication with the database server.

  Default Value: false
  Parameters:
    `enable` - The new rollbackLocalTxUponConnClose value

### getRollbackLocalTxUponConnClose

    public boolean getRollbackLocalTxUponConnClose()

  Whether WLS connection pool will call rollback() on the connection before putting it back in the pool.

  Returns:
    The rollbackLocalTxUponConnClose value

### setTestStatementTimeout

    public void setTestStatementTimeout(int timeout)

  The time after which the test statement (configured by applications using the pool attribute Test Table Name) or initialization statement (configured by applications using the pool attribute InitSQL) currently being executed will be timed out.

  Efficacy of this feature 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.

  A dynamic MBean attribute
  Default Value: -1
  Legal Minimum Value: -1
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `timeout` - The new testStatementTimeout value
  See Also:
    `setTestTableName(java.lang.String)`, `setInitSQL(java.lang.String)`

### getTestStatementTimeout

    public int getTestStatementTimeout()

  Returns the configured testStatementTimeout value.

  Default Value: -1
  Returns:
    the testStatementTimeout value
  See Also:
    `setTestTableName(java.lang.String)`, `setInitSQL(java.lang.String)`

### setStatementTimeout

    public void setStatementTimeout(int timeout)

  The time after which a statement currently being executed will be timed-out.

  Efficacy of this feature 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.

  A dynamic MBean attribute
  Default Value: -1
  Legal Minimum Value: -1
  Legal Maximum Value: java.lang.Integer.MAX_VALUE
  Parameters:
    `timeout` - The new statementTimeout value

### getStatementTimeout

    public int getStatementTimeout()

  Returns the configured statementTimeout value.

  Default Value: -1
  Returns:
    the statementTimeout value

### setIgnoreInUseConnectionsEnabled

    public void setIgnoreInUseConnectionsEnabled(boolean enable)

  Enables pool to be shutdown even if connections are still in use.

  A dynamic MBean attribute
  Parameters:
    `enable` - The new ignoreInUseConnectionsEnabled value

### isIgnoreInUseConnectionsEnabled

    public boolean isIgnoreInUseConnectionsEnabled()

  Returns the configured ignoreInUseConnectionsEnabled value.

  Default Value: true
  Returns:
    the ignoreInUseConnectionsEnabled value

### setCountOfRefreshFailuresTillDisable

    public void setCountOfRefreshFailuresTillDisable(int newVal)

  Set the number of consecutive failures to replace dead pool connections before we disable the pool. Zero means we will never disable the pool.

  Parameters:
    `newVal` - The new attribute value

### getCountOfRefreshFailuresTillDisable

    public int getCountOfRefreshFailuresTillDisable()

  Set the number of consecutive failures to replace dead pool connections before we disable the pool. Zero means we will never disable the pool.

  Default Value: 0

### setCountOfTestFailuresTillFlush

    public void setCountOfTestFailuresTillFlush(int newVal)

  Set the number of consecutive failed pool connection tests before we close all the connections the pool. Zero means we will never close all the connections in the pool.

  Parameters:
    `newVal` - The new attribute value

### getCountOfTestFailuresTillFlush

    public int getCountOfTestFailuresTillFlush()

  Get the number of consecutive failed pool connection tests before we close all the connections the pool. Zero means we will never close all the connections at once for that reason.

  Default Value: 0

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Documentation is available at http://e-docs.bea.com/wls/docs81
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD