Class BasicDataSource

java.lang.Object
org.datanucleus.store.rdbms.datasource.dbcp2.BasicDataSource
All Implemented Interfaces:
AutoCloseable, Wrapper, MBeanRegistration, CommonDataSource, DataSource, BasicDataSourceMXBean
public class BasicDataSource extends Object implements DataSource, BasicDataSourceMXBean, MBeanRegistration, AutoCloseable

Basic implementation of javax.sql.DataSource that is configured via JavaBeans properties. This is not the only way to combine the commons-dbcp2 and commons-pool2 packages, but provides a "one stop shopping" solution for basic requirements.

Since:
2.0

  • Field Details

    • log

      private static final org.datanucleus.util.NucleusLogger log

    • defaultAutoCommit

      private volatile Boolean defaultAutoCommit
      The default auto-commit state of connections created by this pool.

    • defaultReadOnly

      private transient Boolean defaultReadOnly
      The default read-only state of connections created by this pool.

    • defaultTransactionIsolation

      private volatile int defaultTransactionIsolation
      The default TransactionIsolation state of connections created by this pool.

    • defaultQueryTimeoutSeconds

      private Integer defaultQueryTimeoutSeconds

    • defaultCatalog

      private volatile String defaultCatalog
      The default "catalog" of connections created by this pool.

    • defaultSchema

      private volatile String defaultSchema
      The default "schema" of connections created by this pool.

    • cacheState

      private boolean cacheState
      The property that controls if the pooled connections cache some state rather than query the database for current state to improve performance.

    • driver

      private Driver driver
      The instance of the JDBC Driver to use.

    • driverClassName

      private String driverClassName
      The fully qualified Java class name of the JDBC driver to be used.

    • driverClassLoader

      private ClassLoader driverClassLoader
      The class loader instance to use to load the JDBC driver. If not specified, Class.forName(String) is used to load the JDBC driver. If specified, Class.forName(String, boolean, ClassLoader) is used.

    • lifo

      private boolean lifo
      True means that borrowObject returns the most recently used ("last in") connection in the pool (if there are idle connections available). False means that the pool behaves as a FIFO queue - connections are taken from the idle instance pool in the order that they are returned to the pool.

    • maxTotal

      private int maxTotal
      The maximum number of active connections that can be allocated from this pool at the same time, or negative for no limit.

    • maxIdle

      private int maxIdle
      The maximum number of connections that can remain idle in the pool, without extra ones being destroyed, or negative for no limit. If maxIdle is set too low on heavily loaded systems it is possible you will see connections being closed and almost immediately new connections being opened. This is a result of the active threads momentarily closing connections faster than they are opening them, causing the number of idle connections to rise above maxIdle. The best value for maxIdle for heavily loaded system will vary but the default is a good starting point.

    • minIdle

      private int minIdle
      The minimum number of active connections that can remain idle in the pool, without extra ones being created when the evictor runs, or 0 to create none. The pool attempts to ensure that minIdle connections are available when the idle object evictor runs. The value of this property has no effect unless timeBetweenEvictionRunsMillis has a positive value.

    • initialSize

      private int initialSize
      The initial number of connections that are created when the pool is started.

    • maxWaitMillis

      private long maxWaitMillis
      The maximum number of milliseconds that the pool will wait (when there are no available connections) for a connection to be returned before throwing an exception, or invalid input: '<'= 0 to wait indefinitely.

    • poolPreparedStatements

      private boolean poolPreparedStatements
      Prepared statement pooling for this pool. When this property is set to true both PreparedStatements and CallableStatements are pooled.

    • maxOpenPreparedStatements

      private int maxOpenPreparedStatements

      The maximum number of open statements that can be allocated from the statement pool at the same time, or negative for no limit. Since a connection usually only uses one or two statements at a time, this is mostly used to help detect resource leaks.

      Note: As of version 1.3, CallableStatements (those produced by Connection.prepareCall(String)) are pooled along with PreparedStatements (produced by Connection.prepareStatement(String)) and maxOpenPreparedStatements limits the total number of prepared or callable statements that may be in use at a given time.

    • testOnCreate

      private boolean testOnCreate
      The indication of whether objects will be validated as soon as they have been created by the pool. If the object fails to validate, the borrow operation that triggered the creation will fail.

    • testOnBorrow

      private boolean testOnBorrow
      The indication of whether objects will be validated before being borrowed from the pool. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.

    • testOnReturn

      private boolean testOnReturn
      The indication of whether objects will be validated before being returned to the pool.

    • timeBetweenEvictionRunsMillis

      private long timeBetweenEvictionRunsMillis
      The number of milliseconds to sleep between runs of the idle object evictor thread. When non-positive, no idle object evictor thread will be run.

    • numTestsPerEvictionRun

      private int numTestsPerEvictionRun
      The number of objects to examine during each run of the idle object evictor thread (if any).

    • minEvictableIdleTimeMillis

      private long minEvictableIdleTimeMillis
      The minimum amount of time an object may sit idle in the pool before it is eligible for eviction by the idle object evictor (if any).

    • softMinEvictableIdleTimeMillis

      private long softMinEvictableIdleTimeMillis
      The minimum amount of time a connection may sit idle in the pool before it is eligible for eviction by the idle object evictor, with the extra condition that at least "minIdle" connections remain in the pool. Note that minEvictableIdleTimeMillis takes precedence over this parameter. See getSoftMinEvictableIdleTimeMillis().

    • evictionPolicyClassName

      private String evictionPolicyClassName

    • testWhileIdle

      private boolean testWhileIdle
      The indication of whether objects will be validated by the idle object evictor (if any). If an object fails to validate, it will be dropped from the pool.

    • password

      private volatile String password
      The connection password to be passed to our JDBC driver to establish a connection.

    • url

      private String url
      The connection URL to be passed to our JDBC driver to establish a connection.

    • userName

      private String userName
      The connection user name to be passed to our JDBC driver to establish a connection.

    • validationQuery

      private volatile String validationQuery
      The SQL query that will be used to validate connections from this pool before returning them to the caller. If specified, this query MUST be an SQL SELECT statement that returns at least one row. If not specified, Connection.isValid(int) will be used to validate connections.

    • validationQueryTimeoutSeconds

      private volatile int validationQueryTimeoutSeconds
      Timeout in seconds before connection validation queries fail.

    • connectionFactoryClassName

      private String connectionFactoryClassName
      The fully qualified Java class name of a ConnectionFactory implementation.

    • connectionInitSqls

      private volatile List<String> connectionInitSqls
      These SQL statements run once after a Connection is created.

      This property can be used for example to run ALTER SESSION SET NLS_SORT=XCYECH in an Oracle Database only once after connection creation.

    • accessToUnderlyingConnectionAllowed

      private boolean accessToUnderlyingConnectionAllowed
      Controls access to the underlying connection.

    • maxConnLifetimeMillis

      private long maxConnLifetimeMillis

    • logExpiredConnections

      private boolean logExpiredConnections

    • jmxName

      private String jmxName

    • autoCommitOnReturn

      private boolean autoCommitOnReturn

    • rollbackOnReturn

      private boolean rollbackOnReturn

    • disconnectionSqlCodes

      private volatile Set<String> disconnectionSqlCodes

    • fastFailValidation

      private boolean fastFailValidation

    • connectionPool

      private volatile GenericObjectPool<PoolableConnection> connectionPool
      The object pool that internally manages our connections.

    • connectionProperties

      private Properties connectionProperties
      The connection properties that will be sent to our JDBC driver when establishing new connections. NOTE - The "user" and "password" properties will be passed explicitly, so they do not need to be included here.

    • dataSource

      private volatile DataSource dataSource
      The data source we will use to manage connections. This object should be acquired ONLY by calls to the createDataSource() method.

    • logWriter

      private volatile PrintWriter logWriter
      The PrintWriter to which log messages should be directed.

    • abandonedConfig

      private AbandonedConfig abandonedConfig

    • closed

      private boolean closed

    • registeredJmxObjectName

      private ObjectNameWrapper registeredJmxObjectName
      Actual name under which this component has been registered.

  • Constructor Details

    • BasicDataSource

      public BasicDataSource()

  • Method Details

    • validateConnectionFactory

      protected static void validateConnectionFactory(PoolableConnectionFactory connectionFactory) throws Exception
      Throws:
      Exception

    • addConnectionProperty

      public void addConnectionProperty(String name, String value)
      Adds a custom connection property to the set that will be passed to our JDBC driver. This MUST be called before the first connection is retrieved (along with all the other configuration property setters). Calls to this method after the connection pool has been initialized have no effect.
      Parameters:
      name - Name of the custom connection property
      value - Value of the custom connection property

    • close

      public void close() throws SQLException

      Closes and releases all idle connections that are currently stored in the connection pool associated with this data source.

      Connections that are checked out to clients when this method is invoked are not affected. When client applications subsequently invoke Connection.close() to return these connections to the pool, the underlying JDBC connections are closed.

      Attempts to acquire connections using getConnection() after this method has been invoked result in SQLExceptions.

      This method is idempotent - i.e., closing an already closed BasicDataSource has no effect and does not generate exceptions.

      Specified by:
      close in interface AutoCloseable
      Throws:
      SQLException - if an error occurs closing idle connections

    • closeConnectionPool

      private void closeConnectionPool()
      Closes the connection pool, silently swallowing any exception that occurs.

    • createConnectionFactory

      protected ConnectionFactory createConnectionFactory() throws SQLException
      Creates a JDBC connection factory for this data source. The JDBC driver is loaded using the following algorithm:
      1. If a Driver instance has been specified via setDriver(Driver) use it
      2. If no Driver instance was specified and driverClassName is specified that class is loaded using the ClassLoader of this class or, if driverClassLoader is set, driverClassName is loaded with the specified ClassLoader.
      3. If driverClassName is specified and the previous attempt fails, the class is loaded using the context class loader of the current thread.
      4. If a driver still isn't loaded one is loaded via the DriverManager using the specified url.

      This method exists so subclasses can replace the implementation class.

      Returns:
      A new connection factory.
      Throws:
      SQLException - If the connection factort cannot be created

    • createConnectionPool

      protected void createConnectionPool(PoolableConnectionFactory factory)
      Creates a connection pool for this datasource. This method only exists so subclasses can replace the implementation class.

      This implementation configures all pool properties other than timeBetweenEvictionRunsMillis. Setting that property is deferred to startPoolMaintenance(), since setting timeBetweenEvictionRunsMillis to a positive value causes GenericObjectPool's eviction timer to be started.

      Parameters:
      factory - The factory to use to create new connections for this pool.

    • createDataSource

      protected DataSource createDataSource() throws SQLException

      Creates (if necessary) and return the internal data source we are using to manage our connections.

      Returns:
      The current internal DataSource or a newly created instance if it has not yet been created.
      Throws:
      SQLException - if the object pool cannot be created.

    • createDataSourceInstance

      protected DataSource createDataSourceInstance() throws SQLException
      Creates the actual data source instance. This method only exists so that subclasses can replace the implementation class.
      Returns:
      A new DataSource instance
      Throws:
      SQLException - if unable to create a datasource instance

    • createObjectPool

      protected GenericObjectPool<PoolableConnection> createObjectPool(PoolableConnectionFactory factory, GenericObjectPoolConfig<PoolableConnection> poolConfig, AbandonedConfig abandonedConfig)
      Creates an object pool used to provide pooling support for JDBC connections.
      Parameters:
      factory - the object factory
      poolConfig - the object pool configuration
      abandonedConfig - the abandoned objects configuration
      Returns:
      a non-null instance

    • createPoolableConnectionFactory

      protected PoolableConnectionFactory createPoolableConnectionFactory(ConnectionFactory driverConnectionFactory) throws SQLException
      Creates the PoolableConnectionFactory and attaches it to the connection pool. This method only exists so subclasses can replace the default implementation.
      Parameters:
      driverConnectionFactory - JDBC connection factory
      Returns:
      A new PoolableConnectionFactory configured with the current configuration of this BasicDataSource
      Throws:
      SQLException - if an error occurs creating the PoolableConnectionFactory

    • evict

      public void evict() throws Exception
      Manually evicts idle connections
      Throws:
      Exception - when there is a problem evicting idle objects.

    • getAbandonedLogWriter

      public PrintWriter getAbandonedLogWriter()
      Gets the print writer used by this configuration to log information on abandoned objects.
      Returns:
      The print writer used by this configuration to log information on abandoned objects.

    • getAbandonedUsageTracking

      public boolean getAbandonedUsageTracking()
      If the connection pool implements UsageTracking, should the connection pool record a stack trace every time a method is called on a pooled connection and retain the most recent stack trace to aid debugging of abandoned connections?
      Specified by:
      getAbandonedUsageTracking in interface BasicDataSourceMXBean
      Returns:
      true if usage tracking is enabled

    • getAutoCommitOnReturn

      public boolean getAutoCommitOnReturn()
      Returns the value of the flag that controls whether or not connections being returned to the pool will be checked and configured with Connection.setAutoCommit(true) if the auto commit setting is false when the connection is returned. It is true by default.
      Returns:
      Whether or not connections being returned to the pool will be checked and configured with auto-commit.

    • getCacheState

      public boolean getCacheState()
      Returns the state caching flag.
      Specified by:
      getCacheState in interface BasicDataSourceMXBean
      Returns:
      the state caching flag

    • getConnection

      public Connection getConnection() throws SQLException
      Creates (if necessary) and return a connection to the database.
      Specified by:
      getConnection in interface DataSource
      Returns:
      a database connection
      Throws:
      SQLException - if a database access error occurs

    • getConnection

      public Connection getConnection(String user, String pass) throws SQLException
      BasicDataSource does NOT support this method.
      Specified by:
      getConnection in interface DataSource
      Parameters:
      user - Database user on whose behalf the Connection is being made
      pass - The database user's password
      Returns:
      nothing - always throws UnsupportedOperationException
      Throws:
      UnsupportedOperationException - always thrown.
      SQLException - if a database access error occurs

    • getConnectionFactoryClassName

      public String getConnectionFactoryClassName()
      Returns the ConnectionFactoryClassName that has been configured for use by this pool.

      Note: This getter only returns the last value set by a call to setConnectionFactoryClassName(String).

      Returns:
      the ConnectionFactoryClassName that has been configured for use by this pool.
      Since:
      2.7.0

    • getConnectionInitSqls

      public List<String> getConnectionInitSqls()
      Returns the list of SQL statements executed when a physical connection is first created. Returns an empty list if there are no initialization statements configured.
      Returns:
      initialization SQL statements

    • getConnectionInitSqlsAsArray

      public String[] getConnectionInitSqlsAsArray()
      Provides the same data as getConnectionInitSqls() but in an array so it is accessible via JMX.
      Specified by:
      getConnectionInitSqlsAsArray in interface BasicDataSourceMXBean
      Returns:
      getConnectionInitSqlsAsArray()

    • getConnectionPool

      protected GenericObjectPool<PoolableConnection> getConnectionPool()

    • getConnectionProperties

      Properties getConnectionProperties()

    • getDefaultAutoCommit

      public Boolean getDefaultAutoCommit()
      Returns the default auto-commit property.
      Specified by:
      getDefaultAutoCommit in interface BasicDataSourceMXBean
      Returns:
      true if default auto-commit is enabled

    • getDefaultCatalog

      public String getDefaultCatalog()
      Returns the default catalog.
      Specified by:
      getDefaultCatalog in interface BasicDataSourceMXBean
      Returns:
      the default catalog

    • getDefaultQueryTimeout

      public Integer getDefaultQueryTimeout()
      Gets the default query timeout that will be used for Statements created from this connection. null means that the driver default will be used.
      Returns:
      The default query timeout in seconds.

    • getDefaultReadOnly

      public Boolean getDefaultReadOnly()
      Returns the default readOnly property.
      Specified by:
      getDefaultReadOnly in interface BasicDataSourceMXBean
      Returns:
      true if connections are readOnly by default

    • getDefaultSchema

      public String getDefaultSchema()
      Returns the default schema.
      Specified by:
      getDefaultSchema in interface BasicDataSourceMXBean
      Returns:
      the default schema.
      Since:
      2.5.0

    • getDefaultTransactionIsolation

      public int getDefaultTransactionIsolation()
      Returns the default transaction isolation state of returned connections.
      Specified by:
      getDefaultTransactionIsolation in interface BasicDataSourceMXBean
      Returns:
      the default value for transaction isolation state
      See Also:

    • getDisconnectionSqlCodes

      public Set<String> getDisconnectionSqlCodes()
      Returns the set of SQL_STATE codes considered to signal fatal conditions.
      Returns:
      fatal disconnection state codes
      Since:
      2.1
      See Also:

    • getDisconnectionSqlCodesAsArray

      public String[] getDisconnectionSqlCodesAsArray()
      Provides the same data as getDisconnectionSqlCodes() but in an array so it is accessible via JMX.
      Specified by:
      getDisconnectionSqlCodesAsArray in interface BasicDataSourceMXBean
      Returns:
      getDisconnectionSqlCodesAsArray()
      Since:
      2.1

    • getDriver

      public Driver getDriver()
      Returns the JDBC Driver that has been configured for use by this pool.

      Note: This getter only returns the last value set by a call to setDriver(Driver). It does not return any driver instance that may have been created from the value set via setDriverClassName(String).

      Returns:
      the JDBC Driver that has been configured for use by this pool

    • getDriverClassLoader

      public ClassLoader getDriverClassLoader()
      Returns the class loader specified for loading the JDBC driver. Returns null if no class loader has been explicitly specified.

      Note: This getter only returns the last value set by a call to setDriverClassLoader(ClassLoader). It does not return the class loader of any driver that may have been set via setDriver(Driver).

      Returns:
      The class loader specified for loading the JDBC driver.

    • getDriverClassName

      public String getDriverClassName()
      Returns the JDBC driver class name.

      Note: This getter only returns the last value set by a call to setDriverClassName(String). It does not return the class name of any driver that may have been set via setDriver(Driver).

      Specified by:
      getDriverClassName in interface BasicDataSourceMXBean
      Returns:
      the JDBC driver class name

    • getEnableAutoCommitOnReturn

      @Deprecated public boolean getEnableAutoCommitOnReturn()
      Deprecated.
      Use getAutoCommitOnReturn().
      Returns the value of the flag that controls whether or not connections being returned to the pool will be checked and configured with Connection.setAutoCommit(true) if the auto commit setting is false when the connection is returned. It is true by default.
      Returns:
      Whether or not connections being returned to the pool will be checked and configured with auto-commit.

    • getEvictionPolicyClassName

      public String getEvictionPolicyClassName()
      Gets the EvictionPolicy implementation in use with this connection pool.
      Returns:
      The EvictionPolicy implementation in use with this connection pool.

    • getFastFailValidation

      public boolean getFastFailValidation()
      True means that validation will fail immediately for connections that have previously thrown SQLExceptions with SQL_STATE indicating fatal disconnection errors.
      Specified by:
      getFastFailValidation in interface BasicDataSourceMXBean
      Returns:
      true if connections created by this datasource will fast fail validation.
      Since:
      2.1
      See Also:

    • getInitialSize

      public int getInitialSize()
      Returns the initial size of the connection pool.
      Specified by:
      getInitialSize in interface BasicDataSourceMXBean
      Returns:
      the number of connections created when the pool is initialized

    • getJmxName

      public String getJmxName()
      Returns the JMX name that has been requested for this DataSource. If the requested name is not valid, an alternative may be chosen.
      Returns:
      The JMX name that has been requested for this DataSource.

    • getLifo

      public boolean getLifo()
      Returns the LIFO property.
      Specified by:
      getLifo in interface BasicDataSourceMXBean
      Returns:
      true if connection pool behaves as a LIFO queue.

    • getLogAbandoned

      public boolean getLogAbandoned()

      Flag to log stack traces for application code which abandoned a Statement or Connection.

      Defaults to false.

      Logging of abandoned Statements and Connections adds overhead for every Connection open or new Statement because a stack trace has to be generated.

      Specified by:
      getLogAbandoned in interface BasicDataSourceMXBean
      Returns:
      getLogAbandoned()

    • getLogExpiredConnections

      public boolean getLogExpiredConnections()
      When getMaxConnLifetimeMillis() is set to limit connection lifetime, this property determines whether or not log messages are generated when the pool closes connections due to maximum lifetime exceeded.
      Specified by:
      getLogExpiredConnections in interface BasicDataSourceMXBean
      Returns:
      getLogExpiredConnections()
      Since:
      2.1

    • getLoginTimeout

      public int getLoginTimeout() throws SQLException
      BasicDataSource does NOT support this method.

      Returns the login timeout (in seconds) for connecting to the database.

      Calls createDataSource(), so has the side effect of initializing the connection pool.

      Specified by:
      getLoginTimeout in interface CommonDataSource
      Specified by:
      getLoginTimeout in interface DataSource
      Returns:
      login timeout in seconds
      Throws:
      SQLException - if a database access error occurs
      UnsupportedOperationException - If the DataSource implementation does not support the login timeout feature.

    • getLogWriter

      public PrintWriter getLogWriter() throws SQLException

      Returns the log writer being used by this data source.

      Calls createDataSource(), so has the side effect of initializing the connection pool.

      Specified by:
      getLogWriter in interface CommonDataSource
      Specified by:
      getLogWriter in interface DataSource
      Returns:
      log writer in use
      Throws:
      SQLException - if a database access error occurs

    • getMaxConnLifetimeMillis

      public long getMaxConnLifetimeMillis()
      Returns the maximum permitted lifetime of a connection in milliseconds. A value of zero or less indicates an infinite lifetime.
      Specified by:
      getMaxConnLifetimeMillis in interface BasicDataSourceMXBean
      Returns:
      getMaxConnLifetimeMillis()

    • getMaxIdle

      public int getMaxIdle()

      Returns the maximum number of connections that can remain idle in the pool. Excess idle connections are destroyed on return to the pool.

      A negative value indicates that there is no limit

      Specified by:
      getMaxIdle in interface BasicDataSourceMXBean
      Returns:
      the maximum number of idle connections

    • getMaxOpenPreparedStatements

      public int getMaxOpenPreparedStatements()
      Gets the value of the maxOpenPreparedStatements property.
      Specified by:
      getMaxOpenPreparedStatements in interface BasicDataSourceMXBean
      Returns:
      the maximum number of open statements

    • getMaxTotal

      public int getMaxTotal()

      Returns the maximum number of active connections that can be allocated at the same time.

      A negative number means that there is no limit.

      Specified by:
      getMaxTotal in interface BasicDataSourceMXBean
      Returns:
      the maximum number of active connections

    • getMaxWaitMillis

      public long getMaxWaitMillis()
      Returns the maximum number of milliseconds that the pool will wait for a connection to be returned before throwing an exception. A value less than or equal to zero means the pool is set to wait indefinitely.
      Specified by:
      getMaxWaitMillis in interface BasicDataSourceMXBean
      Returns:
      the maxWaitMillis property value

    • getMinEvictableIdleTimeMillis

      public long getMinEvictableIdleTimeMillis()
      Returns the minEvictableIdleTimeMillis property.
      Specified by:
      getMinEvictableIdleTimeMillis in interface BasicDataSourceMXBean
      Returns:
      the value of the minEvictableIdleTimeMillis property
      See Also:

    • getMinIdle

      public int getMinIdle()
      Returns the minimum number of idle connections in the pool. The pool attempts to ensure that minIdle connections are available when the idle object evictor runs. The value of this property has no effect unless timeBetweenEvictionRunsMillis has a positive value.
      Specified by:
      getMinIdle in interface BasicDataSourceMXBean
      Returns:
      the minimum number of idle connections
      See Also:

    • getNumActive

      public int getNumActive()
      [Read Only] The current number of active connections that have been allocated from this data source.
      Specified by:
      getNumActive in interface BasicDataSourceMXBean
      Returns:
      the current number of active connections

    • getNumIdle

      public int getNumIdle()
      [Read Only] The current number of idle connections that are waiting to be allocated from this data source.
      Specified by:
      getNumIdle in interface BasicDataSourceMXBean
      Returns:
      the current number of idle connections

    • getNumTestsPerEvictionRun

      public int getNumTestsPerEvictionRun()
      Returns the value of the numTestsPerEvictionRun property.
      Specified by:
      getNumTestsPerEvictionRun in interface BasicDataSourceMXBean
      Returns:
      the number of objects to examine during idle object evictor runs
      See Also:

    • getParentLogger

      public Logger getParentLogger() throws SQLFeatureNotSupportedException
      Specified by:
      getParentLogger in interface CommonDataSource
      Throws:
      SQLFeatureNotSupportedException

    • getPassword

      public String getPassword()
      Returns the password passed to the JDBC driver to establish connections.
      Specified by:
      getPassword in interface BasicDataSourceMXBean
      Returns:
      the connection password

    • getRegisteredJmxName

      protected ObjectName getRegisteredJmxName()

    • getRemoveAbandonedOnBorrow

      public boolean getRemoveAbandonedOnBorrow()

      Flag to remove abandoned connections if they exceed the removeAbandonedTimeout when borrowObject is invoked.

      The default value is false.

      If set to true a connection is considered abandoned and eligible for removal if it has not been used for more than removeAbandonedTimeout seconds.

      Abandoned connections are identified and removed when getConnection() is invoked and all of the following conditions hold:

      Specified by:
      getRemoveAbandonedOnBorrow in interface BasicDataSourceMXBean
      Returns:
      getRemoveAbandonedOnBorrow()
      See Also:

    • getRemoveAbandonedOnMaintenance

      public boolean getRemoveAbandonedOnMaintenance()

      Flag to remove abandoned connections if they exceed the removeAbandonedTimeout during pool maintenance.

      The default value is false.

      If set to true a connection is considered abandoned and eligible for removal if it has not been used for more than removeAbandonedTimeout seconds.

      Specified by:
      getRemoveAbandonedOnMaintenance in interface BasicDataSourceMXBean
      Returns:
      getRemoveAbandonedOnMaintenance()
      See Also:

    • getRemoveAbandonedTimeout

      public int getRemoveAbandonedTimeout()

      Timeout in seconds before an abandoned connection can be removed.

      Creating a Statement, PreparedStatement or CallableStatement or using one of these to execute a query (using one of the execute methods) resets the lastUsed property of the parent connection.

      Abandoned connection cleanup happens when:

      The default value is 300 seconds.

      Specified by:
      getRemoveAbandonedTimeout in interface BasicDataSourceMXBean
      Returns:
      getRemoveAbandonedTimeout()

    • getRollbackOnReturn

      public boolean getRollbackOnReturn()
      Gets the current value of the flag that controls whether a connection will be rolled back when it is returned to the pool if auto commit is not enabled and the connection is not read only.
      Returns:
      whether a connection will be rolled back when it is returned to the pool.

    • getSoftMinEvictableIdleTimeMillis

      public long getSoftMinEvictableIdleTimeMillis()

      Returns the minimum amount of time a connection may sit idle in the pool before it is eligible for eviction by the idle object evictor, with the extra condition that at least "minIdle" connections remain in the pool.

      When minEvictableIdleTimeMillis is set to a positive value, minEvictableIdleTimeMillis is examined first by the idle connection evictor - i.e. when idle connections are visited by the evictor, idle time is first compared against minEvictableIdleTimeMillis (without considering the number of idle connections in the pool) and then against softMinEvictableIdleTimeMillis, including the minIdle, constraint.

      Specified by:
      getSoftMinEvictableIdleTimeMillis in interface BasicDataSourceMXBean
      Returns:
      minimum amount of time a connection may sit idle in the pool before it is eligible for eviction, assuming there are minIdle idle connections in the pool

    • getTestOnBorrow

      public boolean getTestOnBorrow()
      Returns the testOnBorrow property.
      Specified by:
      getTestOnBorrow in interface BasicDataSourceMXBean
      Returns:
      true if objects are validated before being borrowed from the pool
      See Also:

    • getTestOnCreate

      public boolean getTestOnCreate()
      Returns the testOnCreate property.
      Specified by:
      getTestOnCreate in interface BasicDataSourceMXBean
      Returns:
      true if objects are validated immediately after they are created by the pool
      See Also:

    • getTestOnReturn

      public boolean getTestOnReturn()
      Returns the value of the testOnReturn property.
      Returns:
      true if objects are validated before being returned to the pool
      See Also:

    • getTestWhileIdle

      public boolean getTestWhileIdle()
      Returns the value of the testWhileIdle property.
      Specified by:
      getTestWhileIdle in interface BasicDataSourceMXBean
      Returns:
      true if objects examined by the idle object evictor are validated
      See Also:

    • getTimeBetweenEvictionRunsMillis

      public long getTimeBetweenEvictionRunsMillis()
      Returns the value of the timeBetweenEvictionRunsMillis property.
      Specified by:
      getTimeBetweenEvictionRunsMillis in interface BasicDataSourceMXBean
      Returns:
      the time (in milliseconds) between evictor runs
      See Also:

    • getUrl

      public String getUrl()
      Returns the JDBC connection url property.
      Specified by:
      getUrl in interface BasicDataSourceMXBean
      Returns:
      the url passed to the JDBC driver to establish connections

    • getUsername

      public String getUsername()
      Returns the JDBC connection userName property.
      Specified by:
      getUsername in interface BasicDataSourceMXBean
      Returns:
      the userName passed to the JDBC driver to establish connections

    • getValidationQuery

      public String getValidationQuery()
      Returns the validation query used to validate connections before returning them.
      Specified by:
      getValidationQuery in interface BasicDataSourceMXBean
      Returns:
      the SQL validation query
      See Also:

    • getValidationQueryTimeout

      public int getValidationQueryTimeout()
      Returns the validation query timeout.
      Specified by:
      getValidationQueryTimeout in interface BasicDataSourceMXBean
      Returns:
      the timeout in seconds before connection validation queries fail.

    • invalidateConnection

      public void invalidateConnection(Connection connection) throws IllegalStateException
      Manually invalidates a connection, effectively requesting the pool to try to close it, remove it from the pool and reclaim pool capacity.
      Parameters:
      connection - The Connection to invalidate.
      Throws:
      IllegalStateException - if invalidating the connection failed.
      Since:
      2.1

    • isAccessToUnderlyingConnectionAllowed

      public boolean isAccessToUnderlyingConnectionAllowed()
      Returns the value of the accessToUnderlyingConnectionAllowed property.
      Specified by:
      isAccessToUnderlyingConnectionAllowed in interface BasicDataSourceMXBean
      Returns:
      true if access to the underlying connection is allowed, false otherwise.

    • isClosed

      public boolean isClosed()
      If true, this data source is closed and no more connections can be retrieved from this data source.
      Specified by:
      isClosed in interface BasicDataSourceMXBean
      Returns:
      true, if the data source is closed; false otherwise

    • isEmpty

      private boolean isEmpty(String value)
      Delegates in a null-safe manner to String.isEmpty().
      Parameters:
      value - the string to test, may be null.
      Returns:
      boolean false if value is null, otherwise String.isEmpty().

    • isPoolPreparedStatements

      public boolean isPoolPreparedStatements()
      Returns true if we are pooling statements.
      Specified by:
      isPoolPreparedStatements in interface BasicDataSourceMXBean
      Returns:
      true if prepared and callable statements are pooled

    • isWrapperFor

      public boolean isWrapperFor(Class<?> iface) throws SQLException
      Specified by:
      isWrapperFor in interface Wrapper
      Throws:
      SQLException

    • jmxRegister

      private void jmxRegister()

    • log

      protected void log(String message)

    • log

      protected void log(String message, Throwable throwable)
      Logs the given throwable.
      Parameters:
      message - TODO
      throwable - the throwable.
      Since:
      2.7.0

    • postDeregister

      public void postDeregister()
      Specified by:
      postDeregister in interface MBeanRegistration

    • postRegister

      public void postRegister(Boolean registrationDone)
      Specified by:
      postRegister in interface MBeanRegistration

    • preDeregister

      public void preDeregister() throws Exception
      Specified by:
      preDeregister in interface MBeanRegistration
      Throws:
      Exception

    • preRegister

      public ObjectName preRegister(MBeanServer server, ObjectName objectName)
      Specified by:
      preRegister in interface MBeanRegistration

    • removeConnectionProperty

      public void removeConnectionProperty(String name)
      Removes a custom connection property.
      Parameters:
      name - Name of the custom connection property to remove
      See Also:

    • setAbandonedLogWriter

      public void setAbandonedLogWriter(PrintWriter logWriter)
      Sets the print writer to be used by this configuration to log information on abandoned objects.
      Parameters:
      logWriter - The new log writer

    • setAbandonedUsageTracking

      public void setAbandonedUsageTracking(boolean usageTracking)
      If the connection pool implements UsageTracking, configure whether the connection pool should record a stack trace every time a method is called on a pooled connection and retain the most recent stack trace to aid debugging of abandoned connections.
      Parameters:
      usageTracking - A value of true will enable the recording of a stack trace on every use of a pooled connection

    • setAccessToUnderlyingConnectionAllowed

      public void setAccessToUnderlyingConnectionAllowed(boolean allow)

      Sets the value of the accessToUnderlyingConnectionAllowed property. It controls if the PoolGuard allows access to the underlying connection. (Default: false)

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      allow - Access to the underlying connection is granted when true.

    • setAutoCommitOnReturn

      public void setAutoCommitOnReturn(boolean autoCommitOnReturn)
      Sets the value of the flag that controls whether or not connections being returned to the pool will be checked and configured with Connection.setAutoCommit(true) if the auto commit setting is false when the connection is returned. It is true by default.
      Parameters:
      autoCommitOnReturn - Whether or not connections being returned to the pool will be checked and configured with auto-commit.
      Since:
      2.6.0

    • setCacheState

      public void setCacheState(boolean cacheState)
      Sets the state caching flag.
      Parameters:
      cacheState - The new value for the state caching flag

    • setConnectionFactoryClassName

      public void setConnectionFactoryClassName(String connectionFactoryClassName)
      Sets the ConnectionFactory class name.
      Parameters:
      connectionFactoryClassName - A class name.
      Since:
      2.7.0

    • setConnectionInitSqls

      public void setConnectionInitSqls(Collection<String> connectionInitSqls)
      Sets the list of SQL statements to be executed when a physical connection is first created.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      connectionInitSqls - Collection of SQL statements to execute on connection creation

    • setConnectionProperties

      public void setConnectionProperties(String connectionProperties)
      Sets the connection properties passed to driver.connect(...).

      Format of the string must be [propertyName=property;]*

      NOTE - The "user" and "password" properties will be added explicitly, so they do not need to be included here.

      Parameters:
      connectionProperties - the connection properties used to create new connections

    • setDefaultAutoCommit

      public void setDefaultAutoCommit(Boolean defaultAutoCommit)

      Sets default auto-commit state of connections returned by this datasource.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      defaultAutoCommit - default auto-commit value

    • setDefaultCatalog

      public void setDefaultCatalog(String defaultCatalog)

      Sets the default catalog.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      defaultCatalog - the default catalog

    • setDefaultQueryTimeout

      public void setDefaultQueryTimeout(Integer defaultQueryTimeoutSeconds)
      Sets the default query timeout that will be used for Statements created from this connection. null means that the driver default will be used.
      Parameters:
      defaultQueryTimeoutSeconds - The default query timeout in seconds.

    • setDefaultReadOnly

      public void setDefaultReadOnly(Boolean defaultReadOnly)

      Sets defaultReadonly property.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      defaultReadOnly - default read-only value

    • setDefaultSchema

      public void setDefaultSchema(String defaultSchema)

      Sets the default schema.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      defaultSchema - the default catalog
      Since:
      2.5.0

    • setDefaultTransactionIsolation

      public void setDefaultTransactionIsolation(int defaultTransactionIsolation)

      Sets the default transaction isolation state for returned connections.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      defaultTransactionIsolation - the default transaction isolation state
      See Also:

    • setDisconnectionSqlCodes

      public void setDisconnectionSqlCodes(Collection<String> disconnectionSqlCodes)
      Sets the SQL_STATE codes considered to signal fatal conditions.

      Overrides the defaults in Utils.DISCONNECTION_SQL_CODES (plus anything starting with Utils.DISCONNECTION_SQL_CODE_PREFIX). If this property is non-null and getFastFailValidation() is true, whenever connections created by this datasource generate exceptions with SQL_STATE codes in this list, they will be marked as "fatally disconnected" and subsequent validations will fail fast (no attempt at isValid or validation query).

      If getFastFailValidation() is false setting this property has no effect.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      disconnectionSqlCodes - SQL_STATE codes considered to signal fatal conditions
      Since:
      2.1

    • setDriver

      public void setDriver(Driver driver)
      Sets the JDBC Driver instance to use for this pool.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      driver - The JDBC Driver instance to use for this pool.

    • setDriverClassLoader

      public void setDriverClassLoader(ClassLoader driverClassLoader)

      Sets the class loader to be used to load the JDBC driver.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      driverClassLoader - the class loader with which to load the JDBC driver

    • setDriverClassName

      public void setDriverClassName(String driverClassName)

      Sets the JDBC driver class name.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      driverClassName - the class name of the JDBC driver

    • setEnableAutoCommitOnReturn

      @Deprecated public void setEnableAutoCommitOnReturn(boolean autoCommitOnReturn)
      Deprecated.
      Use setAutoCommitOnReturn(boolean).
      Sets the value of the flag that controls whether or not connections being returned to the pool will be checked and configured with Connection.setAutoCommit(true) if the auto commit setting is false when the connection is returned. It is true by default.
      Parameters:
      autoCommitOnReturn - Whether or not connections being returned to the pool will be checked and configured with auto-commit.

    • setEvictionPolicyClassName

      public void setEvictionPolicyClassName(String evictionPolicyClassName)
      Sets the EvictionPolicy implementation to use with this connection pool.
      Parameters:
      evictionPolicyClassName - The fully qualified class name of the EvictionPolicy implementation

    • setFastFailValidation

      public void setFastFailValidation(boolean fastFailValidation)
      Parameters:
      fastFailValidation - true means connections created by this factory will fast fail validation
      Since:
      2.1
      See Also:

    • setInitialSize

      public void setInitialSize(int initialSize)

      Sets the initial size of the connection pool.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      initialSize - the number of connections created when the pool is initialized

    • setJmxName

      public void setJmxName(String jmxName)
      Sets the JMX name that has been requested for this DataSource. If the requested name is not valid, an alternative may be chosen. This DataSource will attempt to register itself using this name. If another component registers this DataSource with JMX and this name is valid this name will be used in preference to any specified by the other component.
      Parameters:
      jmxName - The JMX name that has been requested for this DataSource

    • setLifo

      public void setLifo(boolean lifo)
      Sets the LIFO property. True means the pool behaves as a LIFO queue; false means FIFO.
      Parameters:
      lifo - the new value for the LIFO property

    • setLogAbandoned

      public void setLogAbandoned(boolean logAbandoned)
      Parameters:
      logAbandoned - new logAbandoned property value

    • setLogExpiredConnections

      public void setLogExpiredConnections(boolean logExpiredConnections)
      When getMaxConnLifetimeMillis() is set to limit connection lifetime, this property determines whether or not log messages are generated when the pool closes connections due to maximum lifetime exceeded. Set this property to false to suppress log messages when connections expire.
      Parameters:
      logExpiredConnections - Whether or not log messages are generated when the pool closes connections due to maximum lifetime exceeded.

    • setLoginTimeout

      public void setLoginTimeout(int loginTimeout) throws SQLException
      BasicDataSource does NOT support this method.

      Set the login timeout (in seconds) for connecting to the database.

      Calls createDataSource(), so has the side effect of initializing the connection pool.

      Specified by:
      setLoginTimeout in interface CommonDataSource
      Specified by:
      setLoginTimeout in interface DataSource
      Parameters:
      loginTimeout - The new login timeout, or zero for no timeout
      Throws:
      UnsupportedOperationException - If the DataSource implementation does not support the login timeout feature.
      SQLException - if a database access error occurs

    • setLogWriter

      public void setLogWriter(PrintWriter logWriter) throws SQLException

      Sets the log writer being used by this data source.

      Calls createDataSource(), so has the side effect of initializing the connection pool.

      Specified by:
      setLogWriter in interface CommonDataSource
      Specified by:
      setLogWriter in interface DataSource
      Parameters:
      logWriter - The new log writer
      Throws:
      SQLException - if a database access error occurs

    • setMaxConnLifetimeMillis

      public void setMaxConnLifetimeMillis(long maxConnLifetimeMillis)

      Sets the maximum permitted lifetime of a connection in milliseconds. A value of zero or less indicates an infinite lifetime.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      maxConnLifetimeMillis - The maximum permitted lifetime of a connection in milliseconds.

    • setMaxIdle

      public void setMaxIdle(int maxIdle)
      Sets the maximum number of connections that can remain idle in the pool. Excess idle connections are destroyed on return to the pool.
      Parameters:
      maxIdle - the new value for maxIdle
      See Also:

    • setMaxOpenPreparedStatements

      public void setMaxOpenPreparedStatements(int maxOpenStatements)

      Sets the value of the maxOpenPreparedStatements property.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      maxOpenStatements - the new maximum number of prepared statements

    • setMaxTotal

      public void setMaxTotal(int maxTotal)
      Sets the maximum total number of idle and borrows connections that can be active at the same time. Use a negative value for no limit.
      Parameters:
      maxTotal - the new value for maxTotal
      See Also:

    • setMaxWaitMillis

      public void setMaxWaitMillis(long maxWaitMillis)
      Sets the MaxWaitMillis property. Use -1 to make the pool wait indefinitely.
      Parameters:
      maxWaitMillis - the new value for MaxWaitMillis
      See Also:

    • setMinEvictableIdleTimeMillis

      public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis)
      Sets the minEvictableIdleTimeMillis property.
      Parameters:
      minEvictableIdleTimeMillis - the minimum amount of time an object may sit idle in the pool
      See Also:

    • setMinIdle

      public void setMinIdle(int minIdle)
      Sets the minimum number of idle connections in the pool. The pool attempts to ensure that minIdle connections are available when the idle object evictor runs. The value of this property has no effect unless timeBetweenEvictionRunsMillis has a positive value.
      Parameters:
      minIdle - the new value for minIdle
      See Also:

    • setNumTestsPerEvictionRun

      public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun)
      Sets the value of the numTestsPerEvictionRun property.
      Parameters:
      numTestsPerEvictionRun - the new numTestsPerEvictionRun value
      See Also:

    • setPassword

      public void setPassword(String password)

      Sets the password.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      password - new value for the password

    • setPoolPreparedStatements

      public void setPoolPreparedStatements(boolean poolingStatements)

      Sets whether to pool statements or not.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      poolingStatements - pooling on or off

    • setRemoveAbandonedOnBorrow

      public void setRemoveAbandonedOnBorrow(boolean removeAbandonedOnBorrow)
      Parameters:
      removeAbandonedOnBorrow - true means abandoned connections may be removed when connections are borrowed from the pool.
      See Also:

    • setRemoveAbandonedOnMaintenance

      public void setRemoveAbandonedOnMaintenance(boolean removeAbandonedOnMaintenance)
      Parameters:
      removeAbandonedOnMaintenance - true means abandoned connections may be removed on pool maintenance.
      See Also:

    • setRemoveAbandonedTimeout

      public void setRemoveAbandonedTimeout(int removeAbandonedTimeout)

      Sets the timeout in seconds before an abandoned connection can be removed.

      Setting this property has no effect if getRemoveAbandonedOnBorrow() and getRemoveAbandonedOnMaintenance() are false.

      Parameters:
      removeAbandonedTimeout - new abandoned timeout in seconds
      See Also:

    • setRollbackOnReturn

      public void setRollbackOnReturn(boolean rollbackOnReturn)
      Sets the flag that controls if a connection will be rolled back when it is returned to the pool if auto commit is not enabled and the connection is not read only.
      Parameters:
      rollbackOnReturn - whether a connection will be rolled back when it is returned to the pool.

    • setSoftMinEvictableIdleTimeMillis

      public void setSoftMinEvictableIdleTimeMillis(long softMinEvictableIdleTimeMillis)
      Sets the minimum amount of time a connection may sit idle in the pool before it is eligible for eviction by the idle object evictor, with the extra condition that at least "minIdle" connections remain in the pool.
      Parameters:
      softMinEvictableIdleTimeMillis - minimum amount of time a connection may sit idle in the pool before it is eligible for eviction, assuming there are minIdle idle connections in the pool.
      See Also:

    • setTestOnBorrow

      public void setTestOnBorrow(boolean testOnBorrow)
      Sets the testOnBorrow property. This property determines whether or not the pool will validate objects before they are borrowed from the pool.
      Parameters:
      testOnBorrow - new value for testOnBorrow property

    • setTestOnCreate

      public void setTestOnCreate(boolean testOnCreate)
      Sets the testOnCreate property. This property determines whether or not the pool will validate objects immediately after they are created by the pool
      Parameters:
      testOnCreate - new value for testOnCreate property

    • setTestOnReturn

      public void setTestOnReturn(boolean testOnReturn)
      Sets the testOnReturn property. This property determines whether or not the pool will validate objects before they are returned to the pool.
      Parameters:
      testOnReturn - new value for testOnReturn property

    • setTestWhileIdle

      public void setTestWhileIdle(boolean testWhileIdle)
      Sets the testWhileIdle property. This property determines whether or not the idle object evictor will validate connections.
      Parameters:
      testWhileIdle - new value for testWhileIdle property

    • setTimeBetweenEvictionRunsMillis

      public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis)
      Sets the timeBetweenEvictionRunsMillis property.
      Parameters:
      timeBetweenEvictionRunsMillis - the new time between evictor runs
      See Also:

    • setUrl

      public void setUrl(String url)

      Sets the url.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      url - the new value for the JDBC connection url

    • setUsername

      public void setUsername(String userName)

      Sets the userName.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      userName - the new value for the JDBC connection user name

    • setValidationQuery

      public void setValidationQuery(String validationQuery)

      Sets the validationQuery.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      validationQuery - the new value for the validation query

    • setValidationQueryTimeout

      public void setValidationQueryTimeout(int validationQueryTimeoutSeconds)
      Sets the validation query timeout, the amount of time, in seconds, that connection validation will wait for a response from the database when executing a validation query. Use a value less than or equal to 0 for no timeout.

      Note: this method currently has no effect once the pool has been initialized. The pool is initialized the first time one of the following methods is invoked: getConnection, setLogwriter, setLoginTimeout, getLoginTimeout, getLogWriter.

      Parameters:
      validationQueryTimeoutSeconds - new validation query timeout value in seconds

    • startPoolMaintenance

      protected void startPoolMaintenance()
      Starts the connection pool maintenance task, if configured.

    • unwrap

      public <T> T unwrap(Class<T> iface) throws SQLException
      Specified by:
      unwrap in interface Wrapper
      Throws:
      SQLException

    • updateJmxName

      private void updateJmxName(GenericObjectPoolConfig<?> config)