Class DataSourceProxy

  • All Implemented Interfaces:
    PoolConfiguration
    Direct Known Subclasses:
    DataSource

    public class DataSourceProxy
    extends Object
    implements PoolConfiguration
    The DataSource proxy lets us implements methods that don't exist in the current compiler JDK but might be methods that are part of a future JDK DataSource interface.
    It's a trick to work around compiler issues when implementing interfaces. For example, I could put in Java 6 methods of javax.sql.DataSource here, and compile it with JDK 1.5 and still be able to run under Java 6 without getting NoSuchMethodException.
    Version:
    1.0
    • Constructor Detail

      • DataSourceProxy

        public DataSourceProxy()
    • Method Detail

      • createPool

        public ConnectionPool createPool()
                                  throws SQLException
        Sets up the connection pool, by creating a pooling driver.
        Returns:
        the connection pool
        Throws:
        SQLException - Error creating pool
      • getConnectionAsync

        public Future<Connection> getConnectionAsync()
                                              throws SQLException
        Invokes an sync operation to retrieve the connection.
        Returns:
        a Future containing a reference to the connection when it becomes available
        Throws:
        SQLException - Connection error
      • close

        public void close()
      • close

        public void close​(boolean all)
      • getPoolSize

        public int getPoolSize()
      • setPoolProperties

        public void setPoolProperties​(PoolConfiguration poolProperties)
      • setDriverClassName

        public void setDriverClassName​(String driverClassName)
        The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible from the same classloader as tomcat-jdbc.jar
        Specified by:
        setDriverClassName in interface PoolConfiguration
        Parameters:
        driverClassName - a fully qualified Java class name of a Driver implementation.
      • setInitialSize

        public void setInitialSize​(int initialSize)
        Set the number of connections that will be established when the connection pool is started. Default value is 10. If this value exceeds PoolConfiguration.setMaxActive(int) it will automatically be lowered.
        Specified by:
        setInitialSize in interface PoolConfiguration
        Parameters:
        initialSize - the number of connections to be established.
      • setInitSQL

        public void setInitSQL​(String initSQL)
        A custom query to be run when a connection is first created. The default value is null. This query only runs once per connection, and that is when a new connection is established to the database. If this value is non null, it will replace the validation query during connection creation.
        Specified by:
        setInitSQL in interface PoolConfiguration
        Parameters:
        initSQL - the init SQL used to run against the DB or null if no query should be executed
      • setLogAbandoned

        public void setLogAbandoned​(boolean logAbandoned)
        boolean flag to set if stack traces should be logged for application code which abandoned a Connection. Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated. The default value is false.
        Specified by:
        setLogAbandoned in interface PoolConfiguration
        Parameters:
        logAbandoned - set to true if stack traces should be recorded when getConnection() is called.
      • setMaxActive

        public void setMaxActive​(int maxActive)
        The maximum number of active connections that can be allocated from this pool at the same time. The default value is 100
        Specified by:
        setMaxActive in interface PoolConfiguration
        Parameters:
        maxActive - hard limit for number of managed connections by this pool
      • setMaxWait

        public void setMaxWait​(int maxWait)
        The maximum number of milliseconds that the pool will wait (when there are no available connections and the PoolConfiguration.getMaxActive() has been reached) for a connection to be returned before throwing an exception. Default value is 30000 (30 seconds)
        Specified by:
        setMaxWait in interface PoolConfiguration
        Parameters:
        maxWait - the maximum number of milliseconds to wait.
      • setMinEvictableIdleTimeMillis

        public void setMinEvictableIdleTimeMillis​(int minEvictableIdleTimeMillis)
        The minimum amount of time an object must sit idle in the pool before it is eligible for eviction. The default value is 60000 (60 seconds).
        Specified by:
        setMinEvictableIdleTimeMillis in interface PoolConfiguration
        Parameters:
        minEvictableIdleTimeMillis - the number of milliseconds a connection must be idle to be eligible for eviction.
      • setNumTestsPerEvictionRun

        public void setNumTestsPerEvictionRun​(int numTestsPerEvictionRun)
        Property not used
        Specified by:
        setNumTestsPerEvictionRun in interface PoolConfiguration
        Parameters:
        numTestsPerEvictionRun - parameter ignored.
      • setRemoveAbandonedTimeout

        public void setRemoveAbandonedTimeout​(int removeAbandonedTimeout)
        The time in seconds before a connection can be considered abandoned. The timer can be reset upon queries using an interceptor.
        Specified by:
        setRemoveAbandonedTimeout in interface PoolConfiguration
        Parameters:
        removeAbandonedTimeout - the time in seconds before a used connection can be considered abandoned
        See Also:
        ResetAbandonedTimer
      • setTestOnBorrow

        public void setTestOnBorrow​(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. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
        Specified by:
        setTestOnBorrow in interface PoolConfiguration
        Parameters:
        testOnBorrow - set to true if validation should take place before a connection is handed out to the application
        See Also:
        PoolConfiguration.getValidationInterval()
      • setTestOnConnect

        public void setTestOnConnect​(boolean testOnConnect)
        Set to true if we should run the validation query when connecting to the database for the first time on a connection. Normally this is always set to false, unless one wants to use the validationQuery as an init query. Setting an PoolConfiguration.setInitSQL(String) will override this setting, as the init SQL will be used instead of the validation query
        Specified by:
        setTestOnConnect in interface PoolConfiguration
        Parameters:
        testOnConnect - set to true if we should run the validation query upon connect
      • setTestOnReturn

        public void setTestOnReturn​(boolean testOnReturn)
        The indication of whether objects will be validated after being returned to the pool. If the object fails to validate, it will be dropped from the pool. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
        Specified by:
        setTestOnReturn in interface PoolConfiguration
        Parameters:
        testOnReturn - true if validation should take place after a connection is returned to the pool
        See Also:
        PoolConfiguration.getValidationInterval()
      • setTimeBetweenEvictionRunsMillis

        public void setTimeBetweenEvictionRunsMillis​(int timeBetweenEvictionRunsMillis)
        The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner and idle pool resizing. This value should not be set under 1 second. It dictates how often we check for idle, abandoned connections, and how often we validate idle connection and resize the idle pool. The default value is 5000 (5 seconds)
        Specified by:
        setTimeBetweenEvictionRunsMillis in interface PoolConfiguration
        Parameters:
        timeBetweenEvictionRunsMillis - the sleep time in between validations in milliseconds
      • setValidationInterval

        public void setValidationInterval​(long validationInterval)
        avoid excess validation, only run validation at most at this frequency - time in milliseconds. If a connection is due for validation, but has been validated previously within this interval, it will not be validated again. The default value is 3000 (3 seconds).
        Specified by:
        setValidationInterval in interface PoolConfiguration
        Parameters:
        validationInterval - the validation interval in milliseconds
      • setValidationQuery

        public void setValidationQuery​(String validationQuery)
        The SQL query that will be used to validate connections from this pool before returning them to the caller or pool. If specified, this query does not have to return any data, it just can't throw an SQLException. The default value is null. Example values are SELECT 1(mysql), select 1 from dual(oracle), SELECT 1(MS Sql Server)
        Specified by:
        setValidationQuery in interface PoolConfiguration
        Parameters:
        validationQuery - the query used for validation or null if no validation is performed
      • setValidatorClassName

        public void setValidatorClassName​(String className)
        Set the name for an optional validator class which will be used in place of test queries. If set to null, standard validation will be used.
        Specified by:
        setValidatorClassName in interface PoolConfiguration
        Parameters:
        className - the name of the optional validator class
      • setValidationQueryTimeout

        public void setValidationQueryTimeout​(int validationQueryTimeout)
        The timeout in seconds before a connection validation queries fail. A value less than or equal to zero will disable this feature. Defaults to -1.
        Specified by:
        setValidationQueryTimeout in interface PoolConfiguration
        Parameters:
        validationQueryTimeout - The timeout value
      • setJdbcInterceptors

        public void setJdbcInterceptors​(String interceptors)
        A semicolon separated list of classnames extending JdbcInterceptor class. These interceptors will be inserted as an interceptor into the chain of operations on a java.sql.Connection object. Example interceptors are StatementFinalizer to close all used statements during the session. ResetAbandonedTimer resets the timer upon every operation on the connection or a statement. ConnectionState caches the auto commit, read only and catalog settings to avoid round trips to the DB. The default value is null.
        Specified by:
        setJdbcInterceptors in interface PoolConfiguration
        Parameters:
        interceptors - the interceptors that are used for connections. Example format: 'ConnectionState(useEquals=true,fast=yes);ResetAbandonedTimer'
      • setJmxEnabled

        public void setJmxEnabled​(boolean enabled)
        If set to true, the connection pool creates a ConnectionPoolMBean object that can be registered with JMX to receive notifications and state about the pool. The ConnectionPool object doesn't register itself, as there is no way to keep a static non changing ObjectName across JVM restarts.
        Specified by:
        setJmxEnabled in interface PoolConfiguration
        Parameters:
        enabled - set to to if the mbean object should be created upon startup.
      • setFairQueue

        public void setFairQueue​(boolean fairQueue)
        Set to true if you wish that calls to getConnection should be treated fairly in a true FIFO fashion. This uses the FairBlockingQueue implementation for the list of the idle connections. The default value is true. This flag is required when you want to use asynchronous connection retrieval.
        Specified by:
        setFairQueue in interface PoolConfiguration
        Parameters:
        fairQueue - true to use a fair queue
      • setUseLock

        public void setUseLock​(boolean useLock)
        Set to true if a lock should be used when operations are performed on the connection object. Should be set to false unless you plan to have a background thread of your own doing idle and abandon checking such as JMX clients. If the pool sweeper is enabled, then the lock will automatically be used regardless of this setting.
        Specified by:
        setUseLock in interface PoolConfiguration
        Parameters:
        useLock - set to true if a lock should be used on connection operations
      • setDefaultAutoCommit

        public void setDefaultAutoCommit​(Boolean autocommit)
        The default auto-commit state of connections created by this pool. If not set (null), default is JDBC driver default (If set to null then the Connection.setAutoCommit(boolean) method will not be called.)
        Specified by:
        setDefaultAutoCommit in interface PoolConfiguration
        Parameters:
        autocommit - default auto commit setting, null is Driver default.
      • setConnectionProperties

        public void setConnectionProperties​(String properties)
        The properties that will be passed into Driver.connect(String, Properties) method. Username and password do not need to be stored here, they will be passed into the properties right before the connection is established.
        Specified by:
        setConnectionProperties in interface PoolConfiguration
        Parameters:
        properties - properties - Format of the string is [propertyName=property;]* Example: prop1=value1;prop2=value2
      • setUseEquals

        public void setUseEquals​(boolean useEquals)
        Set to true if you wish the ProxyConnection class to use String.equals instead of == when comparing method names. This property does not apply to added interceptors as those are configured individually. The default value is false.
        Specified by:
        setUseEquals in interface PoolConfiguration
        Parameters:
        useEquals - set to true if the pool should use String.equals(Object) instead of == when comparing method names on Connection methods
      • getSuspectTimeout

        public int getSuspectTimeout()
        Returns the time in seconds to pass before a connection is marked an abandoned suspect. Any value lesser than or equal to 0 means the check is disabled.
        Specified by:
        getSuspectTimeout in interface PoolConfiguration
        Returns:
        Returns the time in seconds to pass before a connection is marked an abandoned suspect.
      • setSuspectTimeout

        public void setSuspectTimeout​(int seconds)
        Similar to PoolConfiguration.setRemoveAbandonedTimeout(int) but instead of treating the connection as abandoned, and potentially closing the connection, this simply logs the warning if PoolConfiguration.isLogAbandoned() returns true. If this value is equal or less than 0, no suspect checking will be performed. Suspect checking only takes place if the timeout value is larger than 0 and the connection was not abandoned or if abandon check is disabled. If a connection is suspect a WARN message gets logged and a JMX notification gets sent once.
        Specified by:
        setSuspectTimeout in interface PoolConfiguration
        Parameters:
        seconds - - the amount of time in seconds that has to pass before a connection is marked suspect.
      • getIdle

        public int getIdle()
        If the pool has not been created, it will be created during this call.
        Returns:
        the number of established but idle connections
      • getNumIdle

        public int getNumIdle()
        Returns:
        the number of established but idle connections
      • checkAbandoned

        public void checkAbandoned()
        Forces an abandon check on the connection pool. If connections that have been abandoned exists, they will be closed during this run
      • checkIdle

        public void checkIdle()
        Forces a check for resizing of the idle connections
      • getActive

        public int getActive()
        Returns:
        number of connections in use by the application
      • getNumActive

        public int getNumActive()
        Returns:
        number of connections in use by the application getActive()
      • getWaitCount

        public int getWaitCount()
        Returns:
        number of threads waiting for a connection
      • getSize

        public int getSize()
        Returns:
        the current size of the pool
      • testIdle

        public void testIdle()
        Performs a validation on idle connections
      • getBorrowedCount

        public long getBorrowedCount()
        The total number of connections borrowed from this pool.
        Returns:
        the borrowed connection count
      • getReturnedCount

        public long getReturnedCount()
        The total number of connections returned to this pool.
        Returns:
        the returned connection count
      • getCreatedCount

        public long getCreatedCount()
        The total number of connections created by this pool.
        Returns:
        the created connection count
      • getReleasedCount

        public long getReleasedCount()
        The total number of connections released from this pool.
        Returns:
        the released connection count
      • getRemoveAbandonedCount

        public long getRemoveAbandonedCount()
        The total number of connections released by remove abandoned.
        Returns:
        the PoolCleaner removed abandoned connection count
      • getReleasedIdleCount

        public long getReleasedIdleCount()
        The total number of connections released by eviction.
        Returns:
        the PoolCleaner evicted idle connection count
      • getReconnectedCount

        public long getReconnectedCount()
        The total number of connections reconnected by this pool.
        Returns:
        the reconnected connection count
      • resetStats

        public void resetStats()
        reset the statistics of this pool.
      • getConnectionProperties

        public String getConnectionProperties()
        The connection properties that will be sent to the JDBC driver when establishing new connections. Format of the string is [propertyName=property;]
        NOTE - The "user" and "password" properties will be passed explicitly, so they do not need to be included here. The default value is null.
        Specified by:
        getConnectionProperties in interface PoolConfiguration
        Returns:
        the connection properties
      • getDriverClassName

        public String getDriverClassName()
        The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible from the same classloader as tomcat-jdbc.jar
        Specified by:
        getDriverClassName in interface PoolConfiguration
        Returns:
        fully qualified JDBC driver name.
      • getInitialSize

        public int getInitialSize()
        Returns the number of connections that will be established when the connection pool is started. Default value is 10
        Specified by:
        getInitialSize in interface PoolConfiguration
        Returns:
        number of connections to be started when pool is started
      • getInitSQL

        public String getInitSQL()
        A custom query to be run when a connection is first created. The default value is null. This query only runs once per connection, and that is when a new connection is established to the database. If this value is non null, it will replace the validation query during connection creation.
        Specified by:
        getInitSQL in interface PoolConfiguration
        Returns:
        the init SQL used to run against the DB or null if not set
      • getJdbcInterceptors

        public String getJdbcInterceptors()
        A semicolon separated list of classnames extending JdbcInterceptor class. These interceptors will be inserted as an interceptor into the chain of operations on a java.sql.Connection object. Example interceptors are StatementFinalizer to close all used statements during the session. ResetAbandonedTimer resets the timer upon every operation on the connection or a statement. ConnectionState caches the auto commit, read only and catalog settings to avoid round trips to the DB. The default value is null.
        Specified by:
        getJdbcInterceptors in interface PoolConfiguration
        Returns:
        the interceptors that are used for connections. Example format: 'ConnectionState(useEquals=true,fast=yes);ResetAbandonedTimer'
      • getMaxActive

        public int getMaxActive()
        The maximum number of active connections that can be allocated from this pool at the same time. The default value is 100
        Specified by:
        getMaxActive in interface PoolConfiguration
        Returns:
        the maximum number of connections used by this pool
      • getMaxWait

        public int getMaxWait()
        The maximum number of milliseconds that the pool will wait (when there are no available connections and the PoolConfiguration.getMaxActive() has been reached) for a connection to be returned before throwing an exception. Default value is 30000 (30 seconds)
        Specified by:
        getMaxWait in interface PoolConfiguration
        Returns:
        the number of milliseconds to wait for a connection to become available if the pool is maxed out.
      • getMinEvictableIdleTimeMillis

        public int getMinEvictableIdleTimeMillis()
        The minimum amount of time an object must sit idle in the pool before it is eligible for eviction. The default value is 60000 (60 seconds).
        Specified by:
        getMinEvictableIdleTimeMillis in interface PoolConfiguration
        Returns:
        the minimum amount of idle time in milliseconds before a connection is considered idle and eligible for eviction.
      • getMaxAge

        public long getMaxAge()
        Time in milliseconds to keep this connection before reconnecting. When a connection is idle, returned to the pool or borrowed from the pool, the pool will check to see if the ((now - time-when-connected) > maxAge) has been reached, and if so, it reconnects. Note that the age of idle connections will only be checked if PoolConfiguration.getTimeBetweenEvictionRunsMillis() returns a value greater than 0. The default value is 0, which implies that connections will be left open and no age checks will be done. This is a useful setting for database sessions that leak memory as it ensures that the session will have a finite life span.
        Specified by:
        getMaxAge in interface PoolConfiguration
        Returns:
        the time in milliseconds a connection will be open for when used
      • getName

        public String getName()
        Returns the name of the connection pool. By default a JVM unique random name is assigned.
        Specified by:
        getName in interface PoolConfiguration
        Returns:
        the name of the pool, should be unique in a JVM
      • getPassword

        public String getPassword()
        Description copied from interface: PoolConfiguration
        Returns the password used when establishing connections to the database.
        Specified by:
        getPassword in interface PoolConfiguration
        Returns:
        DOES NOT RETURN THE PASSWORD, IT WOULD SHOW UP IN JMX
      • getRemoveAbandonedTimeout

        public int getRemoveAbandonedTimeout()
        The time in seconds before a connection can be considered abandoned. The timer can be reset upon queries using an interceptor.
        Specified by:
        getRemoveAbandonedTimeout in interface PoolConfiguration
        Returns:
        the time in seconds before a used connection can be considered abandoned
        See Also:
        ResetAbandonedTimer
      • getTimeBetweenEvictionRunsMillis

        public int getTimeBetweenEvictionRunsMillis()
        The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner and idle pool resizing. This value should not be set under 1 second. It dictates how often we check for idle, abandoned connections, and how often we validate idle connection and resize the idle pool. The default value is 5000 (5 seconds)
        Specified by:
        getTimeBetweenEvictionRunsMillis in interface PoolConfiguration
        Returns:
        the sleep time in between validations in milliseconds
      • getUsername

        public String getUsername()
        Returns the username used to establish the connection with
        Specified by:
        getUsername in interface PoolConfiguration
        Returns:
        the username used to establish the connection with
      • getValidationInterval

        public long getValidationInterval()
        avoid excess validation, only run validation at most at this frequency - time in milliseconds. If a connection is due for validation, but has been validated previously within this interval, it will not be validated again. The default value is 3000 (3 seconds).
        Specified by:
        getValidationInterval in interface PoolConfiguration
        Returns:
        the validation interval in milliseconds
      • getValidationQuery

        public String getValidationQuery()
        The SQL query that will be used to validate connections from this pool before returning them to the caller or pool. If specified, this query does not have to return any data, it just can't throw an SQLException. The default value is null. Example values are SELECT 1(mysql), select 1 from dual(oracle), SELECT 1(MS Sql Server)
        Specified by:
        getValidationQuery in interface PoolConfiguration
        Returns:
        the query used for validation or null if no validation is performed
      • getValidationQueryTimeout

        public int getValidationQueryTimeout()
        The timeout in seconds before a connection validation queries fail. A value less than or equal to zero will disable this feature. Defaults to -1.
        Specified by:
        getValidationQueryTimeout in interface PoolConfiguration
        Returns:
        the timeout value in seconds
      • getValidatorClassName

        public String getValidatorClassName()
        Return the name of the optional validator class - may be null.
        Specified by:
        getValidatorClassName in interface PoolConfiguration
        Returns:
        the name of the optional validator class - may be null
      • setValidator

        public void setValidator​(Validator validator)
        Sets the validator object If this is a non null object, it will be used as a validator instead of the validationQuery If this is null, remove the usage of the validator.
        Specified by:
        setValidator in interface PoolConfiguration
        Parameters:
        validator - The validator object
      • isAccessToUnderlyingConnectionAllowed

        public boolean isAccessToUnderlyingConnectionAllowed()
        Property not used. Access is always allowed. Access can be achieved by calling unwrap on the pooled connection. see DataSource interface or call getConnection through reflection or cast the object as PooledConnection
        Specified by:
        isAccessToUnderlyingConnectionAllowed in interface PoolConfiguration
        Returns:
        true
      • isDefaultAutoCommit

        public Boolean isDefaultAutoCommit()
        The default auto-commit state of connections created by this pool. If not set (null), default is JDBC driver default (If set to null then the Connection.setAutoCommit(boolean) method will not be called.)
        Specified by:
        isDefaultAutoCommit in interface PoolConfiguration
        Returns:
        the default auto commit setting, null is Driver default.
      • isLogAbandoned

        public boolean isLogAbandoned()
        boolean flag to set if stack traces should be logged for application code which abandoned a Connection. Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated. The default value is false.
        Specified by:
        isLogAbandoned in interface PoolConfiguration
        Returns:
        true if the connection pool logs stack traces when connections are borrowed from the pool.
      • isPoolSweeperEnabled

        public boolean isPoolSweeperEnabled()
        Returns true if the pool sweeper is enabled for the connection pool. The pool sweeper is enabled if any settings that require async intervention in the pool are turned on boolean result = getTimeBetweenEvictionRunsMillis()>0; result = result && (isRemoveAbandoned() && getRemoveAbandonedTimeout()>0); result = result || (isTestWhileIdle() && getValidationQuery()!=null); return result;
        Specified by:
        isPoolSweeperEnabled in interface PoolConfiguration
        Returns:
        true if a background thread is or will be enabled for this pool
      • getAbandonWhenPercentageFull

        public int getAbandonWhenPercentageFull()
        Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are above the percentage defined by abandonWhenPercentageFull. The value should be between 0-100. The default value is 0, which implies that connections are eligible for closure as soon as removeAbandonedTimeout has been reached.
        Specified by:
        getAbandonWhenPercentageFull in interface PoolConfiguration
        Returns:
        percentage - a value between 0 and 100 to indicate when connections that have been abandoned/timed out are considered abandoned
      • isTestOnBorrow

        public boolean isTestOnBorrow()
        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. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
        Specified by:
        isTestOnBorrow in interface PoolConfiguration
        Returns:
        true if the connection is to be validated upon borrowing a connection from the pool
        See Also:
        PoolConfiguration.getValidationInterval()
      • isTestOnConnect

        public boolean isTestOnConnect()
        Returns true if we should run the validation query when connecting to the database for the first time on a connection. Normally this is always set to false, unless one wants to use the validationQuery as an init query.
        Specified by:
        isTestOnConnect in interface PoolConfiguration
        Returns:
        true if we should run the validation query upon connect
      • isTestOnReturn

        public boolean isTestOnReturn()
        The indication of whether objects will be validated after being returned to the pool. If the object fails to validate, it will be dropped from the pool. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
        Specified by:
        isTestOnReturn in interface PoolConfiguration
        Returns:
        true if validation should take place after a connection is returned to the pool
        See Also:
        PoolConfiguration.getValidationInterval()
      • getDefaultAutoCommit

        public Boolean getDefaultAutoCommit()
        The default auto-commit state of connections created by this pool. If not set (null), default is JDBC driver default (If set to null then the Connection.setAutoCommit(boolean) method will not be called.)
        Specified by:
        getDefaultAutoCommit in interface PoolConfiguration
        Returns:
        the default auto commit setting, null is Driver default.
      • getUseLock

        public boolean getUseLock()
        Return true if a lock should be used when operations are performed on the connection object. Should be set to false unless you plan to have a background thread of your own doing idle and abandon checking such as JMX clients. If the pool sweeper is enabled, then the lock will automatically be used regardless of this setting.
        Specified by:
        getUseLock in interface PoolConfiguration
        Returns:
        true if a lock is used.
      • isFairQueue

        public boolean isFairQueue()
        Returns true if a fair queue is being used by the connection pool
        Specified by:
        isFairQueue in interface PoolConfiguration
        Returns:
        true if a fair waiting queue is being used
      • isJmxEnabled

        public boolean isJmxEnabled()
        If set to true, the connection pool creates a ConnectionPoolMBean object that can be registered with JMX to receive notifications and state about the pool. The ConnectionPool object doesn't register itself, as there is no way to keep a static non changing ObjectName across JVM restarts.
        Specified by:
        isJmxEnabled in interface PoolConfiguration
        Returns:
        true if the mbean object will be created upon startup.
      • isUseEquals

        public boolean isUseEquals()
        Set to true if you wish the ProxyConnection class to use String.equals instead of == when comparing method names. This property does not apply to added interceptors as those are configured individually. The default value is false.
        Specified by:
        isUseEquals in interface PoolConfiguration
        Returns:
        true if pool uses String.equals(Object) instead of == when comparing method names on Connection methods
      • setAbandonWhenPercentageFull

        public void setAbandonWhenPercentageFull​(int percentage)
        Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are above the percentage defined by abandonWhenPercentageFull. The value should be between 0-100. The default value is 0, which implies that connections are eligible for closure as soon as removeAbandonedTimeout has been reached.
        Specified by:
        setAbandonWhenPercentageFull in interface PoolConfiguration
        Parameters:
        percentage - a value between 0 and 100 to indicate when connections that have been abandoned/timed out are considered abandoned
      • setAccessToUnderlyingConnectionAllowed

        public void setAccessToUnderlyingConnectionAllowed​(boolean accessToUnderlyingConnectionAllowed)
        No-op
        Specified by:
        setAccessToUnderlyingConnectionAllowed in interface PoolConfiguration
        Parameters:
        accessToUnderlyingConnectionAllowed - parameter ignored
      • setMaxAge

        public void setMaxAge​(long maxAge)
        Time in milliseconds to keep this connection before reconnecting. When a connection is idle, returned to the pool or borrowed from the pool, the pool will check to see if the ((now - time-when-connected) > maxAge) has been reached, and if so, it reconnects. Note that the age of idle connections will only be checked if PoolConfiguration.getTimeBetweenEvictionRunsMillis() returns a value greater than 0. The default value is 0, which implies that connections will be left open and no age checks will be done. This is a useful setting for database sessions that leak memory as it ensures that the session will have a finite life span.
        Specified by:
        setMaxAge in interface PoolConfiguration
        Parameters:
        maxAge - the time in milliseconds a connection will be open for when used
      • setName

        public void setName​(String name)
        Sets the name of the connection pool
        Specified by:
        setName in interface PoolConfiguration
        Parameters:
        name - the name of the pool, should be unique in a runtime JVM
      • getDataSource

        public Object getDataSource()
        Returns a datasource, if one exists that is being used to create connections. This method will return null if the pool is using a Driver
        Specified by:
        getDataSource in interface PoolConfiguration
        Returns:
        the DataSource to be used for creating connections to be pooled or null if a Driver is used.
      • getDataSourceJNDI

        public String getDataSourceJNDI()
        Returns the JNDI string configured for data source usage.
        Specified by:
        getDataSourceJNDI in interface PoolConfiguration
        Returns:
        the JNDI string or null if not set
      • setAlternateUsernameAllowed

        public void setAlternateUsernameAllowed​(boolean alternateUsernameAllowed)
        Set to true if the call getConnection(username,password) is allowed and honored.. This is used for when the pool is used by an application accessing multiple schemas. There is a performance impact turning this option on, even when not used due to username checks.
        Specified by:
        setAlternateUsernameAllowed in interface PoolConfiguration
        Parameters:
        alternateUsernameAllowed - - set true if getConnection(username,password) is honored, false if it is to be ignored.
      • setCommitOnReturn

        public void setCommitOnReturn​(boolean commitOnReturn)
        Set to true if you want the connection pool to commit any pending transaction when a connection is returned. The default value is false, as this could result in committing data. This parameter is only looked at if the PoolConfiguration.getDefaultAutoCommit() returns false
        Specified by:
        setCommitOnReturn in interface PoolConfiguration
        Parameters:
        commitOnReturn - set to true if the pool should call Connection.commit() when a connection is returned to the pool. Default is false
      • setRollbackOnReturn

        public void setRollbackOnReturn​(boolean rollbackOnReturn)
        Set to true if you want the connection pool to rollback any pending transaction when a connection is returned. The default value is false, as this could result in committing data. This parameter is only looked at if the PoolConfiguration.getDefaultAutoCommit() returns false
        Specified by:
        setRollbackOnReturn in interface PoolConfiguration
        Parameters:
        rollbackOnReturn - set to true if the pool should call Connection.rollback() when a connection is returned to the pool. Default is false
      • setLogValidationErrors

        public void setLogValidationErrors​(boolean logValidationErrors)
        Set to true if you wish that errors from validation should be logged as error messages.
        Specified by:
        setLogValidationErrors in interface PoolConfiguration
        Parameters:
        logValidationErrors - set to true to log validation errors
      • getLogValidationErrors

        public boolean getLogValidationErrors()
        Returns true if errors that happen during validation will be logged
        Specified by:
        getLogValidationErrors in interface PoolConfiguration
        Returns:
        true if errors that happen during validation will be logged
      • getPropagateInterruptState

        public boolean getPropagateInterruptState()
        Returns true if the pool is configured to propagate interrupt state of a thread. A thread waiting for a connection, can have its wait interrupted, and by default will clear the interrupt flag and throw a PoolExhaustedException
        Specified by:
        getPropagateInterruptState in interface PoolConfiguration
        Returns:
        true if the pool is configured to propagate and not clear the thread interrupt state
      • setPropagateInterruptState

        public void setPropagateInterruptState​(boolean propagateInterruptState)
        Configure the pool to propagate interrupt state for interrupted threads waiting for a connection A thread waiting for a connection, can have its wait interrupted, and by default will clear the interrupt flag and throw a PoolExhaustedException If set to true, this behavior will change, while the PoolExhaustedException is still thrown, the threads interrupted state is still set.
        Specified by:
        setPropagateInterruptState in interface PoolConfiguration
        Parameters:
        propagateInterruptState - - set to true to not clear, but propagate, a threads interrupted state.
      • setIgnoreExceptionOnPreLoad

        public void setIgnoreExceptionOnPreLoad​(boolean ignoreExceptionOnPreLoad)
        Set to true if you want to ignore error of connection creation while initializing the pool. Set to false if you want to fail the initialization of the pool by throwing exception.
        Specified by:
        setIgnoreExceptionOnPreLoad in interface PoolConfiguration
        Parameters:
        ignoreExceptionOnPreLoad - set to true if you want to ignore error of connection creation while initializing the pool.
      • getUseStatementFacade

        public boolean getUseStatementFacade()
        Returns true if this connection pool is configured to wrap statements in order to enable equals() and hashCode() methods to be called on the closed statements if any statement proxy is set.
        Specified by:
        getUseStatementFacade in interface PoolConfiguration
        Returns:
        true if the statements are wrapped
      • setUseStatementFacade

        public void setUseStatementFacade​(boolean useStatementFacade)
        Set this to true if you wish to wrap statements in order to enable equals() and hashCode() methods to be called on the closed statements if any statement proxy is set.
        Specified by:
        setUseStatementFacade in interface PoolConfiguration
        Parameters:
        useStatementFacade - set to true to wrap statements
      • purge

        public void purge()
      • purgeOnReturn

        public void purgeOnReturn()