WebLogic Server 8.1 API Reference: Interface JDBCConnectionPoolMBean

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

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"

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:

Retrieves the value of the PasswordEncrypted attribute.
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:

Encrypts the parameter value.
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:

Retrieves the value of the XAPasswordEncrypted attribute.
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:

Encrypts the parameter value.
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()